Desafio TypeScript

Tratamento de null e undefined em união

Enunciado

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.

Requisitos

  • A função deve aceitar string | number | null | undefined.
  • Tratar null e undefined separadamente.
  • Usar typeof para diferenciar número e string.
  • Retornar a string correta para cada caso.

Código inicial

function processarEntrada(entrada: string | number | null | undefined): string {
  // Seu código aqui
}

Saída esperada

Entrada nula
Entrada indefinida
Número: 42
Texto: HELLO
Ver dica

Verifique null e undefined primeiro, pois typeof null retorna 'object'. Use === null e === undefined.

Mostrar solução 
function processarEntrada(entrada: string | number | null | undefined): string {
  // Trata null explicitamente
  if (entrada === null) {
    return 'Entrada nula';
  }
  // Trata undefined explicitamente
  if (entrada === undefined) {
    return 'Entrada indefinida';
  }
  // Agora entrada é string | number
  if (typeof entrada === 'number') {
    return `Número: ${entrada}`;
  }
  // Aqui entrada é string
  return `Texto: ${entrada.toUpperCase()}`;
}

// Testes
console.log(processarEntrada(null));
console.log(processarEntrada(undefined));
console.log(processarEntrada(42));
console.log(processarEntrada('hello'));

Passo a passo

  1. A função recebe união de quatro tipos.
  2. Primeiro verificamos entrada === null e retornamos a mensagem.
  3. Depois verificamos entrada === undefined e retornamos a mensagem.
  4. Após esses dois if, o TypeScript sabe que entrada é string | number.
  5. Usamos typeof entrada === 'number' para separar número de string.
  6. No final, entrada é string e podemos usar toUpperCase().

Por que funciona

A ordem das verificações é crucial: null e undefined são tratados antes de typeof, pois typeof null retorna 'object', o que poderia causar confusão. Após eliminá-los, o narrowing com typeof funciona perfeitamente.

Erros comuns

  • Verificar typeof entrada === 'object' para null: isso não distingue null de outros objetos, e não é necessário aqui.
  • Esquecer de tratar undefined e tentar acessar métodos: causaria erro em tempo de execução se strictNullChecks não estiver ativo, ou erro de compilação se estiver.
  • Usar if (entrada) para verificar null/undefined: valores como 0 ou '' seriam falsy e tratados incorretamente.

Outra forma de resolver

Poderia usar entrada == null (com dois iguais) para capturar tanto null quanto undefined de uma vez, mas o enunciado pede mensagens distintas, então a verificação separada é necessária.

Saída esperada

Entrada nula
Entrada indefinida
Número: 42
Texto: HELLO