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

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

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}

从T. J.克劳德的博客中查看彻底的治疗，正如他在下面的评论中发布的那样。

查看这个基准以了解哪种方法执行得更好：http://jsben.ch/#/QgYAV

从@陈志立开始，使用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

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

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

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

太长别读的版本在下面，但这篇文章是对这个问题的一个很好的讨论，所以如果你有时间，你应该读一读。

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 */};

jQuery还提供了#0方法：

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>

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

_.isArray(object)

如果对象是数组，则返回true。

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

我会创建一个函数来测试您正在处理的对象类型…

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }
// testsconsole.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}

一个简单的函数来检查这个：

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

正如MDN所说在这里：

使用Array.is阵列或Object.prototype.toString.call来区分数组中的常规对象

像这样：

• Object.prototype.toString.call(arr) === '[object Array]'或

• Array.isArray(arr)

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

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

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

这是我的懒惰方法：

if (Array.prototype.array_ === undefined) {Array.prototype.array_ = true;}
// ...
var test = [],wat = {};
console.log(test.array_ === true); // trueconsole.log(wat.array_ === true);  // false

我知道“捣乱”原型是亵渎，但是它的性能明显优于推荐的#0方法。

备注：这种方法的一个缺陷是它无法跨越#0边界，但对于我的用例来说，这不是问题。

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

var myArray=[];
if(myArray instanceof Array){....}

因为我不喜欢任何Object.prototype调用，所以我寻找了另一种解决方案。特别是因为ChaosPandion的解决方案并不总是有效，isArray()的午夜乌龟的解决方案不适用于来自DOM的数组（如获取元素名字）。最后我找到了一个简单的跨浏览器解决方案，这可能也适用于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 element2) array=[];3) array=[10];4) array=new Array();5) array=new Array();array.push("whatever");

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

您可以使用Array.isArray（）。这是一个Poly填充：

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

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

Stoyan Stefan ov的书JavaScript模式中有一个很好的例子，它应该处理所有可能的问题并使用ECMAScript 5方法Array.isArray（）。

这就是：

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

顺便说一句，如果你使用jQuery，你可以使用它的方法$. isArray（）是否必选。

在现代浏览器中，您可以执行以下操作：

Array.isArray(obj)

（支持Chrome5、Firefox 4.0、Internet Explorer 9、Opera 10.5和Safari5）

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

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

如果您使用jQuery，您可以使用jQuery.isArray(obj)或$.isArray(obj)。如果您使用Underscore.js，您可以使用_.isArray(obj)。

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

obj instanceof Array

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

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

这适用于跨浏览器和旧浏览器。这是摘自T. J. Crowders的博客

这是我在考虑到评论的情况下改进这个答案的尝试：

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

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

我用一种非常简单的方法来做这件事。这对我很有效。

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

这是我想出的一个解决方案，并且一直在我的项目中使用…

function isArray (o) {return typeof o === "object" && o.length !== undefined;}
isArray({}); // falseisArray(1); // falseisArray("str"); // falseisArray(function(){}); // false
isArray([]); // true

唯一的陷阱是，如果你的对象恰好有一个长度属性，它会给出一个误报：

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

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

用途：

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

这个函数取自“JavaScript：好的部分”书，它对我来说非常完美。

 var length = 16;                               // Numbervar lastName = "Johnson";                      // Stringvar cars = ["Saab", "Volvo", "BMW"];           // Arrayvar 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();

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

事实证明，在“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/>");

如果变量取un寂寞值，这两种方法都不起作用，但如果你确定它们有一个值，它们就会起作用。关于检查一个值是数组还是单个值的性能，第二种方法看起来是一个有效的快速方法。它比Chrome上的‘instance of’稍微快一点，是Internet Explorer、Opera和Safari（在我的机器上）中第二好的方法的两倍。

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

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

你可以试试这个：

var arr = []; (or) arr = new Array();var obj = {}; (or) arr = new Object();
arr.constructor.prototype.hasOwnProperty('push') //true
obj.constructor.prototype.hasOwnProperty('push') // false

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

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

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

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

这个函数几乎可以将任何东西转换为数组：

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

它使用了一些较新的浏览器功能，因此您可能希望使用Poly填充来获得最大的支持。

示例：

> 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' ]

注意。字符串将被转换为包含单个元素而不是字符数组的数组。如果您希望相反，请删除isString检查。

我在这里使用了Array.isArray，因为它是最强大，也是最简单的。

假设你有这个下面的数组：

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+、Chrome5+、Firefox 4+、Safari5+和Opera 10.5+）

Array.isArray(arr);

jQuery：

$.isArray(arr);

角度：

angular.isArray(arr);

Underscore.js和Lodash：

_.isArray(arr);

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

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

或

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

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

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

用法：

isArray(arr); // Returns true

你可以在下面找到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));

这个问题只有一个答案

x instanceof Array

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

在您的情况下，您可以使用数组的concat方法，它可以接受单个对象以及数组（甚至组合）：

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也很了解它）。

您可以使用isArray方法，但我更喜欢检查：

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

以下是我使用的：

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

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

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

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

这是规范中的一个bug，可以追溯到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"来避免抛出ReferenceError的原因，因为如果obj被显式定义为undefined，obj === undefined只有不要抛出错误。

a = {__proto__: Array.prototype}; // Array {}a.push(5)a // [5]a.length = 5a // [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] // undefinedb[1] === b[5] // trueArray.isArray(a) // falseArray.isArray(b) // true

不过，不要使用is_array()。出于学习目的重新发明轮子是一回事。在生产代码中这样做是另一回事。甚至不要将其用作聚填充。支持旧JavaScript版本意味着支持旧浏览器意味着鼓励使用不安全软件意味着将用户置于恶意软件的风险中。

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

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

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

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

查看其原型和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将其作为数组。

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

// this functions puts a string inside an arrayvar 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 objectconsole.log('step two output: ', typeof output); // object
// use Array.isArray() method to verify output is an arrayconsole.log('step three output: ', Array.isArray(output)); // true

数组，实际上是对象。

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

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

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

最好的做法是使用constructor进行比较，类似这样

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

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

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

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

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

var arr = ['tuna', 'chicken', 'pb&j'];var obj = {sandwich: 'tuna', chips: 'cape cod'};
// Returns trueArray.isArray(arr);
// Return falseArray.isArray(obj);

首先，您可以检查console.log（typeof Object）。

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

函数可以是这样的：

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

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

创建一个TypeOf助手

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

这类似于typeof，但它现在返回Array[]和Object{}。我喜欢将其视为严格的typeof。如果您正在使用Gmail应用程序并且担心性能，那么您可以这样做。

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

你可以在这里停下来，今天就到此为止。但是，你可以使用组合使它更强大。如果你创建了一个TypeBox函数，你会得到很多好处，这也是一个花哨的词，用于将函数传递给值而不是将值传递给函数。

创建TypeBox

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

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

创建ArrayBox

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

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

现在是有趣的部分

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

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

如果输入不是数组，则在一个数组中返回它

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

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

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

var a = [], b = {};
console.log(a.constructor.name == "Array");console.log(b.constructor.name == "Object");

异国情调的

您想检查参数是否为字符串-请尝试

x===x+''

let isStr = x=> x===x+'';
console.log( isStr([]) );console.log( isStr(["aa","bb"]) );console.log( isStr("") );console.log( isStr("abc") );

Array.isArray（obj）并没有给出非常有用的结果。我创建了一个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): trueconsole.log("arrayLike1:" + arr1.isArrayLike());console.log("Array.isArray(arr1):" + Array.isArray(arr1));// arrayLike1: true// Array.isArray(arr1): falseconsole.log("arrayLike2:" + arr2.isArrayLike());console.log("Array.isArray(arr2):" + Array.isArray(arr2));// arrayLike2: false// Array.isArray(arr2): falseconsole.log("arrayLike3:" + arr3.isArrayLike());console.log("Array.isArray(arr3):" + Array.isArray(arr3));// arrayLike3: false// Array.isArray(arr3): falseconsole.log("arrayLike4:" + arr4.isArrayLike());console.log("Array.isArray(arr4):" + Array.isArray(arr4));// arrayLike4: false// Array.isArray(arr4): trueconsole.log("arrayLike5:" + arr5.isArrayLike());console.log("Array.isArray(arr5):" + Array.isArray(arr5));// arrayLike5: false// Array.isArray(arr5): true

//以简单的方式

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