彻底搞懂 JS 对象:从字面量、构造函数到原型链与包装类

彻底搞懂 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' }

关于构造函数,记住三句话:

  1. 构造函数就是被 new 调用的函数 ,习惯首字母大写
  2. 它的作用是批量创建结构相同的对象实例
  3. 不写 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:

js 复制代码
Object.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 处理的完整过程

  1. 你写 str.a = 2,V8 临时 new String('hello'),得到一个包装对象 ;它内部有个 [[PrimitiveValue]] 槽,存着原始值 'hello'
  2. 把 a = 2 挂到这个临时包装对象上
  3. 语句结束,临时包装对象立刻被销毁(拆箱) ,变量 str 仍然指向原始字符串 ------ 并不是真的执行了 delete str.a,而是那个对象本身就不存在了
  4. 下次再读 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,就都不会再让你困惑了。

最后再强调一遍:把文中的六段代码挨个敲一遍,改几个值再跑一遍,比看十篇文章都管用。

相关推荐
bai2731 小时前
同一条 294 字符的路径:Node 走得进去,git add 直接 exit 128
javascript·后端
澹锦汐6 小时前
纯前端秋日银杏与枫叶落叶色板智能聚类器:基于 K-Means 色彩量化与直方图自动配方提取
前端·人工智能·ai·语言模型·vue·react·k-means
Flynt13 小时前
AI 写的 Three.js 大屏,为什么越跑越卡?我在 Node 里复现了它的内存曲线
前端·ai编程·three.js
一个游离的指针15 小时前
Vue2:vue-router
前端·javascript·vue.js
凌晨三点说晚安17 小时前
理解 JavaScript 对象、原型与包装类
javascript
火山引擎和TA的超级拍档们17 小时前
产品情报局 11 | AI 数据湖 LAS:打造大模型时代多模态数据底座
前端·后端
JavaGuide18 小时前
Gemini 真的变强了,写代码做视频的能力接近 Claude Opus5.5 了!
前端·ai编程
凌晨三点说晚安18 小时前
理解 JavaScript 作用域链、return 与闭包
javascript