Vue源码解析：数据双向绑定(响应式)原理

}

console.log(${key}属性被修改了);

val = newVal;

}

})

}

我们声明一个Observer类，用于将对象的所有属性都转变为可侦测，并且，我们要给每一个可侦测的对象添加一个__ob__属性，值为value的Observer的实例，这就相当于给每一个value设置了标识，表示这个value是响应式的了。那么当value是一个对象的时候，我们拿到他的所有的key,循环遍历调用Object.defineProperty()的方法，调用get/set方法来侦测，当发现传入的是一个Object的时候，通过递归的方式，再次通过Observer类去实例这个Object。这样我们就实现了对象的侦测。

2、实现数组的侦测（可观察）

上面我们讲了对象的侦测，现在来聊聊数组的侦测。

数组的可观测与对象的可观测有所不同，因为数组不能用Object.defineProperty()去观测。那么数组如何做到可观测呢，其实大同小异，数组是通过拦截器来做到的，那么这个拦截器是何方神圣？

我们知道，JavaScript中操作数组的原生方法，其实就是那么几个，push/pop/shift/unshift/splice/sort/reverse。这些方法都是通过Array.prototype来访问，那么我们如果在Array.prototype上重新定义一个方法，去实现原生的方法，如newPush去实现与push同样的作用，是不是很完美。既没有修改原生方法，又可以在调用原生方法之前做了相应的操作。

let arr = [1,2,3]

// arr.push(4) 原生方法调用

Array.prototype.newPush = function(val){

console.log(‘arr被修改了’)

this.push(val)

}

arr.newPush(4)

所以，数组的拦截器就是在数组实例和Array.prototype之间重写了操作数组的方法。这样在调用处理的方法的时候，就是调用的重写之后的方法，而不是原生方法。来看拦截器的实现：

// 源码位置：/src/core/observer/array.js

const arrayProto = Array.prototype

export const arrayMethods = Object.create(arrayProto)

const methodsToPatch = [

‘push’,

‘pop’,

‘shift’,

‘unshift’,

‘splice’,

‘sort’,

‘reverse’

]

methodsToPatch.forEach(function (method) {

const original = arrayProto[method]

Object.defineProperty(arrayMethods, method, {

enumerable: false,

configurable: true,

writable: true,

value:function mutator(…args){

const result = original.apply(this, args)

return result

}

})

})

这就是拦截器的实现，当调用数组的方法时，实际调用的是mutator函数，所以，我们可以在这个函数中做一些操作。但是这么做还不够，只有将拦截器挂载在数组实例和Array.prototype之间才能生效，也就是将数据的__proto__属性设置为拦截器arrayMethods即可。

augment(value, arrayMethods, arrayKeys)

// 源码位置：/src/core/observer/index.js

export class Observer {

constructor (value) {

this.value = value

if (Array.isArray(value)) {

const augment = hasProto

? protoAugment

copyAugment

augment(value, arrayMethods, arrayKeys)

} else {

this.walk(value)

}

}

}

// 能力检测：判断__proto__是否可用，因为有的浏览器不支持该属性

export const hasProto = ‘proto’ in {}

const arrayKeys = Object.getOwnPropertyNames(arrayMethods)

/**

• Augment an target Object or Array by intercepting

• the prototype chain using proto

*/

function protoAugment (target, src: Object, keys: any) {

target.proto = src

}

/**

• Augment an target Object or Array by defining

• hidden properties.

*/

/* istanbul ignore next */

function copyAugment (target: Object, src: Object, keys: Array) {

for (let i = 0, l = keys.length; i < l; i++) {

const key = keys[i]

def(target, key, src[key])

}

}

当拦截器生效后，如果数组发生变化，就可以被侦测到了。

以上就是如何让对象，和数组的变化可被侦测。数据仅仅被侦测还远远不够，下面来讲依赖的搜集。

数据的依赖收集

1、对象的依赖收集

依赖收集：视图中用到了哪个数据，视图就依赖哪个数据，把变化的数据收集起来，这个过程就是依赖的收集。

在哪里收集依赖：可观测的数据在getter中被获取，所以getter是收集依赖的场所。

何时通知依赖更新：数据变化在setter中可被观测，自然，通知依赖更新是在setter中。

依赖应该被搜集在哪里？且往下看：

因为更新的数据大小，我们无法控制，所以，对于依赖的收集，我们需要一个依赖管理器：

// 源码位置：src/core/observer/dep.js

export default class Dep {

constructor () {

this.subs = []

}

addSub (sub) {

this.subs.push(sub)

}

// 删除一个依赖

removeSub (sub) {

remove(this.subs, sub)

}

// 添加一个依赖

depend () {

if (window.target) {

this.addSub(window.target)

}

}

// 通知所有依赖更新

notify () {

const subs = this.subs.slice()

for (let i = 0, l = subs.length; i < l; i++) {

subs[i].update()

}

}

}

/**

• Remove an item from an array

*/

export function remove (arr, item) {

if (arr.length) {

const index = arr.indexOf(item)

if (index > -1) {

return arr.splice(index, 1)

}

}

}

有了依赖管理器，我们就可以在getter中收集依赖，在setter中通知依赖更新了。

function defineReactive (obj,key,val) {

if (arguments.length === 2) {

val = obj[key]

}

if(typeof val === ‘object’){

new Observer(val)

}

const dep = new Dep() //实例化一个依赖管理器，生成一个依赖管理数组dep

Object.defineProperty(obj, key, {

enumerable: true,

configurable: true,

get(){

dep.depend() // 在getter中收集依赖

return val;

},

set(newVal){

if(val === newVal){

return

}

val = newVal;

dep.notify() // 在setter中通知依赖更新

}

})

}

getter中调用了dep.depend()方法收集依赖，在setter中调用dep.notify()方法通知所有依赖更新。

其实在vue中实现了一个为每一个变化的依赖数据的watcher类，在之后数据变化时，我们不直接去通知依赖更新，而是通知依赖对应的Watch实例，由Watcher实例去通知真正的视图。

export default class Watcher {

constructor (vm,expOrFn,cb) {

this.vm = vm;

this.cb = cb;

this.getter = parsePath(expOrFn)

this.value = this.get()

}

get () {

window.target = this;

const vm = this.vm

let value = this.getter.call(vm, vm)

window.target = undefined;

return value

}

update () {

const oldValue = this.value

this.value = this.get()

this.cb.call(this.vm, this.value, oldValue)

}

}

/**

• Parse simple path.

• 把一个形如’data.a.b.c’的字符串路径所表示的值，从真实的data对象中取出来

• 例如：

• data = {a:{b:{c:2}}}

• parsePath(‘a.b.c’)(data) // 2

*/

const bailRE = /[^\w.$]/

export function parsePath (path) {

if (bailRE.test(path)) {

return

}

const segments = path.split(‘.’)

return function (obj) {

for (let i = 0; i < segments.length; i++) {

if (!obj) return

obj = obj[segments[i]]

}

return obj

}

}

分析：

• 当实例化watch的时候，先执行构造函数；

• 在构造函数中调用this.get()实例方法；

• 在get()方法中，先通过通过window.target = this 把实例自身赋给全局的一个唯一对象window.target上，然后通过let value = this.getter.call(vm, vm)获取一下被依赖的数据，获取被依赖数据的目的是触发该数据上面的getter，上文我们说过，在getter里会调用dep.depend()收集依赖，而在dep.depend()中取到挂载window.target上的值并将其存入依赖数组中，在get()方法最后将window.target释放掉。

• 而当数据变化时，会触发数据的setter，在setter中调用了dep.notify()方法，在dep.notify()方法中，遍历所有依赖(即watcher实例)，执行依赖的update()方法，也就是Watcher类中的update()实例方法，在update()方法中调用数据变化的更新回调函数，从而更新视图。

简单总结一下就是：

Watcher先把自己设置到全局唯一的指定位置（window.target），然后读取数据。因为读取了数据，所以会触发这个数据的getter。接着，在getter中就会从全局唯一的那个位置读取当前正在读取数据的Watcher，并把这个watcher收集到Dep中去。收集好之后，当数据发生变化时，会向Dep中的每个Watcher发送通知。通过这样的方式，Watcher可以主动去订阅任意一个数据的变化。为了便于理解，我们画出了其关系流程图，如下图：

以上，就彻底完成了对Object数据的侦测，依赖收集，依赖的更新等所有操作。

2、数组的依赖收集

对于数组，其实在依赖收集有个和对象大同小异的方法。

数组的依赖的收集是在observer类中：

// 源码位置：/src/core/observer/index.js

export class Observer {

constructor (value) {

this.value = value

this.dep = new Dep() // 实例化一个依赖管理器，用来收集数组依赖

if (Array.isArray(value)) {

const augment = hasProto

? protoAugment

copyAugment

augment(value, arrayMethods, arrayKeys)

} else {

this.walk(value)

}

}

}

这样我们也在observer中实现了一个依赖管理器。

所以我们可以看看数组的依赖到底是如何收集的，直接上代码：

function defineReactive (obj,key,val) {

let childOb = observe(val)

Object.defineProperty(obj, key, {

enumerable: true,

configurable: true,

get(){

if (childOb) {

childOb.dep.depend()

}

return val;

},

set(newVal){

if(val === newVal){

return

}

val = newVal;

dep.notify() // 在setter中通知依赖更新

}

})

}

/**

• Attempt to create an observer instance for a value,

• returns the new observer if successfully observed,

• or the existing observer if the value already has one.

• 尝试为value创建一个0bserver实例，如果创建成功，直接返回新创建的Observer实例。

• 如果 Value 已经存在一个Observer实例，则直接返回它

*/

export function observe (value, asRootData){

if (!isObject(value) || value instanceof VNode) {

return

}

let ob

if (hasOwn(value, ‘ob’) && value.ob instanceof Observer) {

ob = value.ob

} else {

ob = new Observer(value)

}

return ob

}

在observe函数内部，先判断当前传入的数据上是否有__ob__属性，因为在上篇文章中说了，如果数据有__ob__属性，表示它已经被转化成响应式的了，如果没有则表示该数据还不是响应式的，那么就调用new Observer(value)将其转化成响应式的，并把数据对应的Observer实例返回。而在defineReactive函数中，首先获取数据对应的Observer实例childOb，然后在getter中调用Observer实例上依赖管理器，从而将依赖收集起来。

这样依赖通知依赖更新就显的非常容易了。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

更多面试题

**《350页前端校招面试题精编解析大全》**内容大纲主要包括 HTML，CSS，前端基础，前端核心，前端进阶，移动端开发，计算机基础，算法与数据结构，项目，职业发展等等

资料获取方式：点击蓝色传送门获取

效果低效又漫长，而且极易碰到天花板技术停滞不前！**

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-J0PzOa8g-1712978757617)]

[外链图片转存中…(img-gjpCf75u-1712978757617)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

[外链图片转存中…(img-q43OeD2l-1712978757618)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

更多面试题

**《350页前端校招面试题精编解析大全》**内容大纲主要包括 HTML，CSS，前端基础，前端核心，前端进阶，移动端开发，计算机基础，算法与数据结构，项目，职业发展等等

资料获取方式：点击蓝色传送门获取

[外链图片转存中…(img-mPbmllJs-1712978757618)]