Swift Academy · Aula

Sequências preguiçosas para maior eficiência

Use .lazy para adiar o cálculo e evitar a criação de matrizes intermediárias.

Aula 4 de 412 etapas

Sequências preguiçosas para maior eficiência é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Boas-vindas

As sequências preguiçosas adiam o cálculo até que os resultados sejam necessários, evitando a criação de matrizes intermediárias ao encadear operações.

O problema da avaliação imediata

```swift let result = (1...1_000_000) .filter { $0 % 7 == 0 } // creates array of ~142857 elements .map { $0 * 2 } // creates another 142857-element array .prefix(5) // Wasteful — only 5 elements needed! ```

Adicionando .lazy

```swift let result = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // Only computes what prefix(5) needs — no intermediate arrays! print(Array(result)) // [14,28,42,56,70] ```

Tipos de coleções preguiçosas

Ao chamar `.lazy` em uma sequência, o Swift retorna uma `LazySequence` que a envolve: ```swift let lazyArr = [1,2,3].lazy // LazySequence<[Int]> let lazyMap = lazyArr.map { $0*2 } // LazyMapSequence ```

Quando a avaliação preguiçosa é vantajosa

A avaliação preguiçosa é vantajosa quando: • Você precisa apenas de um prefixo de uma sequência grande • A fonte é infinita (geradores personalizados) • Você encadeia muitas transformações em coleções grandes

Sequências infinitas

```swift struct Fibonacci: Sequence { func makeIterator() -> some IteratorProtocol { var a = 0, b = 1 return AnyIterator { let next = a; a = b; b = next + b; return next } } } let first10 = Array(Fibonacci().prefix(10)) ```

Avaliação preguiçosa com first(where:)

```swift let firstEven = (1...Int.max) .lazy .first { $0 % 2 == 0 } // Returns 2 immediately — doesn't iterate the whole range ```

Forçando a avaliação

Para materializar uma sequência preguiçosa, envolva-a em Array: ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

A avaliação preguiçosa nem sempre é vantajosa

Para coleções pequenas, a avaliação preguiçosa gera sobrecarga devido aos tipos de invólucro. Compare o desempenho antes de aplicar `.lazy` a todas as cadeias. Use-a quando a coleção for grande e você precisar encerrar o processamento antecipadamente.

Gerador preguiçoso personalizado

```swift func naturals() -> AnyIterator { var n = 0 return AnyIterator { n += 1; return n } } Array(naturals().prefix(5)) // [1,2,3,4,5] ```

Verificação rápida

O que o prefixo `.lazy` em uma cadeia de operações sobre uma coleção faz?

Responda na aula interativa

Recapitulação

Principais conclusões: • `.lazy` adia o cálculo de map/filter até o consumo • Evita alocações de matrizes intermediárias • É útil para sequências grandes quando apenas um prefixo é necessário • Combine com `prefix`, `first(where:)` para encerrar o processamento antecipadamente • Materialize com `Array(lazySeq)` quando necessário Curso concluído!

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Sequências preguiçosas para maior eficiência” é grátis?

Sim — o texto completo de “Sequências preguiçosas para maior eficiê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 “Sequências preguiçosas para maior eficiência”?

Use .lazy para adiar o cálculo e evitar a criação de matrizes intermediárias. 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 4 de 4.

Quanto tempo leva a aula “Sequências preguiçosas para maior eficiê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

Funções puras e design sem efeitos colaterais
Funções de ordem superior: map, flatMap, compactMap
Composição de funções e pipelines
Sequências preguiçosas para maior eficiência

← Voltar para Swift Academy