JS类型判断方法对比：typeof、instanceof与toString

一、核心选型结论速览

为了让开发者在实际编写业务逻辑时快速做出合理选择，下表直接总结了三种判断方法的核心定位、检测范围与关键局限：

二、方法一：typeof 的底层机制与适用边界

typeof 是 JavaScript 中的一元运算符。它的执行开销极低，因为其机制直接读取引擎底层存储变量时的二进制类型标记（Type Tag）。

1. 底层存储与类型标记机制

在 V8 引擎及早期 JavaScript 实现中，变量在内存中以字（word）为单位表示，其低位被用来存放 1 到 3 位的类型标签：

• 000：对象引用（Object reference）
• 1：整型小整数（Smi, 31 位有符号整数）
• 010：双精度浮点数（Double）
• 100：字符串指针（String）
• 110：布尔值（Boolean）

2. 完整代码示例与示例输出

以下示例展示了 typeof 在各种数据类型上的实际判断结果：

// 1. 原始类型判定（均为小写字符串）
console.log(typeof 'Hello World');      // 示例输出: 'string'
console.log(typeof 42);                 // 示例输出: 'number'
console.log(typeof NaN);                // 示例输出: 'number' (注意 NaN 也是数字类型)
console.log(typeof true);               // 示例输出: 'boolean'
console.log(typeof undefined);          // 示例输出: 'undefined'
console.log(typeof Symbol('id'));       // 示例输出: 'symbol'
console.log(typeof 100n);               // 示例输出: 'bigint'

// 2. 函数判定
console.log(typeof function() {});       // 示例输出: 'function'
console.log(typeof class MyClass {});    // 示例输出: 'function' (ES6 Class 本质是构造函数)

// 3. 常见陷阱与无法区分的对象
console.log(typeof null);               // 示例输出: 'object' (历史遗留缺陷)
console.log(typeof [1, 2, 3]);          // 示例输出: 'object' (无法识别数组)
console.log(typeof { name: 'Alice' });  // 示例输出: 'object'
console.log(typeof new Date());         // 示例输出: 'object'
console.log(typeof /abc/g);             // 示例输出: 'object'

三、方法二：instanceof 的原型链查找与跨环境限制

instanceof 是一个二元运算符，用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。它适用于面向对象编程中的类与继承关系判定。

1. 原型链遍历算法推导

表达式 L instanceof R 的核心运作过程可表述为如下推导逻辑：

1. 若 L 为原始类型（非对象），直接返回 false。
2. 取得左操作数的隐式原型：proto = Object.getPrototypeOf(L)。
3. 取得右操作数的原型对象：targetPrototype = R.prototype。
4. 进入循环比对：
   • 若 proto === null，说明遍历已到达原型链顶端未命中，返回 false；
   • 若 proto === targetPrototype，说明当前原型节点全等，返回 true；
   • 否则更新 proto = Object.getPrototypeOf(proto)，继续循环向上查找。

2. 核心代码示例

// 1. 自定义类与继承判定
class Animal {}
class Dog extends Animal {}

const myDog = new Dog();
console.log(myDog instanceof Dog);       // 示例输出: true
console.log(myDog instanceof Animal);    // 示例输出: true (沿着原型链向上命中)
console.log(myDog instanceof Object);    // 示例输出: true (所有普通对象最终指向 Object)

// 2. 原始类型字面量不能被判断
const strLiteral = 'test';
const strObject = new String('test');
console.log(strLiteral instanceof String); // 示例输出: false (原始字面量没有指向 String.prototype)
console.log(strObject instanceof String);  // 示例输出: true (包装对象实例为 true)

四、方法三：Object.prototype.toString 的内部标记原理与全能判断

Object.prototype.toString.call(val) 被公认为 JavaScript 中判定原生引用类型最准确、最通用的方法。它通过函数借用（Borrowing Method），直接读取规范中对象的内部类型标记。

1. 内部槽与 Symbol.toStringTag 机制

根据 ECMAScript 规范，当执行 Object.prototype.toString() 时，引擎会执行如下步骤：

• 如果参数为 undefined，返回 "[object Undefined]"；
• 如果参数为 null，返回 "[object Null]"；
• 令 O = ToObject(this)，将原始类型自动转换为对应的包装对象；
• 检查对象是否部署了 Symbol.toStringTag 属性：若存在且为字符串，则使用该值作为 Tag；
• 若未定义，则读取其规范内置的 [[Class]] 内部槽值（如 "Array"、"Date"、"RegExp" 等）；
• 最终返回字符串拼接结果 "[object " + tag + "]"。

2. 典型调用与解析示例

// 借助 call 绑定执行上下文
const toStr = Object.prototype.toString;

console.log(toStr.call('hello'));       // 示例输出: '[object String]'
console.log(toStr.call(123));           // 示例输出: '[object Number]'
console.log(toStr.call(true));          // 示例输出: '[object Boolean]'
console.log(toStr.call(undefined));     // 示例输出: '[object Undefined]'
console.log(toStr.call(null));          // 示例输出: '[object Null]'
console.log(toStr.call([1, 2, 3]));     // 示例输出: '[object Array]'
console.log(toStr.call(new Date()));    // 示例输出: '[object Date]'
console.log(toStr.call(/pattern/i));    // 示例输出: '[object RegExp]'
console.log(toStr.call(new Map()));     // 示例输出: '[object Map]'
console.log(toStr.call(new Set()));     // 示例输出: '[object Set]'
console.log(toStr.call(Promise.resolve())); // 示例输出: '[object Promise]'

// 自定义类可通过 Symbol.toStringTag 声明标签
class CustomStorage {
  get [Symbol.toStringTag]() {
    return 'CustomStorage';
  }
}
console.log(toStr.call(new CustomStorage())); // 示例输出: '[object CustomStorage]'

五、实战选型与决策推导

面对不同业务输入，应当遵循清晰的分流步骤进行类型检测，以兼顾执行性能与安全性：

1. 空值优先排除：使用全等操作符 val === null 和 val === undefined，速度最快且完全防范类型混淆。
2. 原始类型优先 typeof：对于字符串、数字、布尔等基础数据，typeof 在引擎层面以单指令完成，性能最优。
3. 内置对象优先使用专用 API 或 toString：判断数组首选 ES5 标准的 Array.isArray(val)；判断日期、正则、Map 等复杂对象使用 Object.prototype.toString.call(val)。
4. 类实例关系判断使用 instanceof：当需要验证对象的继承链（例如多态派发、错误捕获）且在单 Realm 内运行时，使用 instanceof。

六、12种常见数据类型对比矩阵与避坑要点

下表展示了常见 12 种数据类型在各个判断方式下的实际表现，并在右侧总结了最佳实践：

七、生产级实战封装：通用的类型判断工具函数

在实际企业级项目开发中，我们可以将上述三种方法的优势结合起来，封装一套稳健、低冗余且类型安全的通用工具模块：

/**
 * 生产级通用类型检测模块
 */
const TypeUtils = (() => {
  const toString = Object.prototype.toString;

  /**
   * 获取目标值的精准小写类型名
   * @param {*} value 任意输入值
   * @returns {string} 如 'string', 'number', 'array', 'date', 'null', 'undefined' 等
   */
  function getType(value) {
    // 1. 处理 null 与 undefined（针对部分老旧环境兼容）
    if (value === null) return 'null';
    if (value === undefined) return 'undefined';

    // 2. 原始类型与函数直接通过 typeof 提取（极致性能）
    const baseType = typeof value;
    if (baseType !== 'object') {
      return baseType;
    }

    // 3. 复杂引用类型借用 Object.prototype.toString
    // 截取 '[object Array]' 中的 'Array' 并转为小写 'array'
    const rawTag = toString.call(value);
    return rawTag.slice(8, -1).toLowerCase();
  }

  /**
   * 细分谓词函数（Predicates）
   */
  const isPlainObject = (val) => {
    if (getType(val) !== 'object') return false;
    const proto = Object.getPrototypeOf(val);
    return proto === null || proto === Object.prototype;
  };

  const isArray = Array.isArray || ((val) => getType(val) === 'array');
  const isFunction = (val) => typeof val === 'function';
  const isDate = (val) => getType(val) === 'date';
  const isRegExp = (val) => getType(val) === 'regexp';

  return {
    getType,
    isPlainObject,
    isArray,
    isFunction,
    isDate,
    isRegExp
  };
})();

// --- 生产环境验证示例 ---
console.log(TypeUtils.getType('Hello'));        // 示例输出: 'string'
console.log(TypeUtils.getType(null));           // 示例输出: 'null'
console.log(TypeUtils.getType([1, 2]));         // 示例输出: 'array'
console.log(TypeUtils.getType(new Date()));     // 示例输出: 'date'
console.log(TypeUtils.getType(new Map()));      // 示例输出: 'map'

// 纯对象检测验证
console.log(TypeUtils.isPlainObject({ a: 1 }));        // 示例输出: true
console.log(TypeUtils.isPlainObject(Object.create(null))); // 示例输出: true (无原型对象)
console.log(TypeUtils.isPlainObject(new Date()));       // 示例输出: false (非纯对象)

八、常见疑难问题与边界排查

1. Object.create(null) 实例的类型检测注意事项

通过 Object.create(null) 创建的对象没有原型（其 __proto__ 为 undefined，Object.getPrototypeOf() 为 null）。因此：

• 执行 obj instanceof Object 会返回 false，因为它的原型链上不存在 Object.prototype；
• 直接执行 obj.toString() 会抛出 TypeError: obj.toString is not a function 异常；
• 正确做法：使用 Object.prototype.toString.call(obj)，输出依然是标准合法的 "[object Object]"。

2. 如何保证跨 Realm 场景下的数组安全性？

现代浏览器已原生支持 ES5 引入的 Array.isArray()。根据规范标准，Array.isArray(arg) 内部检查参数的 [[Class]] 或内部数组标记，不会比较不同 Realm 之间的 Array.prototype 内存地址。因此在处理 <iframe> 跨窗口通信传递数据时，应始终以 Array.isArray() 代替 instanceof Array。

3. 自定义错误类的捕获与区分

对于 Node.js 服务端或前端统一错误分发场景，经常需要根据错误类型做不同降级处理。此时应当直接使用 instanceof，利用继承链关系精确分发：

class DatabaseError extends Error {
  constructor(message) {
    super(message);
    this.name = 'DatabaseError';
  }
}

try {
  throw new DatabaseError('Connection timeout');
} catch (err) {
  if (err instanceof DatabaseError) {
    // 示例分支: 专门处理数据库连接失败的告警上报
    console.log('捕获到数据库异常:', err.message);
  } else if (err instanceof Error) {
    // 通用系统错误处理
    console.log('捕获到未知异常:', err.message);
  }
}