怎么用 Object.prototype.toString 准确判断 JS 数组类型

一、核心写法与基础验证

在需要严格识别数组类型时，可以直接使用 Object.prototype.toString，并通过 .call() 或 .apply() 将待检测变量作为上下文传入：

// 基础判断函数封装
function isArray(value) {
  return Object.prototype.toString.call(value) === '[object Array]';
}

// 典型测试案例
console.log(isArray([]));               // true
console.log(isArray([1, 2, 3]));        // true
console.log(isArray(new Array(5)));      // true

// 排除非数组常见用例
console.log(isArray({}));               // false （返回 '[object Object]'）
console.log(isArray({ length: 0 }));    // false （类数组对象，返回 '[object Object]'）
console.log(isArray('abc'));            // false （返回 '[object String]'）
console.log(isArray(null));             // false （返回 '[object Null]'）
console.log(isArray(undefined));        // false （返回 '[object Undefined]'）

该方法之所以可靠，是因为其输出格式严格遵循 ECMAScript 规范定义。当执行该方法时，JavaScript 引擎会获取目标实体的内建类型标签（Tag），并拼装成形如 "[object " + Tag + "]" 的字符串。对于原生数组，该标签在规范定义中固定为 "Array"，因此其返回值恒定为 "[object Array]"。

二、为什么不能直接调用 arr.toString()？

初学者常有的疑惑是：既然变量 arr 本身就拥有 toString 方法，为什么不能直接写 arr.toString()？

这是由于 JavaScript 原型链的“方法遮蔽”（Method Shadowing）机制引起的。在原型链体系中，Array.prototype 继承自 Object.prototype，但 Array.prototype 重写（Override）了自己的 toString 方法：

const arr = [1, 2, 3];

// 直接调用：命中 Array.prototype.toString
console.log(arr.toString());
// 示例输出："1,2,3" （内部调用 join(',')，丢失了类型信息）

// 方法借用：显式执行 Object.prototype 原型上的原始探针
console.log(Object.prototype.toString.call(arr));
// 示例输出："[object Array]"

当直接在 arr 上调用 arr.toString() 时，解释器沿着原型链首先在 Array.prototype 查找到该方法，并立即执行。数组重写后的方法功能是把数组内部元素转换成字符串并用逗号拼接，不会返回对象的元类型标签。

通过使用 Object.prototype.toString.call(arr)，我们跳过了原型链就近查找阶段，直接取出顶层 Object.prototype 上的未篡改版本，并通过 .call(arr) 强行将执行上下文中的 this 重新绑定给 arr，从而成功读取该实例的内部类型槽位。

三、对比其他常见方案：为什么它最准确？

在 JavaScript 开发中，判断变量类型通常有几种惯用手段，但在针对数组时，其他方案均存在明显的短板与失效边界。

1. typeof 操作符的粒度缺失

在规范中，typeof []、typeof {} 以及 typeof null 均返回字符串 "object"。它只能粗粒度区分基本数据类型与引用对象，无法辨别具体的引用对象构造分类。

2. instanceof 的跨执行上下文（Cross-Realm）失效

instanceof 是检验对象原型链中是否包含某个构造函数的 prototype 属性。在单一页面环境中，arr instanceof Array 表现正常；但在多 frame、iframe、Web Worker 或 Electron 窗口等跨环境场景下，每个全局上下文（Realm）都拥有自己独立的全局作用域与内置构造函数：

// 模拟跨 iframe 场景
const iframe = document.createElement('iframe');
document.body.appendChild(iframe);
const iframeArray = iframe.contentWindow.Array;

const arrFromIframe = new iframeArray(1, 2, 3);

// 原型链比较失败：因为 iframe 的 Array 构造函数与主页面的 Array 并非同一个内存引用
console.log(arrFromIframe instanceof Array); // false

// 而 Object.prototype.toString.call 仍可精准识别
console.log(Object.prototype.toString.call(arrFromIframe) === '[object Array]'); // true

3. constructor 属性极易被篡改

通过 arr.constructor === Array 进行判断同样脆弱。首先，constructor 属性在普通对象中可以被自由赋值与覆写；其次，如果目标变量为 null 或 undefined，直接读取该属性会抛出 TypeError。

四、底层执行推导步骤：引擎如何识别数组？

为了理解 Object.prototype.toString 的稳定性，需要参考 ECMAScript 规范关于 Object.prototype.toString () 的具体执行算法（如 ES2015+ 规范第 19.1.3.6 节）。

当调用该方法时，引擎内部按以下精确步骤执行推导：

1. 空值预检：若 this 值为 undefined，直接返回 "[object Undefined]"；若 this 值为 null，直接返回 "[object Null]"。
2. 对象封装（ToObject）：执行规范抽象操作 ToObject(this)，将原始类型值转换为对应的包装对象；如果入参已是对象引用（如数组），则保持其引用不变。
3. 内建分类分支匹配（IsArray）：执行抽象判定 IsArray(O)。如果结果为 true，则内部类型标记 builtinTag 被赋予 "Array"。
4. Symbol.toStringTag 特性评估：检查对象是否拥有具备知名属性 Symbol.toStringTag 的字符串值。对于内置未篡改的原生数组，其内置标识优先被确定。
5. 字符拼接输出：将已确立的标签名与外层前缀后缀进行格式化合并，统一拼装为 "[object " + Tag + "]" 并返回。

五、工程实践与封装方案

在现代工程代码中，ECMAScript 5.1 标准已经原生引入了 Array.isArray() 方法，其内部同样基于引擎级的 IsArray 算法实现，且不需要做字符串格式化比较，运行效率更高。

在实际通用工具库（例如 Lodash、各类 Polyfill 或兼容性基础设施）中，通常采用“优先原生、稳健降级”的健壮架构：

// 模块作用域中提前缓存引用，避免每次判定都发生原型链查找
const toString = Object.prototype.toString;

/**
 * 健壮的数组类型判断函数
 * @param {*} value 待检测的任意目标值
 * @returns {boolean} 是否为合法数组
 */
const isArray = (function () {
  // 现代环境优先使用原生的 Array.isArray
  if (typeof Array.isArray === 'function') {
    return Array.isArray;
  }

  // 老旧环境或特殊宿主环境下稳健降级为 Object.prototype.toString.call
  return function (value) {
    return toString.call(value) === '[object Array]';
  };
})();

// 生产验证
console.log(isArray([1, 2]));        // true
console.log(isArray('hello'));       // false
console.log(isArray({ length: 1 })); // false

六、关键要点总结

掌握 Object.prototype.toString 判断数组的核心逻辑，可以归纳为以下三点：

• 根本手段：通过 Object.prototype.toString.call(target) === '[object Array]' 读取未被遮蔽的原型探针。
• 不可替代性：在跨窗口、跨 iframe（Cross-Realm）环境中，该机制不受孤立堆内存和不同构造函数地址的影响，具备确定性判断结果。
• 最佳实践：日常现代开发优先采用 Array.isArray()，但理解 Object.prototype.toString 的借用机制与内部原理，是深入掌握 JavaScript 原型链、执行上下文与通用类型判定库底层逻辑的基石。