# 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](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/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:

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

```typescript
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.

```typescript
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.

```typescript
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:

```typescript
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](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/typescript-arrays/). Eles são úteis para a escrita de funções que devem lidar com uma quantidade variável de argumentos.

```typescript
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.

```typescript
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.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/typescript-functions/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/typescript-functions/) for AI/LLM consumption.