Unlock the Power of Nested Functions in Swift
When it comes to writing efficient and organized code, understanding nested functions in Swift is a game-changer. But before we dive into the world of nested functions, make sure you have a solid grasp of Swift functions.
What Are Nested Functions?
In Swift, a function can exist inside the body of another function. This is called a nested function, and it’s a powerful tool for creating reusable code blocks.
The Syntax of Nested Functions
So, how do we create nested functions in Swift? It’s simple. We define an inner function inside an outer function, just like this:
func function1() {
func function2() {
// inner function code
}
}
Example 1: A Simple Nested Function
Let’s take a look at an example. We’ll create a greetMessage() function with an inner displayName() function.
func greetMessage() {
func displayName() {
print("Hello, John!")
}
displayName()
}
greetMessage()
As you can see, we’re calling the inner displayName() function from within the outer greetMessage() function. But what happens if we try to call the inner function from outside the outer function? That’s right – we’ll get an error message.
Example 2: Nested Functions with Parameters
Now, let’s add some parameters to the mix. We’ll create an addNumbers() function with an inner display() function that takes two parameters, num1 and num2.
func addNumbers() {
func display(num1: Int, num2: Int) {
print("The sum is: \(num1 + num2)")
}
display(num1: 5, num2: 10)
}
addNumbers()
Example 3: Nested Functions with Return Values
Things get really interesting when we start returning values from our nested functions. Let’s create an operate() function with two inner functions, add() and subtract().
func operate(symbol: String) -> (Int, Int) -> Int {
func add(a: Int, b: Int) -> Int {
return a + b
}
func subtract(a: Int, b: Int) -> Int {
return a - b
}
return symbol == "+"? add : subtract
}
let operation = operate(symbol: "+")
print(operation(8, 3)) // outputs 11
As you can see, the outer operate() function returns one of the inner functions based on the value of the symbol parameter. This allows us to call the inner function from outside the outer function using the operation() function.