浅析Vue3中的响应式原理

2019-10-10 admin

请在此前阅读Vue Composition API内容,熟悉一下api。

实现响应式的方式

  1. defineProperty
  2. Proxy

众所周知在Vue3中使用了ES6提供的ProxyAPI取代了之前defineProperty来实现对数据的侦测.

为啥使用Proxy?

我们知道在Vue2对于监测数组的变化是通过重写了数组的原型来完成的,这么做的原因是:

  1. 不会对数组每个元素都监听,提升了性能.(arr[index] = newValue是不会触发试图更新的,这点不是因为defineProperty的局限性,而是出于性能考量的)
  2. defineProperty不能检测到数组长度的变化,准确的说是通过改变length而增加的长度不能监测到(arr.length = newLength也不会)。

同样对于对象,由于defineProperty的局限性,Vue2是不能检测对象属性的添加或删除的。

function defineReactive(data, key, val) {
    Object.defineProperty(data, key, {
        enumerable: true,
        configurable: true,
        get() {
            console.log(`get key: ${key} val: ${val}`)
            return val
        },
        set(newVal) {
            console.log(`set key: ${key} val: ${newVal}`)
            val = newVal
        }
    })
}
function observe(data) {
    Object.keys(data).forEach((key)=> {
        defineReactive(data, key, data[key])
    })
}
let test = [1, 2, 3]
observe(test)
console.log(test[1])   // get key: 1 val: 2
test[1] = 2       // set key: 1 val: 2
test.length = 1   // 操作是完成的,但是没有触发set
console.log(test.length) // 输出1,但是也没有触发get

实现响应式前的一些小细节

相对于defineProperty,Proxy无疑更加强大,可以代理数组,并且提供了多种属性访问的方法traps(get,set,has,deleteProperty等等)。

let data = [1,2,3]
let p = new Proxy(data, {
    get(target, key, receiver) {
        // target 目标对象,这里即data
        console.log('get value:', key)
        return target[key]
    },
    set(target, key, value, receiver) {
        // receiver 最初被调用的对象。通常是proxy本身,但handler的set方法也有可能在原型链上或以其他方式被间接地调用(因此不一定是proxy本身)。
        // 比如,假设有一段代码执行 obj.name = "jen",obj不是一个proxy且自身不含name属性,但它的原型链上有一个proxy,那么那个proxy的set拦截函数会被调用,此时obj会作为receiver参数传进来。
        console.log('set value:', key, value)
        target[key] = value
        return true // 在严格模式下,若set方法返回false,则会抛出一个 TypeError 异常。
    }
})
p.length = 4   // set value: length 4
console.log(data)   // [1, 2, 3, empty]

但是对于数组的一次操作可能会触发多次get/set,主要原因自然是改变数组的内部key的数量了(即对数组进行插入删除之类的操作),导致的连锁反应。

// data : [1,2,3]
p.push(1)
// get value: push
// get value: length
// set value: 3 1
// set value: length 4
// data : [1,2,3]
p.shift()
// get value: shift
// get value: length
// get value: 0
// get value: 1
// set value: 0 2
// get value: 2
// set value: 1 3
// set value: length 2

同时Proxy是仅代理一层的,对于深层对象,也是需要开发者自行实现的,此外对于对象的添加是可以 set traps侦测到的,删除则需要使用 deleteProperty traps。

let data = {a:1,b:{c:'c'},d:[1,2,3]}
let p = new Proxy(data, {
    ....同上
})
console.log(p.a)
console.log(p.b.c)
console.log(p.d)
console.log(p.d[0])
p.e = 'e'  // 这里可以看到给对象添加一个属性也依然可以侦测到变化
// get value: a
// 1
// get value: b
// c
// get value: d
// [1, 2, 3]
// get value: d
// 1
// set value: e e

还有一件事,对于一些简单的get/set操作,我们在traps中使用target[key]target[key] = value是可以达到我们的需求的,但是对于一些复杂的如delet,in这类操作这样实现就不够优雅了,而ES6提供了ReflectAPI,且与Proxy的traps一一对应,用来代替 Object 的默认行为。 所以我们先将之前的代码改造一下:

let p = new Proxy(data, {
    get(target, key, receiver) {
        console.log('get value:', key)
        const res = Reflect.get(target, key, receiver)
        return res
    },
    set(target, key, value, receiver) {
        console.log('set value:', key, value)
        // 如果赋值成功,则返回true
        const res = Reflect.set(target, key, value, receiver)
        return res
    }
})

实现响应式

明确目标

我们最终实现的效果应该如下一样:

const a = reactive({ b: 0 })
effect(() => {
    console.log(a.b)
})  //effect在传入时就会自动执行一次
a.b ++ // 这时会打印 1

实现思路

熟悉Vue2的同学都知道Vue2的响应式是在get中收集依赖,在set中触发依赖,Vue3想必也不例外,按照这个思路我们的实现步骤如下:

  1. 在触发get时收集effect函数传入的回调,这里我们称这个回调为ReactiveEffect
  2. 在set、deleteProperty…时触发所有的ReactiveEffect

下面我们看下具体的实现步骤

reactive的简单实现

第一步,我们先来简单实现一个可以对对象增删改查侦测的函数 在set的实现中,我们将对象的set分为两类:新增key和更改key的value。通过hasOwnProperty判断这个对象是否含有这个属性,不存在存在则是添加属性,存在则判断新value和旧value是否相同,不同才需要触发log执行。 这里的reactive函数我们记为V1版本。

const hasOwn = (val,key)=>{
    const res = Object.prototype.hasOwnProperty.call(val, key)
    console.log(val,key,res)
    return res
} 

function reactive(data){
    return new Proxy(data, {
        get(target, key, receiver) {
            console.log('get value:', key)
            const res = Reflect.get(target, key, receiver)
            return res
        },
        set(target, key, value, receiver) {
            const hadKey = hasOwn(target, key)
            const oldValue = target[key]
            const res = Reflect.set(target, key, value, receiver)
            if (!hadKey) {
                console.log('set value:ADD', key, value)
            } else if (value !== oldValue) {
                console.log('set value:SET', key, value)
            } 
            return res
        },
        deleteProperty(target, key){
            const hadKey = hasOwn(target, key)
            const oldValue = target[key]
            const res = Reflect.deleteProperty(target, key)
            if (hadKey) {
                console.log('set value:DELETE', key)
            }
            return res
        }
    })
}

依赖收集

在Vue3中针对所有的被监听的对象,存在一张关系表targetMap,key为target,value为另一张关系表depsMap。 depsMap的key为target的每个key,value为由effect函数传入的参数的Set集。

type Dep = Set<ReactiveEffect>
type KeyToDepMap = Map<string | symbol, Dep>
const targetMap = new WeakMap<any, KeyToDepMap>()
// 大概结构如下所示
//    target | depsMap
//      obj  |   key  |  Dep 
//               k1   |  effect1,effect2...
//               k2   |  effect3,effect4...
//      obj2 |   key  |  Dep 
//               k1   |  effect1,effect2...
//               k2   |  effect3,effect4...
//

同时我们还需要收集effect函数的回调ReactiveEffect,当ReactiveEffect内有已被监听的对象get触发get时,便需要一个存储ReactiveEffect的地方。这里使用一个数组记录:

const activeReactiveEffectStack: ReactiveEffect[] = []

effect函数实现如下:

function run(effect,fn,args){
    try {
        activeReactiveEffectStack.push(effect)
        return fn(...args)   //执行fn以收集依赖
    } finally {
        activeReactiveEffectStack.pop()
    }
}
function effect(fn,lazy=false){
    const effect1 = function (...args){
        return run(effect1, fn, args)
    }
    if (!lazy){
        effect1()
    }
    return effect1
}

track跟踪器,由于get时的依赖收集:

function track(target,type,key){
    const effect = activeReactiveEffectStack[activeReactiveEffectStack.length - 1]
    if (effect) {
        let depsMap = targetMap.get(target)
        if (depsMap === void 0) {
            targetMap.set(target, (depsMap = new Map()))
        }
        let dep = depsMap.get(key)
        if (dep === void 0) {
            depsMap.set(key, (dep = new Set()))
        }
        if (!dep.has(effect)) {
            dep.add(effect)
        }
    }
}

trigger触发器,key变化(set,delete…)时触发,获取这个key所对应的所有的ReactiveEffect,然后执行:

function trigger(target,type,key){
    console.log(`set value:${type}`, key)
    const depsMap = targetMap.get(target)
    if (depsMap === void 0) {
        return
    }
    // 获取已存在的Dep Set执行
    const dep = depsMap.get(key)
    if (dep !== void 0) {
        dep.forEach(effect => {
            effect()
        })
    }
}

reactive函数如下:

function reactive(target){
   const observed = new Proxy(target, {
       get(target, key, receiver) {
           const res = Reflect.get(target, key, receiver)
           track(target,"GET",key)
           return res
       },
       set(target, key, value, receiver) {
           const hadKey = hasOwn(target, key)
           const oldValue = target[key]
           const res = Reflect.set(target, key, value, receiver)
           if (!hadKey) {
               trigger(target,"ADD",key)
           } else if (value !== oldValue) {
               trigger(target,"SET",key)
           } 
           return res
       },
       deleteProperty(target, key){
           const hadKey = hasOwn(target, key)
           const oldValue = target[key]
           const res = Reflect.deleteProperty(target, key)
           if (hadKey) {
               console.log('set value:DELETE', key)
           }
           return res
       }
   })
   if (!targetMap.has(target)) {
       targetMap.set(target, new Map())
   }
   return observed
}

深层监听

通常我们都会想到通过递归的方式,对每个key判读啊是否为对象来进行监听,在Vue3中:

function get(target, key, receiver) {
    const res = Reflect.get(target, key, receiver)
    track(target, "GET", key)
    return isObject(res) ? reactive(res) : res
}

Vue3中,这里做了性能的优化,做了一层lazy access的操作,这样只有在访问到深层的对象时才会去做代理。

注意

此时我们所有的ReactiveEffect都是和key绑定的,也就是说,在ReactiveEffect函数中,我们必须get一次确定的某个key,否则在set时是没有ReactiveEffect可以触发的,举个列子:

let data = {a:1,b:{c:'c'}}
let p = reactive(data)
effect(()=>{console.log(p)})
p.a = 3 

上面这种情况是不会打印p的.

let data = {a:1,b:{c:'c'}}
let p = reactive(data)
effect(()=>{console.log(p.a)})
p.a = 3  // 3

这种情况才会执行()=>{console.log(p.a),打印3

数组类型的问题

但对于数组进行一些操作时,执行起来会有一点小不同,我们来使用V1版本的reactive函数来监听一个数组p = reactive([1,2,3]),并分别对p进行操作看看结果:

p.push(1)
// set value:ADD 3 1
p.unshift(1)
// set value:ADD 3 3
// set value:SET 2 2
// set value:SET 1 1
p.splice(0,0,2)
// set value:ADD 3 3
// set value:SET 2 2
// set value:SET 1 1
// set value:SET 0 2
p[3] = 4
// set value:ADD 3 4
--------
p,pop()
// set value:DELETE 2
// set value:SET length 2
p.shift()
// set value:SET 0 2
// set value:SET 1 3
// set value:DELETE 2
// set value:SET length 2
delete p[0]
// set value:DELETE 0
// 这里p的length依然是三

可以发现当我们对数组添加元素时,对于length的SET并不会触发(),而删除元素时才会触发length的SET,同时对数组的一次操作触发了多次log。

这里在我们对数组添加操作时就会出现一个问题,我们使用p.push(1),操作的index是3,上面的列子我们知道在effect函数中我们必须get这个3,才会把ReactiveEffect给绑定上去,但那时候是很没有3这个index的,所以就会导致没有办法执行ReactiveEffect。 Vue3中的处理是在trigger中添加一段代码:

function trigger(target,type,key){
    console.log(`set value:${type}`, key)
    const depsMap = targetMap.get(target)
    if (depsMap === void 0) {
        return
    }
    const effects = new Set()
    if (key !== void 0) {
        const depSet = depsMap.get(key)
        if (depSet !== void 0) {
            depSet.forEach(effect => {
                effects.add(effect)
            })
        }
    }
    // 就是这里啦,(这里做了一些更改)
    if (type === "ADD" || type === "DELETE") {
        if(Array.isArray(target)){
            const iterationKey = 'length'
            const depSet = depsMap.get(iterationKey)
            if (depSet !== void 0) {
                depSet.forEach(effect => {
                    effects.add(effect)
                })
            }
        }
    }
    // 获取已存在的Dep Set执行
    effects.forEach(effect=>effect())
}

当监听的target为数组时,操作为ADD或者DELETE时,触发的ReactiveEffect为绑在数组length上的,看下面一段代码:

let data = { foo: 'foo', ary: [1, 2, 3] }
let r = reactive(data)
effect(()=>console.log(r.ary.length))
r.ary.unshift(1)  // 4

验证

我们来拿Vue3的代码执行一下看一下是否和我们的一样; yarn build 之后引入reactivity.global.js

const { reactive, effect } = VueObserver
let data = { foo: 'foo', ary: [1, 2, 3] }
let r = reactive(data)
effect(()=>console.log(r.ary.length))
r.ary.unshift(1)  // 4
--------------
const { reactive, effect } = VueObserver
let data = { foo: 'foo', ary: [1, 2, 3] }
let r = reactive(data)
effect(()=>console.log(r.ary))
r.ary.unshift(1)  // 没有打印
-------
const { reactive, effect } = VueObserver
let data = { foo: 'foo', ary: [1, 2, 3] }
let r = reactive(data)
effect(()=>console.log(r))
r.foo = 1   // 啥也没打印
--------
const { reactive, effect } = VueObserver
let data = { foo: 'foo', ary: [1, 2, 3] }
let r = reactive(data)
effect(()=>console.log(r.foo))
r.foo = 1   // 1
------
const { reactive,effect } = VueObserver
let data = { foo: 'foo', ary: [1, 2, 3] }
let r = reactive(data)
effect(()=>console.log(r.ary.join()))
r.ary.unshift(1)
// 1,2,3
// 1,2,3,3
// 1,2,2,3
// 1,1,2,3
//多次打印,证明多次触发

可以发现我们的代码和Vue3表现是一致的。 测试的代码都在这个里面➡️代码

总结

到此我们应该算是对Vue3中的响应式有一个了解了,第一次写文章哈,如有错误的地方还望雅正

完整的代码

const activeReactiveEffectStack = []
const targetMap = new WeakMap()
const isObject = (val) => val !== null && typeof val === 'object'
const hasOwn = (val,key)=>{
    const res = Object.prototype.hasOwnProperty.call(val, key)
    //console.log(val,key,res)
    return res
}
function run(effect,fn,args){
    try {
        activeReactiveEffectStack.push(effect)
        return fn(...args)   //执行fn以收集依赖
    } finally {
        activeReactiveEffectStack.pop()
    }
}
function effect(fn,lazy=false){
    const effect1 = function (...args){
        return run(effect1, fn, args)
    }
    if (!lazy){
        effect1()
    }
    return effect1
}
function track(target,type,key){
    const effect = activeReactiveEffectStack[activeReactiveEffectStack.length - 1]
    if (effect) {
        let depsMap = targetMap.get(target)
        if (depsMap === void 0) {
            targetMap.set(target, (depsMap = new Map()))
        }
        let dep = depsMap.get(key)
        if (dep === void 0) {
            depsMap.set(key, (dep = new Set()))
        }
        if (!dep.has(effect)) {
            console.log(key,effect)
            dep.add(effect)
        }
    }
}
function trigger(target,type,key){
    console.log(`set value:${type}`, key)
    const depsMap = targetMap.get(target)
    if (depsMap === void 0) {
        return
    }
    const effects = new Set()
    if (key !== void 0) {
        const depSet = depsMap.get(key)
        if (depSet !== void 0) {
            depSet.forEach(effect => {
                effects.add(effect)
            })
        }
    }
    if (type === "ADD" || type === "DELETE") {
        if(Array.isArray(target)){
            const iterationKey = 'length'
            const depSet = depsMap.get(iterationKey)
            if (depSet !== void 0) {
                depSet.forEach(effect => {
                    effects.add(effect)
                })
            }
        }
    }
    // 获取已存在的Dep Set执行
    effects.forEach(effect=>effect())
}
function reactive(target){
    const observed = new Proxy(target, {
        get(target, key, receiver) {
            const res = Reflect.get(target, key, receiver)
            track(target,"GET",key)
            return isObject(res) ? reactive(res): res
        },
        set(target, key, value, receiver) {
            const hadKey = hasOwn(target, key)
            const oldValue = target[key]
            const res = Reflect.set(target, key, value, receiver)
            if (!hadKey) {
                trigger(target,"ADD",key)
            } else if (value !== oldValue) {
                trigger(target,"SET",key)
            }
            return res
        },
        deleteProperty(target, key){
            const hadKey = hasOwn(target, key)
            const oldValue = target[key]
            const res = Reflect.deleteProperty(target, key)
            if (hadKey) {
                console.log('set value:DELETE', key)
            }
            return res
        }
    })
    if (!targetMap.has(target)) {
        targetMap.set(target, new Map())
    }
    return observed
}

[转载]原文链接:https://segmentfault.com/a/1190000020637178

本站文章除注明转载外,均为本站原创或编译。欢迎任何形式的转载,但请务必注明出处。

转载请注明:文章转载自 JavaScript中文网 [https://www.javascriptcn.com]

本文地址:https://www.javascriptcn.com/read-77020.html

文章标题:浅析Vue3中的响应式原理

相关文章
v-charts | 饿了么团队开源的基于 Vue 和 ECharts 的图表工具
在使用echarts生成图表时,经常需要做繁琐的数据类型转化、修改复杂的配置项,v-charts的出现正是为了解决这个 痛点。基于Vue2.0和echarts封装的v-charts图表组件,只需要统一提供一种对前后端都友好的数据格式 设置简...
2018-05-24
JavaScript实现PC手机端和嵌入式滑动拼图验证码三种效果
PC和手机端网站滑动拼图验证码效果源码,同时包涵了弹出式Demo,使用ajax形式提交二次验证码所需的验证结果值,嵌入式Demo,使用表单形式提交二次验证所需的验证结果值,移动端手动实现弹出式Demo三种效果 首先要确认前端使用页面,比如...
2017-03-17
Vue获取DOM元素样式和样式更改示例
在 vue 中用 document 获取 dom 节点进行节点样式更改的时候有可能会出现 ‘style’ is not definde的错误,这时候可以在 mounted 里用 $refs 来获取样式,并进行更改: &lt;template...
2017-03-13
Vue.js组件tab实现选项卡切换
本文实例为大家分享了vue插件tab选项卡的具体代码,供大家参考,具体内容如下 效果图: 代码如下: &lt;!DOCTYPE html&gt; &lt;html lang=&quot;en&quot;&gt; &lt;head&gt; ...
2017-03-13
YouTube正式默认使用HTML5视频播放器
YouTube视频网站现在默认使用HTML5播放器,这意味着更好的性能、 稳定性、 电池寿命和甚至是更好的安全性。现在用户通过Chrome、IE 11、Safari 8和Beta版本的Firefox进行浏览的时候都默认使用HTML5视频播放...
2015-11-12
JavaScript教程:JS中的原型
Keith Peters 几年前发表的一篇博文,关于学习没有“new”的世界,其中解释了使用原型继承代替构造函数。两者都是纯粹的原型编码。 标准方法(The Standard Way) 一直以来,我们学习的在 JavaScript 里创建对...
2015-11-12
JS中的语音合成——Speech Synthesis API
JS中的语音合成——Speech Synthesis API 简介 HTML5中和Web Speech相关的API实际上有两类,一类是“语音识别(Speech Recognition)”,另外一个就是“语音合成(Speech Synthes...
2018-05-17
layui表格checkbox选择全选样式及功能的实
在之前的版本,默认复选框是要有值得,默认为“勾选”两个字,在表格里用来做选择不适合,很难改,还好layui升级后,可以支持不写name值,来适应表格中的选择操作。 1、layui版本号为 v1.0.9 rls版本(当前最新版本) &lt;s...
2018-03-08
React Native v0.13.3 发布,Facebook开源框架
React is a JavaScript library for building user interfaces. Just the UI: Lots of people use React as the V in MVC. Since...
2015-11-12
必须记住的 30 类 CSS 选择器
开篇 有 30 个 CSS 选择器你必须烂熟于心,它们适应于当今各大主流浏览器。 1.* * { margin: 0; padding: 0; } *选择器选择的是每一个单一元素。很多程序员用上面的 CSS 将所有元素的 ma...
2015-11-16
回到顶部