如何在 JavaScript 中检查变量是否为数组？

您还可以使用：

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

在我看来，这似乎是一个非常优雅的解决方案，但对每个人来说都是他自己的。

编辑：

从 ES5 开始，现在还有：

Array.isArray(value);

但这在较旧的浏览器上会中断，除非您使用的是 polyfills（基本上......IE8 或类似版本）。

通过克罗克福德：

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

Crockford 提到的主要失败是无法正确确定在不同上下文中创建的数组，例如 . 如果这还不够，该页面有一个更复杂的版本。window

有多种解决方案各有各的怪癖。本页提供了一个很好的概述。一种可能的解决方案是：

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

我注意到有人提到了jQuery，但我不知道有一个isArray（）函数。事实证明，它是在 1.3 版中添加的。

jQuery按照Peter的建议实现它：

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

我已经对jQuery充满信心（尤其是他们的跨浏览器兼容性技术），我将升级到1.3版本并使用他们的功能（前提是升级不会导致太多问题），或者直接在我的代码中使用这个建议的方法。

非常感谢您的建议。

引用自 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);};

当我发布这个问题时，我使用的 JQuery 版本不包含函数。如果有的话，我可能会使用它，相信该实现是执行此特定类型检查的最佳独立于浏览器的方式。isArray

由于 JQuery 现在确实提供了这个功能，所以我会一直使用它......

$.isArray(obj);

（自 1.6.2 版起）它仍然使用对表单中的字符串进行比较来实现

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

这是一个老问题，但遇到同样的问题，我找到了一个非常优雅的解决方案，我想分享。

将原型添加到 Array 使它变得非常简单

Array.prototype.isArray = true;

现在，一旦你有一个对象，你想测试它是否是一个数组，你只需要检查新属性

var box = doSomething();

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

isArray 仅在其数组时可用

我个人喜欢 Peter 的建议：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 中，它说是使用 ECMAScript 5 实现的。另请注意，如果您要担心实现的更改，您还应该担心其他所有内置方法的更改。为什么使用？有人可以改变它！这种做法是愚蠢的。上述检查是为那些担心改变的人提供的解决方案，但我认为检查是不必要的。Array.isArray()Object.prototype.toString.call()toString()push()toString()

以为我会为那些可能已经在脚本中使用 Underscore.js 库的人添加另一个选项。Underscore.js 有一个 isArray（） 函数（参见 http://underscorejs.org/#isArray）。

_.isArray(object) 

如果 object 是 Array，则返回 true。

我使用的是这行代码：

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

我喜欢布莱恩的回答：

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

如果您只处理 EcmaScript 5 及更高版本，则可以使用内置函数Array.isArray

例如，

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

对于那些编写高尔夫代码的人来说，一个字符最少的不可靠测试：

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]

在 Crockford 的 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'));
};

他解释道：

首先，我们询问该值是否真实。我们这样做是为了拒绝 null 和其他虚假值。其次，我们询问值的类型是否为“对象”。对于对象、数组和（奇怪的）null 都是如此。第三，我们询问该值是否具有一个数字的 length 属性。对于数组，这始终是正确的，但对于对象通常不是这样。第四，我们询问该值是否包含拼接方法。这同样适用于所有数组。最后，我们询问 length 属性是否可枚举（长度会由 for 循环生成吗？对于所有数组，这都是错误的。这是我发现的最可靠的阵列性测试。不幸的是，它是如此复杂。

在现代浏览器（以及一些传统浏览器）中，您可以执行以下操作

Array.isArray(obj)

(基金资助Chrome 5、Firefox 4.0、IE 9、Opera 10.5 和 Safari 5）

如果需要支持旧版本的 IE，可以使用 es5-shim 对 Array.isArray 进行 polyfill;或添加以下内容

# 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

注意：可用于访问函数参数的关键字不是 Array，即使它（通常）的行为类似于 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)

由于 .length 属性是 javascript 中数组的特殊属性，因此您可以简单地说

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

Underscorejs 和其他几个库使用这个简短的技巧。

如果您使用的是 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

我创建了一小段代码，它可以返回真正的类型。

我还不确定性能，但这是正确识别类型的尝试。

https://github.com/valtido/better-typeOf 也在这里写了一些关于它的博客 http://www.jqui.net/jquery/better-typeof-than-the-javascript-native-typeof/

它的工作原理类似于当前的 typeof。

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

它认为它可能需要一些微调，并考虑到一些事情，我没有遇到或正确测试它。因此，欢迎进一步的改进，无论是性能方面，还是错误地重新移植 typeOf。

我认为使用 myObj.constructor==Object 和 myArray.constructor==Array 是最好的方法。它比使用 toString（） 快近 20 倍。如果您使用自己的构造函数扩展对象并希望这些创建也被视为“对象”，那么这是行不通的，但除此之外，它的速度更快。typeof 与构造函数方法一样快，但 typeof []=='object' 返回 true，这通常是不可取的。http://jsperf.com/constructor-vs-tostring

需要注意的一点是 null.constructor 会抛出一个错误，所以如果你可能正在检查 null 值，你必须先执行 if（testThing！==null）{}

有几种方法可以检查变量是否为数组。最好的解决方案是您选择的解决方案。

variable.constructor === Array

这是 Chrome 上最快的方法，很可能是所有其他浏览器。所有数组都是对象，因此检查构造函数属性对于 JavaScript 引擎来说是一个快速的过程。

如果在确定对象属性是否为数组时遇到问题，则必须首先检查该属性是否存在。

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

其他一些方法有：

Array.isArray(variable)

2019 年 5 月 23 日使用 Chrome 75 更新，向 @AnduAndrici 大喊大叫，让我带着他的问题重新审视这个问题在我看来，最后一个是最丑陋的，也是最慢最快的之一。作为第一个示例，运行速度约为 1/5。这家伙慢了大约 2-5%，但很难说。使用起来很扎实！结果给我留下了深刻的印象。Array.prototype，实际上是一个数组。您可以在此处阅读有关它的更多信息 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray

variable instanceof Array

作为第一个示例，此方法的运行速度约为 1/3。仍然相当坚固，看起来更干净，如果你只关注漂亮的代码而不是性能。请注意，检查数字不会像往常一样返回 。更新：instanceof 现在的速度提高了 2/3！variable instanceof Numberfalse

所以又一次更新

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

这家伙是尝试检查数组最慢的。但是，这是您正在寻找的任何类型的一站式商店。但是，由于您正在寻找数组，因此只需使用上面最快的方法即可。

另外，我进行了一些测试： http://jsperf.com/instanceof-array-vs-array-isarray/35 所以玩得开心，看看吧。

注意：@EscapeNetscape已创建另一个测试，因为 jsperf.com 已关闭。http://jsben.ch/#/QgYAV我想确保每当 jsperf 重新上线时，原始链接都会保留。

通用解决方案如下：

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

我刚刚想出的东西：

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

来自 w3schools：

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

我在这里尝试了大部分解决方案。但他们都没有奏效。然后我想出了一个简单的解决方案。希望它能帮助某人并节省他们的时间。

if(variable.constructor != undefined && variable.constructor.length > 0) {
        /// IT IS AN ARRAY
} else {
       /// IT IS NOT AN ARRAY
}

这是一个在旧浏览器和跨框架中都有效的答案。它采用了 EcmaScript 5+ 推荐的 Array.isArray（） 静态方法和 ES5 之前推荐的旧方法，并将它们组合在一起，以便您在新旧 JS 版本中都能正常工作：

isArray = Array.isArray || function(value) {
    return Object.prototype.toString.call(value)=="[object Array]";
}

isArray([]);//true

当然，Array.isArray（） 已经有 10 多年的历史了。因此，您可能不需要支持比这更旧的浏览器。但是，您不应低估仍然存在的旧浏览器的数量。

 if(elem.length == undefined){
    // is not an array
 }else{
    // is an array
 }