(Swift for Beginners)
Swift Function Parameters and Return Values
In this article, you’ll learn about different user defined functions that takes inputs of different types and returns output, with examples.
In the previous article Swift Functions, we learned about functions. Now, we’ll look at the different ways and types we can create a function in Swift, i.e. handling input and output in a function.
Function with no parameter and no return value
These type of functions do not take any input and return value.
func funcname() { //statements } OR func funcname() -> () { //statements } OR func funcname() -> Void { //statements }
All the above syntax are valid to create a function that takes no parameters and doesn’t return value.
The above syntax func funcname() -> ()
is also equivalent to func funcname() -> Void
because Void
is just a typealias of ()
. You can visit Swift Typealias to learn more.
Example 1: No Parameters passed and no return value
func greetUser() {
print("Good Morning!")
}
greetUser()
When you run the above program, the output will be:
Good Morning!
Function with no parameter but return value
These type of functions do not take any input parameters but return a value. To add the return type you need to add arrow (->
) and the return type.
func funcname() -> ReturnType { //statements return value }
Example 2: No Parameters passed but return value
func greetUser() -> String {
return "Good Morning!"
}
let msg = greetUser()
print(msg)
When you run the above program, the output will be:
Good Morning!
In the above program, you have defined the return Type to be String
. Now, the statement must return a string from the statement inside the function, otherwise you will get an error.
return
keyword transfers control of the program from body of the function to the function call. If you need to return value from the function, add value after the return
keyword.
return "Good Morning!"
statement returns value of type String
from the function. Note that the type of the return and the value must match.
You can also assign the return value to a variable or a constant. let msg =
assigns the return value to the constant msg. So the statement print(msg)
outputs Good Morning! in the console.
If you want to neglect the value, you can simply use _
as let _ =
.
Function with parameter but no return value
Parameters are used to take input in the function. The parameter contains a parameter name and the type followed by a colon (:
). These type of functions take input parameter but do not return value.
func funcname(parameterName:Type) { //statements }
Example 3: Parameters passed but no return value
func greetUser(msg:String) {
print(msg)
}
greetUser(msg: "Good Morning!")
When you run the above program, the output will be:
Good Morning!
In the above program, the function accepts a single parameter of type String
. The parameter can only be used inside the function. msg is the name of parameter.
You can call the function by passing it a string value with the parameter name as greetUser(msg: "Good Morning!")
. The msg parameter name is visible only inside the function greetUser()
.
Therefore, statement print(msg)
outputs Good Morning! in the console.
Function with parameter and return value
These type of functions take parameters and also return value.
func funcname(parameterName:Type) -> ReturnType { //statements }
Example 4: Parameters passed and returns value
func greetUser(name:String) -> String {
return "Good Morning! " + name
}
let msg = greetUser(name: "Jack")
print(msg)
When you run the above program, the output will be:
Good Morning! Jack
In the above program, the function accepts a single parameter of type String
and also returns value Good Morning! Jack of type String
.
Function with multiple parameters and multiple return values
These type of functions take multiple parameters that are separated by comma and also return multiple values. You can return multiple value in Swift using Tuples. See Swift Tuples to learn more about it.
func funcname(parameterName:Type, parameterName2:Type ,...) -> (ReturnType, ReturnType...) { //statements }
Example 5: Multiple Parameters passed and multiple return value
func greetUser(name:String, age:Int) -> (String, Int) {
let msg = "Good Morning!" + name
var userage = age
if age < 0 {
userage = 0
}
return (msg, userage)
}
let msg = greetUser(name: "Jack", age: -2)
print(msg.0)
print("You have (msg.1) coins left")
When you run the above program, the output will be:
Good Morning!Jack You have 0 coins left
In the above program, the function greetUser()
accepts multiple parameters of type String
and Int
. The function also returns multiple values as a tuple of type String
and Int
.
To access each return value, we use index positions 0, 1, … Here, we’ve used msg.0 to access Good Morning!Jack and msg.1 to access 0.
Using index positions can be unintuitive and unreadable at times. We can solve this issue elegantly by giving names to return values. The above program can also be rewritten as below.
Example 6: Multiple return values with name
func greetUser(name:String, coins:Int) -> (name:String, coins:Int) {
let msg = "Good Morning!" + name
var userCoins = coins
if coins < 0 {
userCoins = 0
}
return (msg, userCoins)
}
let msg = greetUser(name: "Jack",coins: -2)
print(msg.name)
print("You have (msg.coins) coins left")
In this program, the return type is of tuple that contains the variable name with the type. The main advantage of this is you can access the result using the variable name as msg.name and msg.coins instead of msg.0 and msg.1.
Function with argument label
When you define a function that accepts inputs, you can define the input name with the help of parameter name. However, there is another type of name which you can give along with the parameter name, known as argument label.
The use of argument labels allow a function to be called in an expressive way, sentence-like manner, while still providing a function body that is readable and clear in intent.
Each function parameter has both an argument label and a parameter name. By default, parameters use their parameter name as their argument label. But, if you explicitly define the argument name, the argument label is used when calling the function.
The syntax of function with argument label is
func funcname(argumentLabel parameterName:Type)-> Return Type { //statements }
Let’s see this in example below.
Example 7: Function without argument label
func sum(a:Int, b:Int) -> Int {
return a + b
}
let result = sum(a: 2, b: 3)
print("The sum is (result)")
When you run the above program, the output will be:
The sum is 5
In the above example, we have not specified the argument label, so it takes default parameter name a and bas the argument label while calling the function.
You may notice the function call is not expressive/sentence when calling the function. You may think it can be made more expressive as English if you could make the function call as:
let result = sum(of: 2, and: 3)
Now let’s change the function as:
Example 8: Function with better function call but not as parameter names
func sum(of:Int, and:Int) -> Int {
return of + and
}
let result = sum(of: 2, and: 3)
print("The sum is (result)")
Now the method call is expressive. However, now we have to use the parameter name of & and in return of + and
to find the sum of two numbers. Now, this makes the function body unreadable. Use of a and b instead of of&and would make more sense inside the function body.
For this purpose we have to explicitly define argument label as:
Example 9: Function with argument labels
func sum(of a :Int, and b:Int) -> Int {
return a + b
}
let result = sum(of: 2, and: 3)
print("The sum is (result)")
In the above program, the function accepts two parameter of type Int
. The function call uses the argument label of & and which makes sense while calling the function as sum(of: 2, and: 3)
instead of sum(a: 2, b: 3)
.
Also, the function body uses the parameter name a and b instead of of & and which also makes more sense while applying operations.
You can also omit the argument label by writing a _
before the parameter name.
func sum(_ a :Int, _ b:Int) -> Int {
return a + b
}
let result = sum(2, 3)
print("The sum is (result)")
Function with default parameter values
You can give default values for any parameter in a function by assigning a value to the parameter after that parameter’s type. Giving a default parameter allows you to neglect the parameter while calling the function.
If you do not pass value to the parameter while calling the function, its default value is used. However, if you explicitly pass a value to the parameter while calling, the specified value is used.
func funcname(parameterName:Type = value) -> Return Type { //statements }
Example 10: Function with default parameter values
func sum(of a :Int = 7, and b:Int = 8) -> Int {
return a + b
}
let result1 = sum(of: 2, and: 3)
print("The sum is (result1)")
let result2 = sum(of: 2)
print("The sum is (result2)")
let result3 = sum(and: 2)
print("The sum is (result3)")
let result4 = sum()
print("The sum is (result4)")
When you run the above program, the output will be:
The sum is 5 The sum is 10 The sum is 9 The sum is 15
In the above program, the function sum(of a :Int = 7 , and b:Int = 8) -> Int
accepts two parameter of type Int
but also specifies the default value of parameter a = 7
and b = 8.
If you pass value as a parameter in the function call as sum(of: 2, and: 3)
then 2 and 3 is used instead of parameter default value.
But if you don’t pass the parameter value as sum()
, then default value 7 and 8 are used as the parameter value.
Function with variadic parameters
A variadic parameter can accept zero or more values of a specific type. You can specify variadic parameter by inserting three period characters (…) after the parameter’s type name.
You usually use a variadic parameter when you need to pass a varying number of input values to the parameter when the function is called. For example, a list of numbers, a list of alphabets, etc.
The syntax of function with variadic parameters is:
func funcname(parameterName:Type...) -> Return Type { //statements }
Example 11: Function with variadic parameters
func sum(of numbers:Int...) {
var result = 0
for num in numbers {
result += num
}
print("The sum of numbers is (result)")
}
sum(of: 1, 2, 3, 4, 5, 6, 7, 8)
In the above program, the function sum(of numbers:Int...)
accepts a variadic parameter of type Int
. A variadic parameter can accept multiple values separated by comma as sum(of: 1, 2, 3, 4, 5, 6, 7, 8)
.
The values 1, 2, 3, 4, 5, 6, 7, 8 passed as a variadic parameter are made available within the function’s body as an array of the Int
type. Therefore, we can apply for-in
loop in the value as for num in numbers
.
When you run the above program, the output will be:
The sum of numbers is 36
Note: Swift built in print()
function also accepts variadic parameter of type Any
.
Any
represents to any data type in Swift e.g. Int
, Float
, Double
,String
etc.
Function with in-out parameters
When you define the function parameter, the function parameters cannot be modified inside the body. So they are constants by default. Let’s see this in example:
func process(name:String) { if name == ""{ name = "guest" } }
The above program results a compile-time error because you cannot change the value of a parameter.
If you want a function to modify a parameter’s value, you need to define the parameter as in-out parameter. You write an in-out parameter by placing the inout
keyword right before a parameter’s type.
Behind the scenes, an in-out parameter has a value that is passed into the function, is modified by the function, and is passed back out of the function to replace the original value. Therefore the value passed in the function call cannot be a constant. You must declare it as a variable.
The syntax of function with inout parameter is:
func funcname(parameterName:inout Type) -> Return Type { //statements }
Example 12: Function with in out parameter
func process(name:inout String) {
if name == ""{
name = "guest"
}
}
var userName = ""
process(name: &userName)
print(userName)
When you run the above program, the output will be:
guest
In the above program, we have declared a function that accepts inout
parameter name so that the parameter can be changed/altered inside the body of the function.
You must use ampersand (&)
sign directly before a variable’s name when you pass argument to an in-out parameter so that it can be modified by the function.
Disclaimer: The information and code presented within this recipe/tutorial is only for educational and coaching purposes for beginners and developers. Anyone can practice and apply the recipe/tutorial presented here, but the reader is taking full responsibility for his/her actions. The author (content curator) of this recipe (code / program) has made every effort to ensure the accuracy of the information was correct at time of publication. The author (content curator) does not assume and hereby disclaims any liability to any party for any loss, damage, or disruption caused by errors or omissions, whether such errors or omissions result from accident, negligence, or any other cause. The information presented here could also be found in public knowledge domains.
Learn by Coding: v-Tutorials on Applied Machine Learning and Data Science for Beginners
Latest end-to-end Learn by Coding Projects (Jupyter Notebooks) in Python and R:
All Notebooks in One Bundle: Data Science Recipes and Examples in Python & R.
End-to-End Python Machine Learning Recipes & Examples.
End-to-End R Machine Learning Recipes & Examples.
Applied Statistics with R for Beginners and Business Professionals
Data Science and Machine Learning Projects in Python: Tabular Data Analytics
Data Science and Machine Learning Projects in R: Tabular Data Analytics
Python Machine Learning & Data Science Recipes: Learn by Coding
R Machine Learning & Data Science Recipes: Learn by Coding
Comparing Different Machine Learning Algorithms in Python for Classification (FREE)
There are 2000+ End-to-End Python & R Notebooks are available to build Professional Portfolio as a Data Scientist and/or Machine Learning Specialist. All Notebooks are only $29.95. We would like to request you to have a look at the website for FREE the end-to-end notebooks, and then decide whether you would like to purchase or not.