如何检查对象是否为数组？

我正在尝试编写一个接受字符串列表或单个字符串的函数。如果它是一个字符串，那么我想将其转换为仅包含一项的数组，因此我可以遍历它而不必担心错误。

那么，如何检查变量是否为数组？

我整理了以下各种解决方案，并创建了jsperf测试。它们都非常快，因此只需使用Array.isArray- 现在得到了很好的支持，并且可以跨框架使用。

在现代浏览器中，您可以

Array.isArray(obj)

（受 Chrome 5，Firefox 4.0，IE 9，Opera 10.5和Safari 5支持）

为了向后兼容，您可以添加以下内容

# 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

ECMAScript标准中提供的用于找到Object类的toString方法是使用中的方法Object.prototype。

if( Object.prototype.toString.call( someVar ) === '[object Array]' ) {
    alert( 'Array!' );
}

或者您可以使用typeof它来测试它是否为字符串：

if( typeof someVar === 'string' ) {
    someVar = [ someVar ];
}

或者，如果您不关心性能，则可以concat对一个新的空数组执行a操作。

someVar = [].concat( someVar );

还有一个可以直接查询的构造函数：

if (somevar.constructor.name == "Array") {
    // do something
}

检查出一个彻底的治疗从@TJ克罗德的博客，张贴在下面他的评论。

查看此基准，以了解哪种方法效果更好：http : //jsben.ch/#/QgYAV

从@Bharath使用Es6将字符串转换为数组以解决以下问题：

const convertStringToArray = (object) => {
   return (typeof object === 'string') ? Array(object) : object 
}

假设：

let m = 'bla'
let n = ['bla','Meow']
let y = convertStringToArray(m)
let z = convertStringToArray(n)
console.log('check y: '+JSON.stringify(y)) . // check y: ['bla']
console.log('check y: '+JSON.stringify(z)) . // check y: ['bla','Meow']

我将首先检查您的实现是否支持isArray：

if (Array.isArray)
    return Array.isArray(v);

您也可以尝试使用instanceof运算符

v instanceof Array

jQuery还提供了一种$.isArray()方法：

var a = ["A", "AA", "AAA"];

if($.isArray(a)) {
  alert("a is an array!");
} else {
  alert("a is not an array!");
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

在所有方法（支持所有浏览器）中，这是最快的：

function isArray(obj){
    return !!obj && obj.constructor === Array;
}

假设您在下面有这个数组：

var arr = [1,2,3,4,5];

Javascript（新旧浏览器）：

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

要么

function isArray(arr) {
  return arr instanceof Array;
}

要么

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

然后这样称呼它：

isArray(arr);

Javascript（IE9 +，Ch5 +，FF4 +，Saf5 +，Opera10.5 +）

Array.isArray(arr);

jQuery的：

$.isArray(arr);

角度：

angular.isArray(arr);

下划线和Lodash：

_.isArray(arr);

Array.isArray可以快速运行，但并非所有版本的浏览器都支持。因此，您可以为其他人设置例外并使用通用方法：

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }

简单的功能检查一下：

function isArray(object)
{
    return object.constructor === Array;
}

正如MDN 在这里所说：

使用Array.isArray或Object.prototype.toString.call区分常规对象和数组

像这样：

• Object.prototype.toString.call(arr) === '[object Array]'， 要么

• Array.isArray(arr)

这个问题只有一种解决方案

x instanceof Array

其中x是变量，如果x是一个数组，它将返回true，否则返回false。

您可以检查变量的类型是否为数组；

var myArray=[];

if(myArray instanceof Array)
{
....
}

我将提供一个功能来测试您要处理的对象的类型...

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }

// tests
console.log(
  whatAmI(["aiming","@"]),
  whatAmI({living:4,breathing:4}),
  whatAmI(function(ing){ return ing+" to the global window" }),
  whatAmI("going to do with you?")
);

// output: Array Object Function String

那么您可以编写一个简单的if语句...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}

我用一种非常简单的方式来做。为我工作。有什么缺点吗？

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)

考虑到以下评论，这是我尝试改善此答案的尝试：

var isArray = myArray && myArray.constructor === Array;

它摆脱了if / else，并考虑了数组为null或undefined的可能性

https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Global_Objects/Array/isArray

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

我用两种替代方法以及错误检查更新了jsperf提琴。

事实证明，在“对象”和“数组”原型中定义常量值的方法比任何其他方法都快。这是一个令人惊讶的结果。

/* Initialisation */
Object.prototype.isArray = function() {
  return false;
};
Array.prototype.isArray = function() {
  return true;
};
Object.prototype._isArray = false;
Array.prototype._isArray = true;

var arr = ["1", "2"];
var noarr = "1";

/* Method 1 (function) */
if (arr.isArray()) document.write("arr is an array according to function<br/>");
if (!noarr.isArray()) document.write("noarr is not an array according to function<br/>");
/* Method 2 (value) - **** FASTEST ***** */
if (arr._isArray) document.write("arr is an array according to member value<br/>");
if (!noarr._isArray) document.write("noarr is not an array according to member value<br/>");

如果变量采用未定义的值，这两种方法将不起作用，但是，如果您确定它们具有值，则它们将起作用。关于考虑性能的问题，值是数组还是单个值，第二种方法看起来像是有效的快速方法。它比Chrome上的“ instanceof”稍快，是Internet Explorer，Opera和Safari（在我的机器上）的次佳方法的两倍。

我知道，人们正在寻找某种原始的javascript方法。但是，如果您想考虑的较少，请看这里：http : //underscorejs.org/#isArray

_.isArray(object) 

如果object是Array，则返回true。

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true

我见过的最好的解决方案是跨浏览器替换typeof。在此处检查Angus Croll的解决方案。

TL; DR版本在下面，但是本文对这个问题进行了很好的讨论，因此如果有时间，您应该阅读它。

Object.toType = function(obj) {
    return ({}).toString.call(obj).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
// ... and usage:
Object.toType([1,2,3]); //"array" (all browsers)

// or to test...
var shouldBeAnArray = [1,2,3];
if(Object.toType(shouldBeAnArray) === 'array'){/* do stuff */};

这是我的懒惰方法：

if (Array.prototype.array_ === undefined) {
  Array.prototype.array_ = true;
}

// ...

var test = [],
    wat = {};

console.log(test.array_ === true); // true
console.log(wat.array_ === true);  // false

我知道要“与”原型“讨好”是牺牲品，但它的性能似乎明显优于推荐的toString方法。

注：此方法的缺陷是，它不会工作跨越iframe边界，但我的使用情况下，这不是一个问题。

Stoyan Stefanov的书《JavaScript模式》中有一个很好的示例，该示例假定可以处理所有可能的问题并利用ECMAScript 5方法Array.isArray（）。

所以这里是：

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

顺便说一句，如果您使用的是jQuery，则可以使用它的方法$ .isArray（）

检查对象是否为数组的最简单，最快的方法。

 var arr = [];
  arr.constructor.name ==='Array'  //return true;

要么

arr.constructor ===Array //return true;

或者您可以使一个实用程序功能：

function isArray(obj){ return obj && obj.constructor ===Array}

用法：

isArray(arr); //return true

如果您知道您的对象没有concat方法，则可以使用以下内容。

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an array");
}

您可以使用isArray方法，但我希望与

Object.getPrototypeOf(yourvariable) === Array.prototype

如果只能传递给此函数的两种值是字符串或字符串数​​组，请使其简单并使用typeof检查字符串可能性的方法：

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}

A = [1,2,3]
console.log(A.map==[].map)

在搜索最短版本时，这是我到目前为止所得到的。

注意，没有完美的功能可以始终检测所有可能的组合。最好了解工具的所有功能和局限性，而不是期望使用魔术工具。

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

var ar = ["ff","tt"]
alert(isArray(ar))

测试输入值是否为数组的简单函数如下：

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

这适用于跨浏览器，以及旧版浏览器。这是从TJ Crowders的博客文章中提取的

您可以尝试以下方法：

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

arr.constructor.prototype.hasOwnProperty('push') //true

obj.constructor.prototype.hasOwnProperty('push') // false

这个函数将把几乎所有东西变成一个数组：

function arr(x) {
    if(x === null || x === undefined) {
        return [];
    }
    if(Array.isArray(x)) {
        return x;
    }
    if(isString(x) || isNumber(x)) {
        return [x];
    }
    if(x[Symbol.iterator] !== undefined || x.length !== undefined) {
        return Array.from(x);
    }
    return [x];
}

function isString(x) {
    return Object.prototype.toString.call(x) === "[object String]"
}

function isNumber(x) {
    return Object.prototype.toString.call(x) === "[object Number]"
}

它使用了一些较新的浏览器功能，因此您可能想对此进行填充以提供最大支持。

例子：

> arr(null);
[]
> arr(undefined)
[]
> arr(3.14)
[ 3.14 ]
> arr(1/0)
[ Infinity ]
> gen = function*() { yield 1; yield 2; yield 3; }
[Function: gen]
> arr(gen())
[ 1, 2, 3 ]
> arr([4,5,6])
[ 4, 5, 6 ]
> arr("foo")
[ 'foo' ]

NB字符串将被转换为具有单个元素的数组，而不是字符数组。isString如果您不希望这样做，请删除该支票。

我在Array.isArray这里使用过，因为它是最可靠且最简单的。

在您的情况下，您可以使用Arrayconcat方法，该方法既可以接受单个对象，也可以接受数组（甚至可以合并）：

function myFunc(stringOrArray)
{
  var arr = [].concat(stringOrArray);

  console.log(arr);

  arr.forEach(function(item, i)
  {
    console.log(i, "=", item);
  })
}

myFunc("one string");

myFunc(["one string", "second", "third"]);

concat 似乎是Array最古老的方法之一（即使IE 5.5也很清楚）。