TypeScript

https://www.typescriptlang.org/pt/docs
Admin
TypeScript is a typed superset of JavaScript that compiles to plain JavaScript, providing a powerful...
Tokens:80,348
Snippets:636
Trust Score:9.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Example Project Structure

Source: https://www.typescriptlang.org/pt/docs/handbook/project-references.html

Illustrates a typical project layout with separate directories for source files, test files, and the main configuration file.

```shell
/src/converter.ts
/src/units.ts
/test/converter-tests.ts
/test/units-tests.ts
/tsconfig.json
```

--------------------------------

### TypeScript Test File Example

Source: https://www.typescriptlang.org/pt/docs/handbook/project-references.html

A sample TypeScript test file demonstrating how implementation modules are imported and assertions are made. This highlights the inter-module dependencies within a project.

```typescript
// converter-tests.ts
import * as converter from "../converter";
assert.areEqual(converter.celsiusToFahrenheit(0), 32);
```

--------------------------------

### TypeScript Module Resolution Trace Output Example

Source: https://www.typescriptlang.org/pt/docs/handbook/module-resolution.html

An example of the output generated when running the TypeScript compiler with the --traceResolution flag. It details the search path, package.json lookup, and the final resolved module path.

```txt
======== Resolving module 'typescript' from 'src/app.ts'. ========
Module resolution kind is not specified, using 'NodeJs'.
Loading module 'typescript' from 'node_modules' folder.
File 'src/node_modules/typescript.ts' does not exist.
File 'src/node_modules/typescript.tsx' does not exist.
File 'src/node_modules/typescript.d.ts' does not exist.
File 'src/node_modules/typescript/package.json' does not exist.
File 'node_modules/typescript.ts' does not exist.
File 'node_modules/typescript.tsx' does not exist.
File 'node_modules/typescript.d.ts' does not exist.
Found 'package.json' at 'node_modules/typescript/package.json'.
'package.json' has 'types' field './lib/typescript.d.ts' that references 'node_modules/typescript/lib/typescript.d.ts'.
File 'node_modules/typescript/lib/typescript.d.ts' exist - use it as a module resolution result.
======== Module name 'typescript' was successfully resolved to 'node_modules/typescript/lib/typescript.d.ts'. ========
```

--------------------------------

### Implementar e aplicar Decorador de Acesso

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Demonstra como criar um decorador de fábrica para configurar a propriedade 'configurable' de um acessador e como aplicá-lo a métodos get em uma classe.

```typescript
class Ponto {
  private _x: number;
  private _y: number;
  constructor(x: number, y: number) {
    this._x = x;
    this._y = y;
  }
  @configuravel(false)
  get x() {
    return this._x;
  }
  @configuravel(false)
  get y() {
    return this._y;
  }
}

function configuravel(valor: boolean) {
  return function (
    alvo: any,
    chaveDePropriedade: string,
    descritor: DescritorDePropriedade
  ) {
    descritor.configurable = valor;
  };
}
```

--------------------------------

### Compiling with --noResolve

Source: https://www.typescriptlang.org/pt/docs/handbook/module-resolution.html

Example command to compile TypeScript files using the --noResolve flag. This demonstrates how only explicitly provided files ('app.ts' and 'moduleA.ts') will be included in the compilation, while unresolved modules not passed as arguments will cause errors.

```shell
tsc app.ts moduleA.ts --noResolve
```

--------------------------------

### Configure Fallback Path Mappings in tsconfig.json

Source: https://www.typescriptlang.org/pt/docs/handbook/module-resolution.html

This example shows how to use wildcard patterns in 'paths' to define fallback locations for module resolution. It allows the compiler to check multiple paths for a module before failing.

```json
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "*": ["*", "generated/*"]
    }
  }
}
```

--------------------------------

### Install Type Declarations via NPM

Source: https://www.typescriptlang.org/pt/docs/handbook/declaration-files/consumption.html

Uses the npm package manager to install type definitions for a specific library. This command adds the dependency to the devDependencies section of the package.json file.

```cmd
npm install --save-dev @types/lodash
```

--------------------------------

### Test.ts: TypeScript Example for Using Validators

Source: https://www.typescriptlang.org/pt/docs/handbook/namespaces.html

Demonstrates how to use the `LettersOnlyValidator` and `ZipCodeValidator` classes in TypeScript. It initializes an array of strings and a dictionary of validators, then iterates through them to check and log the validation results. This script requires the validation files to be referenced.

```typescript
/// <reference path="Validation.ts" />
/// <reference path="LettersOnlyValidator.ts" />
/// <reference path="ZipCodeValidator.ts" />
// Alguns exemplos
let strings = ["Hello", "98052", "101"];
// Validadores para usar
let validators: { [s: string]: Validation.StringValidator } = {};
validators["ZIP code"] = new Validation.ZipCodeValidator();
validators["Letters only"] = new Validation.LettersOnlyValidator();
// Mostrar qual string passou por qual validador
for (let s of strings) {
  for (let name in validators) {
    console.log(
      `"${s}" - ${validators[name].isAcceptable(s) ? "matches" : "does not match"} ${name}`
    );
  }
}
```

--------------------------------

### Configuração de HTML para TypeScript Greeter

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-tooling-in-5-minutes.html

Este arquivo HTML serve como o ponto de entrada para o aplicativo web, carregando o script compilado 'greeter.js'. Ele demonstra a estrutura básica necessária para renderizar a saída do código TypeScript no navegador.

```html
<!DOCTYPE html>
<html>
  <head>
    <title>TypeScript Greeter</title>
  </head>
  <body>
    <script src="greeter.js"></script>
  </body>
</html>
```

--------------------------------

### Obtenção de Informações de Tipo em Tempo de Execução (C#)

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-oop.html

Exemplo em C# demonstrando como obter o nome de um tipo genérico em tempo de execução usando `typeof`. Isso contrasta com o sistema de tipos apagado do TypeScript.

```csharp
// C#
static void TipoDoLog<T>() {
    Console.WriteLine(typeof(T).Name);
}
```

--------------------------------

### Consume Type Declarations in TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/declaration-files/consumption.html

Demonstrates how to use installed type declarations in TypeScript code. It covers both modular imports and global variable usage for libraries like lodash.

```ts
import * as _ from "lodash";
_.padStart("Hello TypeScript!", 20, " ");
```

```ts
_.padStart("Hello TypeScript!", 20, " ");
```

--------------------------------

### Instalar TypeScript via npm

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-tooling-in-5-minutes.html

Comando para instalar o compilador TypeScript globalmente no sistema utilizando o gerenciador de pacotes Node.js.

```shell
npm install -g typescript
```

--------------------------------

### Exemplo de Tipo Vazio em TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-oop.html

Ilustra o conceito de tipo vazio em TypeScript, onde um objeto sem propriedades pode ser compatível com um tipo que não declara propriedades. Isso destaca a verificação estrutural.

```typescript
class Vazio {}
 
function fn(arg: Vazio) {
	// fazer algo?
}
 
// Sem erro, mas isso não é um 'Vazio' ?
fn({ k: 10 });
```

--------------------------------

### TypeScript: HTMLElementTagNameMap Interface Definition

Source: https://www.typescriptlang.org/pt/docs/handbook/manipulacao-dom.html

An example interface definition for `HTMLElementTagNameMap` in TypeScript. This interface maps HTML tag names to their corresponding element types, enabling type-safe creation of specific HTML elements.

```typescript
interface HTMLElementTagNameMap {
    "a": HTMLAnchorElement;
    "abbr": HTMLElement;
    "address": HTMLElement;
    "applet": HTMLAppletElement;
    "area": HTMLAreaElement;
        ...
}
```

--------------------------------

### Verificando Compatibilidade de Objetos com Interfaces em TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-oop.html

Demonstra como objetos podem ser usados com interfaces em TypeScript se eles possuírem as propriedades necessárias, mesmo sem uma declaração explícita de relação. Isso ilustra a tipagem estrutural do TypeScript.

```typescript
interface Ponto {
	x: number;
	y: number;
}
interface Nomeada {
	nome: string;
}
 
function exibirPonto(point: Ponto) {
	console.log('x = ' + point.x + ', y = ' + point.y);
}
 
function exibirNome(x: Nomeada) {
	console.log('Olá, ' + x.nome);
}
 
const obj = {
	x: 0,
	y: 0,
	nome: 'Origem'
};
 
exibirPonto(obj);
exibirNome(obj);
```

--------------------------------

### TypeScript Structural Typing Example

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-func.html

Demonstrates structural typing in TypeScript where an object's type is determined by its structure rather than explicit declaration. An object literal with extra properties is assignable to a type with fewer properties if the required properties match.

```typescript
// @strict: false
let o = { x: 'olá', extra: 1 }; // ok
let o2: { x: string } = o; // ok
```

--------------------------------

### Exemplos de Comportamento Inesperado do JavaScript

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-from-scratch.html

Demonstra comportamentos surpreendentes do JavaScript, como a coerção de tipos com o operador de igualdade e a avaliação de expressões booleanas. Estes exemplos destacam a necessidade de uma verificação mais rigorosa.

```javascript
if ('' == 0) {
	// É! mas porque??
}
if (1 < x < 3) {
	// Verdadeiro para qualquer valor de x!
}
```

--------------------------------

### Embedding Expressions in JSX (TypeScript)

Source: https://www.typescriptlang.org/pt/docs/handbook/jsx.html

Demonstrates how to embed JavaScript expressions within JSX tags using curly braces. This example shows mapping an array and embedding the result of an operation, highlighting potential type errors if the operation is invalid for the data type.

```typescript
var a = (
  <div>
    {["foo", "bar"].map((i) => (
      <span>{i / 2}</span>
    ))}
  </div>
);
```

```typescript
var a = (
  <div>
    {["foo", "bar"].map(function (i) {
      return <span>{i / 2}</span>;
    })}
  </div>
);
```

--------------------------------

### Implementar e aplicar Decorador de Propriedade com Metadados

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Mostra o uso de decoradores de propriedade para registrar metadados em uma classe usando a biblioteca reflect-metadata, permitindo a recuperação posterior de informações de formatação.

```typescript
import "reflect-metadata";

class Recepcionista {
  @formato("Olá, %s")
  cumprimento: string;
  constructor(mensagem: string) {
    this.cumprimento = mensagem;
  }
  cumprimentar() {
    let formatoString = obterFormato(this, "cumprimento");
    return formatoString.replace("%s", this.cumprimento);
  }
}

const formatoMetadataKey = Symbol("format");
function formato(formatoString: string) {
  return Reflect.metadata(formatoMetadataKey, formatoString);
}
function obterFormato(alvo: any, chaveDePropriedade: string) {
  return Reflect.getMetadata(formatoMetadataKey, alvo, chaveDePropriedade);
}
```

--------------------------------

### Classes como Namespaces em JavaScript com TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/type-checking-javascript-files.html

Demonstra como classes em arquivos JavaScript podem ser usadas para criar namespaces aninhados, permitindo a organização de código e a simulação de métodos estáticos ou namespaces simples.

```javascript
class C {}
C.D = class {};
Try

```

--------------------------------

### Instalação da biblioteca reflect-metadata

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Comando para instalar a biblioteca necessária para suportar a API de metadados experimental no TypeScript.

```shell
npm i reflect-metadata --save
```

--------------------------------

### Configuração de Decoradores

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Exemplos de como habilitar o suporte experimental a decoradores no TypeScript através da linha de comando ou do arquivo de configuração tsconfig.json.

```shell
tsc --target ES5 --experimentalDecorators
```

```json
{
  "compilerOptions": {
    "target": "ES5",
    "experimentalDecorators": true
  }
}
```

--------------------------------

### Criação de Namespaces Simples em JavaScript

Source: https://www.typescriptlang.org/pt/docs/handbook/type-checking-javascript-files.html

Exibe diferentes maneiras de criar namespaces simples em JavaScript usando objetos literais, IIFEs (Immediately Invoked Function Expressions) ou atribuindo propriedades a variáveis existentes, permitindo agrupar funcionalidades relacionadas.

```javascript
var ns = {};
ns.C = class {};
ns.func = function () {};
 
ns;
Try

```

```javascript
// IIFE
var ns = (function (n) {
  return n || {};
})();
ns.CONST = 1;
 
// defaulting to global
var assign =
  assign ||
  function () {
    // code goes here
  };
assign.extra = 1;
Try

```

--------------------------------

### Split Namespaces Across Multiple Files

Source: https://www.typescriptlang.org/pt/docs/handbook/namespaces.html

Shows how to define a namespace across multiple files. This approach allows for better modularity while maintaining a single namespace scope.

```typescript
namespace Validation {
  export interface StringValidator {
    isAcceptable(s: string): boolean;
  }
}
```

--------------------------------

### Configurar tsconfig.json com lista explícita de arquivos

Source: https://www.typescriptlang.org/pt/docs/handbook/tsconfig-json.html

Exemplo de um arquivo tsconfig.json que utiliza a propriedade 'files' para especificar individualmente os arquivos que devem ser compilados pelo TypeScript.

```json
{
  "compilerOptions": {
    "module": "commonjs",
    "noImplicitAny": true,
    "removeComments": true,
    "preserveConstEnums": true,
    "sourceMap": true
  },
  "files": [
    "core.ts",
    "sys.ts",
    "types.ts",
    "scanner.ts",
    "parser.ts",
    "utilities.ts",
    "binder.ts",
    "checker.ts",
    "emitter.ts",
    "program.ts",
    "commandLineParser.ts",
    "tsc.ts",
    "diagnosticInformationMap.generated.ts"
  ]
}
```

--------------------------------

### Implementando Tipagem Estrutural

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes.html

Ilustra o sistema de tipagem estrutural do TypeScript, onde a compatibilidade é baseada no formato do objeto. Demonstra como objetos e classes são validados pela presença das propriedades necessárias, independentemente da declaração de tipo explícita.

```typescript
interface Ponto {
	x: number;
	y: number;
}

function exibirPonto(p: Ponto) {
	console.log(`${p.x}, ${p.y}`);
}

const ponto = { x: 12, y: 26 };
exibirPonto(ponto);

const ponto3 = { x: 12, y: 26, z: 89 };
exibirPonto(ponto3);

class PontoVirtual {
	x: number;
	y: number;

	constructor(x: number, y: number) {
		this.x = x;
		this.y = y;
	}
}

const novoPontoV = new PontoVirtual(13, 56);
exibirPonto(novoPontoV);
```

--------------------------------

### Manipular o tipo 'any' e tipagem gradual

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-func.html

Demonstra o comportamento do tipo 'any' no TypeScript, que desativa a verificação de tipos e pode propagar comportamentos dinâmicos através de variáveis.

```typescript
const anys = [];
anys.push(1);
anys.push('oh não');
anys.push({ qualquer: 'coisa' });

anys.map(anys[1]);
let sepsis = anys[0] + anys[1];
```

--------------------------------

### Utilizar métodos em tipos primitivos

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-func.html

Exemplifica o uso de métodos em tipos primitivos, como o número, e como o TypeScript lida com a chamada de métodos em literais numéricos.

```typescript
(1).toExponential();
// é equivalente a
Number.prototype.toExponential.call(1);
```

--------------------------------

### Implementar anotações de tipo

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-tooling-in-5-minutes.html

Demonstração de como adicionar anotações de tipo para garantir que a função receba apenas strings, resultando em erros de compilação caso tipos incompatíveis sejam passados.

```typescript
function greeter(person: string) {
  return "Hello, " + person;
}

let user = "Jane User";

document.body.textContent = greeter(user);
```

--------------------------------

### Configuração do compilador para metadados

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Instruções para habilitar metadados de decoradores via linha de comando ou arquivo de configuração tsconfig.json.

```shell
tsc --target ES5 --experimentalDecorators --emitDecoratorMetadata
```

```json
{
  "compilerOptions": {
    "target": "ES5",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}
```

--------------------------------

### Demonstrar tipagem estrutural com interfaces e classes

Source: https://www.typescriptlang.org/pt/docs/handbook/type-compatibility.html

Exemplo básico mostrando como uma classe pode ser atribuída a uma interface se possuir os membros necessários, ilustrando a natureza estrutural do TypeScript.

```typescript
interface Nomeado {
  nome: string;
}
class Pessoa {
  nome: string;
}
let p: Nomeado;
// OK, por causa da tipagem estrutural
p = new Pessoa();
```

--------------------------------

### Simulação de Métodos Estáticos com Funções em JavaScript

Source: https://www.typescriptlang.org/pt/docs/handbook/type-checking-javascript-files.html

Mostra como funções construtoras em JavaScript, antes do ES2015, podem ser usadas para simular métodos estáticos e organizar código, atribuindo propriedades à própria função.

```javascript
function Outer() {
  this.y = 2;
}
 
Outer.Inner = function () {
  this.yy = 2;
};
 
Outer.innter();
Try

```

--------------------------------

### Configurar Prepend em Referências de Projeto TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/project-references.html

Demonstra como habilitar a opção 'prepend' dentro do array 'references' no arquivo tsconfig.json. Isso instrui o compilador a incluir a saída da dependência referenciada acima da saída do projeto atual.

```json
"references": [
    { "path": "../utils", "prepend": true }
]
```

--------------------------------

### Demonstrar parâmetros opcionais e rest

Source: https://www.typescriptlang.org/pt/docs/handbook/type-compatibility.html

Mostra como o TypeScript trata parâmetros opcionais e rest de forma flexível para acomodar callbacks que recebem um número variável de argumentos.

```typescript
function chamaDepois(args: any[], callback: (...args: any[]) => void) {
  /* ... Chama callback com 'args' ... */
}
// Não sólido - chamaDepois "poderia" prover qualquer numero de argumentos
chamaDepois([1, 2], (x, y) => console.log(x + ", " + y));
// Confuso (x e y, na verdade, são requeridos ) e indetectáveis
chamaDepois([1, 2], (x?, y?) => console.log(x + ", " + y));
```

--------------------------------

### Definição de Decorador e Fábrica

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Demonstra a sintaxe básica para criar um decorador simples e uma fábrica de decoradores que permite a personalização com parâmetros.

```ts
function selado(alvo) {
  // executa algo com o alvo...
}

function cor(valor: string) {
  return function (alvo) {
    // este é o decorador
  };
}
```

--------------------------------

### Importando um Módulo de Ambiente em TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/namespaces-and-modules.html

Demonstra como importar um módulo de ambiente ('AlgumModulo') usando a instrução 'import' após referenciar seu arquivo de declaração com '/// <reference>'. Isso permite que o compilador localize as definições de tipo para o módulo.

```typescript
/// <reference path="meusModulos.d.ts" />
import * as m from "AlgumModulo";
```

--------------------------------

### Implementação de Decoradores de Parâmetro e Método

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Exemplo de criação de um decorador de parâmetro '@obrigatorio' para marcar argumentos e um decorador de método '@validar' para verificar a presença desses argumentos em tempo de execução. Requer a biblioteca 'reflect-metadata'.

```typescript
import "reflect-metadata";
const chaveDeMetodosNecessaria = Symbol("obrigatorio");

function obrigatorio(
  alvo: Object,
  chaveDePropriedade: string | symbol,
  indiceDeParametro: number
) {
  let parametrosNecessariosExistentes: number[] = Reflect.getOwnMetadata(chaveDeMetodosNecessaria, alvo, chaveDePropriedade) || [];
  parametrosNecessariosExistentes.push(indiceDeParametro);
  Reflect.defineMetadata(chaveDeMetodosNecessaria, parametrosNecessariosExistentes, alvo, chaveDePropriedade);
}

function validar(
  alvo: any,
  nomeDaPropriedade: string,
  descritor: PropertyDescriptor
) {
  let metodo = descritor.value;
  descritor.value = function () {
    let parametrosObrigatorios: number[] = Reflect.getOwnMetadata(chaveDeMetodosNecessaria, alvo, nomeDaPropriedade);
    if (parametrosObrigatorios) {
      for (let indiceDeParametro of parametrosObrigatorios) {
        if (indiceDeParametro >= arguments.length || arguments[indiceDeParametro] === undefined) {
          throw new Error("Argumento obrigatório ausente.");
        }
      }
    }
    return metodo.apply(this, arguments);
  };
}
```

--------------------------------

### Executar Compilação Incremental com tsc --build

Source: https://www.typescriptlang.org/pt/docs/handbook/project-references.html

Exemplos de uso da linha de comando para o modo de compilação incremental do TypeScript. O comando 'tsc -b' orquestra a compilação de projetos referenciados na ordem correta de dependência.

```shell
> tsc -b                            # Usa o tsconfig.json no diretório atual
> tsc -b src                        # Usa o src/tsconfig.json
> tsc -b foo/prd.tsconfig.json bar  # Usa o foo/prd.tsconfig.json e bar/tsconfig.json
```

--------------------------------

### Exemplo de declaração de importação

Source: https://www.typescriptlang.org/pt/docs/handbook/module-resolution.html

Demonstra a sintaxe de importação de módulos utilizada pelo TypeScript para localizar arquivos de definição durante a compilação.

```typescript
import { b } from "./moduleB";
import { b } from "moduleB";
```

--------------------------------

### Acesso a Propriedades Inexistentes em JavaScript

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-from-scratch.html

Ilustra como o JavaScript permite o acesso a propriedades que não existem em um objeto, resultando em `NaN` em operações matemáticas. Isso pode levar a bugs difíceis de rastrear.

```javascript
const obj = { width: 10, height: 15 };
// Porque isso é NaN? Ortografia é difícil!
const area = obj.width * obj.heigth;
```

--------------------------------

### Criar e compilar arquivo TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-tooling-in-5-minutes.html

Exemplo básico de uma função de saudação em TypeScript e o comando de terminal para compilar o arquivo .ts em um arquivo .js executável.

```typescript
function greeter(person) {
  return "Hello, " + person;
}

let user = "Jane User";

document.body.textContent = greeter(user);
```

```shell
tsc greeter.ts
```

--------------------------------

### Compile TypeScript to JavaScript using outFile flag

Source: https://www.typescriptlang.org/pt/docs/handbook/namespaces.html

Compiles multiple TypeScript files into a single JavaScript file named `sample.js`. The `--outFile` flag ensures that all referenced TypeScript files are concatenated in the correct order, respecting the /// <reference> directives.

```bash
tsc --outFile sample.js Test.ts
```

```bash
tsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts
```

--------------------------------

### Estender configurações base do tsconfig

Source: https://www.typescriptlang.org/pt/docs/handbook/tsconfig-json.html

Demonstra como utilizar a propriedade 'extends' para herdar configurações de ambientes específicos, como o @tsconfig/node12, simplificando a manutenção do arquivo de configuração do projeto.

```json
{
  "extends": "@tsconfig/node12/tsconfig.json",
  "compilerOptions": {
    "preserveConstEnums": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "**/*.spec.ts"]
}
```

--------------------------------

### Utilizando Tipos Genéricos

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes.html

Explica o uso de genéricos para criar componentes reutilizáveis que podem trabalhar com diferentes tipos de dados. Mostra a definição de arrays tipados e interfaces customizadas com parâmetros de tipo.

```typescript
type ArrayDeStrings = Array<string>;
type ArrayDeNumeros = Array<number>;
type ObjetoComNomeArray = Array<{ nome: string }>;

interface Mochila<Tipo> {
	adicionar: (obj: Tipo) => void;
	buscar: () => Tipo;
}

declare const mochila: Mochila<string>;
const objeto = mochila.buscar();
```

--------------------------------

### Comparação de Classes com Estruturas Idênticas em TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-oop.html

Mostra um cenário em TypeScript onde instâncias de classes diferentes (`Carro` e `Golfer`) podem ser atribuídas uma à outra se suas estruturas (métodos) forem idênticas, devido à tipagem estrutural.

```typescript
class Carro {
	dirigir() {
		// pressionar o acelerador
	}
}
class Golfer {
	dirigir() {
		// jogar a bola para longe
	}
}
// Sem erro?
let w: Carro = new Golfer();
```

--------------------------------

### Substituir sobrecargas por tipos de união em TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/declaration-files/do-s-and-don-ts.html

Demonstra como consolidar sobrecargas que diferem apenas pelo tipo de um argumento específico usando tipos de união. Esta abordagem facilita a passagem de valores dinâmicos para a função.

```typescript
/* ERRADO */
interface Momento {
  utcOffset(): number;
  utcOffset(b: number): Momento;
  utcOffset(b: string): Momento;
}

/* OK */
interface Momento {
  utcOffset(): number;
  utcOffset(b: number | string): Momento;
}
```

--------------------------------

### Definindo Tipos de União

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes.html

Demonstra como usar uniões para permitir que uma variável ou parâmetro aceite múltiplos tipos ou valores literais específicos. Inclui exemplos de tipos booleanos, literais de string/número e funções que lidam com tipos variados.

```typescript
type MeuBooleano = true | false;
type EstadoDaJanela = 'aberto' | 'fechado' | 'minimizado';
type EstadosDeBloqueio = 'trancado' | 'destrancado';
type NumerosImparesMenoresQue10 = 1 | 3 | 5 | 7 | 9;

function buscarComprimento(obj: string | string[]) {
	return obj.length;
}

function envolverEmArray(obj: string | string[]) {
  if (typeof obj === "string") {
    return [obj];
  }
  return obj;
}
```

--------------------------------

### Incluir bibliotecas integradas com referência de barra tripla

Source: https://www.typescriptlang.org/pt/docs/handbook/triple-slash-directives.html

Exemplo de uso da diretiva de referência de biblioteca para incluir tipos específicos, como os métodos de string do ES2017, garantindo que o compilador reconheça as APIs necessárias.

```typescript
/// <reference lib="es2017.string" />
"foo".padStart(4);
```

--------------------------------

### Uso de Decoradores em Classe

Source: https://www.typescriptlang.org/pt/docs/handbook/Decorators.html

Demonstração da aplicação dos decoradores '@validar' e '@obrigatorio' em um método de classe para garantir que o parâmetro 'nome' seja fornecido.

```typescript
class Recepcionista {
  cumprimento: string;
  constructor(mensagem: string) {
    this.cumprimento = mensagem;
  }
  @validar
  cumprimentar(@obrigatorio nome: string) {
    return "Olá " + nome + ", " + this.cumprimento;
  }
}
```

--------------------------------

### Utilizar interfaces para definir contratos

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-tooling-in-5-minutes.html

Uso de interfaces para descrever a estrutura esperada de um objeto, permitindo a verificação de compatibilidade de tipos baseada na estrutura interna.

```typescript
interface Person {
  firstName: string;
  lastName: string;
}

function greeter(person: Person) {
  return "Hello, " + person.firstName + " " + person.lastName;
}

let user = { firstName: "Jane", lastName: "User" };

document.body.textContent = greeter(user);
```

--------------------------------

### Definir funções e tipos de objetos no TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/typescript-in-5-minutes-func.html

Demonstra a sintaxe de tipagem para funções genéricas e literais de objeto, destacando como o TypeScript espelha a estrutura de valores JavaScript.

```typescript
let fst: <T, U>(a: T, b: U) => T = (a, b) => a;
let o: { n: number; xs: object[] } = { n: 1, xs: [] };
```

--------------------------------

### Configurar tsconfig.json com include e exclude

Source: https://www.typescriptlang.org/pt/docs/handbook/tsconfig-json.html

Exemplo de configuração que utiliza padrões glob para incluir diretórios inteiros de código-fonte e excluir pastas como node_modules ou arquivos de teste.

```json
{
  "compilerOptions": {
    "module": "system",
    "noImplicitAny": true,
    "removeComments": true,
    "preserveConstEnums": true,
    "outFile": "../../built/local/tsc.js",
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "**/*.spec.ts"]
}
```

--------------------------------

### Demonstrar bivariância de parâmetros de função

Source: https://www.typescriptlang.org/pt/docs/handbook/type-compatibility.html

Exemplifica como o TypeScript permite a atribuição de funções com tipos de parâmetros mais especializados em contextos onde um tipo base é esperado, facilitando padrões comuns de callback.

```typescript
enum EventType {
  Mouse,
  Keyboard,
}
interface Event {
  timestamp: number;
}
interface MouseEvent extends Event {
  x: number;
  y: number;
}
interface KeyEvent extends Event {
  keyCode: number;
}
function listenEvent(eventType: EventType, handler: (n: Event) => void) {
  /* ... */
}
// Não sólido, mas útil e comum
listenEvent(EventType.Mouse, (e: MouseEvent) => console.log(e.x + "," + e.y));
// Alternativas indesejáveis na presença de solidez
listenEvent(EventType.Mouse, (e: Event) =>
  console.log((e as MouseEvent).x + "," + (e as MouseEvent).y)
);
listenEvent(EventType.Mouse, ((e: MouseEvent) =>
  console.log(e.x + "," + e.y)) as (e: Event) => void);
// Ainda não permitido (erro claro). Segurança de tipos forçada para tipos completamente incompatíveis
listenEvent(EventType.Mouse, (e: number) => console.log(e));
```

--------------------------------

### Substituir sobrecargas por parâmetros opcionais em TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/declaration-files/do-s-and-don-ts.html

Demonstra a substituição de múltiplas sobrecargas de interface que diferem apenas nos parâmetros finais por uma única assinatura com parâmetros opcionais. Isso melhora a compatibilidade de assinaturas e a verificação de tipos com 'strict null checks'.

```typescript
/* ERRADO */
interface Exemplo {
  diff(um: string): number;
  diff(um: string, dois: string): number;
  diff(um: string, dois: string, tres: boolean): number;
}

/* OK */
interface Exemplo {
  diff(um: string, dois?: string, tres?: boolean): number;
}
```

--------------------------------

### TypeScript Alias Import for Namespaces

Source: https://www.typescriptlang.org/pt/docs/handbook/namespaces.html

Demonstrates using the `import q = x.y.z` syntax in TypeScript to create shorter aliases for commonly used objects or namespaces. This is distinct from module import syntax and can be used for any symbol, including types and namespaces.

```typescript
namespace Shapes {
  export namespace Polygons {
    export class Triangle {}
    export class Square {}
  }
}
import polygons = Shapes.Polygons;
let sq = new polygons.Square(); // Mesmo que 'new Shapes.Polygons.Square()'
```

--------------------------------

### Aumento de Módulos em TypeScript

Source: https://www.typescriptlang.org/pt/docs/handbook/declaration-merging.html

Demonstra como estender uma classe importada de outro módulo adicionando um novo método ao seu protótipo e informando o compilador através de uma declaração de módulo.

```typescript
// observable.ts
export class Observable<T> {
  // ... implementação deixada como exercício para o leitor ...
}

// map.ts
import { Observable } from "./observable";
declare module "./observable" {
  interface Observable<T> {
    map<U>(f: (x: T) => U): Observable<U>;
  }
}
Observable.prototype.map = function (f) {
  // ... outro exercicio para o leitor
};

// consumer.ts
import { Observable } from "./observable";
import "./map";
let o: Observable<number>;
o.map((x) => x.toFixed());
```
Tokens:
Raw