JavaScript Academy · Aula

Funções puras e efeitos colaterais

Escreva funções previsíveis e fáceis de testar.

Funções puras e efeitos colaterais é uma aula grátis de JavaScript 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 JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.

O que torna uma função pura

Uma função pura tem duas propriedades: com as mesmas entradas, sempre retorna a mesma saída e não causa efeitos colaterais observáveis. Funções puras são previsíveis e fáceis de testar.

function add(a, b) {
  return a + b;
}
console.log(add(2, 3));
console.log(add(2, 3)); // always 5

Saída determinística

A pureza significa determinismo. Os mesmos argumentos sempre devem corresponder ao mesmo resultado, sem depender de estado oculto, do tempo ou da aleatoriedade.

function double(n) {
  return n * 2;
}
console.log(double(10)); // always 20

O que é um efeito colateral

Um efeito colateral é qualquer coisa que uma função faz além de retornar um valor: registrar informações, modificar estado externo, gravar no armazenamento, fazer chamadas de rede ou alterar seus argumentos.

let total = 0;
function impureAdd(n) {
  total += n;     // side effect: mutates outer state
  return total;
}
console.log(impureAdd(5));
console.log(impureAdd(5)); // 5 then 10, not pure

Dependendo de estado externo

Ler estado externo mutável também rompe a pureza, pois a saída muda mesmo quando o argumento permanece igual.

let rate = 1.5;
function priceImpure(x) {
  return x * rate; // depends on outside variable
}
console.log(priceImpure(10)); // 15
rate = 2;
console.log(priceImpure(10)); // 20 - different result

Tornando-a pura

Passe como argumentos tudo de que a função precisa. Agora, o resultado depende apenas das entradas.

function price(x, rate) {
  return x * rate;
}
console.log(price(10, 1.5)); // 15
console.log(price(10, 2));   // 20

Alterar argumentos é impuro

Alterar um objeto ou uma matriz recebida como argumento é um efeito colateral observável pelo chamador. Funções puras não alteram suas entradas.

function impurePush(arr, x) {
  arr.push(x);   // mutates caller array
  return arr;
}
const a = [1, 2];
impurePush(a, 3);
console.log(a); // [1, 2, 3] - caller changed

Retornando novos valores

Uma versão pura cria e retorna um novo valor em vez de modificar a entrada.

function pureAppend(arr, x) {
  return [...arr, x];
}
const a = [1, 2];
const b = pureAppend(a, 3);
console.log(a); // [1, 2] unchanged
console.log(b); // [1, 2, 3]

Por que a pureza ajuda

Funções puras são fáceis de testar (sem configuração inicial, sem simulações), seguras para armazenar em cache (memorizar) e seguras para executar em qualquer ordem ou em paralelo. Elas tornam local o raciocínio sobre o código.

function square(n) { return n * n; }
console.log([1, 2, 3].map(square)); // [1, 4, 9]

Isolando a impureza

Não é possível evitar todos os efeitos colaterais; os aplicativos precisam registrar informações, buscar dados e renderizar. O objetivo é levar os efeitos para as extremidades e manter a lógica central pura.

function computeTotal(items) {
  return items.reduce((s, i) => s + i.price, 0);
}
const total = computeTotal([{ price: 5 }, { price: 7 }]);
console.log(total); // 12 - pure core, log at the edge

Transparência referencial

Uma chamada pura pode ser substituída pelo resultado sem alterar o comportamento. add(2, 3) é intercambiável com 5 em qualquer lugar. Essa propriedade é chamada de transparência referencial.

function add(a, b) { return a + b; }
const x = add(2, 3) + add(2, 3);
const y = 5 + 5;
console.log(x === y); // true

Identificando a impureza

Observe estes indícios: console, Math.random, Date.now, atribuições a variáveis externas ou alteração de argumentos. Qualquer um deles torna a função impura.

function pureRoll(seed) {
  return (seed * 1103515245 + 12345) % 100;
}
console.log(pureRoll(42)); // deterministic, testable

Verificação rápida

Identificando funções puras.

Recapitulação

Funções puras são determinísticas e não têm efeitos colaterais: não fazem mutação externa, não realizam operações de entrada/saída e não alteram argumentos. Passe as dependências como argumentos e retorne novos valores em vez de modificar os existentes. A pureza proporciona facilidade de teste, memorização, transparência referencial e segurança em paralelo. Mantenha o núcleo puro e leve os efeitos para as extremidades.

Perguntas Frequentes

A aula “Funções puras e efeitos colaterais” é grátis?

Sim — o texto completo de “Funções puras e 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 JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.

O que vou aprender em “Funções puras e efeitos colaterais”?

Escreva funções previsíveis e fáceis de testar. Você pratica JavaScript 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 JavaScript Academy?

Nenhuma experiência prévia é necessária. JavaScript 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 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 JavaScript Academy?

Sim. Cada aula de JavaScript 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

← Voltar para JavaScript Academy