管中窥豹--对vue-next响应式原理的一些小收获

什么是响应式

粗俗的讲,响应式就是指假如B依赖于A,如果A改变了,A会通知B。
对于一般性对象(这里的对象是指依赖或者被依赖的东西)X,它有两个列表,一个是依赖列表,一个是被依赖列表。这样,X就可以看成是一条链路上面的一个节点,而一个响应式系统则是有很多这样的节点构成:
image.png
一个响应式的系统就是由很多想上面的节点组成的一个网状结构:
image.png
我们通过修改基础数据,触发从该数据出发的整一串链路的的数据的变更,这个就是响应式系统的简易说明。

js对响应式的支持

实现这个响应式系统的一个难点就是如何收集依赖关系构建依赖网络。至今,js有两个方式可以实现在存、取属性的时候触发额外的代码

1、defineProperty

在es5的时候,我们就可以指定属性的属性

Object.defineProperty(obj, prop, descriptor)
Object.defineProperties(obj, props)

详细的用法可以见defineProperty defineProperties
在vue3之前都是使用这种方式收集依赖的

2、Proxy / Reflect

在这里我也不细说了,直接附上链接:Proxy Reflect
附上一句,这两个对象是ESCMScript中规定的内置对象

vue对响应式的实现

好了,说了那么多额外的东西终于到vue了,这里先声明,我使用的vue-next是基于91269da52c30abf6c50312555b715f5360224bb0版本的,由于现在还处于alpha中,不同的版本之间可能相差比较大。
我们先从demo开始入手:

yarn install
yarn run dev

将一下文件放入到packages\vue\dist中,再用浏览器打开这个页面就能看到效果了
index.html

<!DOCTYPE html>
<html>

<head>
    <title>vue3.0 demo</title>
</head>

<body>
    <script src="./vue.global.js"></script>
    <div id="container"></div>
    <script>
        const App = {
            setup() {
                const state = Vue.reactive({ count: 0 })
                const addOne = ()=> {
                    ++state.count
                }
                return {
                    state,
                    addOne
                }
            },
            template: `<span>{{state.count}}</span><br/>
            <button @click="addOne">加一</button>`
        }
        
        Vue.createApp(App).mount(container)
    </script>
</body>

</html>

1、找到程序的入口

上面的代码首先创建了一个对象App,然后调用了Vue.createApp,最后,将至挂载至container,我们可以看出createApp就是这个程序的入口了。但是,在创建对象App的时候,我们看到了创建响应式对象的方法Vue.reactive,他在createApp之前已经帮我们创建了一个具有响应式功能的对象,这相当于是将响应式从整个vue大框架中解耦出来了,成为了一个单独的模块,这对于vue来说是一个很大的变动。
现在我们分析整个项目的结构
image.png
package.json中找到开发的脚本

"scripts": {
    "dev": "node scripts/dev.js"
  }

在scripts/dev.js中设置了一些参数并且执行了rollup.config.js,在里面,我们看到了项目的入口目录

const packagesDir = path.resolve(__dirname, 'packages')
const packageDir = path.resolve(packagesDir, process.env.TARGET)

点开packages,我们看到作者将vue的各个功能模块拆分到各自的目录中,程序通过vue这个目录将其他的目录串联起来实现完整的代码。
在packages\vue\src\index.ts中我们看到这里注册了一个compiler(看方法名猜的):registerRuntimeCompiler
并且导出了另外一个模块的方法:

export * from '@vue/runtime-dom'

我们进入这个文件packages\runtime-dom\src\index.ts
在里面,我们找到了这个入口的方法:

export const createApp = ((...args) => {
  const app = ensureRenderer().createApp(...args)

  const { mount } = app
  app.mount = (containerOrSelector) => {
    // ......省略
  }

  return app
})

还有我们关心的reactive也在里面有说明

// re-export everything from core
// h, Component, reactivity API, nextTick, flags & types
export * from '@vue/runtime-core'

在packages\runtime-core\src\index.ts我们看到了reactive

export {
  // ... 忽略其他
  reactive,
  // ... 忽略其他
} from '@vue/reactivity'

目标已经很接近了,在packages\reactivity\src\index.ts

export {
  reactive,
  // ... 忽略其他
} from './reactive'

好的,我们找到了,在packages\reactivity\src\reactive.ts
我简化了一下代码,希望能够帮助理解

import { mutableHandlers } from './baseHandlers'
import { mutableCollectionHandlers } from './collectionHandlers'
const rawToReactive = new WeakMap()
const reactiveToRaw = new WeakMap()
export function reactive(target: object) {
  return createReactiveObject(target, rawToReactive, reactiveToRaw,
    mutableHandlers, mutableCollectionHandlers
  )
}
function createReactiveObject(target, toProxy, toRaw,
  baseHandlers, collectionHandlers
) {
  // target已经实现了响应式
  let observed = toProxy.get(target)
  if (observed !== void 0) {
    return observed
  }
  // target已经是响应式,注意A对象和A的响应式对象并不是同一个对象,所以会有两个判断
  if (toRaw.has(target)) {
    return target
  }
  // 判断是Set, Map, WeakMap, WeakSet的话要用容器类的handler
  const handlers = collectionTypes.has(target.constructor)
    ? collectionHandlers
    : baseHandlers;
  // 创建响应式对象
  observed = new Proxy(target, handlers)
  // 保存响应式映射关系方便再次调用时直接返回
  toProxy.set(target, observed)
  toRaw.set(observed, target)
  // 返回响应式对象
  return observed
}

我们看看mutableHandlers,里面实现了前面所说的依赖列表和被依赖列表

export const mutableHandlers: ProxyHandler<object> = {
  get,
  set,
  // ...省略其他
}

我们主要看get和set

function createGetter() {
  return function get(target, key, receiver) {
    const res = Reflect.get(target, key, receiver);
    // 重点!!这里会加入依赖列表
    track(target, TrackOpTypes.GET, key);
    // 为了避免循环依赖,在这里延迟设置响应式
    return isObject(res)? reactive(res): res;
  }
};

function createSetter() {
  return function set(target, key, value, receiver) {
    const oldValue = target[key];
    const hadKey = hasOwn(target, key);
    const result = Reflect.set(target, key, value, receiver);
    // 重要!!这里触发修改事件,会导致所有依赖改对象的对象做更新
    // 根据新增或修改发送触发不同的事件
    if (!hadKey) {
      trigger(target, TriggerOpTypes.ADD, key, value);
    } else if (hasChanged(value, oldValue)) {
      trigger(target, TriggerOpTypes.SET, key, value, oldValue);
    }
    return result;
  }
};

我们先看packages\reactivity\src\effect.ts中的track函数

const targetMap = new WeakMap()

export function track(target, type, key) {
  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(activeEffect)) {
    dep.add(activeEffect)
    activeEffect.deps.push(dep)
  }
}

我们看到,代码中有一个变量activeEffect,我们把activeEffect加入到被依赖列表dep,在activeEffect的依赖列表中加入dep。
那这个变量activeEffect在哪里赋值的呢?
我们添加一个computed,依赖于state,看看里面是怎样处理的,先贴一下修改后的index.html代码

<!DOCTYPE html>
<html>

<head>
    <title>vue3.0 demo</title>
</head>

<body>
    <script src="./vue.global.js"></script>
    <div id="container"></div>
    <script>
        const App = {
            setup() {
                const state = Vue.reactive({ count: 0 })
                const nextState = Vue.computed(()=>state.count+1)
                const addOne = ()=> {
                    ++state.count
                }
                return {
                    state,
                    nextState,
                    addOne
                }
            },
            template: `<span>当前值:{{state.count}}</span><br/>
            <span>下一个值:{{nextState}}</span><br/>
            <button @click="addOne">加一</button>`
        }
        
        Vue.createApp(App).mount(container);
    </script>
</body>

</html>

我们把目光聚焦在const nextState = Vue.computed(()=>state.count+1)
computed的方法在packages\reactivity\src\computed.ts,这里我们就不细说查找过程了

export function computed(getterOrOptions) {
  let getter
  let setter

  if (isFunction(getterOrOptions)) {
    getter = getterOrOptions
    setter = NOOP
  } else {
    getter = getterOrOptions.get
    setter = getterOrOptions.set
  }

  let dirty = true
  let value
  let computed

  const runner = effect(getter, {
    lazy: true,
    computed: true,
    scheduler: () => {
      if (!dirty) {
        dirty = true
        trigger(computed, TriggerOpTypes.SET, 'value')
      }
    }
  })
  computed = {
    _isRef: true,
    effect: runner,
    get value() {
      if (dirty) {
        value = runner()
        dirty = false
      }
      track(computed, TrackOpTypes.GET, 'value')
      return value
    },
    set value(newValue: T) {
      setter(newValue)
    }
  }
  return computed
}

我们看看packages\reactivity\src\effect.ts中的effect是怎么写的

export function effect (fn, options) {
  if (isEffect(fn)) {
    fn = fn.raw
  }
  const effect = createReactiveEffect(fn, options)
  if (!options.lazy) {
    effect()
  }
  return effect
}
function createReactiveEffect (fn, options) {
  const effect = function reactiveEffect (...args) {
    return run(effect, fn, args)
  }
  effect._isEffect = true
  effect.active = true
  effect.raw = fn
  effect.deps = []
  effect.options = options
  return effect
}

function run(effect, fn, args) {
  if (!effect.active) {
    return fn(...args)
  }
  if (!effectStack.includes(effect)) {
    cleanup(effect)
    try {
      enableTracking()
      effectStack.push(effect)
      activeEffect = effect
      return fn(...args)
    } finally {
      effectStack.pop()
      resetTracking()
      activeEffect = effectStack[effectStack.length - 1]
    }
  }
}

这里会把effect设置成activeEffect。在此就与上面的getter代码呼应了。

评论

暂无评论