彻底搞懂 JS 对象:从字面量、构造函数到原型链与包装类
建议跟着文中的代码片段亲手敲一遍,改几个值再跑一遍,比单纯看文章管用得多。
学 JS 的时候,你大概率写过这样的代码:
js
let str = 'hello'
str.a = 2
console.log(str.a) // undefined
奇怪吗?没报错,但属性也没加上。
再比如这两行:
js
let a = 'hello'
let b = 'hello'
console.log(a === b) // true
let c = Symbol('a')
let d = Symbol('a')
console.log(c === d) // false
看起来一模一样的东西,为什么一个相等、一个不相等?
这些问题的答案,全都指向同一个东西 ------ 对象。下面我们按六段代码的顺序,把「对象」从里到外讲清楚。
一、万物皆对象?先把数据类型分清楚
JS 里常说「万物皆对象」,这句话不完全准确,但很能说明对象的地位。先看官方的分类:
| 类别 | 类型 |
|---|---|
| 基本数据类型(7 种) | Number、String、Boolean、Null、Undefined、Symbol、BigInt |
| 引用数据类型 | Object(包括 {}、[]、function () {}) |
区别在于「变量里到底存了什么」:
- 基本类型 :存的是值本身,比较时比的是值
- 引用类型 :存的是地址,比较时比的是「是不是同一个地址」
第一段代码正好说明了这一点:
js
let a = 'hello'
let b = 'hello'
console.log(a === b) // true ------ 两个字符串的值相同
let c = Symbol('a')
let d = Symbol('a')
console.log(c === d) // false ------ Symbol 每次创建都是独一无二的
字符串 'hello' 是基本类型,值一样就相等;Symbol('a') 虽然描述一样,但每个 Symbol 都是全新的、唯一的,所以不相等。
记住这个分类,后面所有的「坑」都从这里来。
二、对象 = 键值对集合
数组 是有序的线性集合,每个元素都有唯一索引;而对象 是键值对的集合,每个值都有一个名字(键)。
我们看第二段代码:
js
let obj = { // 创建对象字面量
name: '张三',
age: 18,
}
obj.girlfriend = '小红' // 新增属性
obj.age = 20 // 修改属性
delete obj.girlfriend // 删除属性
let a = 'hello'
obj[a] = 'world' // 用变量的值作为属性名
console.log(obj)
最终结果是:
js
{ name: '张三', age: 20, hello: 'world' }
短短几行,把对象的增、删、改、查全用了一遍:
| 操作 | 写法 |
|---|---|
| 读 | obj.name |
| 新增 | obj.key = 值(键不存在时就是新增) |
| 修改 | obj.key = 新值(键已存在时就是修改) |
| 删除 | delete obj.key |
为什么 obj[a] 是 hello?
因为方括号里的内容会被当作表达式求值 ,a 的值是 'hello',所以等价于 obj['hello'] = 'world'。
两种写法的区分很简单:
js
obj.name // 找名字叫 name 的属性
obj[a] // 把变量 a 的值当成属性名
如果属性名是个变量,必须用方括号,点语法做不到。
再补一个细节:对象的键本质上都是字符串(Symbol 除外),数字键也会被转成字符串,所以 obj[1] 和 obj['1'] 访问的是同一个键。
另外要注意:对象是引用类型,obj 变量里存的只是地址,真正的数据在堆内存里。
三、创建对象:字面量 vs new
日常最常用的写法就是上面那种花括号,称为对象字面量。
第三段代码的结尾还演示了另一种写法:
js
let obj = new Object() // {}
let arr = new Array() // []
new Object() 和 {} 效果完全一样,只是写法啰嗦,实际开发基本不用。但这个 new 很关键,它是理解构造函数和原型的钥匙。
顺便记住:数组也是对象 ,new Array() 出来的就是一个对象,只是这个对象有自己特殊的行为(有序、有 length、能用下标)。
四、批量创建:构造函数 + new
假设要给三辆车建对象,手写三遍(第三段代码中注释掉的部分):
js
let car1 = { name: 'su7', height: 1400, weight: 1500, lang: 4800, color: 'red' }
let car2 = { name: 'su7', height: 1400, weight: 1500, lang: 4800, color: 'blue' }
let car3 = { name: 'su7', height: 1400, weight: 1500, lang: 4800, color: 'green' }
重复得让人头大。这时候就该用构造函数了:
js
function Car(color) {
this.name = 'su7'
this.height = 1400
this.weight = 1500
this.lang = 4800
this.color = color
}
let car1 = new Car('red')
let car2 = new Car('blue')
let car3 = new Car('green')
console.log(car1) // Car { name: 'su7', height: 1400, ..., color: 'red' }
关于构造函数,记住三句话:
- 构造函数就是被
new调用的函数 ,习惯首字母大写 - 它的作用是批量创建结构相同的对象实例
- 不写
new直接调用,this就不再指向新对象,结果就错了
new 到底帮你做了什么?
执行 new Car('red') 时,JS 悄悄做了四件事:
kotlin
① 创建一个空对象 {}
② 把空对象的 __proto__ 指向构造函数的 prototype(原型链接线,下一节细讲)
③ 把这个空对象赋给 this,执行函数体(往 this 上挂属性)
④ 返回这个对象
小细节:如果构造函数里
return了一个对象,就用这个 return 的对象;return 原始值或不写 return,照样返回新创建的对象。
所以 this.name = 'su7' 就是在给新对象加属性,最后拿到的就是 { name: 'su7', ..., color: 'red' }。
原生也一样,new Object() 和 new Array() 都是官方提供的构造函数,专门用来创建对应类型的实例。
五、prototype 和 proto:对象背后的查找链
上面那辆车的例子有个隐患:如果给 Car 加个方法,每个实例都会存一份自己的函数,浪费内存。要理解这个问题的解法和原理,得先认识两个属性。
两个天生就有的属性
js
function Car() {} // 每个函数天生自带 prototype,且它是个对象
const obj = {} // 每个对象天生自带 __proto__,它也指向一个对象
prototype:显式原型,函数天生拥有__proto__:隐式原型,对象天生拥有
注意措辞:prototype 属于函数 ,__proto__ 属于对象。
核心等式
js
console.log(car1.__proto__ === Car.prototype) // true
一句话:
实例对象的隐式原型 === 构造函数的显式原型
这正是 new 四个步骤里第 ② 步干的活:创建实例时,引擎把实例的 __proto__ 接到构造函数的 prototype 上,于是所有实例共享同一份原型对象。
现代写法提示:
__proto__是历史遗留的访问器(只在浏览器环境的 Annex B 里标准化),正式代码推荐用Object.getPrototypeOf:
jsObject.getPrototypeOf(car1) === Car.prototype // true,推荐 car1.__proto__ === Car.prototype // true,能跑但属于旧写法
把方法挂到原型上
第四段代码演示了这个用法:
js
function Car(color) {
this.name = 'su7'
this.color = color
}
Car.prototype.push = function () {
console.log('push执行了')
}
let car1 = new Car('red')
console.log(car1.__proto__ === Car.prototype) // true
car1.push() // push执行了
car1 自己身上并没有 push,为什么能调用?因为引擎会顺着原型链往上找。
原型链长什么样?
一行图看懂:
javascript
car1 ──__proto__──▶ Car.prototype ──__proto__──▶ Object.prototype ──__proto__──▶ null
自己的属性 └─ push() └─ toString / hasOwnProperty ...
V8 的查找规则
当引擎访问对象的一个属性时:
csharp
先找对象自己 → 找不到 → 去 __proto__ 上找 → 还找不到继续往上 → 直到 null
这条不断向上的链,就是原型链 。走到 null 还没有,结果就是 undefined。
怎么区分一个属性是「自己的」还是「原型上借来的」?用 hasOwnProperty:
js
car1.hasOwnProperty('name') // true ------ 自己的
car1.hasOwnProperty('push') // false ------ 原型上的
数组为什么能用 push?
第四段代码开头的注释就在说这件事:
js
let arr = [] // 等价于 new Array()
arr.push(1)
console.log(arr.__proto__ === Array.prototype) // true
arr 自己身上没有 push,但 Array.prototype 上有,于是沿原型链找到了。同理,str.toUpperCase()、[].map() 全都是这么来的。
为什么要把方法放原型上?
因为「构造函数里的属性」每个实例单独一份,而「原型上的属性」全部实例共享:
js
function Person(name) {
this.name = name
}
Person.prototype.sayHi = function () {
console.log('我是' + this.name)
}
const p1 = new Person('小明')
const p2 = new Person('小红')
console.log(p1.sayHi === p2.sayHi) // true ------ 同一个函数,省内存
this 依然能正确指向各自的对象,因为谁调用,this 就指向谁。
六、包装类:为什么 str.a 拿不到
回到开头那个问题:
js
var str = 'hello' // 相当于 new String('hello')
str.a = 2 // 往字符串对象上添加一个属性 a
console.log(str.a) // undefined
console.log(str.length) // 5
原始类型不能添加属性和方法。那为什么没报错?
先澄清一个误区
let str = 'hello' 这一步,V8 并不会 真的去 new String('hello'),str 里存的就是一个原始字符串。包装只发生在访问属性或方法的那一刻,而且是临时的。
V8 处理的完整过程
- 你写
str.a = 2,V8 临时new String('hello'),得到一个包装对象 ;它内部有个[[PrimitiveValue]]槽,存着原始值'hello' - 把
a = 2挂到这个临时包装对象上 - 语句结束,临时包装对象立刻被销毁(拆箱) ,变量
str仍然指向原始字符串 ------ 并不是真的执行了delete str.a,而是那个对象本身就不存在了 - 下次再读
str.a,引擎又新建一个全新的临时包装对象,上面自然没有a------ 得到undefined
用数字再试一遍,现象一模一样:
js
const n = 123 // new Number(123)
n.a = 2 // 挂在临时 Number 对象上,然后对象被销毁
console.log(n) // 123
console.log(n.a) // undefined
这就是包装类:JS 为了方便你操作原始类型,在访问属性时内部临时把它包装成对象,操作完立刻拆箱。
那 str.length 为什么有值?
因为包装对象的 [[PrimitiveValue]] 对应着字符串内容,包装对象上天然就有 length:
js
console.log('hello'.length) // 5
同理,'hello'.toUpperCase() 也是临时包装之后,从 String.prototype 上找到的方法 ------ 这也是为什么原始类型能「调方法」,但方法并不挂在原始值自己身上。
常见的包装对象:
| 原始类型 | 包装对象 |
|---|---|
| String / Number / Boolean | new String() / new Number() / new Boolean() |
| Symbol / BigInt | 不能 new,只能用 Object(sym) 包装 |
补充:以上静默失败的行为发生在非严格模式;严格模式下给原始类型加属性会直接抛
TypeError: Cannot create property ...。
一句话记忆
原始类型只是「借」了一下对象的能力,借完就还,什么都留不下。
七、一张表收尾
| 知识点 | 关键结论 |
|---|---|
| 数据类型 | 基本类型 7 种按值比较;Object / Array / Function 是引用类型,按地址比较 |
| 创建对象 | {} 最常用,new Object() 等价但少用 |
| 增删改查 | obj.key = 值、delete obj.key、obj[key](键是变量时必须用方括号) |
| 构造函数 | 被 new 调用的函数,首字母大写,用于批量创建实例 |
| new 四步 | 建空对象 → 接 __proto__ → 绑定 this 执行函数 → 返回对象 |
| prototype | 函数天生拥有的显式原型 |
| proto | 对象天生拥有的隐式原型 ,现代替代写法 Object.getPrototypeOf() |
| 核心等式 | 实例.__proto__ === 构造函数.prototype |
| 原型链查找 | 先找自己,再沿 __proto__ 往上,直到 null;hasOwnProperty 判断是否自有 |
| 数组 | 也是对象,arr.__proto__ === Array.prototype |
| 包装类 | 访问属性时临时包装、立即拆箱;原始类型留不下任何自定义属性 |
最后
对象的难,不在语法,而在两个「看不见」的东西:
- 看不见的地址:引用类型变量里存的不是数据,而是地址
- 看不见的原型链:你调用的方法,可能根本不在对象自己身上
把这两点想通,str.a 为什么是 undefined、car1.push 为什么能执行、a === b 为什么有时 true 有时 false,就都不会再让你困惑了。
最后再强调一遍:把文中的六段代码挨个敲一遍,改几个值再跑一遍,比看十篇文章都管用。