Swift Academy · Aula

Captura de Valores por Referência

Entenda como closures capturam o estado ao redor.

Captura de Valores por Referência é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que closures capturam

Um fechamento captura as variáveis e constantes do escopo ao redor às quais faz referência. As variáveis capturadas são mantidas por referência, então o fechamento vê alterações posteriores.

Capturando uma constante

O fechamento se lembra de greeting mesmo depois que a função retorna:

func makeGreeter() -> () -> String {
    let greeting = "Hello"
    return { greeting }
}
let greet = makeGreeter()
print(greet())  // "Hello"

Capturando uma variável por referência

Como count é mutável, o fechamento altera o mesmo armazenamento entre as chamadas:

func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}
let next = makeCounter()
print(next(), next(), next())  // 1 2 3

Armazenamento compartilhado

Dois closures podem capturar a mesma variável e perceber as alterações um do outro:

func makePair() -> (() -> Void, () -> Int) {
    var value = 0
    let inc = { value += 1 }
    let read = { value }
    return (inc, read)
}
let (inc, read) = makePair()
inc(); inc()
print(read())  // 2

A captura reflete alterações posteriores

O fechamento lê o valor atual da variável no momento da chamada, não o valor que ela tinha quando o fechamento foi criado:

var message = "first"
let show = { print(message) }
message = "second"
show()  // "second"

Captura por referência versus por valor

Por padrão, uma variável mutável é capturada por referência. Se quiser uma cópia congelada do valor no momento da criação, liste-a em uma lista de captura, como [x].

Congelando um valor

Uma lista de captura copia o valor imediatamente:

var n = 10
let frozen = { [n] in n }   // copies 10 now
n = 99
print(frozen())  // 10

Cada fechamento, estado independente

Cada chamada à fábrica cria uma nova variável capturada:

func counter() -> () -> Int {
    var c = 0
    return { c += 1; return c }
}
let a = counter(), b = counter()
print(a(), a(), b())  // 1 2 1

Capturando em um loop

Sem cuidado, os closures em um loop podem compartilhar a mesma variável. Use uma lista de captura para criar uma cópia do estado a cada iteração:

var closures: [() -> Int] = []
for i in 1...3 {
    closures.append { [i] in i }
}
print(closures.map { $0() })  // [1, 2, 3]

Capturando self em um método

Um fechamento criado dentro de um método captura a instância ao redor, permitindo que ele leia e altere propriedades posteriormente:

class Bank {
    var balance = 0
    func deposit() -> () -> Void {
        return { self.balance += 10 }
    }
}
let bank = Bank()
let add = bank.deposit()
add(); add()
print(bank.balance)  // 20

Por que isso importa

A captura por referência dá suporte a contadores, acumuladores e retornos de chamada com estado — mas também significa que um fechamento pode manter objetos vivos, algo que gerenciaremos com listas de captura a seguir.

func accumulator() -> (Int) -> Int {
    var total = 0
    return { total += $0; return total }
}
let add = accumulator()
print(add(10), add(5))  // 10 15

Verificação rápida

Como uma variável mutável é capturada por um fechamento por padrão?

Recapitulação

Você aprendeu a semântica de captura:

Closures capturam as variáveis referenciadas do próprio escopo
Variáveis mutáveis são capturadas por referência — alterações e mutações são compartilhadas
Uma lista de captura [x] congela uma cópia do valor no momento da criação
Isso dá suporte a contadores e retornos de chamada com estado

Próximo: closures escapantes.

Perguntas Frequentes

A aula “Captura de Valores por Referência” é grátis?

Sim — o texto completo de “Captura de Valores por Referência” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Captura de Valores por Referência”?

Entenda como closures capturam o estado ao redor. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Captura de Valores por Referência”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy