Vue3响应式原理

        // 定义一个保存副作用函数的变量
        let activeEffect
        // 定义一个副作用函数调用栈
        const effectStack = []
        // 定义副作用函数
        function effect(fn, options = {}) {
            const effectFn = () => {
                // 每次执行副作用函数前，清空之前保存的副作用函数
                cleanup(effectFn)
                activeEffect = effectFn
                // 根据栈先进后出原则
                effectStack.push(effectFn)
                const res = fn()
                effectStack.pop()
                // 使每一次的副作用函数都跟当前值相互对应，防止副作用函数嵌套，引发的更新问题
                activeEffect = effectStack[effectStack.length - 1]
                return res
            }
            // 保存options配置
            effectFn.options = options
            // 在当前副作用函数下创建deps数组，与触发数据变更的key的副作用函数建立引用关系
            effectFn.deps = []
            if (!options.lazy) {
                effectFn()
            }
            return effectFn
        }
        function track(target, key) {
            if (!activeEffect) return
            // 获取当前对象绑定的map集合，如果没有则新建
            let depsMap = bucket.get(target)
            if (!depsMap) {
                bucket.set(target, (depsMap = new Map()))
            }
            // 获取当前key绑定的set集合，如果没有则新建
            let deps = depsMap.get(key)
            if (!deps) {
                depsMap.set(key, (deps = new Set()))
            }
            // 将副作用函数与key相关联
            deps.add(activeEffect)
            // 建立引用关系
            activeEffect.deps.push(deps)
        }
        function trigger(target, key) {
            // 获取map集合
            const depsMap = bucket.get(target)
            if (!depsMap) return
            // 获取set集合
            const effects = depsMap.get(key)
            // 创建一个新的集合，将effects集合内函数，添加到新集合内，防止set集合的新增和删除造成死循环
            const effectToRun = new Set()
            effects && effects.forEach(effectFn => {
                if (effectFn !== activeEffect) {
                    effectToRun.add(effectFn)
                }
            })
            effectToRun.forEach(effectFn => {
                if (effectFn.options.scheduler) {
                    effectFn.options.scheduler(effectFn)
                } else {
                    effectFn()
                }
            })
        }
        function cleanup(effectFn) {
            // 每次触发副作用函数时，先清空跟当前key相关的旧副作用函数
            for (let i = 0; i < effectFn.deps.length; i++) {
                const deps = effectFn.deps[i]
                deps.delete(effectFn)
            }
            effectFn.deps.length = 0
        }
        const jobQueue = new Set()
        const p = Promise.resolve()
        let isFlushing = false
        function flushJob() {
            if (isFlushing) return
            isFlushing = true
            p.then(() => {
                jobQueue.forEach(job => job())
            }).finally(() => {
                isFlushing = false
            })
        }
        const data = { foo: 1, bar: 2 }
        // 定义map集合
        const bucket = new WeakMap()
        const obj = new Proxy(data, {
            get(target, key, receiver) {
                track(target, key)
                return Reflect.get(target, key, receiver)
            },
            set(target, key, newVal, receiver) {
                const res = Reflect.set(target, key, newVal, receiver)
                trigger(target, key)
                return res
            }
        })
        const effectFn = effect(() => obj.foo + obj.bar, {
            lazy: true
        })
        function computed(getter) {
            let value
            let dirty = true
            const effectFn = effect(getter, {
                lazy: true,
                scheduler() {
                    if (!dirty) {
                        dirty = true
                        trigger(obj, 'value')
                    }

                }
            })
            const obj = {
                get value() {
                    if (dirty) {
                        value = effectFn()
                        dirty = false
                    }
                    track(obj, 'value')
                    return value
                }
            }
            return obj
        }
        function watch(source, cb) {
            effect(() => source.foo),
            {
                scheduler() {
                    cb()
                }
            }
        }
        const sumRes = computed(() => obj.foo + obj.bar)
        effect(() => {
            console.log(sumRes.value)
        })
        effect(() => {
            console.log('副作用触发')
            obj.foo
        })
        obj.foo++
        console.log(sumRes.value)
        // console.log(sumRes.value)
        // watch(obj,()=>{
        //     console.log('数据变化了')
        // })