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

Question

我正在尝试编写一个接受字符串列表或单个字符串的函数。如果它是一个字符串，那么我想将它转换为一个只有一个项目的数组，这样我就可以循环它而不必担心出错。

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

score 2007 · Accepted Answer

ECMAScript 标准中给出的查找Object类的方法是使用toStringfrom 的方法Object.prototype。

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

或者你可以typeof用来测试它是否是一个字符串：

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

或者如果你不关心性能，你可以concat对一个新的空数组做一个。

someVar = [].concat(someVar);

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

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

从TJ Crowder 的博客中查看彻底的治疗，正如他在下面的评论中所发布的那样。

查看此基准以了解哪种方法性能更好：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']

score 1461 · Accepted Answer

在现代浏览器中，您可以：

Array.isArray(obj)

（受Chrome 5、Firefox 4.0、Internet Explorer 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)or $.isArray(obj)。如果你使用Underscore.js，你可以使用_.isArray(obj).

如果您不需要检测在不同帧中创建的数组，您也可以使用instanceof：

obj instanceof Array

score 1315 · Accepted Answer

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

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

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

v instanceof Array

score 305 · Accepted Answer

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>

score 108 · Accepted Answer

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

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

score 50 · Accepted Answer

想象一下，您在下面有这个数组：

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（Internet Explorer 9+、Chrome 5+、Firefox 4+、Safari 5+ 和 Opera 10.5+）

Array.isArray(arr);

jQuery：

$.isArray(arr);

角度：

angular.isArray(arr);

Underscore.js和Lodash：

_.isArray(arr);

score 35 · Accepted Answer

Array.isArray 运行速度很快，但并非所有版本的浏览器都支持。

因此，您可以为其他人破例并使用通用方法：

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

score 32 · Accepted Answer

一个简单的功能来检查这个：

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

score 20 · Accepted Answer

正如 MDN在这里所说：

使用Array.isArray或Object.prototype.toString.call将常规对象与数组区分开来

像这样：

Object.prototype.toString.call(arr) === '[object Array]'，或者
Array.isArray(arr)

score 20 · Accepted Answer

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

x instanceof Array

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

score 18 · Accepted Answer

您可以使用Array.isArray()。这是一个polyfill：

if (Array.isArray == null) {
  Array.isArray = (arr) => Object.prototype.toString.call(arr) === "[object Array]"
}

score 16 · Accepted Answer

我会做一个函数来测试你正在处理的对象的类型......

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
}

score 16 · Accepted Answer

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

var myArray=[];

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

score 14 · Accepted Answer

我以一种非常简单的方式做到这一点。这个对我有用。

Array.prototype.isArray = true;

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

score 13 · Accepted Answer

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

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

它摆脱了 if/else，并解释了数组为空或未定义的可能性

score 12 · Accepted Answer

我知道，人们正在寻找某种原始的 JavaScript 方法。但是，如果您想少考虑它，请查看Underscore.js的 isArray：

_.isArray(object)

如果object是 Array，则返回 true。

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

score 12 · Accepted Answer

我已经用两种替代方法以及错误检查更新了jsperf fiddle 。

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

/* 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（在我的机器上）中第二好的方法的两倍。

score 11 · Accepted Answer

最好的做法是使用constructor类似这样的东西来比较它

if(some_variable.constructor === Array){
  // do something
}

您也可以使用其他方法，例如typeOf，将其转换为字符串然后进行比较，但将其与 dataType 进行比较始终是更好的方法。

score 6 · Accepted Answer

我见过的最好的解决方案是跨浏览器替换 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 */};

score 5 · Accepted Answer

如果可以传递给此函数的仅有两种值是字符串或字符串数组，请保持简单并typeof检查字符串的可能性：

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

score 5 · Accepted Answer

这是我的懒惰方法：

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边界工作，但对于我的用例来说这不是问题。

score 5 · Accepted Answer

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()。

score 5 · Accepted Answer

var a = [], b = {};

console.log(a.constructor.name == "Array");
console.log(b.constructor.name == "Object");

score 5 · Accepted Answer

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

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

score 5 · Accepted Answer

这个函数将几乎任何东西变成一个数组：

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]"
}

它使用了一些较新的浏览器功能，因此您可能需要对其进行 polyfill 以获得最大支持。

例子：

> 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这里使用过，因为它是最强大且最简单的。

score 5 · Accepted Answer

您可以使用isArray方法，但我更愿意检查：

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

score 4 · Accepted Answer

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

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

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

score 4 · Accepted Answer

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))

score 4 · Accepted Answer

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

为了寻找最短的版本，这是我到目前为止得到的。

请注意，没有完美的函数可以始终检测所有可能的组合。了解你的工具的所有能力和限制比期待一个神奇的工具更好。

score 4 · Accepted Answer

异国情调的

您想检查参数是否为字符串 - 所以试试

x===x+''

let isStr = x=> x===x+'';

console.log( isStr([]) );
console.log( isStr(["aa","bb"]) );
console.log( isStr("") );
console.log( isStr("abc") );

score 4 · Accepted Answer

在您的情况下，您可以使用可以接受单个对象以及数组（甚至组合）的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 也很清楚）。

score 4 · Accepted Answer

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

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

或者

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

或者你可以创建一个实用函数：

const isArray = (obj) => !!obj && obj.constructor === Array;

用法：

isArray(arr); // Returns true

score 4 · Accepted Answer

你可以试试这个：

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

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

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

score 3 · Accepted Answer

虽然有一些可靠的答案，但我更喜欢使用functor的函数式方法。函子只是一种奇特的方式来表示我们将把一个函数传递给一个值。（我看到的建议是将值传递给函数。）

创建一个 TypeOf 助手

const TypeOf = obj => Object.prototype.toString.call(obj).slice(8,-1);

这类似于 typeof，但它现在返回Arrayfor[]和Objectfor {}。我喜欢将其视为严格的typeof。如果您正在开发 Gmail 应用程序并且性能是一个问题，那么您可以执行类似的操作。

const TypeOf = obj => (
  Array.isArray(obj)
   ? "array"
    : obj === null // catch null edge case.  typeof null is an object :)
   ? null
    : typeof obj
)

你可以在这里停下来，收工。但是，您可以使用组合使其更强大。如果您创建了一个 TypeBox Functor，您将获得很多好处，这又是一个花哨的词，用于将函数传递给一个值，而不是将一个值传递给一个函数。

创建类型框

const TypeBox = (predicate, defaultValue) => {
  const TypePredicate = value => ({
     value,
     map: cb => predicate(value)
                ? TypePredicate(cb(value))
                : TypePredicate(defaultValue)
  });
  return TypePredicate;
}

这里发生了很多事情，但它非常强大。TypeBox 函数使用闭包并返回我们的 Functor。闭包让您可以访问 Lexical_Scope。把它想象成一个背包，里面装着你以后想要访问的东西。

创建数组框

const ArrayBox = TypeOf(obj => TypeOf(obj) === 'Array' ? obj : [obj]);

ArrayBox 将我们的predicateand传递defaultValue给TypeOf并在我们调用/执行时可用ArrayBox（将其命名为对您的用例有意义的名称）。

现在有趣的部分

如果输入是一个数组，则返回它。

ArrayBox(["foo", "bar"]).value; // ['foo', 'bar']

如果输入不是数组，则将其返回一个

ArrayBox("foo").value // ["foo"]

这种方法的优点在于它可以扩展，易于测试，并且它使用组合。您可以以任何方式组合函数以获得所需的结果。

还有许多其他方法可以使用 Either 或monads来解决这个问题。

score 3 · Accepted Answer

值得庆幸的是，ECMAScript 5Array.isArray()早在 2009 年 12 月就推出了。如果由于某种原因，您使用的 JavaScript 版本早于 ECMAScript 5，请升级。

但是，如果您坚持这样做，那么数组确实具有将它们与任何其他类型区分开来的某些属性。我在其他任何答案中都没有提到的属性。让我们进入一些 JavaScript 政治。

数组是一个对象 ( typeof [] === "object")，但与传统对象不同的是，它们具有长度属性 ( typeof ( {} ).length === "undefined")。null也是一个对象 ( )，但您无法访问的属性，因为它不是对象。typeof null === "object"nullnull

这是规范中的一个错误，可以追溯到 JavaScript 的最开始，当时对象具有类型标记0并null表示为文字空指针0x00，这导致解释器将其与对象混淆。

不幸的是，这并没有考虑到[]vs. {length:0}. 所以我们现在必须转向原型链。

( [] ).__proto__ === Array.prototype && ( [] ).__proto__ !== Object.prototype.

因此，如果没有Array.isArray()，这几乎是我们能得到的最接近的：

function is_array(array){
    return array !== null
        && typeof array === "object"
        && array.__proto__ === Array.prototype;
}

[ [], [1,2,3], {length: 0}, {},
  1, 0, Infinity, NaN, "1", "[1,2,3]",
  null, undefined, [null], [undefined], {a:[]},
  [{}], [{length: 0}], [Infinity], [NaN],
  {__proto__: Array.prototype}
].filter(is_array)
// Expected: [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN] ]
// Actual:   [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN], {__proto__: Array.prototype} ]

恶意设计为看起来像数组的对象实际上通过了图灵测试。但是，用 Array 原型链替换原型链就足以让它像一个数组一样工作，有效地使它成为一个数组。

世界上唯一能分辨出这样一个对象的其实不是数组，是Array.isArray(). 但是出于您通常检查对象是否为数组的目的，所述对象应该与您的代码配合得很好。

甚至当您人为地更改数组长度时的行为也是相同的：如果长度大于数组中元素的数量，您将拥有那种特殊的“隐式未定义”类型的“空槽”，它在某种程度上不同于未定义同时也是=== undefined；与我们typeof obj !== "undefined"用来避免抛出 a的原因完全相同的类型，ReferenceError因为obj === undefined只有在明确定义为时才不会抛出错误。objundefined

a = {__proto__: Array.prototype}; // Array {}
a.push(5)
a // [5]
a.length = 5
a // [5, empty x 4]
b = a.map(n => n*n) // [25, empty x 4]
b.push(undefined)
b.push(undefined)
b // [25, empty x 4, undefined, undefined]
b[1] // undefined
b[1] === b[5] // true
Array.isArray(a) // false
Array.isArray(b) // true

不过，不要使用is_array()。为了学习目的而重新发明轮子是一回事。在生产代码中执行此操作是另一回事。甚至不要将它用作polyfill。支持旧的 JavaScript 版本意味着支持旧的浏览器意味着鼓励使用不安全的软件意味着使用户面临恶意软件的风险。

score 2 · Accepted Answer

也有其他方法可以检查，但我更喜欢以下方法作为我最好的检查方法（因为您可以轻松检查其他对象的类型）。

> a = [1, 2]
[ 1, 2 ]
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>
> Object.prototype.toString.call([]).slice(8,-1) // best approach
'Array'

解释（在 Node REPL 上有简单的例子）»

> o = {'ok': 1}
{ ok: 1 }
> a = [1, 2]
[ 1, 2 ]
> typeof o
'object'
> typeof a
'object'
>
> Object.prototype.toString.call(o)
'[object Object]'
> Object.prototype.toString.call(a)
'[object Array]'
>

对象或数组 »

> Object.prototype.toString.call(o).slice(8,).replace(/\]$/, '')
'Object'
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>

空或未定义 »

> Object.prototype.toString.call(undefined).slice(8,).replace(/\]$/, '')
'Undefined'
> Object.prototype.toString.call(null).slice(8,).replace(/\]$/, '')
'Null'
>

细绳 ”

> Object.prototype.toString.call('ok').slice(8,).replace(/\]$/, '')
'String'

数字 ”

> Object.prototype.toString.call(19).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.0).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.7).slice(8,).replace(/\]$/, '')
'Number'
>

我很欣赏@mpen使用 -1 代替正则表达式的建议，如下所示。

> Object.prototype.toString.call(12).slice(8,-1)
'Number'
>
> Object.prototype.toString.call(12.0).slice(8,-1)
'Number'
>
> Object.prototype.toString.call([]).slice(8,-1)
'Array'
> Object.prototype.toString.call({}).slice(8,-1)
'Object'
>
> Object.prototype.toString.call('').slice(8,-1)
'String'
>

score 2 · Accepted Answer

2

我现在找到了最短的答案：

var x = [1,2,3]
console.log(x.map?1:0)

于 2019-04-23T13:01:20.567 回答

score 1 · Accepted Answer

利用：

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

这个函数取自“ JavaScript: The Good Parts ”一书，它非常适合我。

score 1 · Accepted Answer

这是我提出并一直用于我的项目的解决方案...

function isArray (o) {
    return typeof o === "object" && o.length !== undefined;
}

isArray({}); // false
isArray(1); // false
isArray("str"); // false
isArray(function(){}); // false

isArray([]); // true

唯一的缺陷是，如果您的对象碰巧具有长度属性，它会给出误报：

isArray({length:0}); // true

如果你可以接受这个缺点并且知道你的纯对象不会有那个属性，那么它是一个干净的解决方案并且应该比 Object.prototype.toString.call 方法更快。

score 0 · Accepted Answer

由于我不喜欢任何 Object.prototype 调用，因此我搜索了另一种解决方案。特别是因为ChaosPandion 的解决方案并不总是有效，而MidnightTortoise 的解决方案不适isArray()用于来自 DOM 的数组（如getElementsByTagName）。最后我找到了一个简单的跨浏览器解决方案，它可能也适用于 Netscape 4。;)

只是这四行（检查任何对象h）：

function isArray(h){
    if((h.length!=undefined&&h[0]!=undefined)||(h.length===0&&h[0]===undefined)){
        return true;
    }
    else{ return false; }
}

我已经测试了这些数组（全部返回 true）：

1) array=d.getElementsByName('some_element'); //'some_element' can be a real or unreal element
2) array=[];
3) array=[10];
4) array=new Array();
5) array=new Array();
   array.push("whatever");

这适用于所有情况吗？或者是否存在我的解决方案不起作用的情况？

score 0 · Accepted Answer

首先你可以检查console.log(typeof Object)。

如果输出为object，则var {data}=object，即根据对象键解构对象。

函数可以是这样的：

const abc = (str1, str2=null) => {
    var result = [];
    result.push(str1);
    result.push(str2);
    return result.join("");
}

score 0 · Accepted Answer

这是一个代码片段，它将解释在学习 JavaScript 时应该尽早知道的数组的一个重要事实（不像我）。

// this functions puts a string inside an array
var stringInsideArray = function(input) {
  if (typeof input === 'string') {
    return [input];
  }
  else if (Array.isArray(input)) {
    return input;
  }
  else {
    throw new Error("Input is not a string!");
  }
}

var output = stringInsideArray('hello');
console.log('step one output: ', output); // ["hello"]

// use typeof method to verify output is an object
console.log('step two output: ', typeof output); // object

// use Array.isArray() method to verify output is an array
console.log('step three output: ', Array.isArray(output)); // true

数组，实际上是对象。

使用typeof运算符，的输出stringInsideArray('hello')证明它["hello"]确实是一个对象。这让我困惑了很长时间，因为我认为数组将是一种 JavaScript 数据类型......

JavaScript 数据类型只有七种，而数组不是其中之一。

要回答您的问题，使用Array.isArray()方法确定output是一个数组。

score 0 · Accepted Answer

// 以简单的方式

const arr = [1, 2, 3];
const obj = { message: 'nice' };
const str = 'nice';
const empty = null;

console.log(Array.isArray(arr));
console.log(Array.isArray(obj));
console.log(Array.isArray(str));
console.log(Array.isArray(empty));

score 0 · Accepted Answer

Array.isArray是解决这个问题的方法。例如：

var arr = ['tuna', 'chicken', 'pb&j'];
var obj = {sandwich: 'tuna', chips: 'cape cod'};

// Returns true
Array.isArray(arr);

// Return false
Array.isArray(obj);

score 0 · Accepted Answer

您可以通过push以下方式找到：

function isArray(obj){
   return (typeof obj.push === 'function') ? true : false;
}

var array = new Array();

or

var array = ['a', 'b', 'c'];
console.log(isArray(array));

score 0 · Accepted Answer

您可以使用此函数来获取数据类型。

var myAr = [1,2];

checkType(myAr);

function checkType(data) {
  if(typeof data ==='object') {
    if(Object.prototype.toString.call(data).indexOf('Array') !== (-1)) {
      return 'array';
    } else {
      return 'object';
    }
  } else {
    return typeof data;
  }
}

if(checkType(myAr) === 'array') {
  console.log('yes, it is an array')
};

score 0 · Accepted Answer

检查它的原型和 Array.isArray 是有区别的：

function isArray(obj){
    return Object.getPrototypeOf(obj) === Array.prototype
}

此函数将直接检查 obj 是否为数组。

但是对于这个 Proxy 对象：

var arr = [1,2,3]

var proxy = new Proxy(arr,{})

console.log(Array.isArray(proxy)) // true

Array.isArray将其作为数组。

score -1 · Accepted Answer

这是我使用的：

function isArray(input) {
  if (input instanceof Array || Object.prototype.toString.call(input) === '[object Array]') {
        return true;
  } else return false;
}

score -1 · Accepted Answer

您还可以检查数组的长度属性。当您尝试访问数组的长度属性时，它将返回一个数字（空数组为 0），而如果您尝试访问对象的长度属性，它将返回未定义。

if(Object.prototype.toString.call(arrayList) === '[object Array]') {
  console.log('Array!');
}

score -1 · Accepted Answer

Array.isArray(obj) 没有给出非常有用的结果。我创建了一个 Object 的原型方法，它似乎可以正确地确定 object 是否是一个数组。

我知道它失败的唯一边缘情况是数组中的项目设置为未定义。

Object.prototype.isArrayLike = function()
{
    var length = this.length || Object.keys(this).length;
    if (length === 0 || this.constructor.name === "String")
        return false;
    for (i = 0; i < length; i++)
    {
        if (typeof this[i] === "undefined")
            return false;
    }
    return true;
};

var arr = ['aaa', 'bbb', 'ccc', 'ddd'];
var arr1 = {"0":'aaa', "1":'bbb', 2:'ccc', 3:'ddd'};
var arr2 = {"0":'aaa', "a":'bbb', 2:'ccc', 3:'ddd'};
var arr3 = "qwerty";
var arr4 = [];
var arr5 = {0:'aaa', 1:'bbb', 2:'ccc', 3:'ddd'};

console.log("arrayLike:" + arr.isArrayLike());
console.log("Array.isArray(arr):" + Array.isArray(arr));
// arrayLike: true
// Array.isArray(arr): true
console.log("arrayLike1:" + arr1.isArrayLike());
console.log("Array.isArray(arr1):" + Array.isArray(arr1));
// arrayLike1: true
// Array.isArray(arr1): false
console.log("arrayLike2:" + arr2.isArrayLike());
console.log("Array.isArray(arr2):" + Array.isArray(arr2));
// arrayLike2: false
// Array.isArray(arr2): false
console.log("arrayLike3:" + arr3.isArrayLike());
console.log("Array.isArray(arr3):" + Array.isArray(arr3));
// arrayLike3: false
// Array.isArray(arr3): false
console.log("arrayLike4:" + arr4.isArrayLike());
console.log("Array.isArray(arr4):" + Array.isArray(arr4));
// arrayLike4: false
// Array.isArray(arr4): true
console.log("arrayLike5:" + arr5.isArrayLike());
console.log("Array.isArray(arr5):" + Array.isArray(arr5));
// arrayLike5: false
// Array.isArray(arr5): true

score -4 · Accepted Answer

 var length = 16;                               // Number
 var lastName = "Johnson";                      // String
 var cars = ["Saab", "Volvo", "BMW"];           // Array
 var x = {firstName:"John", lastName:"Doe"};

 Object.prototype.myCheck= function(){
 if (this.constructor === Array){
          alert('array');
        }else if (this.constructor === Object)
       {
         alert('object');
        }else if (this.constructor === Number)
        {
          alert('number');
        }else if (this.constructor === String)
        {
          alert('string');
        }

 }
 cars.myCheck();
 lastName.myCheck();
 length.myCheck();

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

51 回答 51

异国情调的

Related

Reference