在 JavaScript (ECMAScript 5) 中不仅有对象和数组，一共有 5 种基本类型：

string, number, undefined, boolean, object

通常的方法是使用typeof将返回相应字符串的运算符，即：

typeof 'hola' === 'string'
typeof true === 'boolean'
typeof 123 === 'number'
typeof undefined === 'undefined'
typeof {} === 'object'
typeof [] === 'object'

如何？是的，数组是常规对象（ where ），但它们在（符号：）和 propertytypeof [] === "object"之间有关系。他们也继承自.keyvalor[key]lengthArray.prototype

检查对象是否为数组的一种好方法（所有当前浏览器都支持）是：Array.isArray(valor)

所以你不能只区分数组和对象，因为它有可能既不是一件事也不是另一件事。

您可以执行以下操作：

if (Array.isArray(valor)) {
  // es un array
} else if (typeof valor === 'object') {
  // es un objeto regular que no es un array
} else {
  // puede ser undefined, string, number o boolean.
}

但要小心！, 有一个例外，typeof null === 'object'所以你还应该检查值是否为空，因为具有值的变量null会误报为对象。这是 ECMAScript 5 中的一个错误，版本 6 修复了它并返回“null”。

我想澄清一下，该变量可能包含一个函数，在这种情况下它将是typeof function(){} === 'function'

有关MDN的更多信息，不幸的是它是英文的。

您可以使用Object.prototype.toString.call(valor)来了解对象类型valor

switch(Object.prototype.toString.call(valor)) {
    case '[object Array]':
        // Es un arreglo
        break;
    case '[object Object]':
        // Es un object
        break;
    default:
        // Es cualquier otro tipo incluyendo "Null", "Undefined",   
        // "Arguments", "Boolean", "Date", "Error", "Function", "JSON", "Math",
        // "Number", "RegExp" y "String"
}

注意：字符串[object class ]其中class可以是Undefined、Null或对象的类由ECMAScript 5.1 规范第 15.2.4.2 节保证。类的可能值可以在第 8.6.2 节中查阅

如何区分对象和数组？

if( Object.prototype.toString.call( valor ) === '[object Array]' ) {
     alert( 'Arreglo!' );
} else if ( Object.prototype.toString.call( valor ) === '[object Object]' ) {
     alert( 'Objeto!' );
}

一个简单的方法是将函数JSON.stringify()应用于变量并检查结果字符串的第一个字符是什么：

• 如果是方括号 ( [)，则变量是一个数组。
• 如果是大括号 ( {)，则该变量是一个对象。
• 在任何其他情况下，变量都是不同的。

考虑到这一点，我创建了一个简单的函数，如果参数是数组，则返回字符串“array”，如果参数是对象，则返回“object”，如果是另一种类型的变量，则返回“other”：

function arrayuobjeto(variable) {
  var aux = JSON.stringify(variable); 
  switch(aux[0]) {
    case "[": return "array";  break;
    case "{": return "objeto"; break;
    default:  return "otro";   break;
  }
}

以下是一系列示例：

function arrayuobjeto(variable) {
  //Si JSON.stringify lanza una excepción, entonces no era ni array ni objeto
  try {
    var aux = JSON.stringify(variable);
    switch(aux[0]) {
      case "[": return "array";  break;
      case "{": return "objeto"; break;
      default:  return "otro";   break;
    }
  } catch(ex) {
    return "otro";
  }
}
var ejemplos=[
  //Arrays
  [1,2] ,
  [] ,

  //Objetos
  {valor: 1} ,
  {} ,
  
  //Otros
  "[1,2]" ,
  "{ valor: 1}" ,
  "" ,
  " " ,
  1 ,
  0 ,
  true ,
  false ,
  null ,
  function(){} ,
  undefined
]
for(var i in ejemplos)
{
  console.log(
    arrayuobjeto(ejemplos[i]),
    typeof ejemplos[i]!="function"?
      JSON.stringify(ejemplos[i])
    :ejemplos[i]+""
  )
}

验证对象是否为 JSON 或 Array 类型的最佳方法，我推荐以下方法，同时考虑到：

var a = [],
    j = {};

解决方案 1

toString.call(o) === '[object Object]'; // true
toString.call(a) === '[object Array]'; // true

解决方案 2

a.constructor.name === 'Array'; // true
o.constructor.name === 'Object'; // true

但严格来说，数组是 JSON 语法的一部分。也就是说，以下两个示例是该结构的有效部分。

示例 1：

console.log(response); // {"message": "success"}
console.log(response); // {"user": "bart", "id":3}

示例 2：

console.log(response); // [{"user":"chofoteddy"}, {"user":"bart"}]
console.log(response); // ["chofoteddy", "bart"]

如果有一个文本（字符串）类型的变量，您想验证其结构以了解它是否与上述两种类型中的任何一种一致，建议使用以下函数：

function isJSON (valor) {
    if (typeof valor !== 'string')
        valor = JSON.stringify(valor);

    try {
        JSON.parse(valor);
        return true;
    } catch (e) {
        return false;
    }
}

你可以用来检测 json a

try{
    JSON.parse(valor);
    tipo = "JSON";
 }catch (Exception e){
    tipo =  typeof(valor) 
    //retornara undefined, number, boolean, string, object,null,function

  }

您可以在此处查看有关 typeof 的更多信息

前段时间我遇到了类似的问题，我找到了以下解决方案，根据你的类型分配你，type在这个例子中它是一个对象。arrayobjectjson

var myJson = {"name":"juan"};

var type = Object.prototype.toString.call(myJson).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();

if (type == "array") {                 

} else if (type == "object") {

}

我希望这个对你有用。

简短的回答

如果您的目标是现代浏览器，请使用Array.isArray(variable)ECMAScript 5 中介绍的浏览器。所有详细信息都在Array.isArray()中。

解释

根据ECMAScript 7，数组，也称为数组，是一种特殊对象，它对数组/数组索引属性键进行特殊处理。

换句话说，数组共享是一个具有某些特性的对象，这使得很难区分数组和不是数组的对象。幸运的是Array.isArray()，它是作为标准功能引入的，并且受到现代浏览器的支持。

示范

/* Primitivos */
console.info(Array.isArray(true)); // Booleano true. Devuelve false
console.info(Array.isArray(1)); // Entero. Devuelve false
console.info(Array.isArray(3.14)); // Número de punto flotante. Devuelve false
console.info(Array.isArray('Hola')); // Cadena. Devuelve false
console.info(Array.isArray(null)); // null. Devuelve false
console.info(Array.isArray(undefined)); // undefined. Devuelve false
console.info(Array.isArray(Symbol())); // Symbol. Devuelve false

/* Objetos */
console.info(Array.isArray({nombre:"Benito",apellido:"Juárez"})); // Objeto literal. Devuelve false
console.info(Array.isArray([1,2,3])); // Matriz. Devuelve true

但是，如果您使用更通用的解决方案，其中标识了数据类型，请考虑使用toString.call()它，因为这将返回 [object class ] 形式的字符串，其中class表示数据类型。

注意：不要假设因为对象是为基元指示的，所以 JavaScript 中的一切都是对象，因为这是不正确的。发生的情况是 JavaScript 临时将原语转换为对象，以便能够调用相应对象的属性，在这种情况下是函数toString

function describeTipo(o){
   console.info(toString.call(o));
}

describeTipo(1); // Devuelve [object Number]
describeTipo(3.14); // Devuelve [object Number]
describeTipo('Hola'); // Devuelve [object String]
describeTipo(null); // Devuelve [object Null]
describeTipo(undefined); // Devuelve [object Undefined]
describeTipo(Symbol()); // Devuelve [object Symbol]
describeTipo({nombre:"Benito",apellido:"Juárez"});// Devuelve [object Object]
describeTipo([1,2,3]); // Devuelve [object Array]