Swift Academy · Aula

Mapeamento, filtragem e redução de arrays

Transforme arrays com funções funcionais de ordem superior.

Aula 3 de 412 etapas

Mapeamento, filtragem e redução de arrays é 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.

Boas-vindas

As funções de ordem superior do Swift — `map`, `filter` e `reduce` — transformam coleções sem modificá-las. Elas tornam suas intenções explícitas e eliminam laços sujeitos a erros.

Mapear — transformar cada elemento

```swift let nums = [1, 2, 3, 4] let doubled = nums.map { $0 * 2 } // [2,4,6,8] let strings = nums.map { "Item \($0)" } // ["Item 1","Item 2",...] ``` `map` aplica um fechamento a cada elemento e retorna um novo vetor com os resultados.

Filtrar — manter os elementos correspondentes

```swift let scores = [45, 80, 92, 37, 68] let passing = scores.filter { $0 >= 60 } // [80,92,68] let even = (1...10).filter { $0 % 2 == 0 } // [2,4,6,8,10] ``` `filter` retorna um novo vetor contendo somente os elementos para os quais o fechamento retorna `true`.

Reduzir — combinar em um único valor

```swift let nums = [1, 2, 3, 4, 5] let sum = nums.reduce(0) { $0 + $1 } // 15 let product = nums.reduce(1, *) // 120 let joined = ["a","b","c"].reduce("") { $0 + $1 } // "abc" ```

Encadeando map, filter e reduce

```swift let result = (1...10) .filter { $0 % 2 == 0 } // [2,4,6,8,10] .map { $0 * $0 } // [4,16,36,64,100] .reduce(0, +) // 220 ``` O encadeamento é lido da esquerda para a direita, expressando claramente o fluxo de dados.

compactMap — mapear e desempacotar

```swift let strings = ["1","two","3","four","5"] let nums = strings.compactMap { Int($0) } // [1,3,5] ``` `compactMap` transforma os resultados e remove os valores nil — perfeito para conversões que podem falhar.

flatMap — achatar vetores aninhados

```swift let nested = [[1,2,3],[4,5],[6]] let flat = nested.flatMap { $0 } // [1,2,3,4,5,6] let words = ["hello world","foo bar"] let all = words.flatMap { $0.split(separator: " ") } // ["hello","world","foo","bar"] ```

forEach — somente efeitos colaterais

```swift [1, 2, 3].forEach { print($0) } ``` `forEach` é semelhante a um laço `for-in`, mas não permite usar `break` nem `continue`. Use-o somente quando precisar de efeitos colaterais e não precisar interromper a execução antecipadamente.

Reduzir em dicionários

```swift let words = ["apple","banana","apricot","blueberry"] let grouped = words.reduce(into: [Character:[String]]()) { dict, word in let key = word.first! dict[key, default: []].append(word) } // ["a":["apple","apricot"],"b":["banana","blueberry"]] ```

Encadeamentos lazy para desempenho

```swift let lazyResult = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // No intermediate arrays created! ``` Adicione `.lazy` no início de um encadeamento para avaliá-lo sob demanda.

Verificação rápida

Qual função transforma cada elemento e remove os resultados nil?

Responda na aula interativa

Recapitulação

Pontos principais: • `map` — transforma cada elemento em um novo vetor • `filter` — mantém os elementos que correspondem a um predicado • `reduce` — acumula os valores em um único resultado • `compactMap` — transforma e descarta os valores nil • `flatMap` — transforma e achata sequências aninhadas • Encadeie com `.lazy` para evitar alocações intermediárias A seguir: vetores bidimensionais e coleções aninhadas.

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 “Mapeamento, filtragem e redução de arrays” é grátis?

Sim — o texto completo de “Mapeamento, filtragem e redução de arrays” é 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 “Mapeamento, filtragem e redução de arrays”?

Transforme arrays com funções funcionais de ordem superior. 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 “Mapeamento, filtragem e redução de arrays”?

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

Criação e modificação de arrays
Ordenação, busca e divisão em fatias
Mapeamento, filtragem e redução de arrays
Arrays bidimensionais e coleções aninhadas

← Voltar para Swift Academy