0Pricing
Swift Academy · Aula

map e filter Preguiçosos

Encadeie transformações preguiçosas sem arrays intermediários.

map e filter Preguiçosos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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.

Vetores intermediários

Cadeias de avaliação imediata alocam um vetor novo entre cada etapa. filter().map() em um vetor grande cria dois vetores completos, embora você possa querer apenas alguns elementos.

A alocação imediata

Dois vetores intermediários são criados aqui:

let nums = Array(1...6)
let result = nums
    .filter { $0 % 2 == 0 }  // builds [2, 4, 6]
    .map { $0 * 10 }         // builds [20, 40, 60]
print(result)  // [20, 40, 60]

Fundindo etapas com avaliação tardia

Uma cadeia de avaliação tardia funde as operações: cada elemento passa por todas as etapas antes que o próximo elemento comece, portanto nenhum vetor intermediário é alocado.

Uma cadeia de avaliação tardia

A mesma lógica, sem vetores intermediários:

let nums = Array(1...6)
let result = nums.lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * 10 }
print(Array(result))  // [20, 40, 60]

Fluxo elemento a elemento

O rastreamento mostra uma execução intercalada, em vez de uma execução etapa por etapa:

let out = [1, 2, 3].lazy
    .filter { n -> Bool in print("filter \(n)"); return n > 1 }
    .map   { n -> Int  in print("map \(n)");    return n }
print(Array(out))  // filter 1, filter 2, map 2, filter 3, map 3 -> [2, 3]

A saída antecipada economiza trabalho

Combine uma cadeia de avaliação tardia com first(where:) para parar assim que possível:

let nums = Array(1...1_000_000)
let hit = nums.lazy.map { $0 + 1 }.first { $0 > 5 }
print(hit!)  // 6  -- only a handful of elements processed

Avaliação tardia com prefix

Obtenha apenas os primeiros resultados de uma transformação dispendiosa:

let squares = (1...).lazy.map { $0 * $0 }
print(Array(squares.prefix(5)))  // [1, 4, 9, 16, 25]

Contando o trabalho evitado

Um contador comprova quantos poucos elementos são executados:

var transforms = 0
let result = Array(1...100).lazy
    .map { (n: Int) -> Int in transforms += 1; return n * 2 }
    .prefix(3)
_ = Array(result)
print(transforms)  // 3, not 100

compactMap com avaliação tardia

compactMap também tem uma forma com avaliação tardia:

let raw = ["1", "x", "3", "y", "5"]
let first = raw.lazy.compactMap { Int($0) }.first
print(first!)  // 1

Combinando várias etapas

Fluxos de dados longos e fundidos continuam sem alocações até serem concretizados:

let r = Array(1...20).lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }
    .filter { $0 > 50 }
print(Array(r))  // [64, 100, 144, 196, 256, 324, 400]

Quando a fusão ajuda mais

A fusão com avaliação tardia é vantajosa quando a fonte é grande e você mantém apenas parte do resultado. Se consumir tudo em um vetor de qualquer forma, a economia diminui e a avaliação imediata pode ser mais clara.

let big = Array(1...10_000)
let sample = Array(big.lazy.filter { $0 % 1000 == 0 })
print(sample)  // [1000, 2000, ... 10000]

Verificação rápida

O que uma cadeia lazy de filter().map() evita, mas uma cadeia imediata cria?

Recapitulação

Você aprendeu sobre cadeias com avaliação tardia:

  • Cadeias imediatas alocam um vetor entre cada etapa
  • .lazy funde as etapas — elemento a elemento, sem intermediários
  • Combina perfeitamente com first(where:) e prefix para uma saída antecipada
  • Maior vantagem: fonte grande e consumo parcial

A seguir: vantagens e desvantagens da avaliação tardia e imediata.

Perguntas Frequentes

A aula “map e filter Preguiçosos” é grátis?

Sim — o texto completo de “map e filter Preguiçosos” é 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 “map e filter Preguiçosos”?

Encadeie transformações preguiçosas sem arrays intermediários. 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 2 de 4.

Quanto tempo leva a aula “map e filter Preguiçosos”?

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

  1. A Propriedade lazy
  2. map e filter Preguiçosos
  3. Compromissos entre Execução Preguiçosa e Ávida
  4. Construção de Sequências Preguiçosas Personalizadas
← Voltar para Swift Academy