In JavaScript (ECMAScript 5) there are not only objects and arrays, there are a total of 5 primitive types:

string, number, undefined, boolean, object

The usual way is to use the operator typeofthat will return the corresponding string, that is:

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

How? Yes, arrays are regular objects (where typeof [] === "object") but they have a relationship between the key(notation: valor[key]) and the property length. They also inherit from Array.prototype.

A good way (supported by all current browsers) to check if an object is an array is:Array.isArray(valor)

So you can't just tell the difference between array and object, since there's a chance that it's neither one thing nor the other.

You could do the following:

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.
}

But beware! , there is an exception, typeof null === 'object'so you should also check if the value is null or not, because a variable with value nullwould give a false positive as an object. This is a bug in ECMAScript 5, version 6 fixes it and returns 'null'.

I want to clarify that the variable could contain a function in which case it would betypeof function(){} === 'function'

More info on MDN , unfortunately it's in English.

You can use Object.prototype.toString.call(valor)to know the object type ofvalor

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"
}

Note : The string [object class ] where class can be Undefined , Null , or the class of the object is guaranteed by the ECMAScript 5.1 specification, section 15.2.4.2 . The possible values ​​for class can be consulted in section 8.6.2

How to differentiate between an object and an array?

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

A simple method would be to apply the function JSON.stringify()to the variable and check what the first character of the resulting string is:

• If it is a square bracket ( [), the variable was an array.
• If it is a brace ( {), the variable was an object.
• In any other case, the variable was something different.

With that in mind, I've created a simple function that returns the string "array" if the parameter was an array, "object" if the parameter was an object, or "other" if it's another type of variable:

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

Here is a series of examples:

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]+""
  )
}

The best way to validate that an object is of the JSON or Array type, I recommend the following, taking into account that:

var a = [],
    j = {};

Solution 1

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

Solution 2

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

But strictly speaking, an array is part of the JSON syntax. That said, the following two examples are a valid part of that structure.

Example 1:

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

Example 2:

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

In case of having a variable of type text (String) that you want to validate its structure to know if it coincides with any of both types mentioned, it would be advisable to use the following function:

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

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

You could use to detect json a

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

  }

You can see more info about the typeof here

Some time ago I had a similar problem, and I found the following solution, where u typeis assigned depending on what type your is , in this example it is an object.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") {

}

I hope it works for you.

Short answer

If your target is modern browsers, use Array.isArray(variable)the one introduced in ECMAScript 5. All details in Array.isArray() .

Explanation

According to ECMAScript 7 , an array, also called an array, is an exotic object that gives special treatment to array/array index property keys.

In other words, a shared array is an object with certain peculiarities which made it difficult to distinguish between an array and an object that is not an array. Fortunately Array.isArray()it was introduced as a standard feature and is supported by modern browsers.

Demonstration

/* 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

However, if you use a more general solution, where the data type is identified, consider using toString.call()it as this will return a string of the form [object class ] where class is indicates the data type.

Note: Do not assume that because object is indicated for primitives, everything is an object in JavaScript as this is incorrect. What happens is that JavaScript temporarily converts the primitive to an object in order to be able to call properties of the corresponding object, in this case the functiontoString

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]