Guia Prático para Parâmetros, Retornos e Tipos de Função

A tipagem de funções no TypeScript permite definir quais valores uma função pode receber e qual tipo de dado ela deve retornar. Na prática, isso torna o código mais previsível, melhora o autocomplete do editor e ajuda a identificar erros ainda durante o desenvolvimento.

É possível tipar parâmetros, especificar explicitamente o retorno, trabalhar com funções que retornam void e até criar tipos reutilizáveis para representar assinaturas de funções.

Embora o TypeScript consiga inferir muitos tipos automaticamente, compreender como declarar essas informações é essencial para escrever aplicações mais seguras e fáceis de manter. Neste guia, você aprenderá de forma prática como funciona a tipagem de funções em TypeScript e como aplicar esses conceitos em projetos reais.

Como tipar parâmetros de funções no TypeScript

Em JavaScript, uma função pode receber praticamente qualquer valor sem que exista uma verificação de tipos antes da execução. Considere uma função criada para somar dois números:

function somar(primeiroNumero, segundoNumero) {
  return primeiroNumero + segundoNumero;
}

Nada impede que alguém passe uma string como primeiro argumento, o que pode produzir um comportamento diferente daquele esperado.

No TypeScript, podemos definir o tipo de cada parâmetro diretamente na assinatura da função:

function somar(
  primeiroNumero: number,
  segundoNumero: number
) {
  return primeiroNumero + segundoNumero;
}

Agora o compilador sabe que ambos os argumentos precisam ser números.

somar(10, 20);    // Correto
somar("10", 20);  // Erro

Essa verificação antecipada é especialmente útil em aplicações maiores. A própria assinatura tipada funciona como uma forma de documentação e permite que editores como o Visual Studio Code ofereçam sugestões mais precisas.

• number pode ser utilizado para parâmetros numéricos.
• string representa valores textuais.
• boolean representa valores verdadeiros ou falsos.
• Objetos, arrays, interfaces e tipos personalizados também podem ser utilizados como parâmetros.

Como definir o tipo de retorno de uma função

Além dos parâmetros, o TypeScript permite declarar explicitamente o tipo de retorno da função. Essa informação é adicionada depois dos parênteses que contêm os parâmetros.

function somar(
  primeiroNumero: number,
  segundoNumero: number
): number {
  return primeiroNumero + segundoNumero;
}

O : number determina que a função deve produzir um número como resultado. Se a implementação tentar retornar um valor incompatível, como uma string, o TypeScript poderá apontar o problema.

Outro exemplo é uma função que recebe um nome e retorna uma saudação:

function saudacao(nome: string): string {
  return `Olá, ${nome}`;
}

Nesse caso, o parâmetro nome precisa ser uma string e o resultado também precisa ser textual.

Embora o TypeScript frequentemente consiga inferir o retorno analisando a implementação, declarar o tipo explicitamente pode ser interessante em APIs públicas, serviços e funções importantes para deixar a intenção do código evidente.

Quando usar void em funções TypeScript

Nem toda função precisa produzir um valor. Algumas existem apenas para executar uma ação, como registrar uma informação no console, atualizar determinado estado ou disparar outro comportamento.

Nesses casos, é comum utilizar o tipo void:

function mostrarMensagem(mensagem: string): void {
  console.log(mensagem);
}

A função recebe uma string e executa uma ação, mas não entrega um resultado útil ao código que realizou a chamada.

Em assinaturas de funções, void é utilizado principalmente para indicar que o consumidor não deve depender de um valor retornado. Isso deixa a intenção da função mais clara para quem estiver utilizando ou mantendo o código.

Como tipar funções armazenadas em variáveis

Funções também podem ser armazenadas em variáveis, passadas como argumentos e retornadas por outras funções. Por isso, o TypeScript permite definir a assinatura completa de uma função.

const multiplicar: (
  primeiroNumero: number,
  segundoNumero: number
) => number = (
  primeiroNumero,
  segundoNumero
) => {
  return primeiroNumero * segundoNumero;
};

A parte abaixo representa o tipo da função:

(
  primeiroNumero: number,
  segundoNumero: number
) => number

Isso significa que a função precisa receber dois números e retornar um número.

Uma vantagem interessante é a tipagem contextual. Como a variável já possui uma assinatura definida, o TypeScript consegue descobrir automaticamente os tipos de primeiroNumero e segundoNumero na implementação.

Esse recurso aparece com frequência em callbacks, eventos, serviços e funções recebidas por componentes.

Como criar tipos reutilizáveis para funções

Quando a mesma assinatura aparece em diferentes partes da aplicação, repeti-la pode deixar o código mais difícil de manter. Uma solução é criar um type específico para representar a função.

type CalcularPreco = (
  preco: number,
  desconto: number
) => number;

Depois podemos reutilizar esse tipo:

const calcularPreco: CalcularPreco = (
  preco,
  desconto
) => {
  return preco - desconto;
};

Agora CalcularPreco funciona como um contrato. Qualquer função que utilize esse tipo precisa respeitar a assinatura definida.

Tipos de função são particularmente úteis quando trabalhamos com callbacks ou comportamentos reutilizados em diferentes partes da aplicação.

• Crie tipos reutilizáveis quando a mesma assinatura aparecer em vários lugares.
• Utilize nomes que expressem a responsabilidade da função.
• Aproveite a inferência do TypeScript para evitar declarações redundantes.
• Prefira parâmetros e retornos específicos em vez de tipos excessivamente genéricos.

Perguntas frequentes sobre tipagem de funções no TypeScript

É obrigatório declarar o retorno de todas as funções?

Qual é a diferença entre tipar parâmetros e tipar uma função?

Tipar parâmetros determina quais valores cada argumento aceita. Já tipar uma função completa descreve sua assinatura, incluindo os parâmetros e o resultado esperado. Isso é particularmente útil para funções armazenadas em variáveis e callbacks.

Quando devo criar um type para uma função?

Vale a pena criar um tipo quando uma assinatura representa um conceito importante da aplicação ou precisa ser reutilizada. Para funções pequenas utilizadas apenas uma vez, declarar a assinatura diretamente costuma ser suficiente.

Conclusão

A tipagem de funções no TypeScript ajuda a transformar funções em contratos claros: você define quais dados entram, qual resultado deve sair e como determinada função pode ser utilizada.

Parâmetros tipados evitam argumentos incompatíveis, tipos de retorno tornam os resultados previsíveis e void comunica quando não existe um valor útil a ser consumido. Já as assinaturas e tipos reutilizáveis permitem representar callbacks e comportamentos de maneira organizada.

O mais importante é encontrar equilíbrio: aproveite a inferência do TypeScript quando ela deixa o código evidente e declare tipos explicitamente quando isso melhora o contrato e a manutenção. Com esses fundamentos dominados, o próximo passo é estudar parâmetros opcionais, valores padrão, rest parameters e sobrecarga de funções para construir aplicações TypeScript ainda mais flexíveis e seguras.