Se você está começando a estudar TypeScript, entender os tipos primitivos é o primeiro passo para escrever um código mais seguro, legível e fácil de manter.
Diferente do JavaScript, que possui tipagem dinâmica, o TypeScript adiciona um sistema de tipos estáticos. Isso significa que ele consegue identificar muitos erros durante o desenvolvimento, antes mesmo de o código ser executado.
Neste artigo, vamos conhecer os principais tipos primitivos do TypeScript e entender quando utilizar cada um deles.
O que são tipos primitivos?
Os tipos primitivos representam os tipos básicos de dados que uma variável pode armazenar.
Os principais são:
* `string`
* `number`
* `boolean`
* `null`
* `undefined`
* `bigint`
* `symbol`
Esses tipos são a base para praticamente tudo o que você fará em TypeScript.
—
String
O tipo `string` é utilizado para armazenar textos.
“`ts
const nome: string = “Lucas”;
const cidade = “Brasília”;
“`
No segundo exemplo, mesmo sem declarar `: string`, o TypeScript identifica automaticamente que o valor atribuído é uma string. Esse comportamento é conhecido como **inferência de tipos**.
Casos de uso:
* Nome de usuários
* Endereço
* Mensagens
* Títulos
—
## Number
O tipo `number` representa qualquer valor numérico, seja inteiro ou decimal.
“`ts
const idade: number = 25;
const salario: number = 3500.50;
const temperatura = 18;
“`
Ao contrário de outras linguagens, o TypeScript não possui tipos separados como `int`, `float` ou `double`. Todos os números utilizam apenas o tipo `number`.
—
## Boolean
O tipo `boolean` representa apenas dois valores possíveis:
* `true`
* `false`
“`ts
const usuarioLogado: boolean = true;
const possuiPermissao = false;
“`
Esse tipo é muito utilizado em validações e tomadas de decisão.
“`ts
if (usuarioLogado) {
console.log(“Bem-vindo!”);
}
“`
—
## Null
O tipo `null` representa a ausência intencional de um valor.
“`ts
const resposta: null = null;
“`
Ele normalmente é utilizado quando queremos indicar que determinado dado existe, mas ainda não possui um valor definido.
—
## Undefined
O tipo `undefined` indica que uma variável ainda não recebeu um valor.
“`ts
let usuario: undefined = undefined;
“`
Embora `null` e `undefined` pareçam semelhantes, eles possuem significados diferentes.
* `null`: ausência intencional de valor.
* `undefined`: valor ainda não definido.
—
## BigInt
O tipo `bigint` é utilizado para trabalhar com números inteiros muito grandes.
“`ts
const numeroGigante: bigint = 9007199254740991n;
“`
Na maioria das aplicações do dia a dia você dificilmente precisará utilizá-lo, mas ele é importante em cenários financeiros, científicos ou que envolvem números extremamente grandes.
—
## Symbol
O tipo `symbol` cria identificadores únicos.
“`ts
const id = Symbol(“id”);
“`
Mesmo que dois Symbols tenham a mesma descrição, eles nunca serão iguais.
“`ts
const id1 = Symbol(“id”);
const id2 = Symbol(“id”);
console.log(id1 === id2); // false
“`
Esse recurso é bastante utilizado internamente em bibliotecas e para evitar conflitos de propriedades em objetos.
—
## Inferência de tipos
Uma das maiores vantagens do TypeScript é sua capacidade de inferir tipos automaticamente.
“`ts
const nome = “Lucas”;
const idade = 25;
const ativo = true;
“`
Nesse exemplo, o TypeScript entende automaticamente que:
* `nome` é uma `string`;
* `idade` é um `number`;
* `ativo` é um `boolean`.
Por isso, nem sempre é necessário declarar o tipo explicitamente.
—
## Como o TypeScript ajuda a evitar erros?
Imagine o seguinte código:
“`ts
let idade: number = 25;
idade = “vinte e cinco”;
“`
Esse código gera um erro imediatamente no editor.
Isso acontece porque a variável foi definida como `number`, mas posteriormente recebeu uma `string`.
Sem TypeScript, esse problema só seria descoberto durante a execução da aplicação. Com TypeScript, o erro aparece enquanto você ainda está escrevendo o código.
Esse é um dos principais motivos pelos quais tantas equipes adotam TypeScript em projetos React, Angular, Node.js e outras aplicações JavaScript.
—
## Conclusão
Os tipos primitivos são a base do TypeScript e entender como eles funcionam torna o aprendizado dos próximos conceitos muito mais simples.
Neste artigo vimos:
* Como utilizar `string`;
* Quando usar `number`;
* Como funciona o tipo `boolean`;
* A diferença entre `null` e `undefined`;
* Quando utilizar `bigint`;
* O propósito do `symbol`;
* Como a inferência de tipos reduz a necessidade de declarações explícitas.
Dominar esses conceitos é o primeiro passo para escrever aplicações mais seguras, previsíveis e fáceis de manter.
No próximo artigo, vamos explorar a **inferência de tipos**, entender como o TypeScript consegue descobrir o tipo de uma variável automaticamente e quando vale a pena declarar o tipo manualmente.
