Typescript: Escrevendo Funções e Function Overloading

Parâmetros

Parâmetros obrigatórios

Por padrão, todos os parâmetros são obrigatórios:

function saudar(nome: string, titulo: string): string {
  return `${titulo} ${nome}`;
}

saudar("Yuri");           // ❌ falta titulo
saudar("Yuri", "Dev");    // ✅

Parâmetros opcionais (?)

function saudar(nome: string, titulo?: string): string {
  return titulo ? `${titulo} ${nome}` : nome;
}

saudar("Yuri");           // ✅ "Yuri"
saudar("Yuri", "Dev");    // ✅ "Dev Yuri"

Valor padrão

function paginar(pagina: number, tamanho: number = 10): string {
  return `Página ${pagina}, ${tamanho} itens`;
}

paginar(1);      // ✅ tamanho = 10
paginar(1, 20);  // ✅ tamanho = 20

Diferente do opcional, valor padrão garante que o tipo dentro da função é sempre number — sem undefined.

Rest parameters

function logar(nivel: string, ...mensagens: string[]): void {
  mensagens.forEach(m => console.log(`[${nivel}] ${m}`));
}

logar("INFO", "iniciando", "conectando", "pronto"); // ✅

void — sem retorno

function logar(msg: string): void {
  console.log(msg);
  // não retorna nada
}

never — nunca termina

function falhar(msg: string): never {
  throw new Error(msg);
  // nunca chega ao fim normalmente
}

Útil no assertNever que vimos antes — o compilador sabe que aquele caminho é impossível.

Tipando funções

A ideia central é que funções são valores em JavaScript/TypeScript, e como qualquer valor, elas têm um tipo. Você pode nomear esse tipo e reutilizá-lo.

Sintaxe:

type NomeDoTipo = (parametro: TipoParametro) => TipoRetorno;

É basicamente uma arrow function, mas no nível do tipo — sem corpo, sem implementação.

// ❌ repetitivo — assinatura duplicada em todo lugar
function executar(fn: (valor: string) => boolean, input: string) { ... }
function validar(fn: (valor: string) => boolean, input: string) { ... }
function aplicar(fn: (valor: string) => boolean, input: string) { ... }

// ✅ com type alias — define uma vez, usa em todo lugar
type Validador = (valor: string) => boolean;

function executar(fn: Validador, input: string) { ... }
function validar(fn: Validador, input: string) { ... }
function aplicar(fn: Validador, input: string) { ... }

Function Overloading

Como tipar uma função que retorna tipos diferentes dependendo do input?

function buscar(valor: number | string): Usuario | Usuario[] {
  // ❌ impreciso — TypeScript não sabe qual retorno corresponde a qual input
}

A solução é a sobrecarga (overloading) de assinaturas.

// assinaturas — o que o chamador vê
function buscar(id: number): Usuario;
function buscar(email: string): Usuario[];

// implementação — o que executa de fato (não é visível externamente)
function buscar(valor: number | string): Usuario | Usuario[] {
  if (typeof valor === "number") {
    return buscarPorId(valor);
  }
  return buscarPorEmail(valor);
}

// TypeScript infere o retorno correto por input
const u1 = buscar(1);             // Usuario ✅
const u2 = buscar("[e-mail]"); // Usuario[] ✅

Caso prático

function processar(evento: EventoEFinanceira): Promise<ResultadoEFinanceira>;
function processar(evento: EventoEFDReinf): Promise<ResultadoEFDReinf>;
function processar(
  evento: EventoEFinanceira | EventoEFDReinf
): Promise<ResultadoEFinanceira | ResultadoEFDReinf> {
  if (evento.tipo === "efinanceira") {
    return transmitirEFinanceira(evento);
  }
  return transmitirEFDReinf(evento);
}

// TypeScript infere o retorno exato ✅
const r1 = await processar(eventoFinanceira); // ResultadoEFinanceira
const r2 = await processar(eventoReinf);      // ResultadoEFDReinf