TypeScript Academy · Aula

Parâmetros Rest em Funções

Defina os tipos de funções que aceitam qualquer quantidade de argumentos.

Parâmetros Rest em Funções é 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.

Funções com Muitos Argumentos

Parâmetros de argumentos restantes permitem que uma função aceite qualquer quantidade de argumentos, reunidos em um único vetor. O TypeScript tipa esse vetor, oferecendo segurança mesmo em chamadas com quantidades variáveis de argumentos.

Parâmetro Básico de Argumentos Restantes

Prefixe o último parâmetro com ... e forneça a ele um tipo de vetor. Dentro da função, ele se comporta como um vetor comum.

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

Chamar sem Argumentos

Um parâmetro de argumentos restantes pode corresponder a zero argumentos — o vetor fica simplesmente vazio. Não é necessário nenhum tratamento especial para o caso sem argumentos.

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

Argumentos Restantes após Parâmetros Fixos

Um parâmetro de argumentos restantes pode vir depois de parâmetros fixos, mas deve ser o último. Os parâmetros fixos são vinculados primeiro; tudo o que sobra vai para o vetor de argumentos restantes.

function join(separator: string, ...parts: string[]): string {
  return parts.join(separator)
}
console.log(join("-", "a", "b", "c")) // a-b-c

Apenas um Parâmetro Restante, Sempre por Último

Você pode ter no máximo um parâmetro de argumentos restantes, e nada pode vir depois dele. Colocar um parâmetro após o restante causa um erro de sintaxe.

// function bad(...nums: number[], last: number) {} // Error
function ok(first: number, ...rest: number[]) {
  return first + rest.length
}
console.log(ok(10, 1, 2)) // 12

Restrições de Tipo dos Elementos

O tipo dos elementos do vetor de argumentos restantes restringe todos os argumentos. Passar um tipo incorreto é detectado no momento da compilação.

function tags(...labels: string[]): string {
  return labels.join(",")
}
console.log(tags("a", "b"))
// tags("a", 5) // Error: 5 is not a string

Argumentos Restantes com Tipo de União

O tipo dos elementos pode ser uma união, permitindo argumentos de tipos mistos. Dentro da função, determine o tipo de cada item antes de usá-lo.

function show(...items: (string | number)[]): string {
  return items.map(String).join(" ")
}
console.log(show("x", 1, "y", 2)) // x 1 y 2

Argumentos Restantes com Tipos de Tupla

Um parâmetro de argumentos restantes pode ser tipado como uma tupla para descrever uma estrutura fixa seguida de uma quantidade variável de elementos. Aqui, o primeiro argumento é uma cadeia de caracteres, seguido por qualquer quantidade de números.

function record(...args: [string, ...number[]]): string {
  const [label, ...values] = args
  return label + ": " + values.join(",")
}
console.log(record("scores", 9, 8, 7))

Restante de Tupla Impõe a Cardinalidade

Com um tipo de tupla para os argumentos restantes, os elementos iniciais são obrigatórios. Omitir o primeiro argumento obrigatório causa um erro de compilação — uma restrição mais forte que a de um vetor comum.

function record(...args: [string, ...number[]]): number {
  return args.length
}
console.log(record("x")) // 1
// record() // Error: missing string argument

Expandir em uma Chamada com Argumentos Restantes

Você pode passar um vetor existente para um parâmetro de argumentos restantes usando a expansão no local da chamada. O tipo dos elementos do vetor deve corresponder ao do parâmetro.

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

Argumentos Restantes na Prática

Parâmetros de argumentos restantes dão suporte a auxiliares de registro, formatadores e utilitários matemáticos — tudo o que lida com uma quantidade variável de entradas usando um tipo compartilhado ou estruturado.

function max(first: number, ...rest: number[]): number {
  return rest.reduce((m, n) => (n > m ? n : m), first)
}
console.log(max(3, 7, 2, 9, 1)) // 9

Verificação rápida

Teste sua compreensão sobre parâmetros tipados de argumentos restantes.

Recapitulação

Parâmetros de argumentos restantes usam ... no último parâmetro para reunir argumentos extras em um vetor tipado. Eles devem estar por último, e pode haver apenas um. Tipá-los como um vetor simples, um vetor de união ou uma tupla permite expressar estruturas fixas seguidas de uma quantidade variável de elementos e impor a cardinalidade. Expanda um vetor existente no local da chamada para fornecê-lo a um parâmetro de argumentos restantes.

Perguntas Frequentes

A aula “Parâmetros Rest em Funções” é grátis?

Sim — o texto completo de “Parâmetros Rest em Funções” é 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 em Funções”?

Defina os tipos de funções que aceitam qualquer quantidade de argumentos. 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 “Parâmetros Rest em Funções”?

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