Guard understanding

Using guard makes your code more readable and simpler. guard is a keyword used for early exit in a function. The concept of early exit means checking conditions at the beginning of a function to determine whether the remaining body of the function needs to be executed or not.

Rules for guard:

1. Know that guard is for early exit.
2. Use guard wherever it fits appropriately.

Let’s look at a simple example. Before creating a user account, we need to verify several things:-The email is valid.-The password meets complexity requirements.-The repeated password matches the original password.

Here’s an example of achieving this with nested if statements:

func createAccount() {
    if email.isValid() {
        if password.isValid() {
            if password == repeatPassword {
                Task {
                    do {
                        try await loginService.createAccount(email: email, password: password)
                    } catch {
                        showError()
                    }
                }
            }
        }
    }
}

If the input is invalid, we also need to display an error message to the user. Here’s the expanded version of the code with error handling:

func createAccount() {
    if email.isValid() {
        if password.isValid() {
            if password == repeatPassword {
                Task {
                    do {
                        try await loginService.createAccount(email: email, password: password)
                    } catch {
                        errorMessage = "Error: \(error.localizedDescription)"
                    }
                }
            } else {
                errorMessage = "Passwords don't match"
            }
        } else {
            errorMessage = "Password must be at least 8 characters, contains numbers and letters"
        }
    } else {
        errorMessage = "Please check email"
    }
}

The code is hard to read, even though the implemented functionality is quite simple. In a real project, the source code is usually much more complex. This kind of approach or style makes the code harder to maintain, increases development time, and raises the likelihood of bugs.Let’s refactor the code using guard. The idea is to verify conditions before proceeding with the main task. This is exactly what guard is designed for:

    func createAccount() {
        guard email.isValid() else {
            errorMessage = "Please check email"
            return
        }
        guard password.isValid() else {
            errorMessage = "Password must be at least 8 characters, contains numbers and letters"
            return
        }
        guard password == repeatPassword else {
            errorMessage = "Passwords don't match"
            return
        }
        Task {
            do {
                try await loginService.createAccount(email: email, password: password)
            } catch {
                errorMessage = "Error: \(error.localizedDescription)"
            }
        }
    }

Explanation of guard logic:

1. guard checks a condition.
2. If the condition is true(means all good for further execution) - the function continues execution.
3. If the condition is false, the code exits early using return.

By applying guard, the code becomes more linear and easier to follow, reducing the need for deeply nested conditions.This approach improves readability, simplifies debugging, and makes the codebase easier to maintain and extend.

SwiftUI’s @ViewBuilder scope

SwiftUI’s @ViewBuilder does not allow the use of guard, so it is not a crime to write ‘if let’ on the entire body of the function.

    @ViewBuilder
    func pointView() -> some View {
        if let point {
            Circle()
                .fill(Color.blue)
                .frame(width: 10, height: 10)
                .position(startLocation)
        }
    }

Real life example

This code

    func handleDrop(provider: NSItemProvider) -> Bool {
        if provider.hasItemConformingToTypeIdentifier(urlType.identifier) {
            provider.loadItem(forTypeIdentifier: urlType.identifier) { (item, error) in
                if let data = item as? Data, let url = URL(dataRepresentation: data, relativeTo: nil) {
                    setupVideo(url)
                }
            }
            return true
        }
        return false
    }

Can be improved

    func handleDrop(provider: NSItemProvider) -> Bool {
        guard provider.hasItemConformingToTypeIdentifier(urlType.identifier) else { return false }
        provider.loadItem(forTypeIdentifier: urlType.identifier) { (item, error) in
            guard let data = item as? Data, let url = URL(dataRepresentation: data, relativeTo: nil) else { return }
            setupVideo(url)
        }
        return true
    }