TypeScript Academy · Aula

Parâmetros rest e spread com tipos

Defina os tipos dos parâmetros rest e das operações spread

Parâmetros rest e spread com tipos é uma aula grátis de TypeScript 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 TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Boas-vindas

Os parâmetros rest reúnem vários argumentos em uma matriz. O TypeScript tipa o parâmetro rest como uma matriz do tipo dos elementos.

Tipando parâmetros de argumentos restantes

Use a sintaxe `...name: T[]` para um parâmetro de argumentos restantes. Ela captura todos os argumentos restantes como uma matriz.

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

Parâmetros restantes após os obrigatórios

Os parâmetros de argumentos restantes devem ser os últimos. Os outros parâmetros obrigatórios vêm antes deles.

function log(level: string, ...messages: string[]): void {
  console.log(level, messages.join(' '));
}
log('INFO', 'Server', 'started', 'on', 'port', '3000');

Expandindo matrizes em funções

Use a expansão `...` para passar os elementos de uma matriz como argumentos individuais. O TypeScript verifica se o tipo expandido corresponde aos parâmetros.

function add(a: number, b: number): number { return a + b; }
const args: [number, number] = [1, 2];
add(...args); // OK — tuple spread is type-safe

Expandindo matrizes comuns

Expandir uma matriz comum em uma função com parâmetros fixos pode causar um erro, pois o TypeScript não consegue verificar se a quantidade corresponde.

const nums = [1, 2]; // number[] — length unknown
// add(...nums); // Error: spread must match parameters
const pair: [number, number] = [1, 2];
add(...pair); // OK — tuple has known length

Parâmetros restantes versus objeto arguments

Os parâmetros restantes substituem o antigo objeto `arguments`. Eles são matrizes reais com suporte completo de tipos do TypeScript, ao contrário de `arguments`.

Expandindo objetos (não parâmetros restantes)

Expandir um objeto cria uma cópia superficial. O TypeScript infere o tipo combinado do resultado da expansão.

const a = { x: 1, y: 2 };
const b = { z: 3 };
const c = { ...a, ...b }; // { x: number; y: number; z: number }

Substituindo propriedades com expansão

Ao expandir, as propriedades posteriores substituem as anteriores que têm o mesmo nome.

const base = { color: 'red', size: 5 };
const updated = { ...base, color: 'blue' };
// { color: 'blue', size: 5 }

Expansão tipada em matrizes

A expansão de uma matriz cria uma nova matriz. O TypeScript infere o tipo combinado dos elementos.

const a: number[] = [1, 2];
const b: number[] = [3, 4];
const c: number[] = [...a, ...b]; // [1, 2, 3, 4]

Elementos restantes variádicos em tuplas

O TypeScript oferece suporte a elementos restantes em tipos de tupla para padrões variádicos avançados.

type Strings = string[];
type StringsAndNumber = [...Strings, number];
const t: StringsAndNumber = ['a', 'b', 42];

Elementos restantes na desestruturação

Use a sintaxe de elementos restantes na desestruturação para reunir os elementos restantes em uma matriz tipada.

const [first, ...rest]: number[] = [1, 2, 3, 4];
// first: number, rest: number[]

Verificação rápida

Que tipo o TypeScript infere para o parâmetro restante `...items` em `function collect(...items: string[])`?

Recapitulação

Os parâmetros restantes (`...args: T[]`) reúnem os argumentos restantes em uma matriz tipada. Expanda matrizes em funções usando tuplas para garantir a segurança de tipos. Expanda objetos para criar cópias superficiais com tipos combinados inferidos.

Perguntas Frequentes

A aula “Parâmetros rest e spread com tipos” é grátis?

Sim — o texto completo de “Parâmetros rest e spread com tipos” é 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 “Parâmetros rest e spread com tipos”?

Defina os tipos dos parâmetros rest e das operações spread 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 3 de 4.

Quanto tempo leva a aula “Parâmetros rest e spread com tipos”?

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

Anotações de tipos de parâmetros e retornos
Parâmetros opcionais e padrão
Parâmetros rest e spread com tipos
void, never e assinaturas de funções

← Voltar para TypeScript Academy