Functions and closures in iOS Swift

Introduction

Functions and closures help you organize your code into reusable blocks. They make your app easier to read and maintain.

When you want to perform a task multiple times without rewriting code.

When you want to pass a small piece of code as a parameter to another function.

When you want to keep your code clean by grouping related actions.

When you want to create quick, temporary functions without naming them.

When you want to handle events like button taps or animations.

Syntax

iOS Swift

func functionName(parameters) -> ReturnType {
    // code to execute
}

let closureName = { (parameters) -> ReturnType in
    // code to execute
}

A function has a name and can be called anywhere in your code.

A closure is like a function without a name and can be stored in variables or passed around.

Examples

This function takes a name and returns a greeting message.

iOS Swift

func greet(name: String) -> String {
    return "Hello, \(name)!"
}

This closure does the same as the function but is stored in a variable.

iOS Swift

let sayHello = { (name: String) -> String in
    return "Hi, \(name)!"
}

This function takes a closure as a parameter and runs it.

iOS Swift

func perform(action: () -> Void) {
    action()
}

perform {
    print("Action performed!")
}

Sample App

This SwiftUI app shows how to use a function and a closure to create greeting messages. The function greet and the closure sayGoodbye both take a name and return a message. The messages are shown on the screen.

iOS Swift

import SwiftUI

struct ContentView: View {
    // Function that returns a greeting
    func greet(name: String) -> String {
        return "Hello, \(name)!"
    }

    // Closure that returns a farewell
    let sayGoodbye = { (name: String) -> String in
        return "Goodbye, \(name)!"
    }

    var body: some View {
        VStack(spacing: 20) {
            Text(greet(name: "Alice"))
                .font(.title)
            Text(sayGoodbye("Bob"))
                .font(.title)
        }
        .padding()
    }
}

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

Important Notes

Functions and closures can capture values from their surroundings, which means they remember variables used inside them.

Closures can be written in a shorter form called trailing closure syntax when passed as the last parameter.

Use descriptive names for functions to make your code easier to understand.

Summary

Functions have names and are reusable blocks of code.

Closures are unnamed functions that can be stored or passed around.

Both help keep your app organized and your code clean.

Practice

1. What is a closure in Swift?
func greet() { print("Hello") }

easy

A. An unnamed block of code that can be stored and passed around

B. A named function that cannot be reused

C. A variable that holds a number

D. A type of loop

Solution

1. Step 1: Understand closure definition

   A closure is a block of code without a name that can be saved and used later.

2. Step 2: Compare with function

   Functions have names, closures do not but both can be reused.

3. Final Answer:

   An unnamed block of code that can be stored and passed around -> Option A

4. Quick Check:

   Closure = unnamed reusable code block [OK]

Hint: Closures are like functions without names [OK]

Common Mistakes:

• Confusing closures with variables
• Thinking closures must have names
• Mixing closures with loops

2. Which of the following is the correct syntax to declare a closure that takes no parameters and returns an Int?

easy

A. let closure = (Int) -> { return 5 }

B. let closure = { () -> Int in return 5 }

C. let closure = func() -> Int { return 5 }

D. func closure() -> Int { return 5 }

Solution

1. Step 1: Identify closure syntax

   Closures use curly braces with parameters and return type before 'in'.

2. Step 2: Check each option

   'let closure = { () -> Int in return 5 }' matches closure syntax. 'func closure() -> Int { return 5 }' declares a named function. 'let closure = func() -> Int { return 5 }' uses invalid syntax. 'let closure = (Int) -> { return 5 }' lacks 'in' keyword and has wrong parameter placement.

3. Final Answer:

   let closure = { () -> Int in return 5 } -> Option B

4. Quick Check:

   Closure syntax = curly braces + 'in' [OK]

Hint: Closures use braces and 'in' keyword [OK]

Common Mistakes:

• Using func keyword inside closure
• Missing 'in' keyword
• Wrong parameter syntax

3. What will be printed by this Swift code?

let multiply = { (a: Int, b: Int) -> Int in
  return a * b
}
print(multiply(3, 4))

medium

A. 34

B. 7

C. 12

D. Error

Solution

1. Step 1: Understand closure parameters and return

   The closure takes two Ints and returns their product.

2. Step 2: Calculate multiply(3, 4)

   3 * 4 equals 12, so print outputs 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   3 times 4 = 12 [OK]

Hint: Closures return calculated values like functions [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Syntax errors in closure call

4. Identify the error in this closure declaration:

let add = { (a: Int, b: Int) Int in
  return a + b
}

medium

A. Missing '->' before return type

B. Missing 'in' keyword

C. Parameters should not have types

D. Closure cannot return Int

Solution

1. Step 1: Check closure signature syntax

   Return type must be preceded by '->' in closure signature.

2. Step 2: Identify missing arrow

   Code has '(a: Int, b: Int) Int' but should be '(a: Int, b: Int) -> Int'.

3. Final Answer:

   Missing '->' before return type -> Option A

4. Quick Check:

   Closure return type needs '->' [OK]

Hint: Return type needs '->' before it in closures [OK]

Common Mistakes:

• Omitting '->' in closure signature
• Placing 'in' incorrectly
• Removing parameter types

5. You want to sort an array of names alphabetically using a closure. Which code correctly uses a closure with the sorted(by:) method?

hard

A. let sortedNames = names.sorted(by: { s1, s2 -> Bool { return s1 > s2 } })

B. let sortedNames = names.sorted(by: { s1, s2 in s1 + s2 })

C. let sortedNames = names.sorted(by: (s1, s2) -> s1 < s2)

D. let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 })

Solution

1. Step 1: Understand sorted(by:) closure

   It expects a closure that returns true if first element should come before second.

2. Step 2: Check each option

   'let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 })' returns true when s1 < s2 (correct for ascending alphabetical order). The version with s1 > s2 sorts descending. The version with (s1, s2) -> s1 < s2 uses invalid syntax without braces or 'in'. The version with s1 + s2 returns String, not Bool.

3. Final Answer:

   let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 }) -> Option D

4. Quick Check:

   sorted(by:) needs Bool-returning closure [OK]

Hint: sorted(by:) needs closure returning true/false [OK]

Common Mistakes:

• Returning wrong type from closure
• Using wrong comparison operator
• Incorrect closure syntax