Desafio JavaScript

Verificador de tipos primitivos

Enunciado

Crie uma função tipoPrimitivo(valor) que retorne uma string indicando o tipo primitivo do valor. Ela deve tratar corretamente null (retornar "null" em vez de "object"), bigint e symbol. Para valores não primitivos (objetos, arrays, funções), deve retornar "objeto" ou "funcao" conforme o caso. Depois, teste a função com pelo menos 7 valores diferentes e imprima os resultados no formato valor -> tipo.

Requisitos

  • A função deve retornar "null" para null.
  • A função deve retornar "bigint" e "symbol" corretamente usando typeof.
  • A função deve retornar "funcao" para funções e "objeto" para objetos e arrays.
  • O programa deve testar a função com pelo menos 7 valores e imprimir cada resultado no formato valor -> tipo.

Código inicial

function tipoPrimitivo(valor) {
  // Implemente a lógica
}

// Testes

Saída esperada

Ana -> string
25 -> number
true -> boolean
null -> null
undefined -> undefined
9007199254740993n -> bigint
Symbol(id) -> symbol
[1,2] -> objeto
function(){} -> funcao
Ver dica

Use typeof para a maioria dos casos. Para null, verifique explicitamente valor === null. Para diferenciar função de objeto, use typeof valor === 'function'.

Mostrar solução 
function tipoPrimitivo(valor) {
  // Trata null explicitamente, pois typeof null retorna 'object'
  if (valor === null) return 'null';

  const tipo = typeof valor;

  // Funções são um caso especial de objeto
  if (tipo === 'function') return 'funcao';

  // Objetos (incluindo arrays) não são primitivos
  if (tipo === 'object') return 'objeto';

  // Demais tipos primitivos: string, number, boolean, undefined, bigint, symbol
  return tipo;
}

// Testes
const valores = [
  'Ana',
  25,
  true,
  null,
  undefined,
  9007199254740993n,
  Symbol('id'),
  [1, 2],
  function() {}
];

for (const v of valores) {
  console.log(`${String(v)} -> ${tipoPrimitivo(v)}`);
}

Passo a passo

  1. A função tipoPrimitivo recebe um valor e primeiro verifica se é null com valor === null, retornando 'null'.
  2. Em seguida, obtém o tipo com typeof valor.
  3. Se o tipo for 'function', retorna 'funcao'.
  4. Se o tipo for 'object' (e não for null, já tratado), retorna 'objeto'.
  5. Caso contrário, retorna o próprio tipo, que será 'string', 'number', 'boolean', 'undefined', 'bigint' ou 'symbol'.
  6. No array de testes, incluímos valores de todos os tipos primitivos e também um array e uma função.
  7. O loop percorre o array e imprime cada valor formatado com String(v) e o resultado da função.

Por que funciona

A função contorna a peculiaridade de typeof null com uma verificação explícita. Também separa funções de objetos, pois embora funções sejam objetos em JavaScript, typeof as identifica como 'function'. Para os demais primitivos, typeof já retorna o nome correto. Assim, a função classifica corretamente todos os casos solicitados.

Erros comuns

  • Esquecer de tratar null antes de typeof: typeof null retorna 'object', então a função retornaria 'objeto' incorretamente.
  • Usar valor instanceof Object para detectar objetos: arrays e funções também são instâncias de Object, mas a função deve diferenciá-los. Melhor usar typeof.
  • Não converter o valor para string ao imprimir: Symbol não pode ser concatenado diretamente com + (lança TypeError). Use template string ou String(v).

Outra forma de resolver

Usar Object.prototype.toString.call(valor) para obter o tipo interno, que retorna [object Null], [object Array], etc. Exemplo:

function tipoPrimitivo(valor) {
  const tag = Object.prototype.toString.call(valor);
  if (tag === '[object Null]') return 'null';
  if (tag === '[object Array]') return 'objeto';
  // ...
}

Preferível quando se precisa distinguir arrays de objetos comuns, mas é mais verboso.

Saída esperada

Ana -> string
25 -> number
true -> boolean
null -> null
undefined -> undefined
9007199254740993n -> bigint
Symbol(id) -> symbol
[1,2] -> objeto
function(){} -> funcao