原始类型与引用类型:赋值时到底复制了什么

先看两段代码。第一段:

javascript 复制代码
let a = 1
let b = a
b = 2
console.log(a)   // 1

第二段:

javascript 复制代码
let obj1 = { n: 1 }
let obj2 = obj1
obj2.n = 2
console.log(obj1.n)   // 2

两段代码的写法几乎一样,都是"把变量赋给另一个变量,再改后者"。但第一段里原变量没变,第二段里原对象却跟着变了。

这个差异让很多初学者困惑:明明只是复制了一下,为什么一个互不影响,另一个却像"连体婴"?答案在于 JavaScript 把值分成了两类:原始类型 和引用类型。它们赋值时复制的东西根本不是一回事。今天就把这件事从底层模型讲清楚。

一、先分清两类值

JavaScript 里的值,可以粗分成两类。

类别 包含哪些 特点
原始类型 string、number、boolean、null、undefined、symbol、bigint 不可变,按值比较
引用类型 object,包括数组、函数、日期、正则等 可变,按引用比较

这里有个著名的坑要先排掉:

javascript 复制代码
typeof null          // "object"
typeof []            // "object"
typeof function(){}  // "function"

typeof null === 'object' 是语言早期实现留下的历史问题,不代表 null 是对象。判断 null 要用 value === null。数组和普通对象的 typeof 都是 "object",想区分得用 Array.isArray()。

1. 原始类型不可变

"不可变"指的是:原始值本身没法被修改,你只能让变量指向一个新值。

javascript 复制代码
let s = 'hello'
s.toUpperCase()     // "HELLO"
console.log(s)      // "hello",原字符串没变

s = 'world'         // 这是重新赋值,不是修改原字符串

字符串方法全部返回新字符串,不会改动原值。数字、布尔同理。

2. 引用类型可以改内容

对象则不同,你可以直接改它内部的属性:

javascript 复制代码
const user = { name: 'Tom' }
user.name = 'Jerry'      // 修改对象内容
console.log(user.name)   // "Jerry"

注意这里用的是 const,但属性照样能改。因为 const 锁的是"user 这个绑定指向哪个对象",不是"对象内部能不能变"。这一点在变量声明那篇里已经展开过,这里只强调:可变性属于值本身,不属于声明关键字。

二、赋值时到底复制了什么

这是全文的核心。先给结论:

  • 原始类型赋值:复制的是值本身。两个变量各拿一份,互不影响。

  • 引用类型赋值:复制的是"引用"(可以理解为指向对象的地址)。两个变量指向同一个对象,改哪个都影响对方。

1. 原始类型:各拿一份

javascript 复制代码
let a = 1
let b = a      // 把 1 这个值复制给 b
b = 2          // b 指向新值 2
console.log(a) // 1

可以把变量想成一个个盒子:a 盒子里装着 1,b = a 是把 1 抄一份放进 b 的盒子。之后改 b 盒子里的内容,a 盒子不受影响。

这是概念模型,方便理解,不代表引擎的真实内存布局。规范只规定行为,不规定实现细节。不同引擎怎么存、怎么优化,是另一回事。但用"盒子"理解赋值行为,足够准确。

2. 引用类型:复制的是"地址"

javascript 复制代码
let obj1 = { n: 1 }
let obj2 = obj1
obj2.n = 2
console.log(obj1.n)   // 2

这里发生的事分两步:

  1. { n: 1 } 这个对象被创建出来,obj1 拿到的是指向它的引用。

  2. obj2 = obj1 复制的是引用 ,不是对象本身。所以 obj1 和 obj2 指向同一个对象。

用盒子模型说:obj1 盒子里装的不是对象,而是一张"地址纸条"。obj2 = obj1 是把纸条抄了一份。两张纸条写着同一个地址,顺着地址找过去,是同一个房间。谁进去改了家具,另一个人看到的也变了。

javascript 复制代码
obj2.n = 2        // 顺着地址进房间,改家具
console.log(obj1.n) // 2,obj1 顺着同一地址进去,看到的是改过的

3. 重新赋值 vs 修改内容

这两个操作经常被混为一谈,但结果完全不同:

javascript 复制代码
let obj1 = { n: 1 }
let obj2 = obj1

// 操作 A:修改对象内容
obj2.n = 2
console.log(obj1.n)   // 2,共享同一个对象

// 操作 B:让 obj2 指向新对象
obj2 = { n: 3 }
console.log(obj1.n)   // 2,obj1 还指向原来的对象
console.log(obj2.n)   // 3

操作 B 只是把 obj2 盒子里的地址纸条换成了新的,obj1 手里的纸条没动,所以它仍指向原对象。

改内容影响对方,换指向不影响对方。 这句话值得记下来,它是排查这类问题的第一判断标准。

三、比较:为什么两个"一样"的对象不相等

赋值说完了,再看比较。原始类型和引用类型的比较规则也不一样。

1. 原始类型按值比较

javascript 复制代码
1 === 1           // true
'abc' === 'abc'   // true
true === true     // true

值相同,就相等。

2. 引用类型按引用比较

javascript 复制代码
{} === {}         // false
[] === []         // false
{ n: 1 } === { n: 1 }   // false

看起来内容一样,为什么是 false?因为 === 比较的是引用是否指向同一个对象,不是内容是否相同。上面每一对都是两个独立创建的对象,地址不同,自然不相等。

只有指向同一个对象时才相等:

javascript 复制代码
const a = { n: 1 }
const b = a
a === b           // true,同一个引用

3. 想比内容怎么办

得自己逐层比较,或者借助工具。简单场景可以手写:

javascript 复制代码
function shallowEqual(a, b) {
  const keysA = Object.keys(a)
  const keysB = Object.keys(b)
  if (keysA.length !== keysB.length) return false
  return keysA.every((key) => a[key] === b[key])
}

shallowEqual({ n: 1 }, { n: 1 })   // true

这叫浅比较 ,只比第一层。嵌套对象里的属性如果还是对象,仍然走引用比较。深层比较需要递归,或者用成熟工具库(如 lodash 的 isEqual)。具体实现和边界条件在写作阶段需核实所用版本的行为。

4. 两个特殊值:NaN 和 ±0

=== 有两个反直觉的地方:

javascript 复制代码
NaN === NaN        // false
+0 === -0          // true

NaN 不等于自身,这是 IEEE 754 浮点规范的定义。判断 NaN 要用 Number.isNaN():

javascript 复制代码
Number.isNaN(NaN)      // true
Number.isNaN('abc')    // false,不会做类型转换

Object.is 则提供了另一套规则:

javascript 复制代码
Object.is(NaN, NaN)    // true
Object.is(+0, -0)      // false
Object.is(1, 1)        // true

它和 === 大部分行为一致,只在 NaN 和正负零上有区别。日常判断相等仍推荐 ===,涉及 NaN 或零值符号时再用 Object.is。

四、函数传参:也是"按值传递"

这是最容易绕晕的一块。先给结论:JavaScript 只有按值传递,没有按引用传递。但因为引用类型的"值"本身是引用,所以表现上像是"传了引用"。

1. 原始类型:改形参不影响外部

javascript 复制代码
function change(x) {
  x = 100
}

let n = 1
change(n)
console.log(n)   // 1

x 拿到的是 1 的副本,改 x 不影响 n。

2. 引用类型:改内容会影响外部

javascript 复制代码
function mutate(o) {
  o.n = 100
}

let obj = { n: 1 }
mutate(obj)
console.log(obj.n)   // 100

o 拿到的是引用的副本,但仍指向同一个对象。所以改 o.n 就是改原对象。

3. 但重新赋值形参不影响外部

javascript 复制代码
function reassign(o) {
  o = { n: 999 }
}

let obj = { n: 1 }
reassign(obj)
console.log(obj.n)   // 1

因为 o = {...} 只是把形参 o 换指向了新对象,外部的 obj 没动。

把这三个例子放在一起,就能理解"按值传递"的准确含义:传的永远是值的副本;原始类型的副本是值本身,引用类型的副本是引用。所谓"传引用",只是对"副本是引用"这件事的口语化说法,严格讲并不准确。

javascript 复制代码
// 一句话总结
// 能改内容,不能换指向
function f(o) {
  o.n = 2        // 影响外部
  o = { n: 3 }   // 不影响外部
}

五、常见误解与排查

误解一:把对象赋给新变量,就是复制了一份

javascript 复制代码
const original = { list: [1, 2, 3] }
const copy = original
copy.list.push(4)
console.log(original.list)   // [1, 2, 3, 4]

copy 和 original 指向同一个对象,任何一方改内容,另一方都能看到。想真正复制,需要浅拷贝或深拷贝。

误解二:展开运算符是深拷贝

javascript 复制代码
const original = { user: { name: 'Tom' } }
const copy = { ...original }
copy.user.name = 'Jerry'
console.log(original.user.name)   // "Jerry"

展开运算符只复制第一层。copy.user 和 original.user 仍指向同一个嵌套对象。这属于浅拷贝 ,嵌套层依旧共享引用。要彻底断开,需要深拷贝;深拷贝涉及循环引用、函数、Date、Map 等边界,方案选择需要单独讨论。

误解三:const 能防止对象被改

javascript 复制代码
const config = { debug: true }
config.debug = false   // 不报错
config = {}            // TypeError

const 只锁绑定,不锁内容。要冻结内容得用 Object.freeze,而且它是浅冻结:

javascript 复制代码
const config = Object.freeze({ debug: true })
config.debug = false
console.log(config.debug)   // true,修改被忽略

严格模式下对冻结对象赋值会抛错,非严格模式静默失败。具体行为取决于运行模式和代码位置,写的时候建议显式验证。

误解四:数组方法都返回新数组

javascript 复制代码
const arr = [3, 1, 2]
const sorted = arr.sort()
console.log(arr)      // [1, 2, 3],原数组被改了
console.log(sorted === arr)   // true,返回的是同一个数组

sort、reverse、splice、push、pop 都会修改原数组。map、filter、slice、concat 才返回新数组。判断一个方法会不会改原值,最稳妥的方式是查文档,别靠猜。

六、落到写法上:几条可执行的建议

  1. 改对象前先想清楚"这是不是共享的"。如果这个对象来自参数、来自模块导出、来自状态容器,改动很可能影响别处。不确定时先复制。

  2. 对外暴露数据时,考虑返回副本。函数返回内部对象时,调用方一改就可能污染内部状态:

    javascript 复制代码
    const state = { count: 0 }
    function getState() {
      return { ...state }   // 浅拷贝,防止外部直接改内部对象
    }

    注意这只是浅拷贝,嵌套结构仍需额外处理。

  3. 比较对象用内容比较,不要用 ===。表单值、配置对象、接口返回数据的相等判断,几乎都需要逐字段比较,或者用专门的工具。

  4. Object.freeze 用在真正不该变的配置上。比如常量表、枚举映射。但要知道它是浅冻结,嵌套对象仍可改。

  5. 调试时打印对象,注意"实时引用" 。控制台里展开对象看到的是当前值,不是打印那一刻的快照。想固定快照可以用 console.log(JSON.parse(JSON.stringify(obj))),或者 structuredClone,但两者都有边界(函数、循环引用等),需要按数据特点选择。

七、初学者常见疑问

问:原始类型真的完全不可变吗?

值本身不可变,但变量可以重新赋值。let s = 'a'; s = 'b' 不是改了 'a',而是让 s 指向了新值 'b'。区分"改变量指向"和"改值内容",是理解不可变的关键。

问:为什么 [] === [] 是 false,但 const a = []; const b = a; a === b 是 true?

前者是两个独立创建的数组,引用不同;后者是同一个数组的两个引用。=== 比的是引用,不是内容。

问:函数传对象,到底算传值还是传引用?

严格说是按值传递,传的是引用的副本。所以能改内容,不能换指向。用"传值"这个词容易误解,用"传引用的副本"更准确。

问:浅拷贝和深拷贝怎么选?

看数据结构。只有一层、或者嵌套层不需要独立修改,浅拷贝够用;嵌套层也要完全隔离,才需要深拷贝。深拷贝有性能成本和边界问题,不是默认选择。

问:typeof null 为什么是 "object"?

历史遗留问题,早期实现里用类型标签的低位判断类型,null 的标签恰好和对象撞了。这个行为为了兼容性一直保留至今。判断 null 用 value === null,不要依赖 typeof。

八、一张图记住核心区别

复制代码
原始类型赋值:
  a ──> [1]
  b ──> [1]      两个独立的值,改 b 不影响 a

引用类型赋值:
  obj1 ──> [地址 A] ──┐
                       ├──> { n: 1 }
  obj2 ──> [地址 A] ──┘
                  两个引用指向同一个对象

记住三句话:

  • 原始类型复制值,引用类型复制引用。

  • 改内容会互相影响,换指向不会。

  • === 比引用,比内容要自己写。

结语

赋值这件事,看起来只是"把右边的给左边",但 JavaScript 在这里分了两条路:一条复制值,一条复制引用。分不清这两条路,就会写出"改了副本、原对象也变了"的代码,然后花半天排查一个其实很简单的共享引用问题。

真正要建立的不是背下七个原始类型,而是一个判断习惯:拿到一个变量时,先问它是原始值还是对象;要改它时,先问这个对象还有没有别的引用。这两个问题问清楚了,大多数"莫名其妙被改了"的 bug 都能提前避开。

现在可以打开控制台,把文中的例子挨个跑一遍。特别是"改内容"和"换指向"那组对比,亲手敲一次,比读十遍都记得牢。

相关推荐
wuyk5559 分钟前
Python办公自动化-第02讲-Excel文件认知与四大库选型
开发语言·python·excel
一条破秋裤31 分钟前
【1115】【多线程】【笔记】
前端·chrome·笔记
黑十32 分钟前
FDE 怎么快速搭一个可演示页面?最小前端方案
java·大数据·前端·数据库·人工智能
Funlang34 分钟前
在 Windows 95 上写前端
前端·javascript·windows
cidy_981 小时前
python第7课. 输入与输出
前端
神明不懂浪漫1 小时前
【第八章】多线程(一)
java·开发语言·经验分享·笔记
小龙66661 小时前
给 Agent 一张地图,而不是一座迷宫:前端 monorepo 目录结构重构实录
前端·agent
樊小肆1 小时前
agent 不报错才最吓人:自研编码工具半年,我踩了 10 个"看着正常"的运行时坑
前端·人工智能·agent
鲸鹏芯海微电子科技上海有限公司1 小时前
手机直连卫星,射频前端到底要解决什么?
前端·后端