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

TypeScript Tipos Básico

Enums e literais

Em TypeScript, enums permitem definir um conjunto de constantes nomeadas, facilitando a leitura e a manutenção do código. Existem dois tipos principais: enum (que gera código JavaScript extra) e const enum (que é completamente removido na compilação, substituindo os valores diretamente).

Uma alternativa mais leve e idiomática é usar união de literais: type Direction = 'Up' | 'Down'. Isso evita a geração de código extra e ainda oferece verificação de tipos. Combinado com as const, você pode criar objetos que se comportam como enums, com a vantagem de serem apenas objetos JavaScript puros.

Cada abordagem tem seu lugar: enums são úteis quando você precisa de valores numéricos ou de um namespace, enquanto uniões de literais são preferíveis para valores string e quando se deseja zero overhead em runtime. O uso de as const é ideal para manter a imutabilidade e inferência literal.

Pontos-chave

  • enum gera um objeto JavaScript em tempo de execução, enquanto const enum é apagado na compilação.
  • Uniões de literais (type X = 'a' | 'b') são mais leves e não geram código extra.
  • as const torna um objeto literal imutável e preserva os tipos literais de suas propriedades.
  • Prefira uniões de literais ou as const para valores string; use enum quando precisar de valores numéricos ou de um namespace.
enums_literais.ts
// Exemplo de enum numérico	enum Direction {
  Up = 1,
  Down,
  Left,
  Right,
}

// const enum: não gera código JS, os valores são inline
const enum Status {
  Active = 'ACTIVE',
  Inactive = 'INACTIVE',
}

// União de literais: mais leve e sem código extra
type Color = 'red' | 'green' | 'blue';

// as const: objeto imutável com tipos literais
const Colors = {
  Red: 'red',
  Green: 'green',
  Blue: 'blue',
} as const;

type ColorFromConst = typeof Colors[keyof typeof Colors]; // 'red' | 'green' | 'blue'

function move(direction: Direction): void {
  console.log(`Movendo para ${Direction[direction]}`);
}

function paint(color: Color): void {
  console.log(`Pintando de ${color}`);
}

move(Direction.Up);
paint(Colors.Red);
console.log(Status.Active); // 'ACTIVE'

Exercícios

  1. 1
    Fácil

    Criando um enum de dias da semana

    Crie um enum chamado Weekday com os valores Monday, Tuesday, Wednesday, Thursday, Friday. Em seguida, escreva uma função isWeekday(day: Weekday): boolean que retorna true para qualquer dia de segunda a sexta e false para sábado e domingo. Imprima o resultado para Weekday.Monday e Weekday.Sunday (que não existe no enum, então use Weekday.Monday e um valor inválido? Não, use apenas os existentes).

    Resolver
  2. 2
    Médio

    Usando união de literais e as const

    Crie um tipo Status como união de literais: 'active' | 'inactive' | 'pending'. Depois, crie um objeto const StatusValues com as propriedades Active, Inactive e Pending usando as const, de forma que os valores sejam exatamente essas strings. Escreva uma função getStatusMessage(status: Status): string que retorna uma mensagem descritiva para cada status. Teste com StatusValues.Active e StatusValues.Pending.

    Resolver
  3. 3
    Desafio

    Comparando enum, const enum e união de literais

    Implemente três versões de um mesmo conceito: um enum chamado LogLevelEnum, um const enum chamado LogLevelConstEnum e um tipo união de literais LogLevelUnion. Cada um deve representar os níveis DEBUG, INFO, WARN, ERROR. Escreva uma função logMessage(level: LogLevelUnion, message: string): void que imprime a mensagem formatada de acordo com o nível (ex.: [DEBUG] mensagem). Em seguida, teste a função com todos os níveis usando o tipo união. Depois, mostre que os valores do enum e do const enum podem ser usados como argumentos para a função (se forem compatíveis).

    Resolver

Continue estudando

← Anterior na trilhaArrays e tuplas Próximo na trilha →Narrowing Trilha completaTodos os conceitos de TypeScript Qualquer linguagem🎲 Sortear outro conceito