Aula 1 - TypeScript

O que é TypeScript?

TypeScript é um superset (superconjunto) do JavaScript. Ele adiciona tipagem estática, interfaces, modificadores de acesso, enumerações e outros recursos de linguagens mais robustas como Java ou C#.

TypeScript adiciona tipagem estática ao JavaScript, o que significa que você pode definir os tipos de variáveis, parâmetros de funções e retornos. Isso facilita a detecção de erros antes mesmo de executar o código. Benefícios do TypeScript:

Detecção precoce de erros: Menos bugs em produção.
Compatível com JavaScript: Permite a migração gradual de projetos.

História do TypeScript

Criado pela Microsoft em 2012.
Idealizado por Anders Hejlsberg, criador do C#.
Surgiu da necessidade de organizar grandes projetos JS.
Hoje amplamente usado com frameworks como Angular, React e Vue.

Objetivos e propósitos do TypeScript

Adicionar tipagem estática opcional.
Detectar erros antes da execução.
Facilitar desenvolvimento escalável.
Melhorar autocompletar e verificação nas IDEs.
Suporte a POO moderna.

Principais problemas do JavaScript (corrigidos pelo TypeScript)

Ausência de Tipagem Estática

let idade = 25;
idade = "vinte e cinco"; // Nenhum erro!

Problema: O tipo da variável pode mudar a qualquer momento, o que pode causar erros ocultos.

TypeScript corrige:

let idade: number = 25;
idade = "vinte e cinco";

Erro ao acessar propriedades inexistentes

const user = { nome: "Ana" };
console.log(user.idade); // undefined (mas sem erro!)

Problema: JS permite acessar propriedades que não existem, o que pode gerar falhas silenciosas.

TypeScript corrige:

const user: { nome: string } = { nome: "Ana" };
console.log(user.idade);

Problemas com `NaN` (Not a Number)

Exemplo em JavaScript:

function dividir(a, b) {
  return a / b;
}

console.log(dividir("abc", 2)); // NaN

Problema: O JavaScript não lança erro ao tentar dividir uma string por um número — retorna NaN. Esse erro só aparece em tempo de execução.

TypeScript corrige com verificação de tipos:

function dividir(a: number, b: number): number {
  return a / b;
}

dividir("abc", 2);

Com TypeScript, você previne o erro antes de executar o código, garantindo que os tipos estejam corretos.

Falta de recursos modernos (antes do ES6)

Antes do ES6, JavaScript não tinha classes, herança ou interfaces nativas. O TypeScript ofereceu essas ferramentas muito antes do JavaScript moderno.

Instalação do TypeScript

Node.js: Certifique-se de que o Node.js está instalado na sua máquina.
- Para verificar: node -v
npm: Instalado automaticamente com o Node.js.
- Para verificar: npm -v
Abra o terminal e execute o comando: npm install -g typescript
- Para verificar se o TypeScript foi instalado corretamente: tsc -v

Configurando um Projeto com TypeScript

Crie uma pasta para o projeto:
```
mkdir meu-projeto-typescript
```
```
cd meu-projeto-typescript
```
Inicialize o projeto com npm:
```
npm init -y
```
Adicione o TypeScript como dependência do projeto:
```
npm install typescript --save-dev
```
Crie o arquivo de configuração do TypeScript:
```
tsc --init
```

Isso criará um arquivo tsconfig.json, onde você pode ajustar configurações como o diretório de saída (outDir) e o diretório de entrada (rootDir).

// Exemplo básico de `tsconfig.json`:
{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "strict": true,
    "outDir": "./dist",
    "rootDir": "./src"
  }
}

Agora instale o TypeScript globalmente:

npm install -g typescript

Verificar versão:

tsc -v

Compilação de aplicativos TypeScript

Criar arquivo index.ts:

let nome: string = "Maria";
console.log(`Olá, ${nome}`);

Compilar com o comando:

tsc index.ts

Tipos de dados

let nome: string = "João";
let idade: number = 30;
let ativo: boolean = true;
let lista: number[] = [1, 2, 3];
let qualquer: any = "pode ser qualquer coisa";

Variáveis e constantes

let → variável com escopo de bloco

const → constante

var → não recomendado no TypeScript

let nome: string = "Carlos";
const PI: number = 3.14;

Saída no console

let nome: string = "Aline";
console.log("Olá, " + nome);