JS中typeof能判断哪些类型？详解其局限性

一、typeof 能够准确判断的类型清单

在 ECMAScript 规范中，typeof 操作符只可能返回以下 8 个固定的字符串之一："undefined"、"boolean"、"string"、"number"、"bigint"、"symbol"、"function" 和 "object"。只要操作数属于基础标量类型，typeof 的判定几乎都是快速且准确的。

// 1. 基础原始类型（无歧义，判定可靠）
typeof "hello world";      // "string"
typeof 1024;               // "number"
typeof NaN;                // "number"（注意：NaN 在语义上是无效数值，但类型仍为数值）
typeof Infinity;           // "number"
typeof true;               // "boolean"
typeof undefined;          // "undefined"
typeof Symbol("token");    // "symbol"（ES6 新增）
typeof 9007199254740995n;  // "bigint"（ES2020 新增）

// 2. 函数对象（可调用对象被特例处理）
typeof function run() {};   // "function"
typeof (() => {});          // "function"
typeof class User {};       // "function"（类本质上是构造函数的语法糖）

对于上述常规数据，使用 typeof 进行防错判断（如函数入参校验 typeof cb === "function"）不仅书写直观，而且在 V8 等现代引擎中有深度的内联缓存优化，执行开销极小。

二、typeof 的底层求值流程与机制

为什么 typeof 既能检查基础值，又能对部分特殊标识符做出反应？了解其求值步骤能帮助我们规避很多非预期的报错。ECMAScript 规范中规定，当执行 typeof Expression 时，引擎会先计算表达式的引用，并按照以下分支逐步解析：

从流程中可以看出两个关键细节：

• 对未声明变量的安全机制：如果操作数是一个未曾用 var、let 或 const 声明的变量，直接读取它会抛出 ReferenceError，但把它传给 typeof 却不会崩溃，而是安全返回 "undefined"。
• 函数的特殊内部槽检测：当操作数是对象时，引擎并不立即返回 "object"，而是先检查该对象内部是否实现了 [[Call]] 内部方法。只要具有该槽位（即是可调用的），就返回 "function"。

三、局限性一：typeof null === "object" 的历史成因

JavaScript 开发者遇到的第一个反直觉现象往往是 typeof null === "object"。根据规范定义，null 是一个独立的原始值（Primitive Value），代表“空值”或“无对象”，它绝不是一个对象。

造成这一现象的原因来自 1995 年 JavaScript 第一版发布时的底层 C 语言实现：

• 在早期架构中，JS 值的机器字长为 32 位，其中低 1 至 3 位被用来存储类型标签（Type Tag）。
• 其中，000 代表操作数是一个对象指针，引擎会读取高 29 位作为堆内存的寻址引用。
• 而 null 在底层表示为 C 语言中的空指针常量（NULL 指针，即 0x00000000）。由于它的 32 位全为 0，低 3 位自然也是 000。
• 当 typeof 检查该值时，只比对末位标签，看到 000 便误判为对象，返回了 "object"。

四、局限性二与三：引用类型无法区分与包装类干扰

除了 null 之外，typeof 在面对丰富的对象子类型时表现得过于粗糙。

1. 引用类型“一刀切”全部返回 "object"

在实际业务中，我们经常需要区分普通对象、数组、正则表达式或日期。但对于 typeof 而言，除了函数之外的所有对象形态，其返回结果全部都是 "object"：

typeof {};               // "object"
typeof [1, 2, 3];          // "object"（无法识别数组）
typeof new Date();         // "object"（无法识别时间对象）
typeof /^[a-z]+$/;         // "object"（无法识别正则表达式）
typeof new Map();          // "object"（无法识别集合）
typeof new Set();          // "object"
typeof new Error("err");   // "object"

这意味着你绝对不能使用 typeof data === "object" 来断定参数是一个普通的键值对字典，因为如果调用方传入一个数组或 null，该表达式依然成立。

2. 原始值的包装对象陷阱

如果使用构造函数实例化了基本类型（虽然在现代开发中强烈不推荐，但在老旧库或防御性编码中常见），typeof 会将其判定为对象，从而使类型校验彻底失真：

const strPrim = "antigravity";
const strObj = new String("antigravity");

typeof strPrim; // "string"
typeof strObj;  // "object"（包装类破坏了原始类型判定）
strObj instanceof String; // true

3. 暂时性死区（TDZ）带来的运行时抛错

很多人误以为 typeof 在任何情况下都是绝对安全的，但 ES6 引入块级作用域变量（let、const）和类声明后，如果在变量声明之前使用 typeof，会直接抛出语法致命错误：

// 针对未声明的标识符：安全
typeof completelyUndeclaredVar; // 返回 "undefined"，不会报错

// 针对存在于作用域但尚未初始化的 let/const 标识符：
typeof age; // 抛出 Uncaught ReferenceError: Cannot access 'age' before initialization
let age = 18;

五、实战破局：现代 JavaScript 精准类型判断方案

既然 typeof 在引用类型、空值检测和包装对象上有明显的盲区，在工程开发中我们应当如何构建一套兼具高性能与高准确率的判断体系？

1. 判空：直接使用全等比较

检测 null 与 undefined 根本无需动用 typeof，直接使用恒等运算符是最高效且清晰的做法：

// 精确校验 null
if (val === null) {
  // 确认为空值
}

// 同时校验 null 和 undefined（常用简写）
if (val == null) {
  // 匹配 null 或 undefined
}

2. 判定数组：使用原生 Array.isArray

ES5 引入的 Array.isArray() 能够完美判定数组，且能够穿透多窗口（iframe 或不同 Realm 上下文）导致的原型链隔离问题，比 instanceof Array 更加稳健：

Array.isArray([1, 2, 3]); // true
Array.isArray({ length: 3 }); // false（排除类数组伪造）

3. 终极底牌：Object.prototype.toString.call

ECMAScript 规范要求，对象的 Object.prototype.toString() 方法在调用时会检查其内部符号 Symbol.toStringTag 或内置内部槽，返回格式固定为 "[object Type]" 的字符串。通过 .call(val) 借用该方法，可以精确区分 JavaScript 中的绝大多数内置类型：

const toString = Object.prototype.toString;

toString.call("abc");          // "[object String]"
toString.call(123);            // "[object Number]"
toString.call(null);           // "[object Null]"（精准区分 null）
toString.call(undefined);      // "[object Undefined]"
toString.call([1, 2]);         // "[object Array]"
toString.call(new Date());     // "[object Date]"
toString.call(/regex/);        // "[object RegExp]"
toString.call(new Map());      // "[object Map]"
toString.call(new Set());      // "[object Set]"
toString.call(new String("")); // "[object String]"（准确识别包装对象原型）

4. 工程实战：封装通用类型诊断函数

综合性能与严谨性，在业务库开发中，可以结合 typeof 的高执行速度与 toString.call 的高精确度，封装如下通用工具：

/**
 * 健壮获取数据精确类型（小写字符串）
 * @param {*} value 待检测的任意数据
 * @returns {string} 如 'null', 'array', 'date', 'regexp', 'string', 'number' 等
 */
function toRawType(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; // 'string', 'number', 'boolean', 'symbol', 'bigint', 'function'
  }

  // 3. 复杂引用类型调用 Object.prototype.toString 提取具体标签
  return Object.prototype.toString
    .call(value)
    .slice(8, -1)
    .toLowerCase();
}

// 验证效果：
console.log(toRawType(null));        // "null"
console.log(toRawType([1, 2]));      // "array"
console.log(toRawType(new Date()));  // "date"
console.log(toRawType({ a: 1 }));    // "object"
console.log(toRawType(new Map()));   // "map"

六、核心总结与选型口诀

回顾全文，typeof 的定位是一个轻量、快速的一元类型探测工具，但不是万能工具。在日常编码中可以遵循以下原则：

• 查标量与函数：放心使用 typeof，代码简洁且执行效率最高。
• 查空值：直接使用 === null，切忌使用 typeof v === "null"（该条件恒为 false）。
• 查数组：一律使用 Array.isArray(v)。
• 查复杂对象与原型标签：调用 Object.prototype.toString.call(v)。
• 防范暂时性死区：变量务必遵循“先声明、后使用”的编码规范，不要把 typeof 当作未声明 let/const 变量的安全网。