引言

在 JavaScript 编程中，我们经常需要对不同类型的变量进行判断和处理。其中，判断一个变量是否是数组是一项基本且常见的任务。虽然 JavaScript 提供了多种方法来实现这个目标，但不同的方法各有优缺点。在本篇博客中，我们将介绍几种常用的方式来判断一个变量是否是数组，并探讨它们的优缺点以及适用场景。

接下来，我们将介绍 Array.isArray() 方法、instanceof 运算符、Object.prototype.toString 方法等常用的判断数组类型的方法，并对它们的进行分析，寻找最适合判断数组的方式。

判断变量是否是数组是我们在 JavaScript 开发中常常遇到的问题之一。作为开发者，我们需要了解不同方法的特点和适用场景，从而能够根据实际需求选择最合适的判断方式。

Array.isArray()

Array.isArray() 方法是 JavaScript 中的一个静态方法，用于判断一个变量是否是数组。它返回一个布尔值，如果变量是一个数组则返回 true，否则返回 false。

Array.isArray() 方法的功能特点包括：

• 准确性：Array.isArray() 方法可以准确判断一个变量是否是数组，不会将其他引用类型误判为数组。

• 跨窗口和跨框架支持：该方法可以在不同的窗口（window）和框架（iframe）中正常工作，不受上下文环境的限制。

以下是使用 Array.isArray() 方法进行数组判断的示例代码：

let arr = [1, 2, 3];
console.log(Array.isArray(arr)); // 输出: truelet obj = { name: "John", age: 25 };
console.log(Array.isArray(obj)); // 输出: falselet str = "Hello";
console.log(Array.isArray(str)); // 输出: false

使用 Array.isArray() 方法可以更可靠地判断一个变量是否是数组，在编写 JavaScript 代码时，特别是处理数组相关的逻辑时，推荐使用 Array.isArray() 方法进行数组的判断。

Object.prototype.toString

Object.prototype.toString.call() 方法是 JavaScript 中用于获取对象类型的方法。当通过该方法调用时，它会返回一个表示对象类型的字符串，以方便进行类型判断。对于数组类型的变量，返回的字符串是 "[object Array]"。

Object.prototype.toString 方法的功能特点包括：

• 简单高效：简单易懂，一行代码即可完成判断，且性能较好。

• 兼容性好：该方法适用于所有标准的 JavaScript 环境，具有很好的兼容性。

• 准确性高：由于数组对象继承了 Array.prototype，因此返回的字符串 [object Array] 是数组特有的，可以准确判断是否为数组。

代码示例：

let arr = [1, 2, 3];
let arrType = Object.prototype.toString.call(arr);
console.log(arrType === "[object Array]"); // 输出: truelet obj = { name: "John", age: 25 };
let objType = Object.prototype.toString.call(obj);
console.log(objType === "[ Array]"); // 输出: falselet str = "Hello";
let strType = Object.prototype.toString.call(str);
console.log(strType === "[object Array]"); // 输出: false

通过 Object.prototype.toString.call() 方法可以准确判断一个变量是否是数组。在实际编程中，推荐使用此方法来进行数组类型的判断。

instanceof

instanceof 运算符用于判断一个对象是否是某个构造函数（或其派生类）的实例。对于数组，除了特殊情况下可以使用判断一个变量是否是数组。

使用 instanceof 运算符判断数组的方法如下：

variable instanceof Array;

其中，variable 是要判断的变量，Array 是数组的构造函数。

instanceof 运算符的判断逻辑是检查的原型链上是否存在构造函数的原型。如果存在，返回 true；如果不存在，返回 false。

以下是使用 instanceof 运算符进行数组判断的示例代码：

let arr = [1, 2, 3];
console.log(arr instanceof Array); // 输出: truelet obj = { name: "John", age: 25 };
console.log(obj instanceof Array); // 输出: falselet str = "Hello";
console.log(str instanceof Array); // 输出: false

误判分析

instanceof 运算符在判断是否为数组时可能存在误判的情况。下面是一个可能产生误判的示例代码：

function MyArray() {// 自定义的类似数组的对象this.length = 0;
}
MyArray.prototype = Array.prototype;const myArr = new MyArray();console.log(myArr instanceof Array); // 输出: true

在上述示例中，我们定义了一个名为 MyArray 的类似数组的对象。该对象具有类似数组的行为，包括 length 属性。通过指定 MyArray.prototype = Array.prototype，我们使该对象继承了 Array.prototype 上的方法和属性。

然后，我们创建了一个 myArr 的实例，并使用 instanceof 运算符判断 myArr 是否是数组。意料之外的是，判断结果是 true，即 myArr instanceof Array 返回 true。

这是因为 instanceof 运算符判断一个对象是否属于某个类时，不仅仅判断对象的构造函数是否是该类，还会检查对象的原型链上是否存在该类的原型。在本例中，myArr 的原型对象为 Array.prototype，因此会被判断为数组。

这种情况下，instanceof 的判断结果会产生误解，因为 myArr 并非通过数组字面量或构造函数创建的真正数组对象。

constructor

使用原型的 constructor 属性判断一个变量是否是数组是一种常见的方式。基于 JavaScript 中对象的 constructor 属性，我们可以通过判断变量的 constructor 是否等于 Array 来确定其是否是数组。

下面是使用 constructor 属性判断变量是否是数组的代码示例：

function isArray(obj) {return obj.constructor === Array;
}// 示例用法
console.log(isArray([])); // 输出: true
console.log(isArray({})); // 输出: false

通过比较 obj 的 constructor 是否等于 Array，如果相等，则说明 obj 是一个数组。

误判分析

constructor 属性判断是否为数组的方法适用于大多数情况下，但对于一些特殊情况，需要谨慎使用，如果对象的 constructor 属性被修改，或者是用户自定义的类，就可能导致判断结果失效。

function isArray(obj) {return obj.constructor === Array;
}// 示例用法
let obj = { name: "John", age: 25 };
console.log(isArray(obj));obj.constructor = Array;
console.log(isArray(obj));

typeof

typeof 运算符是 JavaScript 中的一种操作符，用于判断一个变量的类型。它返回一个表示变量类型的字符串。

typeof 运算符可以用于判断以下几种数据类型：

• "undefined" ：当变量未定义或者被声明但未赋值时的类型。

• "boolean" ：当变量是布尔值类型（true 或 false）时的类型。

• "number" ：当变量是数值类型时的类型。

• "string" ：当变量是字符串类型时的类型。

• "bigint" ：当变量是一个大整数类型时的类型（ES2020 新增）。

• "symbol" ：当变量是一个符号类型时的类型（ES2015 新增）。

• "function" ：当变量是一个函数类型时的类型。

• "object" ：当变量是引用类型的对象（包括数组、null 以及自定义对象等）时的类型。

需要注意的是，typeof 运算符会将数组、null 和其他引用类型都归类为 "object"，而无法准确判断一个对象是否是数组。这是因为在 JavaScript 中，数组是一种特殊的对象类型。所以，如果需要判断一个变量是否是数组，typeof 运算符并不能完全满足需求。

以下是一些 typeof 运算符的示例：

let x;
console.log(typeof x); // 输出: "undefined"let y = true;
console.log(typeof y); // 输出: "boolean"let z = 42;
console.log(typeof z); // 输出: "number"let str = "Hello";
console.log(typeof str); // 输出: "string"let obj = { name: "John", age: 25 };
console.log(typeof obj); // 输出: "object"let arr = [1, 2, 3];
console.log(typeof arr); // 输出: "object"let func = function () {};
console.log(typeof func); // 输出: "function"

如果真想使用 typeof 来判断数组，可以通过以下的方式来判断

let arr = [1, 2, 3]
let obj = { name: 'John' }
console.log(typeof arr === 'object' && typeof arr.length === 'number');  // 输出: true
console.log(typeof obj === 'object' && typeof obj.length === 'number');  // 输出: false

总的来说，typeof 运算符可以用于粗略地判断变量的类型，但对于数组和其他引用类型的判断不够准确。如果需要准确判断一个变量是否是数组，可以使用其他方法。因此，使用 typeof 运算符并不能完全满足判断是否为数组的需求，还需要结合下一步的判断，比如判断length属性才可以完全判断为数组。

总结

通过以上文章的了解，我们总结一下判断一个值是否为数组的几种方式，我总结了 5 种方式判断，如下所示：

• Array.isArray() ：这是最常用的方式，该方法可以直接判断一个值是否为数组。它是 ES5 引入的 Array 构造函数的静态方法，返回一个布尔值。

• Object.prototype.toString.call() ：通过调用 Object.prototype.toString 方法，获取值的内部类型，再进行比较判断。

• instanceof 运算符：使用 instanceof 判断一个对象是否是一个类的实例。但是需要注意，它不仅判断对象的构造函数是否是数组，还会检查对象的原型链上是否存在数组的原型。

• constructor 属性：通过判断一个值的构造函数是否是数组构造函数来确定是否为数组，同时需要注意误判的情况。

• typeof 运算符：使用 typeof 判断值的类型是否为 "object"，再通过判断其是否具有 length 属性来确定是否为数组。

综上所述，选择哪种方式判断数组取决于具体的使用情况。通常情况下，Array.isArray() 和 Object.prototype.toString.call() 是最简洁和推荐的方式。

但在某些特殊情况下，其他方式也可能更适合，比如判断值的类型，同时需要额外的处理逻辑时可以使用 typeof 等。