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

Я нашел возможное решение …

Это лучший способ сделать это?

if (variable.constructor == Array)...

Пользователи с вопросами

Есть несколько способов проверить, является ли переменная массивом или нет. Лучшее решение — это то, которое вы выбрали.

variable.constructor === Array

Это самый быстрый метод в Chrome и, скорее всего, во всех других браузерах. Все массивы являются объектами, поэтому проверка свойства конструктора является быстрым процессом для движков JavaScript.

Если у вас есть проблемы с выяснением, является ли свойство объекта массивом, вы должны сначала проверить, есть ли свойство там.

variable.prop && variable.prop.constructor === Array

Некоторые другие способы:

Array.isArray(variable)

Обновление 23 мая 2019 года с использованием Chrome 75, выкрикивайте @AnduAndrici за то, что я снова вернулась к нему со своим вопросом Этот последний, на мой взгляд, самый уродливый, и это один из самых медленных самых быстрых. имеет свойство Этот парень примерно на 2-5 % медленнее, но сказать это довольно сложно. Твердый в использовании! Впечатлен результатом. Array.prototype, на самом деле массив. Вы можете прочитать больше об этом здесь https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray

variable instanceof Array

Этот метод работает около 1/3 скорость в качестве первого примера. Все еще довольно солидно, выглядит чище, если вы все о симпатичном коде и не столько о производительности. Обратите внимание, что проверка чисел не работает как variable instanceof Number, всегда возвращает false Глядя на вывод Обновление: instanceof теперь идет на 2/3 скорости!

Посмотрите, как просто настроить такую ​​сложную инфраструктуру, как независимая от протокола и источника данных, используя простой файл конфигурации json и простой файл app.js …

Object.prototype.toString.call(variable) === '[object Array]';

Этот парень медленнее всех пытается проверить массив. Тем не менее, это универсальный магазин для любого типа, который вы ищете. Однако, так как вы ищете массив, просто используйте самый быстрый метод выше.

Кроме того, я провел несколько тестов: http://jsperf.com/instanceof-array-vs-array-isarray/35 Так что повеселитесь и проверьте это.

Примечание. @EscapeNetscape создал еще один тест, поскольку jsperf.com не работает. http://jsben.ch/ # / QgYAV Я хотел убедиться, что исходная ссылка остается на всякий раз, когда jsperf возвращается в сеть.

Вы также можете использовать:

if (value instanceof Array) {
  alert('value is Array!');
} else {
  alert('Not an array');
}

Это кажется мне довольно элегантным решением, но для каждого свое.

Мы только что выпустили

Что касается ES5, то теперь есть также:

Array.isArray(value);

Но это сломается в старых браузерах, если вы не используете полифилы (в основном … IE8 или аналогичные).

Я заметил, что кто-то упомянул jQuery, но я не знал, что существует isArray() функция. Оказывается, это было добавлено в версии 1.3.

, jQuery реализует его так, как предлагает Питер:

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

Уже поверив в jQuery (особенно в его методы кросс-браузерной совместимости), я либо обновлюсь до версии 1.3 и использую их функцию (при условии, что обновление не вызывает слишком много проблем), либо использую этот предложенный метод непосредственно в моем код.

Большое спасибо за предложения.

Есть несколько решений со всеми их причудами. эту страницу дает хороший обзор. Одно из возможных решений:

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

В современных браузерах (и некоторых устаревших браузерах) вы можете сделать

Array.isArray(obj)

Обратите внимание, что для тех, кто использует новый Поддерживается Chrome 5, Firefox 4.0, IE 9, Opera 10.5 и Safari 5)

Если вам нужно поддерживать более старые версии IE, вы можете использовать es5-shim , чтобы заполнить Array.isArray ; или добавить следующее

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

Если вы используете jQuery, вы можете использовать jQuery.isArray(obj) или $.isArray(obj). Если вы используете подчеркивание, вы можете использовать ключевое слово _.isArray(obj)

Если вам не нужно обнаруживать массивы, созданные в разных кадрах, вы также можете просто использовать instanceof

obj instanceof Array

Примечание : маркер arguments, которое можно использовать для доступа к аргументу функции, а не массива, даже если она (как правило) ведет себя как единое целое:

var func = function() {
  console.log(arguments)        // [1, 2, 3]
  console.log(arguments.length) // 3
  console.log(Array.isArray(arguments)) // false !!!
  console.log(arguments.slice)  // undefined (Array.prototype methods not available)
  console.log([3,4,5].slice)    // function slice() { [native code] } 
}
func(1, 2, 3)

Это старый вопрос, но с тем же проблема, я нашел очень элегантное решение, которым я хочу поделиться.

Добавление прототипа в Array делает его очень простым

Array.prototype.isArray = true;

Теперь, если у вас есть объект, который вы хотите проверить, чтобы увидеть, является ли он массивом, все, что вам нужно, это проверить новое свойство

var box = doSomething();

if (box.isArray) {
    // do something
}

, isArray доступен только в том случае, если its a array

или использование Crockford :

function typeOf(value) {
    var s = typeof value;
    if (s === 'object') {
        if (value) {
            if (value instanceof Array) {
                s = 'array';
            }
        } else {
            s = 'null';
        }
    }
    return s;
}

Основной провал, который упоминает Крокфорд, — это невозможность правильно определить массивы, созданные в другом контексте, например, window. Эта страница имеет гораздо более сложную версию, если этого недостаточно.

Мне лично нравится предложение Питера: https://stackoverflow.com/a/767499/414784 (для ECMAScript 3. Для ECMAScript 5 используйте Array.isArray() С чем вы столкнулись

комментарии к сообщению, однако, это означает, что если toString() вообще изменен, этот способ проверки массива потерпит неудачу. Если вы действительно хотите быть конкретным и убедиться, что toString() не был изменен, и нет проблем с атрибутом класса объектов ([object Array] является атрибутом класса объекта, который является массивом), тогда я рекомендую сделать что-то вроде этого:

//see if toString returns proper class attributes of objects that are arrays
//returns -1 if it fails test
//returns true if it passes test and it's an array
//returns false if it passes test and it's not an array
function is_array(o)
{
    // make sure an array has a class attribute of [object Array]
    var check_class = Object.prototype.toString.call([]);
    if(check_class === '[object Array]')
    {
        // test passed, now check
        return Object.prototype.toString.call(o) === '[object Array]';
    }
    else
    {
        // may want to change return value to something more desirable
        return -1; 
    }
}

Обратите внимание, что в JavaScript, 6-е издание Полного руководства, 7.10, говорится, что Array.isArray() реализован с использованием Object.prototype.toString.call() в ECMAScript 5 Также обратите внимание, что если вы будете беспокоиться об изменении реализации toString(), вам следует также беспокоиться об изменении любого другого встроенного метода. Зачем использоватьpush()? Кто-то может изменить это! Такой подход глупо. Вышеупомянутая проверка является предложенным решением для тех, кто беспокоится о смене toString(), но я считаю, что проверка не нужна.

Когда я отправил этот вопрос, версия JQuery, которую я использовал, не включала функцию isArray. Если бы он был, я бы, вероятно, просто использовал его, полагая, что реализация — лучший независимый от браузера способ выполнить эту конкретную проверку типа.

Так как JQuery теперь предлагает эту функцию, я бы всегда использовал ее …

$.isArray(obj);

(начиная с версии 1.6.2). Он по-прежнему реализован с использованием сравнений строк в виде

toString.call(obj) === "[object Array]"

Если вы имеете дело только с EcmaScript 5 и выше, вы можете использовать встроенную функцию Array.isArray function

, например, { *} http://underscorejs.org/ # isArray

Array.isArray([])    // true
Array.isArray("foo") // false
Array.isArray({})    // false

Думаю, я бы добавил еще один вариант для тех, кто уже использует библиотеку Underscore.js в своем скрипте. Underscore.js имеет функцию isArray () (см. Возвращает true, если объект является массивом. ).

_.isArray(object) 

Если вы используете Angular, вы можете использовать функцию angular.isArray ()

http://docs.angularjs.org/api/ng/function/angular.isArray

var myArray = [];
angular.isArray(myArray); // returns true

var myObj = {};
angular.isArray(myObj); //returns false

В

JavaScript Крокфорда Хорошие части , есть функция для проверки, является ли данный аргумент массивом: Он объясняет:

var is_array = function (value) {
    return value &&
        typeof value === 'object' &&
        typeof value.length === 'number' &&
        typeof value.splice === 'function' &&
        !(value.propertyIsEnumerable('length'));
};

Сначала мы спрашиваем, является ли значение истинным. Мы делаем это, чтобы отклонить нулевые и другие ложные значения. Во-вторых, мы спрашиваем, является ли значение typeof ‘object’. Это будет верно для объектов, массивов и (странно) пустых значений. В-третьих, мы спрашиваем, имеет ли значение свойство length, которое является числом. Это всегда будет верно для массивов, но обычно не для объектов. В-четвертых, мы спрашиваем, содержит ли значение метод соединения. Это снова будет верно для всех массивов. Наконец, мы спрашиваем, является ли свойство length перечислимым (будет ли длина получена циклом for in?). Это будет ложным для всех массивов. Это самый надежный тест на массивность, который я нашел. К сожалению, это так сложно.

Ниже приведено универсальное решение:

Начиная с ECMAScript 5 формальное решение:

Object.prototype.toString.call(obj)=='[object Array]'

Кроме того, для старых библиотек JavaScript вы можете найти следующее решение, хотя оно недостаточно точное:

Array.isArray(arr)

Решения получены из

var is_array = function (value) {
    return value &&
    typeof value === 'object' &&
    typeof value.length === 'number' &&
    typeof value.splice === 'function' &&
    !(value.propertyIsEnumerable('length'));
};

http://www.pixelstech.net/topic/85-How-to-check-whether-an-object-is-an-array-or-not-in-JavaScript Я использовал эту строку кода:

код по ссылке

if (variable.push) {
   // variable is array, since AMAIK only arrays have push() method.
}

https://github.com/miksago/Evan.js/blob/master/src/evan.js Для тех, кто использует код-гольф, ненадежный тест с наименьшим количеством символы:

  var isArray = Array.isArray || function(obj) {
    return !!(obj && obj.concat && obj.unshift && !obj.callee);};

Это обычно используется при обходе / выравнивании иерархии:

function isArray(a) {
  return a.map;
}

Мне понравился ответ Брайана:

function golf(a) {
  return a.map?[].concat.apply([],a.map(golf)):a;
}

input: [1,2,[3,4,[5],6],[7,[8,[9]]]]
output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

From W3Schools :

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

, но вы можете просто сделать так:

function is_array(o){
    // make sure an array has a class attribute of [object Array]
    var check_class = Object.prototype.toString.call([]);
    if(check_class === '[object Array]')    {
        // test passed, now check
        return Object.prototype.toString.call(o) === '[object Array]';
    } else{
        // may want to change return value to something more desirable
        return -1; 
    }
}

Я создал этот небольшой кусочек кода, который может вернуть истинные типы.

return Object.prototype.toString.call(o) === Object.prototype.toString.call([]);

Я еще не уверен в производительности, но это попытка правильно определить typeof.

http://www.jqui.net/jquery/better-typeof-than-the-javascript-native-typeof/

Кто-то использует Есть ли у него какие-либо другие функции? {* * } элемент с идентификатором это работает, подобно текущему типу.

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

var user = [1,2,3]
typeOf(user); //[object Array]

Я думаю, использование myObj.constructor == Object и myArray.constructor == Array — лучший способ. Это почти в 20 раз быстрее, чем при использовании toString (). Если вы расширяете объекты с помощью своих собственных конструкторов и хотите, чтобы эти создания также считались «объектами», это не сработает, но в противном случае это будет быстрее. typeof работает так же быстро, как и метод конструктора, но typeof [] == ‘object’ возвращает true, что часто нежелательно.

, так как Свойство .length специально для массивов в javascript, вы можете просто сказать

obj.length ===  obj.length // true if obj is an array

javascript — Как узнать, активен ли браузер / вкладка — Переполнение стека

Что-то, что я только что придумал:

if (item.length)
//This is an array
else
//not an array