TypeScript Academy · Aula

Definindo Tipos de Funções Variádicas

Crie APIs flexíveis com tipos de tupla variádicos.

Definindo Tipos de Funções Variádicas é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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 genéricas variádicas

Os tipos de tupla variádica permitem que os genéricos capturem e manipulem listas de argumentos. Isso possibilita utilitários que concatenam tuplas, encaminham parâmetros e remodelam assinaturas de chamada com segurança total de tipos.

Capturando argumentos como uma tupla

Um genérico restrito a unknown[] pode capturar uma lista inteira de argumentos como um tipo de tupla T, preservando o tipo e a posição de cada parâmetro.

function tuple<T extends unknown[]>(...args: T): T {
  return args
}
const t = tuple("a", 1, true) // type [string, number, boolean]
console.log(t)

Propagando uma tupla genérica

Você pode propagar uma tupla genérica capturada para outra lista de parâmetros. Isso encaminha os argumentos preservando seus tipos exatos.

function wrap<T extends unknown[]>(fn: (...args: T) => void) {
  return (...args: T) => fn(...args)
}
const log = wrap((n: number, s: string) => console.log(n, s))
log(1, "hi")

Concatenando duas tuplas

Os tipos de tupla variádica são especialmente úteis ao combinar tuplas. Propagar duas tuplas genéricas em um tipo de retorno produz a concatenação delas.

function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
  return [...a, ...b]
}
const r = concat([1, 2], ["a"]) // [number, number, string]
console.log(r)

Por que o tipo do resultado é preciso

Como [...A, ...B] propaga as tuplas genéricas, o resultado preserva o tipo e a ordem de cada elemento — não apenas um vetor de união ampliado.

function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
  return [...a, ...b]
}
const r = concat([true], [42])
const flag: boolean = r[0]
const num: number = r[1]
console.log(flag, num)

Adicionando um argumento inicial

As tuplas variádicas permitem remodelar listas de parâmetros — por exemplo, criar uma função que adiciona um argumento inicial à assinatura de uma função de retorno de chamada.

function withId<T extends unknown[]>(fn: (...args: T) => void) {
  return (id: number, ...rest: T) => {
    console.log("id", id)
    fn(...rest)
  }
}
const f = withId((msg: string) => console.log(msg))
f(7, "hello")

Extraindo o tipo inicial

Com um parâmetro de tupla, você pode separar o tipo do primeiro elemento e o restante usando uma tupla rotulada e, em seguida, trabalhar com cada parte.

function head<H, T extends unknown[]>(...args: [H, ...T]): H {
  return args[0]
}
const h = head("first", 2, 3) // type string
console.log(h)

Tipo utilitário Parameters

O tipo integrado Parameters<F> extrai a lista de argumentos de uma função como uma tupla — ele próprio construído sobre tipos de tupla variádica. Você pode reutilizar os parâmetros de uma assinatura em outro lugar.

function greet(name: string, age: number) {}
type GreetArgs = Parameters<typeof greet> // [string, number]
const args: GreetArgs = ["Ada", 36]
console.log(args)

Encaminhamento com Parameters

Combine Parameters com uma propagação de resto para criar um encapsulador que encaminha argumentos para uma função existente com tipagem idêntica.

function add(a: number, b: number) { return a + b }
function traced(...args: Parameters<typeof add>): number {
  console.log("calling add", args)
  return add(...args)
}
console.log(traced(2, 3))

Construindo uma assinatura semelhante a curry

As tuplas variádicas permitem criar auxiliares de aplicação parcial: capture alguns argumentos agora, espere os restantes depois e mantenha tudo verificado pelos tipos.

function partial<A extends unknown[], B extends unknown[], R>(
  fn: (...args: [...A, ...B]) => R,
  ...a: A
) {
  return (...b: B) => fn(...a, ...b)
}
const addThree = (x: number, y: number, z: number) => x + y + z
const add5 = partial(addThree, 5)
console.log(add5(2, 3)) // 10

Potência e cautela

Os genéricos de tupla variádica oferecem ferramentas precisas e reutilizáveis para remodelar funções — encapsuladores, encaminhadores e concatenadores. Eles são avançados, portanto use-os quando a precisão dos tipos realmente compensar a complexidade.

function pipe2<A extends unknown[], B, C>(
  f: (...a: A) => B,
  g: (b: B) => C
) {
  return (...a: A) => g(f(...a))
}
const fn = pipe2((n: number) => n * 2, (n) => n + 1)
console.log(fn(5)) // 11

Verificação rápida

Teste sua compreensão dos genéricos de tupla variádica.

Recapitulação

Os tipos de tupla variádica permitem que os genéricos capturem listas de argumentos como tuplas e as propaguem em posições de parâmetros ou de retorno. Isso possibilita a concatenação de tuplas ([...A, ...B]), o encaminhamento de argumentos, a separação entre parte inicial e final e a aplicação parcial — tudo preservando os tipos exatos dos elementos. Tipos integrados como Parameters<F> usam o mesmo mecanismo. Use essas ferramentas quando valer a pena lidar com a complexidade para obter uma tipagem precisa da estrutura da função.

Perguntas Frequentes

A aula “Definindo Tipos de Funções Variádicas” é grátis?

Sim — o texto completo de “Definindo Tipos de Funções Variádicas” é 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 “Definindo Tipos de Funções Variádicas”?

Crie APIs flexíveis com tipos de tupla variádicos. 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 4 de 4.

Quanto tempo leva a aula “Definindo Tipos de Funções Variádicas”?

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