The async Keyword in Swift

The async keyword in Swift helps you write code that performs tasks in the background without freezing your app's interface. This post will explain what the async keyword is, how it works, and show you some easy examples to help you understand how to use it in your Swift projects.

1. What is the async Keyword?

The async keyword is used to mark a function as asynchronous. This means the function can perform tasks that take time to complete, like downloading data from the internet, without blocking other code from running.

2. How to Use the async Keyword

When you define an async function, you add the async keyword to the function signature. Here's a basic example:

func fetchUserData() async -> String {
    // Simulate a delay
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    return "User Data"
}        

In this example, fetchUserData is an asynchronous function that waits for one second (simulating a delay) and then returns "User Data".

3. Calling async Functions with await

To call an async function, you use the await keyword. This tells Swift to wait for the async function to complete before continuing.

func displayUserData() async {
    let data = await fetchUserData()
    print(data)
}

// Calling the displayUserData function
Task {
    await displayUserData()
}        

In this example, displayUserData waits for fetchUserData to finish and then prints the result.

4. Using the Task Function

To run asynchronous code from a non-async context, you use the Task function. This creates a new asynchronous context where you can call your async functions.

Here's how you use the Task function:

Task {
    await displayUserData()
}        

The Task function is useful when you need to start asynchronous work from a place in your code that isn’t already marked as async. It allows you to perform background tasks without blocking the main thread.

5. Real-World Examples

Let's see some real-world examples where the async keyword is useful.

Example 1: Fetching Data from the Internet

Imagine you want to get data from a website. Using async makes this easy and clear.

import Foundation

struct User: Decodable {
    let id: Int
    let name: String
}

func fetchUser() async throws -> User {
    let url = URL(string: "https://jsonplaceholder.typicode.com/users/1")!
    let (data, _) = try await URLSession.shared.data(from: url)
    let user = try JSONDecoder().decode(User.self, from: data)
    return user
}

func displayUser() async {
    do {
        let user = try await fetchUser()
        print("User: \(user.name)")
    } catch {
        print("Failed to fetch user: \(error)")
    }
}

// Calling the displayUser function
Task {
    await displayUser()
}        

In this example, fetchUser gets user data from the internet and displayUser prints the user's name.

Example 2: Doing Multiple Things at Once

You can run several async functions at the same time to make your code faster.

func fetchData() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    return "Data"
}

func processData() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    return "Processed Data"
}

func performTasks() async {
    async let data = fetchData()
    async let processedData = processData()
    
    let results = await (data, processedData)
    print("Results: \(results)")
}

// Calling the performTasks function
Task {
    await performTasks()
}        

In this example, performTasks runs fetchData and processData at the same time, waits for both to finish, and then prints the results.

6. Conclusion

The async keyword in Swift makes writing background tasks easier and your code more readable. By marking functions as async and using await to wait for their results, you can handle tasks that take time without blocking your app's main thread. Whether you're downloading data from the internet or running multiple tasks at once, async is a powerful tool for modern Swift programming.

If you found this post informative or learned something new, please give it a like!