Vue3 源码逐行解析

时间  2020-07-03
标签 vue3 vue 源码 逐行 解析 繁體版
原文   原文链接

Vue3 源码解析

vue3 出来有一段时间了。今天正式开始记录一下 vue 3.0.0-beta 源码学习心得。


本文编写于 2020-06-10，脚手架使用 vite-app 版本 0.20.0，内置 vue 3.0.0-beta.14。javascript

ps: 可能大部分人都不清楚 vue3 的开发api，将源码以前先讲述 使用方法css

环境搭建

最容易搭建 vue3 的方式就是使用做者的 vitehtml

经过 npm 安装前端

$ npm init vite-app <project-name>
  $ cd <project-name>
  $ npm install
  $ npm run dev

也能够经过 yarn 安装vue

$ yarn create vite-app <project-name>
  $ cd <project-name>
  $ yarn
  $ yarn dev

安装的过程当中你可能遇到如下问题（反正本菜遇到了）java

  • 异常1：No valid exports main found for' C:\xxx\xxx\node_ modules\@rollup\pluginutils'
  • 异常2：The engine "node" is incompatible with this module. Expected version ">= 10.16.0". Got "10.15.3

异常1：本菜翻阅了 vite 的 issue，而后 google + baidu 一无所得， 最后发现是由于本菜 node 版本为 13.5.0致使的（版本太高），node

异常2：很明显啦，node 版本过低了。react

最后的解决方式是：本菜经过 nvm 将 node 版本切换到 12.12.0，至于 nvm 没使用过的童鞋们能够去尝试下哦。特别好用webpack

vite 原理解析

当浏览器识别 type="module" 引入js文件的时候，内部的 import 就会发起一个网络请求，尝试去获取这个文件。git

那么就能够经过经过拦截路由 / 和 .js 结尾的请求。而后经过 node 去加载对应的 .js 文件

const fs = require('fs')
    const path = require('path')
    const Koa = require('koa')
    const app = new Koa()

    app.use(async ctx=>{
        const {request:{url} } = ctx
        // 首页
        if(url=='/'){n
            ctx.type="text/html"
            ctx.body = fs.readFileSync('./index.html','utf-8')
        }else if(url.endsWith('.js')){
            // js文件
            const p = path.resolve(__dirname,url.slice(1))
            ctx.type = 'application/javascript'
            const content = fs.readFileSync(p,'utf-8')
            ctx.body = content
        }
    })

    app.listen(3001, ()=>{
        console.log('听我口令，3001端口，起~~')
    })

若是只是简单的代码，这样加载就能够了。彻底是按需加载，比起 webpack 的语法解析性能固然会快很是多。

可是遇到第三方库以上代码就会找不到 .js 文件的位置了，此时 vite 会用 es-module-lexer 把文件解析成 ast，拿到 import 的地址。

经过分析 import 的内容，识别是否是第三方库（这个主要是看前面是否是相对路径）

若是是第三方库就去 node_modules 中查找，vite 中经过在第三方库中添加前缀 /@modules/，而后发现了 /@modules/ 后走 第三方库逻辑

if(url.startsWith('/@modules/')){
        // 这是一个node_module里的东西
        const prefix = path.resolve(__dirname,'node_modules',url.replace('/@modules/',''))
        const module = require(prefix+'/package.json').module
        const p = path.resolve(prefix,module)
        const ret = fs.readFileSync(p,'utf-8')
        ctx.type = 'application/javascript'
        ctx.body = rewriteImport(ret)
    }

这样第三方库也能够解析了。而后是 .vue 单文件解析。

首先 xx.vue 返回的格式大概是这样的

const __script = {
    setup() {
        ...
    }
}
import {render as __render} from "/src/App.vue?type=template&t=1592389791757"
__script.render = __render
export default __script

而后能够用 @vue/compiler-dom 把 html 解析成 render

解析 .css 就更加简单了。经过 document.createElement('style') 而后再注入就行了

参考-大圣 的知乎文章

ps：具体的源码还没看（先搞点 Vue3 吧）

reactive

正式进入正题。

做为 vue2 的使用者最想知道的确定是 vue3 的数据劫持和双向绑定了。在 vue3中，双向绑定和可选项，若是须要使用双向绑定的须要经过 reactive 方法进行数据劫持。

在这以前呢还须要知道一个函数 setup

  • setup 是使用 Composition API 的入口
  • setup 能够返回一个对象，该对象的属性会被合并到渲染上下文，并能够在模板中直接使用
  • setup 也能够返回 render 函数

如今开始写一个简单的 vue

<template>
    <div>
      <div>{{ count }}</div>
      <button @click="increment">count++</button>
    </div>
  </template>

  <script>
    import { reactive } from 'vue'

    export default {
      setup() {
        let count = reactive({
          num: 0
        })

        const increment = () => count.num++

        return {
          count,
          increment
        }
      }
    }
  </script>

emmm。这样点击按钮就能够动态改变 dom 中的 count 值了。

如今开始解读 reactive 源码。

首先找到 reactivity.esm-browser.js 文件，找到 626 行。

function reactive(target) {
  // if trying to observe a readonly proxy, return the readonly version.
  if (target && target.__v_isReadonly) {
      return target;
  }
  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);
}

上面的 __v_isReadonly 实际上是一个 typescript 的枚举值

export const enum ReactiveFlags {
  skip = '__v_skip',
  isReactive = '__v_isReactive',
  isReadonly = '__v_isReadonly',
  raw = '__v_raw',
  reactive = '__v_reactive',
  readonly = '__v_readonly'
}

不一样的枚举值对应了不一样的数据劫持方式，例如 reactive、 shallowReactive 、readonly、 shallowReadonly

而后进入 createReactiveObject 在 649 行，意思就是：建立响应式对象

function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {

    // 略...
    
    // 若是target已经代理了, 返回target
    if (target.__v_raw && !(isReadonly && target.__v_isReactive)) {
        return target;
    }
    // target already has corresponding Proxy
    if (hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) {
        return isReadonly ? target.__v_readonly : target.__v_reactive;
    }
    
    if (!canObserve(target)) {
        return target;
    }

    // 重点...
    // collectionHandlers：对引用类型的劫持, 
    // baseHandlers: 对进行基本类型的劫持
    const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
    def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed);
    return observed;
}

createReactiveObject 作了如下几件事

  1. 防止重复劫持
  2. 只读劫持
  3. 根据不一样类型选择不一样的劫持方式（collectionHandlers 或 baseHandlers）

实现劫持的主要方法是经过 Proxy 方法，（Proxy 使用能够看看阮老师的博客），顺腾摸瓜找到 mutableHandlers 定义的地方。在 338 行

const mutableHandlers = {
    get,
    set,
    deleteProperty,
    has,
    ownKeys
};

// 229行
const get = /*#__PURE__*/ createGetter();

// 251 行
function createGetter(isReadonly = false, shallow = false) {
    return function get(target, key, receiver) {

        // 一些 __v_isReactive、__v_isReadonly、__v_raw的处理
        // 略...

        // 数组操做
        const targetIsArray = isArray(target);
        if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
            return Reflect.get(arrayInstrumentations, key, receiver);
        }
        // 非数组
        const res = Reflect.get(target, key, receiver);
        
        // 其余 调用 track 返回 res 的状况
        // 略...
        
        // 若是可写，那么会调用 track
        !isReadonly && track(target, "get" /* GET */, key);

        // 若是是对象呢。那么递归
        return isObject(res)
            ? isReadonly
                ? // need to lazy access readonly and reactive here to avoid
                    // circular dependency
                    readonly(res)
                : reactive(res)
            : res;
    };
}

mutableHandlers 主要是一个含有 Proxy 各类方法的常量。

get 指向了方法 createGetter, 建立 get 劫持

createGetter 主要作了如下事情

  1. 异常处理
  2. 若是是数组且hasOwn(arrayInstrumentations, key) 则调用 arrayInstrumentations 获取值
  3. 调用 track
  4. 对象迭代 reactive

那么数组的 arrayInstrumentations 是什么呢？ 咱们来到源码的 第 234 行。

const arrayInstrumentations = {};
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
    arrayInstrumentations[key] = function (...args) {
        // 
        const arr = toRaw(this);
        for (let i = 0, l = this.length; i < l; i++) {
            track(arr, "get" /* GET */, i + '');
        }
        // we run the method using the original args first (which may be reactive)
        // 咱们首先 以原始args 运行该方法（多是反应性的）
        const res = arr[key](...args);
        if (res === -1 || res === false) {
            // if that didn't work, run it again using raw values.
            // 若是那不起做用，则使用原始值再次运行它。
            return arr[key](...args.map(toRaw));
        }
        else {
            return res;
        }
    };
});

经过 arrayInstrumentations 获得 hasOwn(arrayInstrumentations, key) 就是指 ['includes', 'indexOf', 'lastIndexOf']

arrayInstrumentations 中仍是调用了 track 方法，那么 track 方法就更加神秘了。来看看它的源码吧？ 源码在 126 行

function track(target, type, key) {
    if (!shouldTrack || activeEffect === undefined) {
        return;
    }
    let depsMap = targetMap.get(target);
    if (!depsMap) {
        targetMap.set(target, (depsMap = new Map()));
    }
    let dep = depsMap.get(key);
    if (!dep) {
        depsMap.set(key, (dep = new Set()));
    }
    if (!dep.has(activeEffect)) {
        dep.add(activeEffect);
        activeEffect.deps.push(dep);
        if ( activeEffect.options.onTrack) {
            activeEffect.options.onTrack({
                effect: activeEffect,
                target,
                type,
                key
            });
        }
    }
}

首先 track 须要 shouldTrack 和 activeEffect 为真。

在不考虑 activeEffect 的状况下。track 所作的事情就是

  1. 建立包含自身的 map
  2. 将 activeEffect 塞到 map 中
  3. 触发 onTrack

而后 activeEffect 又是什么呢？找到 3687 行，这里有个 createReactiveEffect 函数。

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;
}

createReactiveEffect 是在 effect 中被调用的

而 effect 分别在如下地方被使用了

  • trigger 经过 scheduleRun 调用 effect：源码 3756 行

  • mountComponent 经过 setupRenderEffect 调用 effect：源码 6235 行

    • PS 该阶段在 createComponentInstance 以后
  • doWatch 经过 scheduler 调用 effect

先开始讲述 trigget 相关的代码（核心哦）

function trigger(target, type, key, extraInfo) {
    const depsMap = targetMap.get(target);
    
    // 略...

    const effects = new Set();
    const computedRunners = new Set();
    if (type === "clear" /* CLEAR */) {
      // collection being cleared, trigger all effects for target
      depsMap.forEach(dep => {
        addRunners(effects, computedRunners, dep);
      });
    }

    // 略... 
    const run = (effect) => {
      scheduleRun(effect, target, type, key, extraInfo);
    };
    
    computedRunners.forEach(run);
    effects.forEach(run);
  }

trigger 最终是在 set 函数中被使用，源码 3855 行，这个 set 就是数据劫持所用的 set

function set(target, key, value, receiver) {
    value = toRaw(value);
    const oldValue = target[key];
    if (isRef(oldValue) && !isRef(value)) {
        oldValue.value = value;
        return true;
    }
    const hadKey = hasOwn(target, key);
    const result = Reflect.set(target, key, value, receiver);
        {
        const extraInfo = { oldValue, newValue: value };
        if (!hadKey) {
            trigger(target, "add" /* ADD */, key, extraInfo);
        }
        else if (hasChanged(value, oldValue)) {
            trigger(target, "set" /* SET */, key, extraInfo);
        }
        }
    }
    return result;
}

在源码 3900 行中，被 mutableHandlers、readonlyHandlers 等函数中被使用。

还记得吗？ mutableHandlers 是什么？ 能够回到文章开头部分 reactive 源码讲解之初的 createReactiveObject 方法。在经过 Proxy 劫持数据的时候用的就是 mutableHandlers

reactive 总结

因此，这里就成环了。

  1. 其实 effect 才是响应式的核心，在 mountComponent、doWatch、reactive 中被调用。
  2. 由于在 reactive 中 经过 Proxy 实现劫持。
  3. 在 Proxy 劫持set时调用 trigger。
  4. 而后在 targger 中清除收集并触发目标的全部 effects
  5. 最终触发 patch 游戏结束。

最后

  1. 以为有用的请点个赞
  2. 本文内容出自 https://github.com/zhongmeizhi/FED-note
  3. 欢迎关注公众号「前端进阶课」认真学前端，一块儿进阶。回复 全栈 或 Vue 有好礼相送哦

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程