array.isarray() 是判断变量是否为数组最可靠的方法，因为它直接返回布尔值且不受上下文影响，相比 typeof（对数组返回 "object"）和 instanceof（在跨 iframe 时失效）更精确安全，能正确识别跨全局环境的数组，而其他方法如 object.prototype.tostring.call() 虽然也可行但更繁琐，鸭子类型判断则易误判，因此推荐始终使用 array.isarray() 进行数组类型检测。
Array.isArray()是判断一个变量是否为数组最可靠且推荐的方法。它直接返回
true或
false，不受上下文影响，比
typeof或
instanceof等其他方式更为精确和安全，是我在日常开发中首选的判断工具。
解决方案
在 JavaScript 中，判断一个变量是不是数组，最直接、最稳妥的方式就是使用
Array.isArray()。这个方法是 ES5 引入的，现在浏览器和 Node.js 环境都支持得非常好，基本上可以无脑用。
它的用法非常简单，直接把你想判断的变量作为参数传进去就行：
const arr = [1, 2, 3];
const obj = { a: 1 };
const str = "hello";
const num = 123;
const func = () => {};
const n = null;
const u = undefined;
console.log(Array.isArray(arr)); // true
console.log(Array.isArray(obj)); // false
console.log(Array.isArray(str)); // false
console.log(Array.isArray(num)); // false
console.log(Array.isArray(func)); // false
console.log(Array.isArray(n)); // false
console.log(Array.isArray(u)); // false我个人觉得，它之所以这么好用，关键在于它直接问了一个核心问题：“你是不是一个真正的数组？”而不是绕弯子去检查原型链或者类型字符串。这避免了很多潜在的坑，尤其是在跨iframe或者跨全局环境操作时。
Array.isArray() 与 typeof、instanceof 有何不同？为何它更优？
说实话，刚开始学 JavaScript 的时候，我也挺困惑的，判断数组为啥不能直接用
typeof或者
instanceof。但实际踩过坑后，就明白
Array.isArray()的价值了。
typeof操作符在判断数组时，会返回
"object"。这是因为在 JavaScript 的类型系统中，数组本质上也是一种对象。所以，如果你写
typeof []，结果是
"object"。这显然不够精确，因为
null、普通对象、函数等也可能返回
"object"。
console.log(typeof []); // "object"
console.log(typeof {}); // "object"
console.log(typeof null); // "object" (这是一个历史遗留的bug，但它确实返回"object")你看，光靠
typeof，你根本分不清一个变量到底是数组、普通对象还是
null。
再来说
instanceof。它确实能检查一个对象是否是某个构造函数的实例，比如
[] instanceof Array会返回
true。看起来很完美，对吧？但它有一个致命的缺陷：它在多全局环境（比如浏览器中的
iframe）下会失效。
想象一下，你在一个
iframe里创建了一个数组，然后把它传到父窗口来判断：
// 假设这是父窗口的JS
const iframe = document.createElement('iframe');
document.body.appendChild(iframe);
const iframeWindow = iframe.contentWindow;
// 在iframe中创建数组
const iframeArray = iframeWindow.Array(1, 2, 3);
// 在父窗口判断这个数组
console.log(iframeArray instanceof Array); // 极有可能返回 false！
// 因为 iframeWindow.Array 和 window.Array 是不同的构造函数实例
// 但
console.log(Array.isArray(iframeArray)); // true (总是可靠)这就是
instanceof的“跨域”问题，或者说“跨全局对象”问题。每个全局环境（
window或
global）都有自己独立的内置构造函数，包括
Array。一个对象只有在它所处的全局环境中，才能正确地被
instanceof判断为其构造函数的实例。
Array.isArray()则不然，它直接检查对象的内部
[[Class]]属性（在 ES5 规范中，对于数组，这个属性是
"Array"），所以无论数组是在哪个全局环境创建的，它都能给出正确答案。这就是它为什么更优、更可靠的核心原因。
在实际开发中，何时需要特别注意数组判断的陷阱？
除了上面提到的
iframe这种比较特殊的场景，实际开发中还有一些情况需要我们对数组判断保持警惕：
一个常见的“陷阱”是类数组对象 (Array-like Objects)。这些对象长得很像数组，它们有
length属性，并且可以通过索引访问元素，比如
arguments对象、DOM 的
NodeList或者
HTMLCollection。
function showArgs() {
console.log(arguments); // { '0': 1, '1': 2, '2': 3, length: 3 }
console.log(Array.isArray(arguments)); // false
}
showArgs(1, 2, 3);
const divs = document.getElementsByTagName('div'); // 这是一个 NodeList
console.log(divs); // 看起来像数组，有length属性
console.log(Array.isArray(divs)); // falseArray.isArray()会正确地判断它们不是真正的数组。如果你想对这些类数组对象使用数组的方法（比如
map,
forEach），你需要先将它们转换成真正的数组。我通常会用
Array.from()或者展开运算符 (
...) 来处理：
// 将 arguments 转换为数组 const argsArray = Array.from(arguments); // 或者 const argsArraySpread = [...arguments]; // 将 NodeList 转换为数组 const divsArray = Array.from(divs); // 或者 const divsArraySpread = [...divs];
此外，在处理从外部接口（比如 JSON API）获取的数据时，也需要特别小心。虽然 JSON 规范里有数组类型，但如果数据传输过程中出现问题，或者后端返回了非预期的结构，你可能会收到一个看起来像数组但实际上是普通对象的数据。这时候
Array.isArray()就显得尤为重要，它能帮你快速校验数据类型，避免后续操作报错。
除了 Array.isArray()，还有哪些不那么常用的判断方法或思路？
尽管
Array.isArray()是最佳实践，但了解一些其他判断数组的方法也挺有意思，尤其是在一些老旧代码或者特定场景下可能会遇到。
最经典的替代方案之一是使用
Object.prototype.toString.call()。这个方法非常强大，它能返回一个表示对象类型的字符串。对于数组，它会返回
"[object Array]"。
const arr = [1, 2];
const obj = {};
const str = "hello";
console.log(Object.prototype.toString.call(arr)); // "[object Array]"
console.log(Object.prototype.toString.call(obj)); // "[object Object]"
console.log(Object.prototype.toString.call(str)); // "[object String]"
// 所以，你可以这样判断：
function isArrayAlternative(variable) {
return Object.prototype.toString.call(variable) === '[object Array]';
}
console.log(isArrayAlternative(arr)); // true
console.log(isArrayAlternative(obj)); // false这个方法的好处是，它和
Array.isArray()一样，能够跨
iframe正确判断，因为它也是检查对象的内部
[[Class]]属性。在
Array.isArray()还没有被广泛支持的年代（比如 IE8 及更早版本），
Object.prototype.toString.call()是判断数组和许多其他内置类型（如
Date,
RegExp等）的标准方法。
还有一种思路，虽然不推荐用于严格的数组类型判断，但在某些场景下会用到，那就是鸭子类型 (Duck Typing)。它的核心思想是“如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子”。对于数组而言，这意味着检查一个对象是否拥有数组的典型特征，比如
length属性、
push、
pop等方法。
function isProbablyArrayLike(variable) {
return typeof variable === 'object' &&
variable !== null &&
typeof variable.length === 'number' &&
variable.length >= 0 &&
(variable.length === 0 || (variable.length > 0 && (variable.hasOwnProperty(0) || variable.hasOwnProperty(variable.length - 1)))); // 检查是否有索引属性
}
// 这种方法非常粗糙，容易误判
console.log(isProbablyArrayLike([])); // true
console.log(isProbablyArrayLike({ 0: 'a', 1: 'b', length: 2 })); // true (这是个普通对象，但符合条件)
console.log(isProbablyArrayLike({ length: 5 })); // true (即使没有元素，也可能被误判)这种鸭子类型判断方式，我通常只在需要处理“只要能像数组一样遍历和访问就行”的场景下考虑，而不是真正需要一个
Array实例的时候。因为它很容易把普通对象误判为数组，缺乏严谨性。
总而言之，虽然有这些替代方案，但
Array.isArray()依然是我处理数组判断时的首选，它足够简单、高效且健壮。
