Swift Academy · Aula

Funções puras e design sem efeitos colaterais

Escreva funções que sempre retornam a mesma saída para a mesma entrada.

Aula 1 de 412 etapas

Funções puras e design sem efeitos colaterais é 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.

Boas-vindas

Funções puras sempre produzem a mesma saída para a mesma entrada e não causam efeitos colaterais. Elas são o bloco de construção da programação funcional em Swift.

Definição de uma função pura

Uma função é pura se: • A mesma entrada sempre produz a mesma saída • Não há efeitos colaterais observáveis (nenhuma mutação, entrada/saída ou estado global) ```swift func add(_ a: Int, _ b: Int) -> Int { a + b } // pure ```

Exemplo de função impura

```swift var total = 0 func addToTotal(_ n: Int) { total += n } // impure — mutates global ``` Chamar essa função duas vezes com `5` produz resultados diferentes se ela for chamada em contextos diferentes.

Transparência referencial

Uma chamada de função pura pode ser substituída pelo resultado sem alterar o comportamento do programa: ```swift let result = add(2, 3) // same as writing 5 ```

Benefícios das funções puras

• Fáceis de testar — sem configuração nem desmontagem • Seguras para execução em paralelo — sem estado compartilhado • Componíveis — encadeie-as sem se preocupar com efeitos colaterais • Armazenáveis em cache — a memoização é segura

Tipos de valor do Swift favorecem a pureza

Como os métodos de estruturas recebem cópias, eles tendem naturalmente à pureza: ```swift struct Vector { var x, y: Double } func scaled(_ v: Vector, by f: Double) -> Vector { Vector(x:v.x*f, y:v.y*f) } ```

Isolando efeitos colaterais

Transfira os efeitos colaterais para a fronteira do seu sistema: ```swift // Pure core logic: func processOrders(_ orders: [Order]) -> Invoice { ... } // Impure at the edge: func run() { let inv = processOrders(load()); save(inv) } ```

Funções puras e testes

```swift func test() { let result = add(2, 3) assert(result == 5) // no mocks needed! } ``` Funções puras não precisam de objetos simulados — basta chamá-las e verificar o resultado.

Exemplo do mundo real

```swift func discountedPrice(base: Double, discount: Double) -> Double { base * (1 - discount) } let final = discountedPrice(base: 100, discount: 0.2) // 80.0 ```

Compondo funções puras

```swift func double(_ n: Int) -> Int { n * 2 } func addOne(_ n: Int) -> Int { n + 1 } let transform: (Int) -> Int = { addOne(double($0)) } print(transform(5)) // 11 ```

Verificação rápida

Qual propriedade torna uma função fácil de testar sem objetos simulados?

Responda na aula interativa

Recapitulação

Principais conclusões: • Pura: mesma entrada → mesma saída, sem efeitos colaterais • A transparência referencial permite a substituição • Transfira os efeitos colaterais para as fronteiras do sistema • Funções puras são trivialmente testáveis e podem ser executadas em paralelo Próximo: funções de ordem superior.

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 “Funções puras e design sem efeitos colaterais” é grátis?

Sim — o texto completo de “Funções puras e design sem efeitos colaterais” é 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 “Funções puras e design sem efeitos colaterais”?

Escreva funções que sempre retornam a mesma saída para a mesma entrada. 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 “Funções puras e design sem efeitos colaterais”?

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