怎么准确判断JavaScript基本数据类型？

一、明确范围：JavaScript 的 7 种基本数据类型

在深入探讨如何判断之前，必须严格界定“基本数据类型”（Primitive Types）在 JavaScript 规范中的边界。很多开发者容易将数组、函数或特定对象与基本类型混淆，这会导致判断逻辑在设计初期就存在漏洞。

根据最新 ECMAScript 规范，JavaScript 共有 7 种基本数据类型：

• string（字符串）：表示文本字符序列，如 "hello"。
• number（数值）：双精度 64 位二进制浮点数，涵盖正负数、浮点数以及特殊的 NaN 和 Infinity。
• boolean（布尔值）：仅有两个逻辑值，即 true 和 false。
• undefined（未定义）：表示变量声明了但尚未赋值时的默认状态。
• null（空值）：表示一个有意设置的“空对象指针”或“无值”状态。
• symbol（符号）：ES6 引入的基本类型，用于创建全局唯一的不可变标识符。
• bigint（大整数）：ES2020 引入的基本类型，用于安全存储和计算超出安全整数限制（Number.MAX_SAFE_INTEGER）的任意精度整数，如 9007199254740993n。

基本数据类型与引用数据类型（如 Object、Array、Function、Date 等）存在两个关键本质区别：一是存储机制，基本类型的值直接保存在栈内存（Stack）中，按值直接访问；二是不可变性，基本类型的值一经创建便不可更改，任何对字符串或数值的操作都是返回新的值，而不是在原地修改。

二、最常用的 typeof 及其致命死角

在 JavaScript 中，typeof 操作符是检测数据类型最常见、执行速度最快的原生语法。对于绝大多数基本数据类型，typeof 的返回值非常直观且符合预期：

typeof "antigravity"   // "string"
typeof 1024            // "number"
typeof true            // "boolean"
typeof undefined       // "undefined"
typeof Symbol("id")    // "symbol"
typeof 42n             // "bigint"

然而，typeof 存在一个在前端领域人尽皆知的致命死角：

typeof null            // "object" ⚠️ 致命误判！

后来在 ECMAScript 提案（Harmony 阶段）中，曾有人提出将 typeof null 修正为 "null"。但经过实际测试，修复此问题会导致互联网上大量依赖这一历史特性的旧网站发生严重崩溃，因此为了维持生态的向后兼容性，该缺陷被永久保留了下来。

除此之外，typeof 还有另外两个需要留意的特性：

1. typeof NaN === "number"：NaN（Not-a-Number）虽然表示无效数值，但它在类型系统上依然属于 number 基本类型。如果业务需要严格的“有效数字”，仅用 typeof 检查是不够的。
2. 包装对象的干扰：通过构造函数创建的基本类型包装对象（例如 new String("abc") 或 new Number(123)），其 typeof 结果均为 "object"，因为它们本质上是引用对象，而非原始基本类型。

三、准确判断基本类型的推导流程与逐步实现

既然明确了 typeof 的盲区与边界，我们就可以梳理出一套严谨、没有逻辑死角的判断流程。

步骤 1：优先拦截 null

针对 typeof null === "object" 的缺陷，最简单且最高效的防御手段是使用全等操作符（===）。因为 null 在整个运行环境中是唯一的单一值，直接比对即可获得 100% 可靠的结果：

function isNull(val) {
  return val === null;
}

步骤 2：使用 typeof 处理剩余 6 种基本类型

当排除了 null 之后，剩余的 6 种基本类型（string、number、boolean、undefined、symbol、bigint）完全可以通过 typeof 的返回值一一准确对应。

步骤 3：甄别 NaN 与有效数值

当 typeof val === "number" 时，如果需要区分这是正常有效数字还是运算溢出/解析失败得到的 NaN，应使用 ES6 提供的 Number.isNaN()：

// 注意：不要使用全局 isNaN()，因为它会隐式将非数字转换为数字
// 必须使用严格检测的 Number.isNaN()
if (typeof val === "number") {
  if (Number.isNaN(val)) {
    // 特殊情况：属于 number 类型，但是 NaN
  } else {
    // 正常有效数值
  }
}

步骤 4：引入终极基准 —— Object.prototype.toString.call()

如果需要一个不依赖任何分支判断、统一通用的标准判定方案，Object.prototype.toString.call() 是 JavaScript 社区公认的权威手段。

它的原理在于：每个对象或基本类型在被传入 Object.prototype.toString.call(value) 时，如果传入的是基本类型，引擎会先将其装箱或提取内部的 [[Class]] 或 Symbol.toStringTag 标签，并返回格式为 "[object Type]" 的标准化字符串：

Object.prototype.toString.call("hello")       // "[object String]"
Object.prototype.toString.call(123)           // "[object Number]"
Object.prototype.toString.call(true)          // "[object Boolean]"
Object.prototype.toString.call(undefined)     // "[object Undefined]"
Object.prototype.toString.call(null)          // "[object Null]"
Object.prototype.toString.call(Symbol())      // "[object Symbol]"
Object.prototype.toString.call(100n)          // "[object BigInt]"

可以看到，即使是让 typeof 翻车的 null，在 Object.prototype.toString.call(null) 下也会老老实实返回 "[object Null]"，完全没有任何模糊空间。

四、封装开箱即用的类型判断工具函数

将上述推导逻辑组合起来，我们可以编写两个实际可用的生产级工具函数：一个是专门判定基本类型的轻量函数 getPrimitiveType，另一个是全量数据类型判定函数 getType。

1. 基本类型快速判定函数

如果你的需求仅聚焦在基本类型，并希望保持最优的执行效率，可以采用“优先排查 null + typeof 分流”的方案：

/**
 * 准确获取基本数据类型名称
 * @param {*} value 待检测的值
 * @returns {string|null} 若为基本类型返回类型名称，若为引用类型返回 null
 */
function getPrimitiveType(value) {
  // 1. 优先防御 null
  if (value === null) {
    return "null";
  }

  // 2. 使用 typeof 检测
  const type = typeof value;

  // 3. 严格匹配 6 种正常基本类型
  switch (type) {
    case "string":
    case "boolean":
    case "undefined":
    case "symbol":
    case "bigint":
      return type;
    case "number":
      // 如果需要细分 NaN，可在此分支处理
      return Number.isNaN(value) ? "NaN" : "number";
    default:
      // 排除掉所有引用类型 (object, function)
      return null;
  }
}

// 辅助函数：判断是否为基本数据类型
function isPrimitive(value) {
  return value === null || (typeof value !== "object" && typeof value !== "function");
}

2. 通用高精度类型判定函数

如果是构建通用的基础工具库，推荐基于 Object.prototype.toString.call() 封装，它不仅能精准识别 7 种基本类型，还能顺带区分出数组、正则、日期等复杂引用对象：

/**
 * 通用全量数据类型获取函数
 * @param {*} value 待检测的任意值
 * @returns {string} 统一小写的类型名称
 */
function getExactType(value) {
  // 1. 针对基本类型字面量与包装对象的区分：
  // 如果是 null 或 undefined，直接安全返回
  if (value === null) return "null";
  if (value === undefined) return "undefined";

  // 2. 如果是 new String()、new Number() 等包装对象，typeof 会是 "object"
  // 若业务要求只认原始字面量，可结合 typeof 双重校验
  const rawType = Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
  return rawType;
}

// 验证测试
console.log(getPrimitiveType("abc"));          // "string"
console.log(getPrimitiveType(12345));          // "number"
console.log(getPrimitiveType(NaN));            // "NaN"
console.log(getPrimitiveType(false));          // "boolean"
console.log(getPrimitiveType(undefined));      // "undefined"
console.log(getPrimitiveType(null));           // "null"
console.log(getPrimitiveType(Symbol("k")));    // "symbol"
console.log(getPrimitiveType(9999999999999n)); // "bigint"
console.log(getPrimitiveType({ a: 1 }));       // null (非基本类型)
console.log(getPrimitiveType([1, 2, 3]));      // null (非基本类型)
console.log(getPrimitiveType(() => {}));        // null (非基本类型)

五、开发中必须防范的 3 个关键细节

在实际编写类型检查逻辑时，以下 3 个细节极为隐蔽，如果处理不当，很容易在生产环境产生难以排查的 Bug。

1. 绝不使用双等号判断 null 与 undefined

在 JavaScript 中，双等号（==）会触发隐式类型转换。根据抽象相等比较算法（Abstract Equality Comparison），null == undefined 会直接返回 true：

console.log(null == undefined);  // true ⚠️
console.log(null === undefined); // false（正确）

因此，当你的目的是准确判断变量是否为 null，绝不能写成 if (val == null)，因为这会把 undefined 也一并误判进来。必须始终坚持使用全等号 val === null。

2. 警惕基本类型包装对象

JavaScript 允许使用构造函数显式创建包装对象：

const primStr = "hello";
const objStr = new String("hello");

console.log(typeof primStr); // "string"
console.log(typeof objStr);  // "object" ⚠️

console.log(primStr === objStr); // false

包装对象在内存中存在于堆内存，是一个真正的引用对象，它不仅拥有对象原型链，而且两个具有相同内容的包装对象在用 === 比对时也会返回 false。如果你要判断的值必须是“纯粹的基本数据类型”，切记排除 typeof val === "object" 的情况。

3. 特殊数值的处理策略

在 number 类型内部，存在几个特殊值：NaN、+Infinity、-Infinity 以及 +0 / -0：

• NaN 与任何值都不相等，包括它自己（NaN === NaN 返回 false）。检测它必须使用 Number.isNaN()。
• Infinity 是合法的基本数值（typeof Infinity === "number"），但它不是有限数字。若需要检验是否为有效常规数值，应使用 Number.isFinite()。