我正在尝试编写一个函数,它要么接受字符串列表,要么接受单个字符串。如果它是一个字符串,那么我想把它转换成一个只有一个项的数组,这样我就可以在上面循环,而不用担心出错。
那么如何检查变量是否为数组?
我正在尝试编写一个函数,它要么接受字符串列表,要么接受单个字符串。如果它是一个字符串,那么我想把它转换成一个只有一个项的数组,这样我就可以在上面循环,而不用担心出错。
那么如何检查变量是否为数组?
ECMAScript标准中给出的查找Object类的方法是使用Object.prototype中的toString方法。
if(Object.prototype.toString.call(someVar) === '[object Array]') {
alert('Array!');
}
或者您可以使用typeof来测试它是否为字符串:
if(typeof someVar === 'string') {
someVar = [someVar];
}
或者,如果您不关心性能,您可以直接连接到一个新的空数组。
someVar = [].concat(someVar);
还有可以直接查询的构造函数:
if (somevar.constructor.name == "Array") {
// do something
}
查看T.J.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']
我首先检查您的实现是否支持isArray:
if (Array.isArray)
return Array.isArray(v);
也可以尝试使用instanceof运算符
v instanceof Array
如果可以传递给此函数的仅有两种值是字符串或字符串数组,请保持简单,并使用字符串类型检查:
function someFunc(arg) {
var arr = (typeof arg == "string") ? [arg] : arg;
}
我见过的最佳解决方案是用跨浏览器替换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 */};
jQuery还提供了一个$.isArray()方法:
var a=[“a”,“AA”,“AAA”];if($.isArray(a)){alert(“a是一个数组!”);}其他{alert(“a不是数组!”);}<script src=“https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js“></script>
我知道,人们正在寻找某种原始的JavaScript方法。但如果你想少想一想,看看Undercore.js的isArray:
_.isArray(object)
如果对象是数组,则返回true。
(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true
我会制作一个函数来测试您正在处理的对象的类型。。。
函数whatAmI(me){return Object.pr原型.toString.call(me).split(/\W/)[2];}//测试控制台日志(whatAmI([“瞄准”,“@”]),whatAmI({生活:4,呼吸:4}),whatAmI(函数(ing){return ing+“到全局窗口”}),我(“要和你做什么?”));//输出:数组对象函数字符串
然后你可以写一个简单的if语句。。。
if(whatAmI(myVar) === "Array"){
// do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
// do string stuff
}
正如MDN在这里所说:
使用Array.isArray或Object.prototype.toString.call进行区分阵列中的常规对象
这样地:
Object.pr原型.toString.call(arr)==“[对象数组]”,或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); // true
console.log(wat.array_ === true); // false
我知道“搞乱”原型是一种亵渎,但它的性能明显优于推荐的toString方法。
注意:这种方法的一个缺点是它不能跨iframe边界工作,但对于我的用例来说,这不是问题。
因为我不喜欢任何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");
这适用于所有情况吗?或者我的解决方案不起作用?
您可以使用Array.isArray()。这里是一个polyfill:
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 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()。
在现代浏览器中,您可以执行以下操作:
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)或$.isArra(obj)。如果使用Undercore.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 // true
b.isArray // (undefined -> false)
这是我想出的一个解决方案,并一直用于我的项目。。。
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方法更快。
Use:
var is_array = function (value) {
return value &&
typeof value === 'object' &&
typeof value.length === 'number' &&
typeof value.splice === 'function' &&
!(value.propertyIsEnumerable('length'));
};
这个函数取自《JavaScript:TheGoodParts》一书,非常适合我。
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();
我用两种替代方法以及错误检查更新了jsperf fiddle。
事实证明,在“Object”和“Array”原型中定义常量值的方法比任何其他方法都快。这是一个有点令人惊讶的结果。
/*初始化*/Object.prototype.isArray=函数(){return false;};Array.prototype.isArray=函数(){返回true;};Object.protype.isArray=false;Array.prototype.isArray=true;var arr=[“1”,“2”];var noarr=“1”;/*方法1(功能)*/if(arr.isArray())document.write(“arr是根据函数<br/>的数组”);if(!noarr.isArray())document.write(“noarr不是根据函数<br/>的数组”);/*方法2(值)-***最快******/if(arr.isArray)document.write(“arr是根据成员值的数组<br/>”);if(!noarr.isArray)document.write(“noarr不是根据成员值的数组<br/>”);
如果变量采用未定义的值,则这两种方法不起作用,但如果您确定它们具有值,则它们会起作用。关于检查性能,如果一个值是数组还是单个值,第二个方法看起来像是一个有效的快速方法。它比Chrome上的“instanceof”稍快,是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(arr.concat类型==“函数”){console.log(“这是一个数组”);}
此函数将几乎所有内容转换为数组:
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' ]
N.B.字符串将被转换为具有单个元素的数组,而不是字符数组。如果您希望使用其他方式,请删除isString复选框。
我在这里使用了Array.isArray,因为它是最健壮的,也是最简单的。
假设您有以下阵列:
var arr = [1,2,3,4,5];
JavaScript(新浏览器和旧浏览器):
function isArray(arr) {
return arr.constructor.toString().indexOf("Array") > -1;
}
or
function isArray(arr) {
return arr instanceof Array;
}
or
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);
Undercore.js和Lodash:
_.isArray(arr);
检查对象是否为数组的最简单快捷的方法。
var arr = [];
arr.constructor.name === 'Array' // Returns true;
or
arr.constructor === Array // Returns true;
或者您可以创建一个实用函数:
const isArray = (obj) => !!obj && obj.constructor === Array;
用法:
isArray(arr); // Returns true
您可以通过如下推送找到:
函数isArray(obj){return(obj.push类型==“函数”)?真:假;}var array=new array();或var数组=[‘a’,‘b’,‘c’];console.log(isArray(数组));
在您的情况下,您可以使用Array的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也很熟悉)。
以下是我使用的:
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表示为文本null指针0x00,这导致解释器将其与对象混淆。
不幸的是,这不能解释[]与{length:0}之间的关系。所以我们现在必须转向原型链。
( [] ).__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()。但出于通常检查对象是否是数组的目的,所述对象应该在代码中表现良好。
甚至当你人为地改变数组长度时的行为也是一样的:如果长度比数组中的元素数长,你会有一个特殊的“隐式未定义”类型的“空槽”,这种类型在某种程度上不同于未定义,同时也是==未定义的;这就是我们使用typeof obj的原因!==“undefined”以避免引发ReferenceError,因为obj==undefineed仅在obj被显式定义为undefine时才会引发错误。
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版本意味着支持旧浏览器意味着鼓励使用不安全的软件意味着用户面临恶意软件的风险。
您还可以检查数组的长度属性。当您尝试访问数组的长度属性时,它将返回一个数字(对于空数组为0),而如果您尝试访问对象的长度属性,则它将返回undefined。
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'
解释(节点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是否为数组。
但对于此代理对象:
var arr = [1,2,3]
var proxy = new Proxy(arr,{})
console.log(Array.isArray(proxy)) // true
Array.isArray将其作为Array。
下面是一段代码片段,它将解释数组的一个重要事实,在学习JavaScript时应该尽早了解这些事实(与我不同)。
//此函数将字符串放入数组中var stringInsideArray=函数(输入){if(输入类型==“string”){返回[输入];}else if(Array.isArray(输入)){返回输入;}其他{throw new Error(“输入不是字符串!”);}}var output=stringInsideArray('hello');console.log('第一步输出:',输出);//[“你好”]//使用typeof方法验证输出是否为对象console.log('第二步输出:',输出类型);//对象//使用Array.isArray()方法验证输出是否为数组console.log('第三步输出:',Array.isArray(输出));//真的
数组实际上是对象。
使用typeof运算符,stringInsideArray('hello')的输出证明[“hello”]确实是一个对象。这让我困惑了很长一段时间,因为我假设数组是JavaScript数据类型。。。
只有七种JavaScript数据类型,数组不是其中之一。
要回答您的问题,请使用Array.isArray()方法确定输出是一个数组。
最好的做法是使用构造函数进行比较,如下所示
if(some_variable.constructor === Array){
// do something
}
您也可以使用其他方法,如typeOf,将其转换为字符串,然后进行比较,但将其与dataType进行比较总是更好的方法。
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);
首先,您可以检查console.log(对象类型)。
如果输出是对象,则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。我喜欢把它看作是一种严格的类型。如果你正在使用Gmail应用程序,性能是一个问题,那么你可以这样做。
const TypeOf = obj => (
Array.isArray(obj)
? "array"
: obj === null // catch null edge case. typeof null is an object :)
? null
: typeof obj
)
你可以停下来休息一下。然而,您可以使用合成使其更加强大。如果你创建了一个TypeBox Functor,你会得到很多好处,这也是一个将函数传递给值而不是将值传递给函数的好词。
创建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正在将我们的谓词和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+''
设isStr=x=>x===x+'';console.log(isStr([]));console.log(isStr([“aa”,“bb”]));console.log(isStr(“”));console.log(isStr(“abc”));
isArray(obj)没有提供非常有用的结果。我已经创建了一个Object的原型方法,它似乎可以正确地确定和对象是否是数组。
我所知道的唯一失败的边缘情况是数组中的项设置为undefined。
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
//以简单的方式
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));