TypeScript Academy · Aula

Funções Puras e Imutabilidade

Escreva funções previsíveis e sem efeitos colaterais.

Aula 1 de 413 etapas

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

O que é uma função pura?

Uma função pura devolve o mesmo resultado para a mesma entrada e não tem efeitos colaterais. Ela não lê nem grava estado externo, não modifica seus argumentos nem realiza operações de entrada e saída.

Um exemplo puro

Esta função depende apenas de seus argumentos e produz somente um valor de retorno. Chamá-la nunca altera nada fora dela.

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

Um exemplo impuro

Esta função lê e modifica uma variável fora do seu escopo, portanto seu resultado depende de um estado oculto e ela deixa um rastro. Isso a torna impura.

let counter = 0;
function next(): number {
  counter += 1; // side effect
  return counter;
}
console.log(next(), next()); // 1 2, depends on history

Transparência referencial

Uma chamada pura é referencialmente transparente: pode substituir a chamada pelo resultado dela sem alterar o programa. add(2, 3) pode ser substituído por 5 em qualquer lugar.

const x = add(2, 3) * 2;
const y = 5 * 2; // identical meaning
console.log(x === y); // true

Por que a pureza ajuda

Funções puras são fáceis de testar, não exigem configuração inicial, podem ser armazenadas em cache com facilidade, são seguras para execução em paralelo e simples de compreender porque não têm dependências ocultas.

Evite modificar os argumentos

Modificar um vetor ou objeto de entrada é um efeito colateral que quem chama talvez não espere. Em vez disso, crie e devolva um valor novo.

// Impure: mutates input
function pushImpure(xs: number[], v: number) { xs.push(v); return xs; }
// Pure: returns a new array
function pushPure(xs: number[], v: number): number[] { return [...xs, v]; }

Atualizações imutáveis com expansão

O operador de expansão copia um objeto ou vetor, permitindo substituir campos sem tocar no original. Ele é a principal ferramenta para atualizações imutáveis em TS.

interface User { name: string; age: number }
function birthday(u: User): User {
  return { ...u, age: u.age + 1 };
}
const before = { name: "Ada", age: 30 };
const after = birthday(before);
console.log(before.age, after.age); // 30 31

Atualizando vetores de forma imutável

Use map, filter e expansão para derivar novos vetores em vez de modificá-los. O vetor original permanece intacto para que outras partes do código possam usá-lo.

const nums = [1, 2, 3];
const doubled = nums.map(n => n * 2);
console.log(nums, doubled); // [1,2,3] [2,4,6]

readonly para segurança

Marcar os parâmetros como readonly informa ao compilador e a quem lê que a função não os modificará, reforçando a pureza no nível dos tipos.

function sum(xs: readonly number[]): number {
  return xs.reduce((a, b) => a + b, 0);
}
console.log(sum([1, 2, 3])); // 6

Levando os efeitos para as extremidades

Programas reais precisam de efeitos, como registro e rede. O estilo funcional mantém o núcleo puro e isola os efeitos nos limites, para que a maior parte do código continue previsível.

Uma lista mental de verificação

Para cada função, pergunte: ela depende apenas das entradas? Devolve somente um valor? Mantém as entradas e o mundo externo inalterados? Três respostas afirmativas significam que ela é pura.

Verificação rápida

Verificação rápida desta lição.

Responda na aula interativa

Recapitulação

Funções puras dependem apenas das entradas e não produzem efeitos colaterais, proporcionando transparência referencial. Use expansão, map/filter e readonly para atualizações imutáveis e leve os efeitos do mundo real para as extremidades do programa.

Grátis para começar

Aprenda TypeScript 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: 101
Aulas: 352

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

Perguntas Frequentes

A aula “Funções Puras e Imutabilidade” é grátis?

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

O que vou aprender em “Funções Puras e Imutabilidade”?

Escreva funções previsíveis e sem efeitos colaterais. Você pratica TypeScript 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 TypeScript Academy?

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

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 TypeScript Academy?

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