Tipos de dados

Tipos de dados básicos

Number (número)

Representa números inteiros, decimais, hexadecimais binários e octais:

let idade: number = 30;
let preco: number = 19.99;
let hex: number = 0xf00d;
let binario: number = 0b1010;

String (texto)

Sequências de caracteres, podendo ser declaradas com aspas simples, duplas ou crase:

let nome: string = 'Gil';
let saudacao: string = "Olá, mundo!";
let template: string = `Meu nome é ${nome}`;

Boolean (booleano)

Valores lógicos: true ou false.

let ativo: boolean = true;
let inativo: boolean = false;

Array (vetor)

Coleção de elementos de mesmo tipo, declarada como tipo[] ou Array<tipo>:

let numeros: number[] = [1, 2, 3, 4];
let cores: string[] = ['vermelho', 'azul'];

Tuple (tupla)

Array de tamanho fixo em que o tipo de cada elemento pode ser diferente:

let pessoa: [string, number] = ['João', 25];

Enum (enumerado)

Define um conjunto de valores nomeados:

enum DiaSemana { Domingo, Segunda, Terça };
let hoje: DiaSemana = DiaSemana.Segunda;

Any (qualquer tipo)

Aceita qualquer valor, útil para migração de JavaScript:

let qualquerCoisa: any = 42;
qualquerCoisa = 'Olá';
qualquerCoisa = true;

Void

Usado em funções que não retornam valor:

function saudacao(): void {
  console.log('Olá, mundo!');
}

Null e Undefined

Representam ausência de valor e valor não definido:

let valorNulo: null = null;
let valorIndefinido: undefined = undefined;

Never

Usado para funções que nunca retornam (ex: lançam exceção):

function lancaErro(mensagem: string): never {
  throw new Error(mensagem);
}

Union (união)

Permite que uma variável tenha mais de um tipo:

let numeroOuTexto: number | string = 10;
numeroOuTexto = "dez";

Tipos de dados avançados

Genéricos (Generics)

Permitem criar funções, classes e interfaces reutilizáveis, que aceitam diferentes tipos como parâmetros.

function identidade<T>(valor: T): T {
  return valor;
}

let resultadoNum = identidade<number>(10);
let resultadoStr = identidade<string>("teste");

União e Interseção (Union & Intersection Types)

• União: Aceita múltiplos tipos.
• Interseção: Combina tipos diferentes em um só.

// União
let valor: string | number;
valor = "texto";
valor = 42;

// Interseção
type A = { nome: string };
type B = { idade: number };
type C = A & B; // { nome: string; idade: number }
const pessoa: C = { nome: "Anna", idade: 30 };

Tipos Literal e Template Literal Types

Permitem definir valores restritos e criar tipos dinâmicos baseados em combinações de strings.

type Dia = "segunda" | "terca" | "quarta";
type Saudacao = `Olá, ${Dia}!`;

const msg: Saudacao = "Olá, segunda!";

Tipos Discriminados (Discriminated Unions)

Modelam estados complexos, usados em respostas de APIs e máquinas de estados.

type Sucesso = { status: "ok"; dados: object };
type Falha = { status: "erro"; erro: string };
type Estado = Sucesso | Falha;

function tratar(estado: Estado) {
  if (estado.status === "ok") {
    console.log("Sucesso!");
  } else {
    console.log("Erro:", estado.erro);
  }
}

Tipos Mapeados (Mapped Types)

Criam novos tipos baseados em outros, modificando propriedades automaticamente.

type User = { id: number; nome: string };
// Todas as propriedades readonly
type ReadonlyUser = { readonly [K in keyof User]: User[K] };

// Todas as propriedades opcionais
type PartialUser = { [K in keyof User]?: User[K] };

Tipos Utilitários (Utility Types)

TypeScript oferece tipos auxiliares para manipular objetos e propriedades:

• Partial<T>: Todas as propriedades opcionais.
• Readonly<T>: Todas as propriedades somente leitura.
• Record<K,T>: Mapeia um conjunto de chaves a valores.
• Pick<T,K>: Seleciona propriedades específicas.
• Omit<T,K>: Exclui propriedades específicas.

interface Produto { id: number; nome: string; preco: number; }
type ProdutoOpcional = Partial<Produto>;
type ProdutoSomenteLeitura = Readonly<Produto>;
type ProdutoSelecao = Pick<Produto, "id" | "nome">;
type ProdutoSemPreco = Omit<Produto, "preco">;

Assertion e Type Guards

Permitem a validação ou conversão segura entre tipos.

let valor: any = "123";
let tamanho: number = (valor as string).length;

function isString(valor: unknown): valor is string {
  return typeof valor === "string";
}

Os tipos avançados tornam o TypeScript flexível e seguro para aplicações complexas, promovendo reutilização e robustez em projetos modernos.