Como verificar se um objeto é um array em JavaScript: 3 melhores maneiras

Como verificar se um objeto é um array em JavaScript: guia completo

Você já se pegou pensando: "Achei que tinha passado um array, mas o código está dando erro"? Situação familiar. Em JavaScript, arrays são objetos, e a simples verificação com typeof não funciona aqui. Hoje vamos analisar três maneiras principais de verificar se um objeto é um array e descobrir qual delas vale a pena usar em projetos reais.

Por que o typeof não é adequado?

Antes de mergulharmos nos detalhes, vamos entender por que os iniciantes frequentemente tropeçam nesse ponto. Em JavaScript, arrays são um caso especial de objetos. Portanto, o operador typeof para um array retornará "object", e não "array". Experimente você mesmo:

const arr = [1, 2, 3];\nconsole.log(typeof arr); // "object" — inútil

Além disso, typeof null === "object" — este é um bug conhecido da linguagem que não será corrigido. Então, se você está verificando dados do usuário ou de uma API, não pode confiar em typeof. São necessários métodos mais confiáveis.

Método 1: Array.isArray() — o padrão moderno

A partir do ES5 (2009), o JavaScript introduziu o método nativo Array.isArray(). Esta é a maneira mais correta e simples de verificar se um objeto é um array.

const arr = [10, 20, 30];\nconst notArr = { length: 3, 0: 'a', 1: 'b', 2: 'c' };\n\nconsole.log(Array.isArray(arr));    // true\nconsole.log(Array.isArray(notArr)); // false\nconsole.log(Array.isArray('hello')); // false\nconsole.log(Array.isArray(null));    // false

Por que esta é a melhor escolha? Porque Array.isArray() funciona corretamente mesmo em cenários complexos: se o array veio de outro iframe ou frame, o instanceof pode falhar, mas o Array.isArray() não. Ele verifica o tipo interno [[Class]] do objeto, não a cadeia de protótipos.

Suporte a navegadores

O método é suportado por todos os navegadores modernos, incluindo Internet Explorer 9+. Se você precisar suportar navegadores muito antigos (IE 8 e inferiores), use um polyfill ou o terceiro método.

Método 2: instanceof Array — o clássico

O operador instanceof verifica se o protótipo Array.prototype está presente na cadeia de protótipos do objeto. Parece complicado, mas na prática funciona assim:

const arr = [1, 2, 3];\nconsole.log(arr instanceof Array); // true\n\nconst obj = { a: 1 };\nconsole.log(obj instanceof Array); // false\n\n// E aqui está a surpresa:\nconst iframeArr = new iframe.contentWindow.Array(1, 2, 3);\nconsole.log(iframeArr instanceof Array); // false! (se o array for de outro frame)

Aí está o problema: se você tem vários iframes na página ou trabalha com Web Workers, arrays de diferentes contextos globais têm protótipos diferentes. O instanceof não leva isso em conta e pode retornar false para um array verdadeiro. Portanto, no desenvolvimento moderno, é melhor evitar o instanceof para verificar arrays.

Método 3: Object.prototype.toString.call() — o soldado universal

Este método era usado antes do surgimento do Array.isArray(). Ele ainda é relevante se você precisar escrever um polyfill ou trabalhar em um ambiente onde Array.isArray não está disponível.

function isArray(obj) {\n  return Object.prototype.toString.call(obj) === '[object Array]';\n}\n\nconsole.log(isArray([1, 2]));      // true\nconsole.log(isArray({ a: 1 }));    // false\nconsole.log(isArray('string'));    // false\nconsole.log(isArray(null));        // false

Como funciona? O método toString do objeto Object.prototype retorna uma string no formato [object Type]. Para arrays, isso é sempre [object Array]. Este método contorna o problema dos iframes porque verifica o interno