13.11.2024

Aula 16: Closures: Introdução e Sintaxe

Closures em Swift são blocos de funcionalidade autônomos que podem ser atribuídos a variáveis e passados ao longo do seu código. Eles capturam e armazenam referências a quaisquer constantes e variáveis do contexto em que são definidos. Nesta aula, exploraremos a sintaxe e os casos de uso para closures.

O que é um Closure?

Um closure em Swift pode receber parâmetros, retornar valores e capturar valores do contexto ao seu redor. Closures são semelhantes a blocos em C e Objective-C, e a lambdas em outras linguagens de programação.

Sintaxe dos Closures

A sintaxe básica de um closure em Swift é a seguinte:

{ (parâmetros) -> tipoRetorno in
    // corpo do closure
}

Exemplo 1: Closure Simples

Aqui está um exemplo simples de um closure que recebe dois inteiros e retorna sua soma:

let somaClosure = { (a: Int, b: Int) -> Int in
    return a + b
}

// Usando o closure
let resultado = somaClosure(5, 3)
print("A soma é: \(resultado)") // Saída: A soma é: 8

Sintaxe do Closure Trailing

Se um closure for o último argumento de uma função, você pode usar a sintaxe de closure trailing, que permite escrever o closure fora dos parênteses da função.

Exemplo 2: Closure Trailing

Aqui está um exemplo usando uma função que aceita um closure como seu último parâmetro:

func realizarOperacao(em a: Int, e b: Int, operacao: (Int, Int) -> Int) -> Int {
    return operacao(a, b)
}

// Usando a sintaxe de closure trailing
let produto = realizarOperacao(em: 4, e: 5) { (x, y) in
    return x * y
}

print("O produto é: \(produto)") // Saída: O produto é: 20

Closures com Valores Capturados

Closures também podem capturar valores do contexto em que são definidos. Isso significa que eles lembram os valores das variáveis que estavam em escopo quando foram criados.

Exemplo 3: Capturando Valores

func criarIncrementador(incremento: Int) -> () -> Int {
    var total = 0

    let incrementador: () -> Int = {
        total += incremento
        return total
    }

    return incrementador
}

let incrementarPorDois = criarIncrementador(incremento: 2)

print(incrementarPorDois()) // Saída: 2
print(incrementarPorDois()) // Saída: 4

Tipos de Closures

Closures em Swift podem ter diferentes tipos com base em seus parâmetros e valores de retorno. Você pode definir tipos de closures explicitamente se quiser esclarecer as assinaturas de tipo.

Exemplo 4: Tipo de Closure

// Definindo um tipo de closure
typealias OperacaoMatematica = (Int, Int) -> Int

func realizarOperacaoMatematica(_ operacao: OperacaoMatematica, em a: Int, e b: Int) -> Int {
    return operacao(a, b)
}

let divisao: OperacaoMatematica = { (x, y) in
    return x / y
}

let resultadoDivisao = realizarOperacaoMatematica(divisao, em: 8, e: 2)
print("A divisão é: \(resultadoDivisao)") // Saída: A divisão é: 4

Resumo

Nesta aula, cobrimos os conceitos básicos de closures em Swift. Aprendemos sobre sua sintaxe, como utilizar a sintaxe de closure trailing, e como closures capturam valores do contexto ao seu redor. Além disso, exploramos a definição de tipos de closures para melhorar a legibilidade e a estrutura do nosso código.

Closures são um recurso poderoso em Swift que permitem técnicas de programação funcional, possibilitando um código mais limpo, modular e reutilizável. Com prática, você descobrirá que elas são uma ferramenta inestimável no seu arsenal de Swift.

Video

Navigation