Как эффективно проверить, является ли переменная массивом или объектом (в NodeJS и V8)?

Все объекты являются экземплярами как минимум одного класса — Object — в ECMAScript. Вы можете различать экземпляры встроенных классов и обычных объектов только с помощью Object#toString. Все они имеют одинаковый уровень сложности, например, независимо от того, созданы ли они с помощью оператора {} или оператора new.

Object.prototype.toString.call(object) лучше всего подходит для различения обычных объектов и экземпляров других встроенных классов, так как object === Object(object) здесь не работает. Однако я не вижу причин, по которым вам нужно делать то, что вы делаете, поэтому, возможно, если вы поделитесь вариантом использования, я могу предложить немного больше помощи.

Для простой проверки объекта или массива без дополнительного вызова функции (скорость).

массив()

isArray = function(a) {
    return (!!a) && (a.constructor === Array);
};
console.log(isArray(        )); // false
console.log(isArray(    null)); // false
console.log(isArray(    true)); // false
console.log(isArray(       1)); // false
console.log(isArray(   'str')); // false
console.log(isArray(      {})); // false
console.log(isArray(new Date)); // false
console.log(isArray(      [])); // true

являетсяОбъект()

isObject = function(a) {
    return (!!a) && (a.constructor === Object);
};
console.log(isObject(        )); // false
console.log(isObject(    null)); // false
console.log(isObject(    true)); // false
console.log(isObject(       1)); // false
console.log(isObject(   'str')); // false
console.log(isObject(      [])); // false
console.log(isObject(new Date)); // false
console.log(isObject(      {})); // true

Если дело просто в том, чтобы определить, имеете ли вы дело с Object, я мог бы подумать о

Object.getPrototypeOf( obj ) === Object.prototype

Однако это, вероятно, не удастся для необъектных примитивных значений. На самом деле нет ничего плохого в вызове .toString() для получения свойства [[cclass]]. Вы даже можете создать хороший синтаксис, например

var type = Function.prototype.call.bind( Object.prototype.toString );

а затем используйте его как

if( type( obj ) === '[object Object]' ) { }

Это может быть не самая быстрая операция, но я не думаю, что утечка производительности там слишком велика.

underscore.js использует следующее

toString = Object.prototype.toString;

_.isArray = nativeIsArray || function(obj) {
    return toString.call(obj) == '[object Array]';
  };

_.isObject = function(obj) {
    return obj === Object(obj);
  };

_.isFunction = function(obj) {
    return toString.call(obj) == '[object Function]';
  };

Привет, я знаю, что эта тема устарела, но есть гораздо лучший способ отличить массив в Node.js от любого другого объекта, взгляните на документы.

var util = require('util');

util.isArray([]); // true
util.isArray({}); // false

var obj = {};
typeof obj === "Object" // true

Я использую typeof, чтобы определить, является ли переменная, на которую я смотрю, объектом. Если это так, я использую instanceof, чтобы определить, какой это вид

var type = typeof elem;
if (type == "number") {
    // do stuff
}
else if (type == "string") {
    // do stuff
}
else if (type == "object") { // either array or object
    if (elem instanceof Buffer) {
    // other stuff

Только что нашел быстрое и простое решение для определения типа переменной.

ES6

export const isType = (type, val) => val.constructor.name.toLowerCase() === type.toLowerCase();

ES5

function isType(type, val) {
  return val.constructor.name.toLowerCase() === type.toLowerCase();
}

Примеры:

isType('array', [])
true
isType('array', {})
false
isType('string', '')
true
isType('string', 1)
false
isType('number', '')
false
isType('number', 1)
true
isType('boolean', 1)
false
isType('boolean', true)
true

ИЗМЕНИТЬ

Улучшение для предотвращения «неопределенных» и «нулевых» значений:

ES6

export const isType = (type, val) => !!(val.constructor && val.constructor.name.toLowerCase() === type.toLowerCase());

ES5

function isType(type, val) {
  return !!(val.constructor && val.constructor.name.toLowerCase() === type.toLowerCase());
}

Если вы знаете, что параметр определенно будет либо массивом, либо объектом, может быть проще проверить наличие массива по сравнению с проверкой объекта с чем-то вроде этого.

function myIsArray (arr) {
    return (arr.constructor === Array);
}

Лучший способ, которым я могу использовать свой проект. Используйте hasOwnProperty хитрым способом!.

var arr = []; (or) arr = new Array();
var obj = {}; (or) arr = new Object();

arr.constructor.prototype.hasOwnProperty('push') //true (This is an Array)

obj.constructor.prototype.hasOwnProperty('push') // false (This is an Object)

глядя на jQuery, они там jQuery.isArray(...) делают:

    isArray = Array.isArray || function( obj ) {
    return jQuery.type(obj) === "array";
}

это приводит нас к: jQuery.type:

    type = function( obj ) {
    return obj == null ?
        String( obj ) :
        class2type[ toString.call(obj) ] || "object";
}

и опять приходится заглядывать: class2type

class2type = {};

// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
    class2type[ "[object " + name + "]" ] = name.toLowerCase();
});

и в нативном JS:

var a, t = "Boolean Number String Function Array Date RegExp Object".split(" ");
for( a in t ) {
    class2type[ "[object " + t[a] + "]" ] = t[a].toLowerCase();
}

это заканчивается:

var isArray = Array.isArray || function( obj ) {
    return toString.call(obj) === "[object Array]";
}

Я знаю, что это было давно, но я подумал, что обновлю ответ, так как есть новые (более быстрые и простые) способы решения этой проблемы. Поскольку ECMAscript 5.1 вы можете использовать метод isArray() доступен в классе Array.

Вы можете увидеть его документацию в MDN здесь.

if (!Array.isArray) {
  Array.isArray = function(arg) {
    return Object.prototype.toString.call(arg) === '[object Array]';
  };
}

Я использовал эту функцию для решения:

function isArray(myArray) {
    return myArray.constructor.toString().indexOf("Array") > -1;
}