Quais são as diferenças entre usar async/await e handlers de conclusão ao trabalhar com código assíncrono?

As principais diferenças entre async/await e os manipuladores de conclusão ao trabalhar com código assíncrono no iOS:

• Sintaxe e legibilidade: async/await permite escrever código assíncrono em estilo sequencial, o que melhora a legibilidade e facilita a depuração. Os manipuladores de conclusão usam closures aninhadas, o que pode levar ao "inferno de callbacks".

• Tratamento de erros: com async/await, pode-se usar o mecanismo habitual try/catch para tratar erros, enquanto nos manipuladores de conclusão, os erros geralmente são passados por parâmetros, exigindo verificações adicionais.

• Compatibilidade: async/await é suportado no Swift a partir da versão 5.5 e iOS 15, enquanto os manipuladores de conclusão funcionam em todas as versões.

Exemplo com async/await:

func fetchData() async throws -> Data {
    let url = URL(string: "https://example.com/data")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

Task {
    do {
        let data = try await fetchData()
        print("Dados recebidos: \(data)")
    } catch {
        print("Erro: \(error)")
    }
}

Exemplo com manipulador de conclusão:

func fetchData(completion: @escaping (Result<Data, Error>) -> Void) {
    let url = URL(string: "https://example.com/data")!
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        if let data = data {
            completion(.success(data))
        }
    }.resume()
}

fetchData { result in
    switch result {
    case .success(let data):
        print("Dados recebidos: \(data)")
    case .failure(let error):
        print("Erro: \(error)")
    }
}

Assim, async/await simplifica o trabalho com código assíncrono, tornando-o mais compreensível e conveniente.