TypeScript functions: Tutorial de funções do TypeScript

Funções da linguagem de programação TypeScript são blocos de códigos que permitem a definição de tipos de parâmetros e de valores de retorno, o que resulta na detecção antecipada de erros e aumenta a qualidade das aplicações em desenvolvimento. Ou seja, TypeScript functions garantem que os tipos de dados corretos sejam utilizados.

O que são TypeScript functions?

Funções são um dos componentes centrais da linguagem de programação TypeScript. TypeScript functions se assemelham às funções do JavaScript, mas possuem a vantagem adicional de suportarem tipagens estáticas. Na tipagem estática, tipos de dados para variáveis, parâmetros e valores de retorno são definidos, no código, durante a fase de design (tempo de compilação), não podendo ser alterados no processo de execução. Isso ajuda a reduzir erros no ambiente de produção.

Outra importante característica das funções do TypeScript é a flexibilidade delas. TypeScript functions podem ter parâmetros opcionais e valores padrão para parâmetros, o que facilita a aplicação delas a diferentes tipos de códigos. Assim, elas podem ser usadas no processamento de dados, em interações com interfaces de usuário, na programação assíncrona e em outras situações. Ainda, funções do TypeScript possibilitam a definição de sobrecargas, que oferecem diferentes funcionalidades a depender dos valores de entrada.

Além da declaração de funções tradicionais, o TypeScript também suporta o uso de funções de seta, de sintaxe mais curta e amplamente utilizadas em práticas modernas do desenvolvimento em JavaScript. Por esses e outros motivos, as funções do TypeScript são consideradas essenciais nos códigos desenvolvidos com essa linguagem de programação, já que elas aumentam a segurança e a legibilidade desses códigos, ao mesmo tempo em que oferecem flexibilidade e adaptabilidade para atender às mais diversas necessidades.

Sintaxe de TypeScript functions

A sintaxe das funções do TypeScript é semelhante à sintaxe das funções do JavaScript, já que TypeScript é uma linguagem de programação que estende o JavaScript. Funções do TypeScript têm de ser delimitadas por chaves { }, dentro das quais a lógica da função correspondente deve ser implementada. Observe a estrutura base de uma função do TypeScript:

function functionName(parameter1: type, parameter2: type): returnType {
    // Function Code
    return result; // (optional)
}

• function: Esta palavra-chave marca o início da declaração da função.
• functionName: Este é o nome da função. Opte por um nome descritivo, que reflita a tarefa da função.
• parameter1, parameter2: Estes são os parâmetros que a função demanda. Cada parâmetro é identificado por um nome e pelo tipo de dado esperado (anotação de tipo).
• returnType: Este é o tipo de dado que a função retorna. Especifique void para a função não retornar nenhum valor.
• return result: Parâmetro opcional, necessário quando a função tiver de retornar um valor.

Você pode chamar uma função do TypeScript usando o nome dessa mesma função seguido por parênteses. Dentro dos parênteses, você deve inserir os argumentos (valores de entrada) para a função, caso ela demande parâmetros.

functionName(argument1, argument2, ...);

Exemplos de aplicação de TypeScript functions

TypeScript functions são extremamente versáteis, sendo capazes de realizar cálculos, operações e fluxos complexos em aplicações.

Funções anônimas

Funções anônimas, na linguagem de programação TypeScript, são funções que não possuem um nome e, portanto, podem ser usadas diretamente em expressões ou como argumentos para outras funções. O uso de funções anônimas é vantajoso quando estas são necessitadas em apenas um ponto específico do código, já que elas não exigem a atribuição de um nome.

var greet = function(name) {
    return "Hello, " + name + "!";
};
var message = greet("John");
console.log(message); // Output: "Hello, John!"

No exemplo, a função anônima é armazenada na variável greet e chamada posteriormente para criar uma mensagem de saudação personalizada para o nome John.

Funções anônimas podem incluir funções lambda, também chamadas de funções de seta.

const add = (a: number, b: number) => a + b;
const result = add(3, 5); // Output: 8

Observe, acima, uma função anônima que realiza a adição de dois números. Ela é atribuída à variável add e, em seguida, chamada.

Parâmetros default

Parâmetros default (também conhecidos como parâmetros padrão ou parâmetros predefinidos) permitem que você defina TypeScript functions de modo a terem valores padrão para os parâmetros. Se uma função for chamada e nenhum valor for fornecido para um parâmetro, o valor padrão será utilizado. Veja:

function greet(name: string = "World") {
    return "Hello, " + name + "!";
}
console.log(greet()); // Output: "Hello, World!"
console.log(greet("John")); // Output: "Hello, John!"

No código, a função greet ganha o valor padrão World para o parâmetro name. Assim, se nenhum valor for fornecido para name na chamada da função, o valor padrão determinado será automaticamente utilizado.

Parâmetros rest

Na linguagem de programação TypeScript, parâmetros rest (também conhecidos como operadores de rest ou sintaxes de parâmetro rest), são capazes de coletar um número indefinido de argumentos em uma função, como um array TypeScript. Eles são úteis para a escrita de funções que devem lidar com uma quantidade variável de argumentos.

function sum(...numbers: number[]): number {
    let total = 0;
    for (const num of numbers) {
        total += num;
    }
    return total;
}
console.log(sum(1, 2, 3, 4, 5)); // Output: 15

Nesse exemplo, a função sum coleta uma quantidade arbitrária de números (com o parâmetro rest numbers) e as adiciona para calcular a soma total. Você poderia passar quantos números desejasse, já que a função é preparada para considerar todos eles.

Sobrecargas

TypeScript functions com overloads (sobrecargas de função) são usadas para definir múltiplas declarações de função de mesmo nome, mas com diferentes tipos de parâmetros ou de valores de retorno. Isso possibilita que o TypeScript selecione automaticamente a declaração correta da função, baseando-se nos argumentos passados e realizando as verificações de tipo correspondentes.

function concatenate(a: string, b: string): string;
function concatenate(a: number, b: number): string;
function concatenate(a: any, b: any): string {
    return a.toString() + b.toString();
}
console.log(concatenate("Hello, ", "World")); // Output: "Hello, World"
console.log(concatenate(3, 5)); // Output: "35"

No exemplo acima, observamos duas sobrecargas da função concatenate. A primeira aceita duas strings e a segunda aceita dois números. A implementação real da função converte os argumentos fornecidos em strings e os concatena. A linguagem de programação TypeScript seleciona automaticamente a sobrecarga adequada, com base nos argumentos fornecidos, e realiza as verificações de tipo necessárias.

Sobrecargas de função são especialmente úteis para o desenvolvimento de APIs ou bibliotecas. Em ambos os casos, é importante que funções do TypeScript sejam escritas de forma simples e sem erros, independentemente do tipo de parâmetro que os usuários virão a fornecer.