如何让checkUsername函数等待Firebase数据库异步回调完成后再返回结果？

Hey there! Let's break down why your current code isn't working as expected, then walk through two solid solutions to get it right.

The Root Cause: Asynchronous Operations #

Firebase's observeSingleEvent(of:with:) is an asynchronous method. That means when you call it, it immediately fires off a network request to the database and returns right away—before the request finishes. Your function then returns the initial value of available (which is true) long before the closure runs and updates available to false.

Put simply: Your return statement runs first, the Firebase callback runs later. That's why you always get true even when the username is already taken.

Solution 1: Use a Completion Handler (Traditional Approach) #

Instead of trying to return a value directly, we'll use a completion closure. This lets us pass the result back after the Firebase request finishes processing.

Here's the revised function:

func checkUsername(username: String, completion: @escaping (Bool) -> Void) {
    Database.database().reference().child("usernames").child(username).observeSingleEvent(of: .value) { snapshot in
        // If the snapshot exists, username is NOT available (return false)
        // If it doesn't exist, username IS available (return true)
        completion(!snapshot.exists())
    }
}

How to Use It:

Call the function and handle the result inside the completion closure:

checkUsername(username: "myDesiredUsername") { isAvailable in
    print("Is username available? \(isAvailable)")
    
    // Update your UI or logic here (always use main thread for UI changes!)
    DispatchQueue.main.async {
        if isAvailable {
            // Let the user proceed with registration
        } else {
            // Show an alert saying "Username is already taken"
        }
    }
}

Solution 2: Use Async/Await (Modern Swift 5.5+) #

If you're using Swift 5.5 or later, Firebase supports async/await for database operations. This makes your async code look and behave more like synchronous code, avoiding callback "hell" and making it easier to read.

Here's the async version of your function:

func checkUsername(username: String) async -> Bool {
    do {
        // Wait for the database request to complete before moving on
        let snapshot = try await Database.database().reference().child("usernames").child(username).getData()
        return !snapshot.exists()
    } catch {
        print("Error checking username availability: \(error)")
        // Handle the error (you might return false or rethrow based on your needs)
        return false
    }
}

How to Use It:

Call the function inside a Task (since async functions can only be called from other async contexts or tasks):

Task {
    let isAvailable = await checkUsername(username: "myDesiredUsername")
    print("Is username available? \(isAvailable)")
    
    // Update UI on the main thread if needed
    DispatchQueue.main.async {
        if isAvailable {
            // Proceed with registration flow
        } else {
            // Notify user the username is taken
        }
    }
}

Key Takeaways #

• Asynchronous operations like Firebase database calls don't block the main thread (great for app performance), but they mean you can't rely on returning values immediately.
• Completion handlers are a reliable, backward-compatible way to handle async results.
• Async/await simplifies async code and makes it more readable if you're working with modern Swift versions.

内容的提问来源于stack exchange，提问作者David