Médio TypeScript

Status com tipos literais e union

Enunciado

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.

Requisitos

  • O tipo Status deve ser uma união de literais.
  • A função mostrarStatus deve imprimir o status.
  • A função proximoStatus deve retornar o próximo status ciclicamente.
  • Usar switch com casos para cada status.

Código inicial

type Status = 'ativo' | 'inativo' | 'pendente';

function mostrarStatus(status: Status): void {
  // Seu código aqui
}

function proximoStatus(status: Status): Status {
  // Seu código aqui
}

Saída esperada

Status: ativo
Status: inativo
Status: pendente
Próximo de pendente: ativo
Próximo de ativo: inativo
Próximo de inativo: pendente
Ver dica

No switch, cada case corresponde a um valor literal. O default pode lançar um erro ou retornar algo, mas como o tipo é fechado, o TypeScript sabe que todos os casos estão cobertos.

Mostrar solução 
type Status = 'ativo' | 'inativo' | 'pendente';

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

function proximoStatus(status: Status): Status {
  switch (status) {
    case 'pendente':
      return 'ativo';
    case 'ativo':
      return 'inativo';
    case 'inativo':
      return 'pendente';
  }
}

// Testes
mostrarStatus('ativo');
mostrarStatus('inativo');
mostrarStatus('pendente');
console.log(`Próximo de pendente: ${proximoStatus('pendente')}`);
console.log(`Próximo de ativo: ${proximoStatus('ativo')}`);
console.log(`Próximo de inativo: ${proximoStatus('inativo')}`);

Passo a passo

  1. Definimos Status como união de três literais string.
  2. mostrarStatus apenas imprime o valor.
  3. proximoStatus usa switch para mapear cada status ao próximo.
  4. Como todos os casos são cobertos, não precisamos de default; o TypeScript entende que a função sempre retorna Status.

Por que funciona

O switch sobre um union de literais permite que o TypeScript verifique exaustivamente os casos. Se esquecermos algum, o compilador pode reclamar (com noImplicitReturns ou strict).

Erros comuns

  • Esquecer um case: o TypeScript pode inferir que a função pode retornar undefined e dar erro se strictNullChecks estiver ativo.
  • Usar if em vez de switch: também funciona, mas o switch é mais claro para múltiplos literais.

Outra forma de resolver

Poderia usar um objeto de mapeamento: const proximo: Record<Status, Status> = { pendente: 'ativo', ativo: 'inativo', inativo: 'pendente' }. Isso é mais conciso, mas menos explícito.

Saída esperada

Status: ativo
Status: inativo
Status: pendente
Próximo de pendente: ativo
Próximo de ativo: inativo
Próximo de inativo: pendente