Swift Academy · Aula

Compromissos entre Execução Preguiçosa e Ávida

Saiba quando a execução preguiçosa ajuda ou prejudica.

Compromissos entre Execução Preguiçosa e Ávida é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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.

Não existe almoço grátis

A avaliação preguiçosa nem sempre é mais rápida. Ela troca a alocação antecipada por sobrecarga a cada acesso e altera quando os efeitos colaterais são executados. Conhecer essas compensações permite escolher corretamente.

A avaliação preguiçosa vence: consumo parcial

É necessária apenas uma fatia de uma transformação enorme — a avaliação preguiçosa ignora o restante:

let data = Array(1...1_000_000)
let top = data.lazy.map { $0 * 2 }.prefix(3)
print(Array(top))  // [2, 4, 6]  -- 999,997 transforms skipped

eager vence: reutilização completa

Se você percorrer o resultado muitas vezes, eager calcula uma vez; a avaliação preguiçosa recalcula a cada passagem:

let doubled = [1, 2, 3].map { $0 * 2 }  // computed once
print(doubled.reduce(0, +))  // 12
print(doubled.max()!)        // 6  -- no recompute

A avaliação preguiçosa recalcula

A mesma visualização preguiçosa refaz o trabalho a cada iteração:

var work = 0
let view = [1, 2, 3].lazy.map { (n: Int) -> Int in work += 1; return n }
_ = view.reduce(0, +)
_ = view.max()
print(work)  // 6  -- transformed twice

Sobrecarga por elemento

Cada etapa preguiçosa envolve a sequência em outro tipo e chama closures elemento por elemento. Para vetores minúsculos, essa sobrecarga pode superar a alocação economizada.

Vetor pequeno: eager é adequado

Para poucos elementos consumidos integralmente, prefira o eager simples — ele é mais simples e a alocação é trivial:

let nums = [3, 1, 2]
let sorted = nums.map { $0 + 1 }.sorted()
print(sorted)  // [2, 3, 4]

O momento dos efeitos colaterais difere

Com a avaliação preguiçosa, o corpo do fechamento é executado depois da linha que o define. Evite depender de efeitos colaterais dentro de transformações preguiçosas:

var log: [Int] = []
let v = [1, 2].lazy.map { (n: Int) -> Int in log.append(n); return n }
print(log)        // []  -- nothing ran yet
_ = Array(v)
print(log)        // [1, 2]

Operações que exigem eager

Algumas operações precisam ler toda a sequência de qualquer forma, então a avaliação preguiçosa não traz benefício nesse caso:

let nums = Array(1...10)
print(nums.lazy.map { $0 * 2 }.sorted())  // sorted must see all -> [2,4,...,20]
print(nums.lazy.map { $0 }.count)         // count walks everything

Avaliação preguiçosa com verificação de inclusão

Operações de curto-circuito, como contains(where:), se beneficiam da avaliação preguiçosa com entradas grandes:

let big = Array(1...1_000_000)
let found = big.lazy.map { $0 * 2 }.contains { $0 == 8 }
print(found)  // true  -- stops at element 4

Uma lista de verificação para decidir

Use a avaliação preguiçosa quando: a fonte for grande AND você mantiver apenas uma parte (prefix / first / verificação de inclusão) AND fizer uma única iteração. Use eager quando: o vetor for pequeno, você reutilizar o resultado ou a legibilidade for mais importante que uma micro-otimização.

let huge = Array(1...100_000)
let first = huge.lazy.filter { $0 % 9973 == 0 }.first
print(first!)  // 9973

Meça, não suponha

A intuição sobre desempenho costuma estar errada. Quando isso for importante, compare as duas versões com dados realistas antes de optar pela avaliação preguiçosa.

let nums = Array(1...50)
let eager = nums.filter { $0 > 25 }.count
let lazyC = nums.lazy.filter { $0 > 25 }.count
print(eager == lazyC)  // true -- same answer, profile for speed

Verificação rápida

Quando eager é uma escolha melhor do que a avaliação preguiçosa?

Recapitulação

Você aprendeu as compensações:

A avaliação preguiçosa vence com fontes grandes e consumo parcial em uma única passagem
eager vence para vetores pequenos e resultados reutilizados (a avaliação preguiçosa recalcula)
Os efeitos colaterais em transformações preguiçosas são executados mais tarde — evite depender deles
Meça antes de otimizar

Próximo: criando sequências preguiçosas personalizadas.

Perguntas Frequentes

A aula “Compromissos entre Execução Preguiçosa e Ávida” é grátis?

Sim — o texto completo de “Compromissos entre Execução Preguiçosa e Ávida” é 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 “Compromissos entre Execução Preguiçosa e Ávida”?

Saiba quando a execução preguiçosa ajuda ou prejudica. 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 3 de 4.

Quanto tempo leva a aula “Compromissos entre Execução Preguiçosa e Ávida”?

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

A Propriedade lazy
map e filter Preguiçosos
Compromissos entre Execução Preguiçosa e Ávida
Construção de Sequências Preguiçosas Personalizadas

← Voltar para Swift Academy