JavaScript有哪些数据类型：基本类型与引用类型分类

在现代 JavaScript（ECMAScript 标准）中，所有数据被清晰划分为 8 种数据类型，归属于两大核心阵营：基本数据类型（Primitive Types，共 7 种）与引用数据类型（Reference Types，即 Object 及其衍生类型）。掌握这两大分类不仅是理解变量赋值、参数传递和深浅拷贝的关键，也是规避生产环境中各种隐式转换与内存泄漏问题的基石。

一、JavaScript 数据类型的全景架构与两大分类

JavaScript 是一门动态弱类型语言，这意味着变量本身没有固定类型，其类型由当前所赋的值决定。按照底层内存管理机制和语言规范，数据类型分为基本类型和引用类型两大类：

• 基本数据类型（7种）：Number、String、Boolean、Undefined、Null、Symbol（ES6新增）、BigInt（ES2020新增）。这类数据占用固定大小的内存空间，直接按值保存在栈内存（Stack）中，值一旦创建便不可变更。
• 引用数据类型（1大类）：统一为 Object 类型。日常使用的普通对象（Object）、数组（Array）、函数（Function）、正则（RegExp）、日期（Date）以及 ES6 的 Map、Set 都是 Object 类型的派生实例。它们在堆内存（Heap）中分配可变空间，栈内存中仅保存指向该堆内存地址的引用指针。

二、7 种基本数据类型（Primitive Types）深度拆解

基本数据类型代表最底层的不可变数据单元。所谓不可变（Immutable），指的是值本身在内存中无法被修改，对基本类型的任何算术或字符串拼接操作，实质上都是生成了一个全新数值并赋给变量。

1. Number（数值类型）

JavaScript 不区分整数与浮点数，所有数字均采用 IEEE 754 标准的双精度 64 位浮点数格式存储。安全整数范围处于 Number.MIN_SAFE_INTEGER（-(2⁵³ - 1)）到 Number.MAX_SAFE_INTEGER（2⁵³ - 1）之间。

const age = 28;            // 整数
const price = 99.95;       // 浮点数
const max = Infinity;      // 正无穷大 (如 1 / 0)
const invalid = NaN;       // Not a Number，表示无法解析的非数字计算结果

2. String（字符串类型）

字符串是由 16 位 Unicode 字符组成的不可变序列。使用单引号、双引号或 ES6 反引号（模板字符串）声明。

const greeting = 'Hello';
const message = `${greeting}, JavaScript!`; // 模板字面量支持插值与换行
// 字符串具有不可变性：修改某索引字符无效
greeting[0] = 'h'; 
console.log(greeting); // 输出依然是 'Hello'

3. Boolean（布尔类型）

仅包含两个字面量：true 和 false。在条件语句中，非布尔值会发生隐式类型转换。以下 8 个值会被转换为 false（称为假值 Falsy），其余所有值（包括空数组 [] 和空对象 {}）均为真值（Truthy）：

• false
• 0、-0、0n（BigInt 零）
• ""（空字符串）
• null
• undefined
• NaN

4. Undefined（未定义）

变量已通过 var、let 或 const 声明，但尚未赋具体初值时的缺省状态。函数的默认返回值也是 undefined。

let uninitializedVar;
console.log(uninitializedVar); // 输出 undefined

function noop() {}
console.log(noop()); // 输出 undefined

5. Null（空值 / 空对象指针）

null 在语义上表示“有意赋予的空值”或“无对象”。常用于释放对象引用以便垃圾回收器回收内存，或作为可能返回对象的函数的空态结果（如 document.getElementById('not-exist') 返回 null）。

6. Symbol（独一无二的符号值 · ES6）

通过 Symbol() 函数生成。每一个 Symbol 值都是全局唯一的，即使传入相同的描述字符串也不相等。主要用于给对象定义私有属性或扩展属性，彻底避免属性名冲突（如在编写插件或库时）。

const sym1 = Symbol('key');
const sym2 = Symbol('key');
console.log(sym1 === sym2); // false，完全独立互不相等

const user = {
  [sym1]: '私有元数据'
};

7. BigInt（任意精度大整数 · ES2020）

用于表示大于 2⁵³ - 1 的整数，解决了传统 Number 类型在超大整数计算时丢失精度的问题。可以在整数末尾添加字母 n，或调用 BigInt() 构造。

const largeInt = 9007199254740991n;
const nextInt = largeInt + 1n; // 9007199254740992n，精度完整保留
// 注意：BigInt 不能与常规 Number 直接混用算术运算符，需先显式转换

三、引用数据类型（Reference Types / Object）

在 JavaScript 中，除了上述 7 种基本类型，其余一切实体在原型链顶层均属于 Object。引用类型的特征是拥有属性和方法，并且其内部状态可以在内存中被动态增删或修改。

具体类型	典型声明示例	设计用途与核心能力
Plain Object (普通对象)	{ id: 101, name: "Admin" }	结构化数据的标准组织形式，属性名可以是字符串或 Symbol。
Array (数组)	[10, 20, 30]	以数字为索引的特殊对象，内置大量排序、遍历、变换方法（如 map, filter）。
Function (函数)	function sum(a, b) { return a + b; }	一等公民（First-class Object），拥有 [[Call]] 内部槽，可被调用与传递。
Date (日期)	new Date()	时间戳与日历时间的解析、格式化及计算容器。
RegExp (正则表达式)	/^[a-z]+$/i	字符串模式匹配与文本替换的高性能引擎。
Map / Set (集合)	new Map() / new Set()	ES6 标准数据容器，Map 允许任意类型（包括对象）作为键名，Set 确保元素唯一。

四、底层原理：栈内存与堆内存的存储及赋值机制

基本类型与引用类型的根本区别，源于 JavaScript 引擎（如 V8）在运行时对内存空间的分配策略。这种底层差异直接决定了变量赋值、参数传递及相等比较的行为表现。

传值还是传引用？严格来说都是“按值传递”

在面试或深度学习中经常遇到一个争论：JavaScript 的函数参数到底是按值传递（Pass by Value）还是按引用传递（Pass by Reference）？

权威规范给出的答案是：ECMAScript 中的所有函数的参数都是按值传递的。

• 传递基本类型时，传入的是该数值的拷贝；函数内部修改参数变量，外部原始值毫无影响。
• 传递引用类型时，传入的是保存在栈中的内存地址指针的拷贝。由于复制后的指针依旧指向同一个堆对象，所以在函数内部通过 param.prop = value 变更属性时，外部对象能够感知到这一变化。但如果你在函数内直接重写整个参数（例如 param = { newObj: true }），这只是把局部指针指向了新的堆地址，外部的原始指针丝毫未变。

五、精准检测数据类型：四种方案与推导决策流程

在实际业务开发中，准确判断变量类型是进行参数校验与逻辑分支的前提。JavaScript 提供了多种检测手段，但各自都有适用边界与设计陷阱：

1. typeof 操作符（轻量检测基本类型）

typeof 可以直接判断 number、string、boolean、undefined、symbol、bigint 和 function。但它存在两个众所周知的严重局限：

• typeof null === 'object'：这是 JavaScript 诞生之初的底层二进制标签 Bug（对象标签为 000，而 null 的空指针全为 0），出于向下兼容考虑一直保留至今。
• 无法区分具体的对象形态：数组、普通对象、日期、正则表达式调用 typeof 统一返回 'object'。

2. instanceof 操作符（检测实例的原型链）

a instanceof B 用于测试构造函数 B.prototype 是否存在于对象 a 的原型链上。适合判断 arr instanceof Array 或自定义类实例，但无法检测基本类型（如 "hello" instanceof String 为 false），且在多全局环境（如跨 iframe）下可能因原型对象不同源而失效。

3. Array.isArray()（专有数组检测）

ES5 引入的标准方法，能够完美穿透多 iframe 环境准确识别数组，是日常开发中检测数组的首选。

4. Object.prototype.toString.call()（终极全能检测方案）

调用 Object 原型上的 toString 方法，能够精准提取内置对象的 [[Class]] 内部标签，无论基本类型还是复杂引用类型均能无死角准确识别：

const getType = (val) => {
  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase();
};

console.log(getType(123));           // "number"
console.log(getType("abc"));           // "string"
console.log(getType(null));            // "null"
console.log(getType(undefined));       // "undefined"
console.log(getType([]));              // "array"
console.log(getType({}));              // "object"
console.log(getType(new Date()));      // "date"
console.log(getType(/test/));          // "regexp"
console.log(getType(new Map()));       // "map"

六、生产环境高频踩坑点与最佳规避方案

1. typeof null === 'object' 的防御性编程

当需要判断一个未知变量是否为真正意义上的对象（排除 null 并支持取属性）时，切勿仅使用 typeof x === 'object'，否则会在传入 null 时触发 Cannot read properties of null 报错。

// 错误示范：传入 null 时判断为 true，后续访问 x.name 直接崩溃
function processData(x) {
  if (typeof x === 'object') {
    console.log(x.name); // TypeError: Cannot read properties of null
  }
}

// 正确方案：必须先排除 null
const isObject = (val) => val !== null && typeof val === 'object';

2. NaN 的唯一性与判断陷阱

在 IEEE 754 规范中，NaN 不等于任何值，包括它自身。因此 NaN === NaN 返回 false。此外，全局的 isNaN() 会先对参数进行隐式类型转换（导致 isNaN('hello') 错误地返回 true），推荐始终使用 ES6 严谨的 Number.isNaN()：

console.log(NaN === NaN);              // false
console.log(isNaN('hello'));           // true（先转为 Number('hello') 得到 NaN，产生误判）
console.log(Number.isNaN('hello'));    // false（严谨判断参数是否本身就是 NaN）

3. 基本类型的“包装对象”（Wrapper Objects）

你可能会好奇：既然 string 是基本类型且没有属性，为什么 "hello".length 或 "hello".toUpperCase() 能够正常工作？

这是因为 JavaScript 引擎在读取基本类型的属性或方法时，会在后台瞬间创建一个临时的包装对象（如 new String("hello")），完成属性读取或方法调用后，这个包装实例会立即被销毁。因此：

const str = 'abc';
str.customProp = 123; // 在临时包装对象上添加属性后立即销毁
console.log(str.customProp); // undefined，无法持久保留属性

// 强烈建议：切勿显式使用 new String() / new Number()，这会生成引用对象而非基本类型
const strObj = new String('abc');
console.log(typeof strObj); // "object" 而非 "string"，破坏类型纯粹性

4. 引用类型赋值时的浅拷贝与深拷贝抉择

正如内存模型所示，引用类型的直接赋值仅仅传递了指针。当需要复制一个对象且避免修改互相影响时：

• 浅拷贝（Shallow Copy）：如展开运算符 { ...obj } 或 Object.assign({}, obj)。仅复制对象的第一层属性，若对象属性值包含嵌套对象，深层属性仍然共享同一指针。
• 深拷贝（Deep Copy）：若存在多层嵌套对象，现代浏览器首选内置标准 API structuredClone(obj)；它原生支持循环引用、Date、RegExp、Map、Set 等结构，比传统的 JSON.parse(JSON.stringify(obj)) 更加健全健壮。

七、基本类型与引用类型核心速查总结

为了帮助你在实际开发与代码评审中快速查阅比对，下方的矩阵总结系统梳理了基本类型与引用类型在各个关键技术维度的对应关系：

清晰区分基本类型与引用类型，是每一位 JavaScript 开发者从“知其然”迈向“知其所以然”的必经之路。在后续进行深浅拷贝、状态管理（如 React 状态不可变更新）、函数式编程与性能调优时，牢记栈堆分离模型与不可变原则，能让你写出更加健壮、可控的高质量代码。