Da trilha de TypeScript Este conceito ainda não saiu como card do dia. ir para o card de hoje

TypeScript Tipos Básico

Union types

Em TypeScript, union types permitem que uma variável aceite valores de mais de um tipo. Você os declara usando o operador | (pipe), por exemplo: let id: number | string. Isso é útil quando um valor pode ser de tipos diferentes em momentos distintos.

Além de tipos primitivos, você pode usar tipos literais para restringir a valores específicos, como "ativo" | "inativo". A combinação de unions com literais cria tipos precisos e seguros.

Para usar um valor de union type, muitas vezes é necessário narrowing (estreitamento). O operador typeof é uma forma comum de verificar o tipo em tempo de execução e permitir que o TypeScript saiba qual tipo está presente em cada ramo do código.

Unions também são essenciais para lidar com null e undefined, especialmente quando a opção strictNullChecks está ativada. Você pode incluir esses tipos na união e depois verificar com typeof ou comparações diretas.

Pontos-chave

  • Union types são declarados com | e permitem que uma variável tenha mais de um tipo.
  • Tipos literais restringem os valores possíveis a strings ou números específicos.
  • typeof é usado para narrowing: verifica o tipo em tempo de execução e refina o tipo estático.
  • null e undefined podem ser incluídos em unions para indicar ausência de valor.
  • O narrowing é essencial para acessar propriedades ou métodos específicos de cada tipo.
union_types.ts
// Exemplo de union types com narrowing usando typeof
function formatarId(id: number | string): string {
  // Narrowing: se for number, formata como número
  if (typeof id === 'number') {
    return `ID numérico: ${id.toFixed(0)}`;
  }
  // Aqui id é string
  return `ID textual: ${id.toUpperCase()}`;
}

// Union com tipos literais
 type Status = 'ativo' | 'inativo' | 'pendente';

function mostrarStatus(status: Status): void {
  console.log(`Status: ${status}`);
}

// Union com null e undefined
function saudacao(nome: string | null | undefined): string {
  if (nome === null) return 'Olá, visitante (null)';
  if (nome === undefined) return 'Olá, visitante (undefined)';
  return `Olá, ${nome}`;
}

// Testando
console.log(formatarId(42));
console.log(formatarId('abc123'));
mostrarStatus('ativo');
console.log(saudacao('Maria'));
console.log(saudacao(null));
console.log(saudacao(undefined));

Exercícios

  1. 1
    Fácil

    Formatar ID com union type

    Crie uma função formatarId que recebe um parâmetro id do tipo number | string e retorna uma string formatada. Se for número, retorne "ID numérico: X" (com X sendo o número). Se for string, retorne "ID textual: Y" (com Y em maiúsculas). Use narrowing com typeof.

    Resolver
  2. 2
    Médio

    Status com tipos literais e union

    Defina um tipo Status que pode ser 'ativo' | 'inativo' | 'pendente'. Crie uma função mostrarStatus que recebe um Status e imprime "Status: X". Depois, crie uma função proximoStatus que recebe um Status e retorna o próximo status na sequência: 'pendente' -> 'ativo', 'ativo' -> 'inativo', 'inativo' -> 'pendente'. Use um switch para garantir que todos os casos sejam tratados.

    Resolver
  3. 3
    Desafio

    Tratamento de null e undefined em união

    Crie uma função processarEntrada que recebe um parâmetro entrada do tipo string | number | null | undefined. A função deve retornar uma string:

    • Se for null, retorne "Entrada nula".
    • Se for undefined, retorne "Entrada indefinida".
    • Se for número, retorne "Número: X" (X é o número).
    • Se for string, retorne "Texto: Y" (Y é a string em maiúsculas). Use narrowing com typeof e comparações diretas. Teste com todos os casos.

    Resolver

Continue estudando