Nesta lição, você aprenderá como trabalhar com tipos de função. Vamos começar com anotações de tipo de parâmetro. Aqui está um exemplo de uma função básica:

function circleArea(radius) {
  return Math.PI * radius * radius;
}

No momento, o TypeScript exibiria uma mensagem de Parameter 'radius' implicitly has an 'any' type. O tipo any indica que um valor pode ter qualquer tipo. Você aprenderá mais sobre esse tipo em uma lição futura. Para se livrar do erro e digitar explicitamente o parâmetro, você pode digitá-lo assim:

function circleArea(radius: number) {
  return Math.PI * radius * radius;
}

Se você tentar chamar a circleArea function com um tipo diferente que não seja um número, o TypeScript exibirá um erro como este:

function circleArea(radius: number) {
  return Math.PI * radius * radius;
}

// Argument of type 'string' is not assignable to parameter of type 'number'
circleArea("3");

Se você tentar fornecer mais argumentos do que a função espera, o TypeScript exibirá um erro:

function circleArea(radius: number) {
  return Math.PI * radius * radius;
}

// Expected 1 arguments, but got 2.
circleArea(3, 4);

Se você fornecer argumentos insuficientes, o TypeScript também exibirá um erro:

function circleArea(radius: number) {
  return Math.PI * radius * radius;
}

// Expected 1 arguments, but got 0.
// An argument for 'radius' was not provided.
circleArea();

Você pode tornar parâmetros opcionais usando o símbolo ? próximo ao parâmetro assim:

function area(radius: number, height?: number): number {
  const baseArea = Math.PI * radius * radius;

  if (height !== undefined) {
    const sideArea = 2 * Math.PI * radius * height;
    return baseArea + sideArea;
  }

  return baseArea;
}

Lembre-se de que parâmetros opcionais devem sempre vir depois dos parâmetros obrigatórios. Colocar um parâmetro obrigatório depois de um opcional resultará em um erro do TypeScript. A verificação condicional dentro da função está lá no caso do argumento height não ser fornecido. Se você quiser digitar seus valores de retorno, pode adicionar anotações de tipo de retorno assim:

function circleArea(radius: number): number {
  return Math.PI * radius * radius;
}

A anotação do tipo de retorno vai depois da lista de parâmetros. Similar às anotações de tipo de variável, na maioria das vezes o TypeScript será inteligente o suficiente para inferir o tipo de retorno. Então use uma anotação explícita do tipo de retorno quando quiser deixar a intenção da função mais clara ou evitar mudanças não intencionais no valor de retorno. O próximo exemplo que vamos analisar lidará com funções assíncronas e promises. Se sua função vai retornar uma promise, você pode usar o tipo Promise assim:

async function getCityTemperature(city: string): Promise<number> {
  const response = await fetch(https://api.example.com/weather?city=${city});
  const data = await response.json(); 
  return data.temperature;
}

Nessa situação, se você tentar remover o tipo de retorno, o TypeScript pode inferir o retorno como Promise<any>. Então, essa seria uma boa situação para tipar explicitamente o valor de retorno. Até este ponto, só vimos exemplos de funções nomeadas. Mas como os tipos funcionam com funções anônimas? Aqui está um exemplo usando uma função anônima no callback passado para um forEach:

const languages = ["JavaScript", "Python", "TypeScript"];

languages.forEach((lang) => {
  console.log(${lang.toUpperCase()} has ${lang.length} characters);
});

O parâmetro lang não tem uma anotação de tipo. Em vez disso, o TypeScript usa tipagem contextual, o que significa que ele infere o tipo a partir do contexto em que aparece.