TypeScript Academy · Aula

Definições de Tipos Recursivos

Escreva tipos que façam referência a si mesmos com segurança.

Definições de Tipos Recursivos é 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 É um Tipo Recursivo

Um tipo recursivo é um tipo que faz referência a si mesmo em sua própria definição. Isso permite descrever estruturas de dados com profundidade ilimitada.

type LinkedList<T> = {
  value: T;
  next: LinkedList<T> | null;
};
// next is the same type again, ending at null.

Um Tipo de Lista Encadeada

O exemplo clássico: cada nó contém um value e um ponteiro next para outro nó, ou null para encerrar a chain.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const list: LinkedList<number> = {
  value: 1,
  next: { value: 2, next: null }
};
console.log(list.value, list.next?.value);

O Caso Base É Importante

Todo tipo recursivo precisa de um terminador, neste caso null, para que a recursão possa terminar. Sem ele, o tipo teria profundidade infinita.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const single: LinkedList<string> = { value: "only", next: null };
console.log(single.next);

Criando Chains Mais Longas

Você pode aninhar quantos níveis quiser; o tipo permite qualquer comprimento porque next é uma lista ou nulo.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const chain: LinkedList<number> = {
  value: 10,
  next: { value: 20, next: { value: 30, next: null } }
};
console.log(chain.next?.next?.value);

Percorrendo uma Lista Encadeada

Uma função pode percorrer a chain seguindo next até chegar a null. O tipo recursivo torna isso totalmente seguro em relação aos tipos.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function toArray<T>(list: LinkedList<T> | null): T[] {
  const out: T[] = [];
  let cur = list;
  while (cur) { out.push(cur.value); cur = cur.next; }
  return out;
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(toArray(l));

Funções Recursivas sobre Tipos Recursivos

Tipos recursivos combinam naturalmente com funções recursivas. Aqui, calculamos o comprimento fazendo recursão sobre next.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function length<T>(list: LinkedList<T> | null): number {
  return list === null ? 0 : 1 + length(list.next);
}
const l: LinkedList<string> = { value: "a", next: { value: "b", next: null } };
console.log(length(l));

Adicionando no Início de uma Lista

Como o tipo é uniforme, criar novas listas é fácil: envolva uma lista existente como o next de um novo nó inicial.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function prepend<T>(value: T, list: LinkedList<T> | null): LinkedList<T> {
  return { value, next: list };
}
const l = prepend(1, prepend(2, null));
console.log(l.value, l.next?.value);

Terminadores Opcionais ou Nulos

Você pode terminar com null ou tornar next opcional. Ambos encerram a recursão; escolha com base na forma como deseja representar o fim.

type ListA<T> = { value: T; next: ListA<T> | null };
type ListB<T> = { value: T; next?: ListB<T> };
const a: ListA<number> = { value: 1, next: null };
const b: ListB<number> = { value: 1 };
console.log(a.value, b.value);

Tipos Recursivos São Preguiçosos

TypeScript só expande um tipo recursivo até onde você realmente o utiliza. A definição pode fazer referência a si mesma sem causar trabalho infinito.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
// Using two levels only expands two levels.
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(l.next?.value);

Mapeando uma Lista

Um map recursivo transforma cada valor preservando a estrutura e retorna uma nova lista com a mesma forma.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function mapList<T, U>(list: LinkedList<T> | null, fn: (v: T) => U): LinkedList<U> | null {
  if (list === null) return null;
  return { value: fn(list.value), next: mapList(list.next, fn) };
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(mapList(l, x => x * 10)?.value);

Por Que Tipos Recursivos São Poderosos

Tipos que fazem referência a si mesmos permitem modelar dados aninhados arbitrariamente, listas, árvores e JSON, com segurança de tipos completa e sem um limite fixo de profundidade no design.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<boolean> = { value: true, next: { value: false, next: null } };
console.log(l.value, l.next?.value);

Verificação Rápida: Tipos Recursivos

Teste sua compreensão das definições de tipos recursivos.

Recapitulação: Definições de Tipos Recursivos

Você aprendeu que um tipo recursivo faz referência a si mesmo, precisa de um caso base como null para terminar e combina naturalmente com funções recursivas para percorrer, mapear e criar listas encadeadas.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<number> = { value: 1, next: null };
console.log(l.value);

Perguntas Frequentes

A aula “Definições de Tipos Recursivos” é grátis?

Sim — o texto completo de “Definições de Tipos Recursivos” é 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 “Definições de Tipos Recursivos”?

Escreva tipos que façam referência a si mesmos com segurança. 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 “Definições de Tipos Recursivos”?

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