Closures: Free iOS Development Tutorial

Topics Covered in This iOS Development Tutorial:

Defining Closures, Working with Parameters & Return Values, Implementing Closures for Callbacks

Exercise Overview

In this exercise, you'll master one of Swift's most powerful features: closures. These self-contained blocks of functionality represent a fundamental shift from traditional function declarations to more flexible, inline code blocks. Closures are essentially anonymous functions—they perform the same operations as named functions but without the formal declaration overhead. This approach not only reduces code verbosity but also enables more expressive and maintainable codebases, particularly when dealing with asynchronous operations and functional programming patterns that have become essential in modern iOS development.

Getting Started

1. Launch Xcode if it isn't already open.

2. If you completed the previous exercise, Car.xcodeproj should still be open. If you closed it, re-open it now.

3. We strongly recommend completing the previous exercises (4A–4B) before proceeding, as they establish the foundational concepts we'll build upon. If you did not complete the previous exercises, follow these steps:

   • Go to File > Open.
   • Navigate to Desktop > Class Files > yourname-iOS App Dev 1 Class > Car Protocols Done and double–click on Car.xcodeproj.

Closures with Returned Values

Let's explore closures through a practical example: calculating fuel costs. Traditional function-based approaches work well, but closures offer a more streamlined solution for simple calculations that don't warrant separate function declarations.

Using conventional methods, you might write a function to calculate gas expenses:

func calculateGas(gallons: Int, price: Int) -> Int {
   return gallons * price
}

var amountOwedForGas = calculateGas(5, price: 3)

However, closures provide a more elegant inline alternative that keeps related logic contained within the scope where it's needed.

1. In the Project Navigator, navigate to ViewController.swift.

2. Inside viewDidLoad, around line 21, create a closure that calculates the gas amount owed (shown in bold):

   mustang.delegate = self
      mustang.start()
   
      var amountOwedForGas = {
   
      }
   }

   Closures follow a specific syntax pattern that mirrors function declarations but with enhanced flexibility. The structure includes parameters, return type, and the in keyword that separates the declaration from the implementation body:

   {(parameters) -> returnType in
      statements
   }

3. Within the curly braces, define the closure signature:

   var amountOwedForGas = {(gallons: Int, price: Int) -> Int in
   
   }

   This syntax creates an anonymous function equivalent to our calculateGas example, but without the overhead of a separate function declaration.

4. Implement the calculation logic within the closure body:

   var amountOwedForGas = {(gallons: Int, price: Int) -> Int in
      return gallons * price
   }

5. Execute the closure by treating the variable as a callable function:

   var amountOwedForGas = {(gallons: Int, price: Int) -> Int in
      return gallons * price
   }
   
   print("The amount you owe for gas is \(amountOwedForGas(5,3))")

   Now let's validate our implementation.

6. At the top right, click the Show the Debug area button if it's not already visible.

7. At the top left of Xcode, click the Run button .

   The simulator will take a moment to load. At this point, it will display a blank white screen.

8. Return to the main Xcode window. Examine the Debug area to confirm the last message reads: The amount you owe for gas is 15

   Perfect! Our closure-based calculation executed successfully.

Closures Used for Callbacks

Closures truly shine when implementing callback patterns—a cornerstone of modern asynchronous programming. Callbacks allow methods to communicate completion status or results back to calling code, enabling responsive and flexible application behavior.

In contemporary iOS development, callbacks handle everything from network requests to user interface updates. Unlike delegates, which require formal protocol declarations, closures provide lightweight, inline callback implementations that keep related code logically grouped and easier to maintain.

1. Let's enhance our Car class with callback functionality. In the Project Navigator, select Car.swift.

2. At the bottom of the Car class, around line 56, add a new method declaration:

   func gasUsed(milesDriven: Float) -> Float {
      let gas = milesDriven / mpg!
      return gas
   }
   
   func accelerateTo(speed: Int) {
   
   }

3. Now incorporate the callback parameters:

   func accelerateTo(speed: Int, success:() -> (), fail: () -> ()) {
   
   }

   This signature demonstrates closure parameter syntax: each callback parameter (success and fail) is defined as a function type that takes no parameters and returns no value. The empty parentheses () indicate void return types, which is standard for status notification callbacks.

4. Implement the conditional logic that determines which callback to execute:

   func accelerateTo(speed: Int, success:() -> (), fail: () -> ()) {
   
      if speed >= 20 {
         success()
      } else {
         fail()
      }
   
   }

   This implementation creates a simple success/failure pattern: speeds of 20 or higher trigger the success callback, while lower speeds trigger the failure callback. In real applications, these conditions might involve complex validation, network operations, or hardware interactions.

5. Now let's implement the callback handling in our view controller. In the Project Navigator, return to ViewController.swift.

6. Add the accelerateTo method call with inline closures:

   print("The amount you owe for gas is \(amountOwedForGas(5,3))")
   
      mustang.accelerateTo(speed: 20, 
         success: {() -> () in
         }, fail: {() -> () in
      })
   }

7. Implement the callback responses with appropriate logging:

   mustang.accelerateTo(speed: 20, 
      success: {() -> () in
         print("We have succeeded")
      }, fail: {() -> () in
         print("We have failed")
   })

   This pattern demonstrates how closures enable clean separation between the triggering action and the response handling, making code more modular and testable.

8. Let's test our callback implementation. At the top right, ensure the Debug area is visible by clicking if necessary.

9. At the top left of Xcode, click the Stop button to halt any running processes.

10. Click the Run button to execute the updated code.

    The simulator will launch momentarily. The display remains a blank white screen as we're focusing on console output.

11. Check the Debug area in the main Xcode window. You should see the message: We have succeeded

    The success callback executed because our speed parameter (20) met the threshold condition we defined earlier.

12. Let's verify the failure path by modifying the speed parameter. In ViewController.swift around line 27, change the speed value from 20 to 10:

    mustang.accelerateTo(speed: 10, 

13. Stop the current execution by clicking the Stop button .

14. Launch the updated code with the Run button .

15. Observe the Debug area output, which should now display:

    We have failed

    The failure callback executed because our speed value (10) fell below the 20-unit threshold, demonstrating how closures provide flexible, condition-based response handling.

16. Save your work and keep Xcode open for the next exercise. You've now implemented both computational closures and callback patterns—essential skills for modern iOS development workflows.