Swift Academy · Aula

A Propriedade lazy

Adie o trabalho de transformação até que ele seja necessário.

A Propriedade lazy é 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.

Avaliação imediata por padrão

Os métodos padrão de coleção são imediatos: map, filter etc. são executados imediatamente e criam um novo vetor completo sem demora, mesmo que você leia apenas o first elemento.

O trabalho imediato acontece agora

Isso cria antecipadamente todo o vetor transformado:

let nums = [1, 2, 3, 4, 5]
let doubled = nums.map { $0 * 2 }  // whole array built now
print(doubled.first!)  // 2

A propriedade de avaliação tardia

Toda coleção expõe uma .lazy view. As operações em uma view de avaliação tardia são adiadas: elas não são executadas até que você realmente percorra a coleção ou solicite um elemento específico.

Criando uma view de avaliação tardia

Basta prefixar a cadeia com .lazy:

let nums = [1, 2, 3, 4, 5]
let view = nums.lazy.map { $0 * 2 }
// nothing computed yet
print(Array(view))  // [2, 4, 6, 8, 10]

Comprovando a execução adiada

Os efeitos colaterais mostram que o fechamento só é executado quando necessário:

let nums = [1, 2, 3]
let lazyMapped = nums.lazy.map { n -> Int in
    print("transforming \(n)")
    return n * 2
}
print("created view")
print(lazyMapped.first!)  // prints "transforming 1" then 2

A avaliação tardia retorna um tipo diferente

Uma cadeia de avaliação tardia é um wrapper leve, não um Array:

let nums = [1, 2, 3]
let view = nums.lazy.map { $0 + 1 }
print(type(of: view).self != [Int].self)  // true -- it is a LazyMapSequence

Materializando uma view de avaliação tardia

Converta novamente para um vetor concreto com Array(...) quando precisar armazená-lo ou retorná-lo:

let nums = [1, 2, 3]
let result: [Int] = Array(nums.lazy.map { $0 * 10 })
print(result)  // [10, 20, 30]

Avaliação tardia e first(where:)

A avaliação tardia compensa quando você para cedo. Apenas elementos suficientes são processados para encontrar uma correspondência:

let nums = [1, 2, 3, 4, 5, 6]
let firstBig = nums.lazy.map { $0 * $0 }.first { $0 > 10 }
print(firstBig!)  // 16  (stops at 4*4)

Avaliação tardia sobre um intervalo

Intervalos também funcionam com avaliação tardia, o que é útil para sequências grandes ou praticamente infinitas:

let firstThree = (1...1000).lazy.map { $0 * $0 }.prefix(3)
print(Array(firstThree))  // [1, 4, 9]

Quando a view é reavaliada

Uma view de avaliação tardia recalcula o resultado sempre que você a percorre — ela não armazena resultados. Percorra-a duas vezes e a transformação será executada duas vezes:

var calls = 0
let view = [1, 2].lazy.map { (n: Int) -> Int in calls += 1; return n }
_ = Array(view)
_ = Array(view)
print(calls)  // 4

Quando recorrer à avaliação tardia

Adicione .lazy quando tiver uma cadeia long, mas consumir apenas parte do resultado — a primeira correspondência, um prefixo ou um único reduce. Para vetores pequenos consumidos por completo, a avaliação imediata é mais simples.

let nums = Array(1...100)
let result = nums.lazy.filter { $0 % 7 == 0 }.first
print(result!)  // 7

Verificação rápida

O que a propriedade .lazy muda em map e filter?

Recapitulação

Você aprendeu os fundamentos da avaliação tardia:

Os métodos padrão de coleção são imediatos — eles criam vetores imediatamente
.lazy retorna uma view adiada (um tipo especial de sequência)
O trabalho só acontece quando você percorre a coleção ou solicita um elemento
Concretize com Array(...); as views são executadas novamente a cada percurso

A seguir: cadeias de map e filter com avaliação tardia.

Perguntas Frequentes

A aula “A Propriedade lazy” é grátis?

Sim — o texto completo de “A Propriedade lazy” é 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 “A Propriedade lazy”?

Adie o trabalho de transformação até que ele seja necessário. 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 “A Propriedade lazy”?

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