Functions and Closures in Swift

# CHAPTER 6

Functions and Closures in Swift #

1. Introduction #

2. Learning Objectives #

• Define and call basic functions in Swift.

• Create functions that accept external data (Parameters).

• Create functions that output data (Return Values).

• Understand the syntax of Closures (Anonymous Functions).

• Utilize Trailing Closure syntax in modern Swift APIs.

3. What is a Function? #

// 1. Defining the function
func greetUser() {
    print("Welcome back to the application!")
    print("Fetching your data...")
}

// 2. Calling the function (You can do this 100 times!)
greetUser() 

4. Parameters (Inputting Data) #

// This function expects a String to be passed into it!
func sayHello(to name: String) {
    print("Hello, \(name)! Have a great day.")
}

// We must provide the 'to' argument label!
sayHello(to: "Alice")
sayHello(to: "Bob")

Multiple Parameters:

func calculateDamage(baseDamage: Int, multiplier: Int) {
    let total = baseDamage * multiplier
    print("You dealt \(total) damage!")
}

calculateDamage(baseDamage: 20, multiplier: 3)

5. Return Values (Outputting Data) #

// The arrow '-> Int' means this function promises to output an Integer!
func multiply(a: Int, b: Int) -> Int {
    let result = a * b
    return result // The 'return' keyword spits the data back out!
}

// Now we can save the output into a variable!
let finalScore = multiply(a: 5, b: 10)
print(finalScore) // Prints 50

6. What are Closures? #

// Normal Function
func addNumbers(x: Int, y: Int) -> Int { return x + y }

// Closure (Assigned directly to a variable!)
let addClosure = { (x: Int, y: Int) -> Int in
    return x + y
}

// Calling the closure
let sum = addClosure(5, 5)

7. Trailing Closures (SwiftUI Magic) #

// A function that downloads data, then executes a closure when it finishes.
func downloadData(completion: () -> Void) {
    print("Downloading...")
    completion() // Execute the closure!
}

// The old, ugly way to call it:
downloadData(completion: {
    print("Finished!")
})

// The Modern Trailing Closure way! (Look how clean it is!)
downloadData {
    print("Finished!")
}

8. Common Mistakes #

• Forgetting Argument Labels: When calling a function in Swift, you MUST type out the parameter names unless the developer explicitly hid them. calculateDamage(20, 3) will crash the compiler. You must write calculateDamage(baseDamage: 20, multiplier: 3).

• Missing Return Keyword: If your function definition has an arrow -> String, the compiler will refuse to build the app until you actually write return "Some String" inside the function block.

9. Best Practices #

• Single Responsibility Principle: A function should do exactly ONE thing. If your function is named calculateScore, it should only do math. It should NOT also save the score to the database and change the color of the screen. If a function is longer than 20 lines, break it into smaller functions!

10. Exercises #

1. 1. Write a function named sayGoodbye that accepts a name: String parameter and prints "Goodbye, [name]!".

1. 2. Write a function named isEven that accepts a number, and returns a Bool (true if even, false if odd).

11. Coding Challenges #

12. MCQ Quiz with Answers #

13. Interview Questions #

• Q: Explain the purpose of Argument Labels in Swift functions. How can a developer omit an argument label when calling a function using the _ syntax?

• Q: Contrast a standard Function with a Closure. Provide a specific iOS development scenario where a Closure is fundamentally required (e.g., asynchronous networking).

• Q: Describe "Trailing Closure" syntax. Why did Apple heavily optimize this syntax design specifically for the introduction of SwiftUI?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #