JavaScript有哪些基本数据类型

一、7 种基本数据类型核心特征解析

基本数据类型代表了 JavaScript 中最底层的原子数据。它们不能再被细分，也不拥有可变的方法与属性（虽然在调用字符串方法时引擎会临时自动装箱，但原始值本身永恒不变）。以下是这 7 种基本类型的具体定义与使用场景：

1. Undefined（未定义）

Undefined 类型只有一个唯一的值，即 undefined。当一个变量使用 let 或 var 声明后没有赋予初始值，JavaScript 引擎会自动为其分配 undefined。在函数定义中，如果调用方没有传入对应形参，或者函数体内没有显式使用 return 语句返回结果，其默认返回值也是 undefined。

// 示例环境：Node.js 18+ 或现代浏览器控制台
let unassignedVar;
console.log(unassignedVar);        // 示例输出：undefined
console.log(typeof unassignedVar); // 示例输出："undefined"

function testReturn() {}
console.log(testReturn());         // 示例输出：undefined

2. Null（空值）

Null 类型同样只有一个唯一的值，即 null。在语义上，它表示一个“故意的空值”或“空对象指针”。它通常用于指示某个变量未来预期指向一个对象，但当前尚未准备好，或者表示函数在预期返回对象时查找失败（例如 document.getElementById("not-found") 返回 null）。

let currentUser = null; // 声明一个用户对象引用，当前未登录

// 历史遗留缺陷测试：
console.log(typeof null); // 示例输出："object" (注意：这并非引用类型)
console.log(currentUser === null); // 示例输出：true (精确判断必须用全等)

3. Boolean（布尔值）

Boolean 类型仅包含两个逻辑字面量：true 和 false。它通常用于流程控制分支语句（如 if、while、三元表达式）中的条件判定。

在 JavaScript 中，任何类型的值都可以通过类型转换规则被隐式或显式（Boolean(val)）转换为布尔值。其中，全局只有 8 个 falsy（假值）：false、0、-0、0n、""（空字符串）、null、undefined 和 NaN。除此以外的所有值（包括空对象 {}、空数组 []）转换为布尔值后均为 true。

4. Number（双精度浮点数）

JavaScript 中的 Number 类型并不区分整型与浮点型，而是统一采用 IEEE 754 标准的双精度 64 位二进制格式存储。其安全整数范围为 -(2^53 - 1) 到 2^53 - 1（即 Number.MIN_SAFE_INTEGER 到 Number.MAX_SAFE_INTEGER，约为 ±9007199254740991）。

除了常规十进制、十六进制数值外，Number 还包含三个特殊的符号值：

• +Infinity 和 -Infinity：表示除以 0 或超出数值表达上限的正负无穷大。
• NaN（Not-a-Number）：表示无效的数值运算结果（例如 Math.sqrt(-1) 或 0 / 0）。

console.log(0.1 + 0.2 === 0.3); // 示例输出：false（二进制浮点数舍入误差：0.30000000000000004）
console.log(Math.abs((0.1 + 0.2) - 0.3) < Number.EPSILON); // 示例输出：true（安全浮点比较）

console.log(NaN === NaN); // 示例输出：false（NaN 不与任何值相等，包括自身）
console.log(Number.isNaN(NaN)); // 示例输出：true

5. String（字符串）

String 类型用于表示文本数据，是由零个或多个 16 位 Unicode 字符（UTF-16 编码单元）组成的不可变有序序列。在 JavaScript 中，单引号 '、双引号 " 以及 ES6 模板字符串 ` 均可用于声明字符串。

字符串的关键特质是完全不可变（Immutable）。一旦创建，其内部的任何单个字符都不能被修改。任何字符串方法（如 replace、slice、toUpperCase）或者拼接操作，都不会修改原字符串，而是返回一个全新的字符串。

let greeting = "hello";
greeting[0] = "H"; // 在严格模式下静默失效或报错，不会改变原字符串
console.log(greeting); // 示例输出："hello"

let upper = greeting.toUpperCase();
console.log(greeting); // 示例输出："hello"（原值未动）
console.log(upper);    // 示例输出："HELLO"（生成的新副本）

6. Symbol（符号，ES6 / ES2015 引入）

Symbol 是在 ECMAScript 2015 中引入的一种全新的原始类型。调用 Symbol() 函数会生成一个全局独一无二且不可变的值。Symbol 常被用作对象属性的键（Key），以确保属性名绝不会与其它代码或库发生命名冲突。

const idA = Symbol("userId");
const idB = Symbol("userId");
console.log(idA === idB); // 示例输出：false（每个 Symbol 都是全球唯一的）

const userProfile = {
  name: "Alex",
  [idA]: "PRIVATE_IDENTIFIER_1001"
};

// Symbol 属性默认不会出现在常规遍历中：
console.log(Object.keys(userProfile)); // 示例输出：["name"]
console.log(Object.getOwnPropertySymbols(userProfile)); // 示例输出：[Symbol(userId)]

7. BigInt（大整数，ES2020 引入）

BigInt 是 ECMAScript 2020 引入的原始类型，用于表示任意精度的整数。在处理后端传递的高精度 ID（如 64 位雪花算法 Snowflake ID）、加密学大质数或纳秒级时间戳时，原有的 Number 类型会发生精度丢失（截断），而 BigInt 则可以无损容纳任意大小的整数。

创建 BigInt 只需在整数字面量末尾附加字母 n，或者调用全局函数 BigInt()：

const maxSafe = 9007199254740991;
console.log(maxSafe + 1 === maxSafe + 2); // 示例输出：true (Number 溢出导致精度丢失)

const bigA = 9007199254740991n;
console.log(bigA + 1n === bigA + 2n);     // 示例输出：false (BigInt 保持精确计算)

// 注意：BigInt 与普通 Number 不能直接混合运算，必须显式转换：
// console.log(10n + 5); // 抛出 TypeError: Cannot mix BigInt and other types
console.log(10n + BigInt(5)); // 示例输出：15n

二、存储架构：基本类型与引用类型的本质区别

要彻底掌握 JavaScript 的数据类型，必须从底层内存分配模型来理解基本类型（Primitive）与引用类型（Reference）的区别。

在现代 JavaScript 引擎（如 V8、SpiderMonkey）中，基本数据类型占用固定大小的内存空间，变量直接保存具体的值，生命周期往往伴随执行上下文存放于栈内存（Stack Memory）中；而对象、数组等复合引用类型的大小是动态未知的，实体保存在堆内存（Heap Memory）中，变量在栈中存放的仅仅是指向该堆内存实体的地址指针。

基于该内存模型，两者的核心行为差异体现在以下三个维度：

1. 赋值机制（Copy by Value vs Copy by Reference）：当把一个基本类型的变量赋值给另一个变量时，引擎会在栈内存中开辟独立的新空间，完整复制该数值。修改其中一个变量，对另一个变量毫无影响；而将对象赋值给新变量时，复制的仅是堆内存地址指针，两个变量指向同一个堆实体，修改属性会相互影响。
2. 比较机制（Equality by Value vs Equality by Reference）：使用严格相等运算符 === 比较时，基本类型直接比较二者的具体值；而对象比较的是它们是否指向堆内存中的同一个内存地址，即便两个对象拥有完全相同的键值对（例如 { a: 1 } === { a: 1 }），比较结果依然为 false。
3. 不可变性（Immutability）：基本类型的值本身不可变。任何看似修改基本类型的操作（如字符串拼接），实际上都在内存中新建了一个值并重新绑定了变量指针。

三、推导流程：如何在代码中精准判定数据类型

在开发实践中，由于 typeof null === "object"、数组与普通对象混淆以及 NaN 缺失自反性等语言特性的存在，单凭一个简单的 typeof 运算符往往无法胜任所有类型检测任务。

为了准确、无歧义地检测出任意变量的真实类型，推荐采用如下标准化推导流程：

上述流程的操作步骤拆解如下：

• 步骤一（排除 null）：首先检测 val === null。如果为 true，直接确认为 "null" 类型，避免后续 typeof 误判为 "object"。
• 步骤二（原语基础识别）：执行 typeof val。若返回值为 "undefined"、"boolean"、"string"、"symbol"、"bigint"，可 100% 信任判定结果。
• 步骤三（数值细分）：若 typeof val === "number"，再通过 Number.isNaN(val) 进一步确认是否为特殊的非数 NaN。
• 步骤四（引用类型精准识别）：对于 typeof val === "object" 且非 null 的情况，调用 Object.prototype.toString.call(val)，获取形如 "[object Array]" 或 "[object Date]" 的原生类型标签。

/**
 * 工业级 JavaScript 变量类型精准判定函数
 * @param {*} value 待检测的任意目标值
 * @returns {string} 规范的小写类型名称
 */
function getExactType(value) {
  if (value === null) return "null";
  if (typeof value === "object") {
    return Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
  }
  if (typeof value === "number" && Number.isNaN(value)) {
    return "nan";
  }
  return typeof value;
}

// 结果验证测试：
console.log(getExactType(undefined));        // 示例输出："undefined"
console.log(getExactType(null));             // 示例输出："null"
console.log(getExactType("JavaScript"));     // 示例输出："string"
console.log(getExactType(100n));             // 示例输出："bigint"
console.log(getExactType(Symbol("key")));    // 示例输出："symbol"
console.log(getExactType(NaN));              // 示例输出："nan"
console.log(getExactType([1, 2, 3]));        // 示例输出："array"
console.log(getExactType({ name: "Dev" }));  // 示例输出："object"

四、7 种基本数据类型特性与边界对照

为了便于快速查阅与区分，下表系统总结了这 7 种基本数据类型的版本规范、取值范围以及常见开发易错点：

五、工程避坑与使用要点总结

在真实业务开发中，围绕基本数据类型有几个高频出现的缺陷陷阱，需要建立清晰的防御意识：

1. 警惕原始包装对象（Wrapper Objects）

JavaScript 为 String、Number、Boolean 提供了对应的构造函数。当访问 "abc".length 时，引擎在后台自动创建了一个临时的 new String("abc") 包装对象，读取属性后再立即销毁。

但是，切勿在代码中手动执行 new Boolean(false) 或 new String("a")！因为通过 new 构造出来的是一个真正的引用对象，其 typeof 结果为 "object"，并且在条件判断中，任何对象都为真值（Truthy）：

const falseObj = new Boolean(false);
console.log(typeof falseObj); // 示例输出："object"
if (falseObj) {
  console.log("执行分支：条件被误判为真！"); // 示例输出：由于对象永远为真，此处必然执行！
}

2. 选用正确的非数值与空值检测 API

• 使用 Number.isNaN() 替代全局 isNaN()：全局 isNaN("hello") 会先强制将参数尝试转为数值，由于 Number("hello") 得到 NaN，导致它返回 true；而 ES6 引入的 Number.isNaN() 仅在参数本身类型为数值且等于 NaN 时才返回 true。
• 利用双等号技巧快速拦截空值：在需要同时拦截 null 和 undefined 时，使用 if (val == null) 是符合规范的最佳实践（因为 null == undefined 为 true，且不与其它任何假值相等）。除此之外的所有比较均应严格使用 ===。