Как проверить, является ли переменная массивом в JavaScript?

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

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

Мне это кажется довольно изящным решением, но каждому свое.

Редактировать:

Начиная с ES5 теперь также:

Array.isArray(value);

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

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

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

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

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

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

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

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

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

Array.isArray(obj)

(Поддерживается Chrome 5, Firefox 4.0, IE 9, Opera 10.5 и Safari 5)

Если вам нужна поддержка более старых версий IE, вы можете использовать es5-shim для полифил-массива .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.prototype.isArray = true;

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

var box = doSomething();

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

isArray доступен, только если это массив

Через 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. На этой странице есть гораздо более сложная версия, если этого недостаточно.

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

e.g.,

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

Мне лично нравится предложение Питера: 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 The Definitive Guide 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]"

Подумал, что добавлю еще один вариант для тех, кто, возможно, уже использует библиотеку Underscore.js в своем скрипте. Underscore.js имеет функцию isArray () (см. http://underscorejs.org/#isArray).

_.isArray(object) 

Возвращает истину, если объект является массивом.

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

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

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

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

В JavaScript The Good Parts Крокфорда есть функция, проверяющая, является ли данный аргумент массивом:

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

Он объясняет:

Во-первых, мы спрашиваем, истинно ли значение. Мы делаем это, чтобы отклонить нулевые и другие ложные значения. Во-вторых, мы спрашиваем, является ли значение typeof «объектом». Это будет верно для объектов, массивов и (как ни странно) null. В-третьих, мы спрашиваем, имеет ли значение свойство длины, которое является числом. Это всегда будет верно для массивов, но обычно не для объектов. В-четвертых, мы спрашиваем, содержит ли значение метод сращивания. Это снова будет верно для всех массивов. Наконец, мы спрашиваем, является ли свойство length перечислимым (будет ли длина создаваться циклом for in?). Это будет неверно для всех массивов. Это самый надежный тест на массивность, который я нашел. Очень жаль, что это так сложно.

Универсальное решение представлено ниже:

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

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

Array.isArray(arr)

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

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

код, указанный на странице 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);};

Я использовал эту строку кода:

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

Для тех, кто кодирует гольф, ненадежный тест с наименьшим количеством символов:

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]

Из 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([]);

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

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

https://github.com/valtido/better-typeOf также немного писал об этом здесь http://www.jqui.net/jquery/better-typeof-than-the-javascript-native-typeof/

он работает аналогично текущему типу.

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

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

Я думаю, что лучше всего использовать myObj.constructor == Object и myArray.constructor == Array. Это почти в 20 раз быстрее, чем при использовании toString (). Если вы расширяете объекты своими собственными конструкторами и хотите, чтобы эти творения также считались «объектами», это не сработает, но в остальном все будет быстрее. typeof работает так же быстро, как и метод конструктора, но typeof [] == 'object' возвращает true, что часто бывает нежелательно. http://jsperf.com/constructor-vs-tostring

Следует отметить, что null.constructor выдаст ошибку, поэтому, если вы можете проверять нулевые значения, вам сначала придется выполнить if (testThing! == null) {}

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

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

Underscorejs и несколько других библиотек используют этот короткий и простой трюк.

Я только что придумал:

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