Swift - Functions

---

---

A function is a set of statements organized together to perform a specific task. A Swift function can be as simple as a simple C function to as complex as an Objective C language function. It allows us to pass local and global parameter values inside the function calls. Also, we can define a function inside another function to encapsulate its functionality inside another function.

Function plays an important role in structuring code, modularity and increasing code readability. They also provide various features such as parameter labels, default parameter values, variadic parameters, and multiple return types.

Function Definition in Swift

In Swift, a function is defined by the "func" keyword. When a function is newly defined, it may take one or several values as input 'parameters' to the function and it will process the functions in the main body and pass back the values to the functions as output 'return types'.

Every function has a function name, which describes the task that the function performs. To use a function, you "call" that function with its name and pass input values (known as arguments) that match the types of the function's parameters. Function parameters are also called as 'tuples'.

A function's arguments must always be provided in the same order as the function's parameter list and the return values are followed by ->.

Syntax

Following is the syntax for creating a function −

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

Example

Swift program to demonstrate how to create a function.

// Function with return type
func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name:"About Functions"))

Output

It will produce the following output −

First Program
About Functions

Calling a Function in Swift

Calling a function means executing the set of statements present inside the function. We can call a function through its name and at the time of calling it is necessary to provide all the arguments (if available).

Let us suppose we defined a function called 'display' to Consider for example to display the numbers a function with function name 'display' is initialized first with argument 'no1' which holds integer data type.

Then the argument 'no1' is assigned to argument 'a' which hereafter will point to the same data type integer. Now the argument 'a' is returned to the function. Here display() function will hold the integer value and return the integer values every time the function is invoked.

Syntax

Following is the syntax for calling a function −

funcName(parameters)

Example

Swift program to demonstrate how to call a function.

// Creating function
func display(no1: Int) -> Int {
   let a = no1
   return a
}

// Calling function
print(display(no1: 100))
print(display(no1: 200))

Output

It will produce the following output −

100
200

Type of Function Parameters in Swift

Parameters are the variables that are specified in the function declaration to get input when the function is called. Or they allow us to pass values to the function at the time of calling and can perform operations on those values. They are always specified inside the function along with the label, type and value(if available). Swift function supports the following types of parameters −

• Regular Parameters
• Varadic Parameters
• In-Out parameters

Let us discuss all types of parameters in detail.

Regular Parameters

Regular parameters are the most commonly used parameters in the function. They allow us to perform basic operations according to the specified value. A function can have a single or multiple regular parameters. Each regular parameter has its argument label, and explicit type and they are separated by comma.

We can also specify the default value in the regular parameter, which means if we omit that parameter while calling that function, then the default value present in that parameter will used.

Syntax

Following is the syntax for regular parameters −

func funcname(name1: Type, name2:Type = defualtValue) -> returntype {
   Statement
   return value
}

Example

Swift program to demonstrate how to create a function with regular parameters.

// Creating function with regular parameters and default value
func Sum(num1: Int, num2: Int = 2) -> Int {
   var result = 0
   result = num1 + num2
   return result
}

// Calling function 
print("Sum 1:", Sum(num1: 10))
print("Sum 2:", Sum(num1: 20, num2: 12))

Output

It will produce the following output −

Sum 1: 12
Sum 2: 32

Variadic Parameters

Swift provide a special type of parameter named a varadic parameter. The variadic parameter allows us to accept multiple input values of the same type in the function. This parameter is useful when we want to pass an arbitrary number of values of the same type inside the function without specifying the exact count of the values.

A single function can contain multiple variadic parameters and after the first variadic parameter, the next variadic parameters must contain argument labels to distinguish them. The values passed inside the variadic parameters are available as an array in the function. A variadic parameter is not marked as inout.

Syntax

Following is the syntax for variadic parameters −

func funcname(_name1: Type…, name2:Type…, name3: Type…) -> returntype
{
   Statement
   return value
}

Example

Swift program to demonstrate how to create a function with varadic parameters.

// Creating function with variadic parameter 
func Product(_ num: Int...) -> Int {

   var result = 1
   for x in num{
      result *= x
   }
   return result
}

// Calling function and passing multiple values of the same type
print("Product:", Product(10, 20, 30))

Output

It will produce the following output −

Product: 6000

In-Out Parameter

In-Out parameters in Swift provide the functionality to retain the parameter values even though their values are modified after the function call. At the beginning of the function parameter definition, 'inout' keyword is declared to retain the member values.

It derives the keyword 'inout' since its values are passed 'in' to the function and its values are accessed and modified by its function body and it is returned back 'out' of the function to modify the original argument. The in-out parameter does not contain a default value.

Variables are only passed as an argument for in-out parameters since their values alone are modified inside and outside the function. Hence no need to declare strings and literals as in-out parameters. '&' before a variable name refers to that we are passing the argument to the in-out parameter.

Syntax

Following is the syntax for In-Out parameters −

func funcname(_name1: inout Type, _name2: inout Type) -> returntype
{
   Statement
   return value
}

Example

Swift program to demonstrate how to create a function with in-out parameters.

// Function to swap two values
func swap(_ x: inout Int, _ y: inout Int) {
   let temp = x
   x = y
   y = temp
}

var p = 15
var q = 10

print("Before swapping: p = \(p), q = \(q)")

swap(&p, &q)

print("After swapping: p = \(p), q = \(q)")

Output

It will produce the following output −

Before swapping: p = 15, q = 10
After swapping: p = 10, q = 15

Function Argument label and Parameter name in Swift

A function can have labels and names for its arguments and parameters. These labels and names provide a clear and descriptive context for the argument and parameter. The parameter name is used in the declaration of function whereas argument label is used when the function is called.

By default, the argument label and parameter name are the same, but multiple parameters can have the same or unique argument label. The names of the parameters should be unique so that the function can easily distinguish them. We can also omit the argument label by placing the underscore(_) before the name of the parameter.

Syntax

Following is the syntax for the argument label and parameter name −

// Parameter name With argument label
func funcname(argumentLabel parameterName: Type, parameterName: Type) -> returntype {
   Statement
   return value
}
funcname(name1:value, name2: value)

// Parameter name without argument label
func funcname(_name1: Type, _name2: Type) -> returntype {
   Statement
   return value
}
funcname(value1, value2)

Example

Swift program to demonstrate how to specify parameter name and argument label in the function.

// Function 1 with parameter names and argument label
func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   return res
}
print("Power:", pow(firstArg:5, secondArg:3))

// Function 2 with parameter names and without argument label
func product(_ a: Int,  b: Int) -> Int {
   let res = a * b
   return res
}
print("Product:", product(5, b:3))

Output

It will produce the following output −

Power: 125
Product: 15

Parameters and Return Values in Swift

Swift provides flexible function parameters and its return values from simple to complex values. We can create functions in various forms such as −

• Function with parameters

• Function without parameters

• Function with return type

• Function without return type

• Function with optional return type

Let's discuss all the forms of function in detail.

Functions with Parameters

A function is accessed by passing its parameter values to the body of the function. We can pass single or multiple parameter values inside the function and each parameter has its own label so that the compiler can identify which corresponds to which parameter.

Syntax

Following is the syntax for a function with parameters −

func funcname(para1: Type, para2: Type) -> datatype {
   return datatype
}

Example

Swift program to create a function with parameters.

// Function with two parameters
func mult(no1: Int, no2: Int) -> Int {
   return no1 * no2
}

// Calling function
print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

Output

It will produce the following output −

40
45
120

Functions without Parameters

We can also define a function without any parameters. Such types of functions are useful when we want to encapsulate a block of code that does not depend upon any external inputs.

Syntax

Following is the syntax for a function without parameters −

func funcname() -> datatype {
   return datatype
}

Example

Swift program to create a function without parameters.

// Function without parameters
func votersname() -> String {
   return "Alice"
}

// Calling function
print(votersname()) 

Output

It will produce the following output −

Alice

Functions with Return Values

Functions are also used to return string, integer, and float data type values as return types. It can return single or multiple values. If the function returns multiple values then it will use tuple to return multiple values.

Syntax

Following is the syntax for a function with return value −

func funcname(para1: Type, para2: Type) -> datatype {
   return datatype
}

Example

Swift program to create a function that returns a value.

// Function to find out the largest and smallest number in a given array 
func ls(array: [Int]) -> (large: Int, small: Int) { 
   var lar = array[0]
   var sma = array[0]
   
   // Comparing value with its previous value
   for i in array[1..<array.count] 
   {
   
      // If the value is lesser than the previous one it is stored in 'sma' argument
      if i < sma {
         sma = i
      }
      // Otherwise it is stored in 'lar' argument
      else if i > lar {
         lar = i
      }
   }
   
   // Returning multiple values using tuple
   return (lar, sma)
}

let num = ls(array: [40, 12, -5, 78, 98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

Output

It will produce the following output −

Largest number is: 98 and smallest number is: -5

Functions without Return Values

Some functions may have arguments declared inside the function without any return values

Syntax

Following is the syntax for a function without return type −

func funcname(para1: Type, para2: Type){
   return datatype
}

Example

Swift program to create a function that does not return a value.

// Function with parameters but no return type
func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

Output

It will produce the following output −

30 20
50 40
30 24

Functions with Optional Return Types

Swift introduces an 'optional' feature to get rid of problems by introducing a safety measure. 'Optional' is used to check 'nil' or garbage values thereby consuming a lot of time in debugging and making the code efficient and readable for the user.

Consider for example we are declaring function values return type as integer but what will happen when the function returns a string value or a nil value. In that case, the compiler will return an error value. 'optional' is introduced to get rid of these problems.

Optional functions will take two forms 'value' and a 'nil'. We will mention 'Optionals' with the key reserved character '?' to check whether the tuple is returning a value or a nil value.

Example

Swift program to create a function that returns an optional type.

// Function with optional return type
func minMax(array: [Int]) -> (min: Int, max: Int)? {

   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
    
   for value in array[1..<array.count] 
   {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

Output

It will produce the following output −

min is -6 and max is 109

Function Types

In Swift, a function type is used to represent the type of function along with its parameter types and return types. The function type allows us to create, pass and use a function as a variable or parameter in a type-safe manner. Parameter type represents what type of parameter are going to be stored in the function whereas return type represents what type of a value the function will return.

Example

Swift program to demonstrate function type.

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}
print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2:6))

Output

It will produce the following output −

2
6

Assign Function to a variable

Swift functions are first-class citizens. So we are allowed to assign a function to a variable just like we assign a value to a variable. After assigning the function to a variable that variable holds the reference of that function.

Syntax

Following is the syntax for assigning function to a variable −

var addition: (Int, Int) -> Int = sum

Here sum is a function name having 'a' and 'b' integer variables which is now declared as a variable to the function name addition. Hereafter both addition and sum functions both have the same number of arguments declared as integer datatype and also return integer values as references.

Example

Swift program to demonstrate how to assign a function to a variable.

// Function
func sum(a: Int, b: Int) -> Int {
   return a + b
}

// Assigning a function to a variable
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

Output

It will produce the following output −

Result: 129

Function Types as Parameter Types

In Swift, we can use a function type as a parameter type in another function, which means we can pass a function as an argument in another function.

Example

Swift program to demonstrate how to pass a function as a parameter into another function.

// Function type is (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// Function type as a parameter
func Display(_ myOperation: (Int, Int) -> Int, _ p: Int, _ q: Int) -> Int {
   return myOperation(p, q)
}

// Passing function as an argument
let sum = Display(add, 5, 7)

print("Sum: \(sum)")       

Output

It will produce the following output −

Sum: 12

Function Types as Return Types

In Swift, we can use a function type as a return type in another function, which means a function can return from another function.

Example

Swift program to demonstrate how a function returns another function.

// Function type is (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// Display() function will return add() function
func Display()->(Int, Int) -> Int {
   return add
}

let myFunc = Display()
let result = myFunc(9, 2)

print("Sum: \(result)")

Output

It will produce the following output −

Sum: 11