Tipagem de Funções no TypeScript: Guia Completo
⚡ Curso de TypeScript • Web-ZoneWare

Tipagem de Funções no TypeScript: Parâmetros, Retornos e Rest

Lição 10 de 50

Tipagem de Funções no TypeScript: Parâmetros, Retornos e Rest

⚡ Módulo 1 • Aula 10 de 50 (Conclusão do Módulo 1 🎉)

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.

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).

funcoes-anatomia.ts
TypeScript
TypeScript 12 linhas
// 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:

parametros-opcionais.ts
TypeScript
TypeScript 12 linhas
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");
⚠️

Regra de Ouro do Compilador: Os parâmetros opcionais devem ficar obrigatoriamente posicionados após todos os parâmetros obrigatórios. Se você tentar declarar um parâmetro opcional antes de um obrigatório, o TypeScript emitirá o erro fatal: 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:

valores-padrao.ts
TypeScript
TypeScript 7 linhas
// "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:

rest-parameters.ts
TypeScript
TypeScript 9 linhas
// "...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:

tipos-assinatura-funcao.ts
TypeScript
TypeScript 15 linhas
// 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:

callbacks-tipados.ts
TypeScript
TypeScript 13 linhas
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:

motor-notificacoes.ts
TypeScript
TypeScript 40 linhas
// 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"
);
Execute e teste códigos interativos na ferramenta oficial do portal:
Abrir no Playground IDE →

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.
💡

Dica Pro de Engenharia Web-ZoneWare: Sempre anote explicitamente o tipo de retorno de funções públicas, módulos e APIs corporativas (ex: 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.

🏆

Parabéns! Módulo 1 Concluído com Sucesso! Você dominou com excelência os Fundamentos, Compilação e Tipagem Básica do TypeScript (10 de 50 aulas entregues — 20% do curso completo). No Módulo 2, daremos um salto em engenharia de dados explorando Interfaces, Types & Modelagem Avançada de Objetos, iniciando na Lição 11 com o estudo aprofundado das Interfaces no TypeScript.

🛠️ Laboratório Prático & Prática Imediata

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.

💻 Desenvolvedor & Código

Editor de Códigos Web Online

Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.

Abrir Ferramenta Online
⚡ Live Code Studio

Playground 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
Foto de Web-Zoneware
✓ Verificado
🎓 Tutor & Coordenador da Web Academy

Web-Zoneware

Tutor Técnico & Desenvolvedor Full-Stack

Desenvolvedor web e instrutor focado na formação prática de novos programadores. Defensor ferrenho de código semântico, arquitetura limpa e acessibilidade W3C/WCAG, dedicando-se a construir cursos estruturados em metodologia passo a passo com execução ao vivo no Playground IDE.

Especialidades: HTML5 Semântico CSS3 & Flexbox/Grid JavaScript Moderno Acessibilidade WCAG 2.2 Didática Prática
Rolar para cima