Tipagem de Funções no TypeScript: Parâmetros, Retornos e Rest
Domine a anatomia completa das funções no TypeScript: aprenda a tipar parâmetros formais e retornos, declare argumentos opcionais e valores padrão, manipule quantidades variáveis com Rest Parameters e estruture assinaturas de callbacks de alta ordem.
📑 Índice do Conteúdo
1. A Anatomia de uma Função Tipada no TypeScript
Em JavaScript, funções são cidadãs de primeira classe (First-Class Citizens), mas operam sem qualquer proteção: qualquer pessoa pode passar números para funções que esperam textos ou esquecer de retornar valores necessários. No TypeScript, funções possuem contratos rigorosos de entrada (parâmetros) e saída (retorno).
TypeScript
// 1. Declaração Tradicional com parâmetros tipados e retorno explícito
function somarValores(a: number, b: number): number {
return a + b;
}
// 2. Arrow Function (Função de Seta) tipada
const calcularMedia = (nota1: number, nota2: number): number => {
return (nota1 + nota2) / 2;
};
// 3. Arrow Function com retorno implícito
const dobrar = (n: number): number => n * 2;
2. Parâmetros Opcionais (?) e a Regra Mandatória de Ordem
Nem todos os parâmetros de uma rotina são obrigatórios em todas as chamadas. Para sinalizar que um argumento é facultativo, adicione o caractere de interrogação (?) imediatamente após o nome do parâmetro:
TypeScript
function enviarNotificacaoEmail(destinatario: string, assunto: string, anexoUrl?: string): void {
console.log(`Enviando e-mail para ${destinatario} com assunto: "${assunto}"`);
// Como anexoUrl é opcional, o compilador infere o tipo: string | undefined
if (anexoUrl !== undefined) {
console.log(`Anexo incluído: ${anexoUrl}`);
}
}
// Ambas as chamadas são 100% válidas:
enviarNotificacaoEmail("[email protected]", "Deploy Concluído");
enviarNotificacaoEmail("[email protected]", "Relatório Semanal", "https://cdn.webzoneware.com/relatorio.pdf");
TS1016: A required parameter cannot follow an optional parameter.
3. Valores Padrão (Default Parameters) e Inferência
O ECMAScript e o TypeScript permitem atribuir valores padrão a parâmetros. Quando você fornece um valor padrão, o TypeScript infere automaticamente o tipo do parâmetro e torna o argumento opcional na chamada:
TypeScript
// "desconto" é inferido como number e possui valor inicial 0.05 (5%)
function calcularPrecoFinal(precoBase: number, desconto = 0.05): number {
return precoBase * (1 - desconto);
}
console.log(calcularPrecoFinal(100)); // Usa o desconto padrão de 5% -> 95
console.log(calcularPrecoFinal(100, 0.20));// Sobrescreve com desconto de 20% -> 80
4. Rest Parameters Tipados (…args)
Quando sua função precisa receber um número indeterminado de argumentos, utilizamos a sintaxe de Rest Parameters. No TypeScript, o parâmetro Rest deve ser obrigatoriamente tipado como um Array ou uma Tupla:
TypeScript
// "...valores" captura todos os argumentos adicionais em um array number[]
function somarTudo(fatorMultiplicador: number, ...valores: number[]): number {
const somaTotal = valores.reduce((acc, curr) => acc + curr, 0);
return somaTotal * fatorMultiplicador;
}
// Chamadas flexíveis e totalmente seguras:
console.log(somarTudo(2, 10, 20)); // (10 + 20) * 2 = 60
console.log(somarTudo(1.5, 4, 6, 10, 20)); // (4 + 6 + 10 + 20) * 1.5 = 60
5. Function Type Expressions (Tipos de Assinatura de Função)
Frequentemente precisamos tipar uma variável ou parâmetro que deve receber uma função com determinado formato. Para isso, utilizamos Function Types com a sintaxe (parâmetros) => retorno:
TypeScript
// 1. Definimos o contrato da função através de um Type Alias:
type OperadorAritmetico = (x: number, y: number) => number;
// 2. Qualquer função atribuída a essa variável deve satisfazer exatamente o contrato:
const somar: OperadorAritmetico = (a, b) => a + b;
const subtrair: OperadorAritmetico = (a, b) => a - b;
const multiplicar: OperadorAritmetico = (a, b) => a * b;
// 3. Função de alta ordem que consome o operador:
function executarCalculo(num1: number, num2: number, operacao: OperadorAritmetico): number {
return operacao(num1, num2);
}
console.log(executarCalculo(10, 5, somar)); // 15
console.log(executarCalculo(10, 5, multiplicar));// 50
6. Callbacks Tipados com void
Ao definir callbacks assíncronos ou manipuladores de eventos que realizam apenas ações secundárias, tipamos o retorno da função como void:
TypeScript
type CallbackNotificacao = (mensagem: string, codigoHttp: number) => void;
function simularRequisicaoAssincrona(sucesso: boolean, callback: CallbackNotificacao): void {
if (sucesso) {
callback("Operação autorizada com sucesso", 200);
} else {
callback("Falha na autenticação do usuário", 401);
}
}
simularRequisicaoAssincrona(true, (msg, code) => {
console.log(`[CALLBACK STATUS ${code}] ${msg}`);
});
7. Exemplo Prático Integrado: Motor de Notificações Multicanal
Veja a aplicação completa de parâmetros obrigatórios, opcionais, valores padrão, rest parameters e callbacks tipados em um motor de disparo corporativo:
TypeScript
// 1. Tipos de domínio para os canais de disparo
type CanalDisparo = "email" | "sms" | "push" | "whatsapp";
type NivelPrioridade = "alta" | "normal" | "baixa";
type CallbackStatusDisparo = (idLog: string, entregue: boolean) => void;
// 2. Função mestre combinando todos os modificadores de parâmetros
function despacharNotificacao(
destinatario: string, // Obrigatório
conteudo: string, // Obrigatório
canal: CanalDisparo = "email", // Valor padrão (opcional)
prioridade: NivelPrioridade = "normal", // Valor padrão (opcional)
callbackConclusao?: CallbackStatusDisparo, // Opcional (?)
...metatags: string[] // Rest parameter (...args)
): string {
const idNotificacao = "MSG-" + Math.floor(Math.random() * 100000);
console.log(`[DISPARO] #${idNotificacao} | Canal: ${canal.toUpperCase()} | Prioridade: ${prioridade}`);
console.log(`Destinatário: ${destinatario} | Mensagem: "${conteudo}"`);
if (metatags.length > 0) {
console.log(`Metatags indexadas: ${metatags.join(", ")}`);
}
// Se o callback opcional foi fornecido, invoca-o:
if (callbackConclusao) {
callbackConclusao(idNotificacao, true);
}
return idNotificacao;
}
// 3. Chamada real utilizando argumentos padrão e Rest parameters:
const idEnviado = despacharNotificacao(
"[email protected]",
"Alerta: Carga de CPU acima de 85%",
"whatsapp",
"alta",
(id, status) => console.log(`[CONFIRMAÇÃO] Envio #${id} concluído com sucesso: ${status}`),
"infra", "servidor-cloud", "alerta-critico"
);
8. Tabela Didática: Modificadores e Regras de Parâmetros
| Tipo de Parâmetro | Sintaxe de Declaração | Tipo Interno Deduzido | Posicionamento na Assinatura |
|---|---|---|---|
| Obrigatório | param: Tipo |
Tipo |
Sempre no início da assinatura. |
| Opcional | param?: Tipo |
Tipo | undefined |
Obrigatoriamente após os obrigatórios. |
| Valor Padrão | param = valor |
Tipo inferido do valor | Opcional para o chamador da função. |
| Rest Parameter | ...param: Tipo[] |
Array<Tipo> |
Obrigatoriamente o último parâmetro. |
function buscar(): Promise<Usuario>). Embora o TypeScript deduza o retorno automaticamente, anotações explícitas blindam o contrato: se alguém alterar o corpo interno da função e acidentalmente quebrar o formato retornado, o compilador apontará o erro imediatamente no ponto exato da alteração.
Aplique o que você aprendeu nesta lição
Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.
Editor de Códigos Web Online
Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.
Abrir Ferramenta OnlinePlayground Web Online
Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.
⚡ Codificar no Playground IDE