Funções no TypeScript

Este artigo explica as funções no TypeScript.

YouTube Video

Funções no TypeScript

As funções no TypeScript são funções JavaScript com anotações de tipo adicionadas. No TypeScript, você pode escrever um código mais robusto definindo claramente os tipos de entradas (parâmetros) e saídas (valores de retorno) para as funções. Abaixo, apresentamos os métodos básicos para definir funções e algumas características das funções no TypeScript.

Definição Básica de Funções

1function add(x: number, y: number): number {
2    return x + y;
3}
4
5console.log(add(5, 10));  // 15

• A função add recebe dois argumentos do tipo number e retorna um valor do tipo number.
• Ela recebe dois argumentos, x e y, ambos do tipo number, com seus tipos explicitamente especificados.
• O tipo de retorno também é especificado como : number.

Funções Anônimas (Expressões de Função)

Funções anônimas e expressões de função também podem ser usadas no TypeScript. Os tipos podem ser anotados da mesma maneira.

1const multiply = function (x: number, y: number): number {
2    return x * y;
3};
4
5console.log(multiply(3, 4));  // 12

• Você pode atribuir uma função anônima a uma variável e chamá-la depois.

1const factorial = function fact(n: number): number {
2  if (n <= 1) return 1;
3  return n * fact(n - 1); // Can call itself recursively
4};
5
6console.log(factorial(5)); // 120

• Você pode usar uma expressão de função nomeada para permitir chamadas recursivas.

Funções Arrow

As anotações de tipo também podem ser usadas com funções arrow.

1const subtract = (x: number, y: number): number => {
2    return x - y;
3};
4
5console.log(subtract(10, 4));  // 6

Este código define uma função seta subtract com anotações de tipo que recebe dois números como argumentos e retorna a diferença entre eles.

Parâmetros Opcionais e Padrão

Os parâmetros podem ser opcionais ou ter valores padrão atribuídos.

Parâmetros Opcionais

Adicionando ? após o nome do parâmetro torna-o opcional.

1function greet(name?: string): string {
2    return name ? `Hello, ${name}` : "Hello!";
3}
4
5console.log(greet());        // Hello!
6console.log(greet("Alice"));  // Hello, Alice

Este código aceita um argumento opcional; se o argumento é fornecido, ele cumprimenta usando o nome, caso contrário retorna uma saudação genérica.

Parâmetros Padrão

Você também pode definir valores padrão para os parâmetros.

1function greetWithDefault(name: string = "Guest"): string {
2    return `Hello, ${name}`;
3}
4
5console.log(greetWithDefault());         // Hello, Guest
6console.log(greetWithDefault("Bob"));    // Hello, Bob

Esta função usa "Guest" como valor padrão se nenhum argumento for passado e cumprimenta usando o nome especificado ou o padrão.

Definição do Tipo da Função

Também é possível definir o tipo da própria função. Por exemplo, isso é usado ao passar uma função como argumento.

1type Operation = (x: number, y: number) => number;
2
3const addOperation: Operation = (x, y) => x + y;
4const multiplyOperation: Operation = (x, y) => x * y;
5
6console.log(addOperation(2, 3));      // 5
7console.log(multiplyOperation(2, 3)); // 6

Este código define um tipo de função Operation que recebe dois números e retorna um número, e então o utiliza para criar e executar funções de adição e multiplicação.

Quando Não Há Valor de Retorno (tipo void)

Para funções sem valor de retorno, especifique o tipo void.

1function logMessage(message: string): void {
2    console.log(message);
3}
4
5logMessage("This is a message.");  // This is a message.

Este código define uma função void chamada logMessage que recebe uma mensagem do tipo string e a imprime no console sem retornar um valor.

Função de Callback

Passar uma função como argumento para outra função e executá-la posteriormente é chamado de função de callback. É frequentemente utilizada em processamento assíncrono e manipulação de eventos.

1function processData(callback: (data: string) => void): void {
2    const data: string = "Processed Data";
3    callback(data);
4}
5
6processData((result: string): void => {
7    console.log(result);
8});

Neste exemplo, uma função que exibe um valor no console é passada como uma função de callback.

Alternativamente, você pode definir um tipo de callback usando type ou interface.

 1type Callback = (data: string) => void;
 2
 3function processData(callback: Callback): void {
 4    const data: string = "Processed Data";
 5    callback(data);
 6}
 7
 8processData((result: string): void => {
 9    console.log(result);
10});

Definir um tipo de callback usando type ou interface melhora a reutilização.

Sobrecarga de Funções

A sobrecarga de funções permite que você defina funções com o mesmo nome, mas com listas de parâmetros diferentes. No TypeScript, você pode definir várias funções com o mesmo nome e realizar diferentes operações com base nos tipos e quantidades de parâmetros.

 1// Overload Signature
 2function double(value: number): number;
 3function double(value: string): string;
 4
 5// Implementation Signature
 6function double(value: number | string): number | string {
 7    if (typeof value === "number") {
 8        return value * 2;
 9    } else if (typeof value === "string") {
10        return value + value;
11    }
12}
13
14console.log(double(10));      // 20
15console.log(double("Hello")); // HelloHello

No TypeScript, a sobrecarga é alcançada da seguinte forma:.

• Assinatura de Sobrecarga

  • Define como a função pode ser usada (sua assinatura). Escrevendo isso várias vezes, a sobrecarga se torna possível.

• Assinatura de Implementação

  • Implementa o corpo real da função. Esta parte é definida apenas uma vez e lida com todos os casos declarados nas assinaturas de sobrecarga.

Regras para Sobrecarga

As seguintes regras se aplicam à sobrecarga de funções:.

• Ordem das Definições da Assinatura de Sobrecarga

  • Como a avaliação ocorre de cima para baixo, recomenda-se definir tipos específicos primeiro, seguidos por tipos mais genéricos.

• Compatibilidade da Assinatura de Implementação

  • A assinatura da implementação deve ser compatível com os argumentos e os valores de retorno de todas as assinaturas de sobrecarga.

• Especifique Detalhes nas Assinaturas de Sobrecarga

  • A assinatura da implementação tende a ser ambígua, então os detalhes devem ser especificados nas assinaturas de sobrecarga.
  • Se apenas a assinatura da implementação for definida, a inferência de tipos para a função será insuficiente.

Resumo

As funções em TypeScript possuem as seguintes características.

• Anotações de Tipo
  • Ao especificar tipos para os argumentos e valores de retorno, você pode escrever um código mais seguro.
• Funções Anônimas e Funções Arrow
  • Elas podem ser usadas da mesma forma que no JavaScript, e adicionar anotações de tipo melhora a segurança de tipos.
• Parâmetros Opcionais e Padrão
  • Você pode tornar a especificação dos argumentos mais flexível conforme necessário.
• Definições de Tipos de Função
  • Defina o tipo da própria função para realizar a verificação de tipos.
• Sobrecarga de Funções
  • Você pode suportar diferentes argumentos com o mesmo nome de função.

Usando estas características, você pode escrever um código mais claro e robusto no TypeScript.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video