乐趣区

vue源码解析一初始化流程及数据响应式过程梳理

jiezi

学习目标

vue 源码分析（一）
  1. 掌握源码学习方法
  2. 初始化流程梳理
  3. 深入理解数据响应式过程

配置环境

  1. 首先拷贝源码：git clon https://github.com/vuejs/vue.git
  2. cd ./vue
  3. npm i
  4. 安装 rollup：打包工具
  5. 需要全局安装 npm i -g rollup
  6. 修改 /yuanma-vue/vue/package.json 中 dev 的脚本：添加 –sourcemap
  7. 执行 dev 脚本：npm run dev
  8. 在 examples 中去添加 test 文件

注：打完断点可以进行测试，源码运行流程

源码环境

  "name": "vue",
  "version": "2.6.11",

文件目录

vue
├──dist #发布目录
├──examples #范例，测试代码在这里
├──flow #试代码
├──packages #核心代码之外的独立库
├──scripts #构建脚本
├──src #源码
├──test #ts 类型声明，上面 flow
└──types #对 flow 的类型声明

重点：源码

  src # 源码  
  ├──compiler  # 编辑器相关
  ├──core  # 核心代码
  ├──────components # 通用组建如 keep-alive
  ├──────global-api # 全局 API
  ├──────instance # 构建函数等
  ├──────observer # 响应式相关
  ├──────vdom # 虚拟 DOM 相关
  └──────platforms # 平台独特的代码 代码扩充

dist 中不同命名输出的解释

common：nodejs 打包的语言输出，服务端渲染。vue.common.dev.js 
esm：版本是 webpack 打包用的版本 es6 的模块
umd：universal module definition(通用模块定义)  兼容 common 和 amd 用于浏览器；前端浏览器 

加 runtime 含义的不同
 添加指不包含编译器：体较小；仅包含运行时，（就不可以用字符串模版）运行时必须经过 webpack，因为 webpack 在程序运行之前，提前打包编译，所以会将 template，<p>{{foo}}</p> 等等都预编译成渲染函数，在 webpack 情况下，就不需要编译器
不添加指包含编译器
比如：当我们在 
new Vue({template:'<div></div>' // 这种格式就需要 需要添加编译器 字符串模版})

<!-- <script src="../../dist/vue.js"></script> -->
// 什么没有没有加的，umd 格式 vue.js

vue 源码分析 - 初始化流程

入口文件：

路径：src/platforms/web/entry-runtime-with-compiler.js

// 首先获取到定义的 $mount 方法，并赋值给 mount；
//主要目的是要重写 $mount 方法；还需要执行之前的 mount 方法；
// 所以主要是扩展 $mount 方法 

const mount = Vue.prototype.$mount  
Vue.prototype.$mount = function (el?: string |Element, hydrating?: boolean): Component {  
    **1. 用户传进来的 el 宿主元素 **  
    **2. 处理选项：render/template/el**  
    const options = this.$options  
    if(!options.render){......}else if(el){.....} //** 都是在处理选项  **
    从这里可以看出来，在 vue 处理 render/template/el 的时候的优先级。// 首选判断 render 是否存在
    if (!options.render) { // 当 render 不存在的时候，才会进到里面的选项。// 如果 template 存在，再走 template 的 if 选项, 紧跟着是 else if  
        let template = options.template  
        if (template) {运行编译：将模板为 render 函数}else if (el) {}  
        从而可以得知 优先级为：render> template > el
        }  
    }  
    扩展 $mount 的主要目的是：判断是否需要编译出渲染函数  
    在组件开发的情况下，会有一个 main.js  
    main.js  
    new vue({render(h){return h(App) // 编译根组建 App  
            }  
    }).$mount('#app')
    render 需要配合 $mount 来使用
}
Vue.prototype.$mount 的来源

路径：src/platforms/web/entry-runtime-with-compiler.js 中
import Vue from ‘./runtime/index’
路径 src/platforms/web/runtime/index.js 文件中，目录还是在 web 平台

web 平台运行时的首页需要实现的功能有哪些：**1\. 安装平台 patch 函数，主要是用于初始化和更新两个功能（虚拟 dom、diff）**  
// install platform patch function  
Vue.prototype.\_\_patch\_\_ = inBrowser ? patch : noop  
**2. 实现 $mount 函数 **  
Vue.prototype.$mount = function (...）{  
    el：宿主  
    **$mount 唯一做的一件事：挂载组建 就是将 vnode 转化为 node 可以理解为 vdome 转化为 dome**  
    return mountComponent(this, el, hydrating)  
}

查找 vue 来源

初始化全局的 API

在 src/platforms/web/runtime/index.js 文件中，

import Vue from 'core/index'  
Vue.prototype.$mount = function (）{}  
路径：src/core/index.js  
1. 初始化全局的 API
initGlobalAPI(Vue)  
如：set delete nextTick .... 等等  
具体的定义可以进到 initGlobalAPI 里来看，举例子：在 import {initUse} from './use' 中进入 initUse  
可以看到 Vue.use 方法  
Vue.use 方法，之前疑惑为什么要在，plugin 去定义 install 方法，从源码就可以看到约定的 install
if (typeof plugin.install === 'function') {.....}

在 src/core/index.js 中
import Vue from ‘./instance/index’
initGlobalAPI(Vue)

查找 vue 的引入

路径：/src/core/instance/index.js
这才是 Vue 实例，构造函数声明的位置
在这，构造函数

    function Vue (options) {......  
    // 在这里面做了一件事，是初始化方法  
    this.\_init(options)  
    }  
    // 实现实例方法和属性  
    initMixin(Vue) // 这里做了一次混入，init 方法的声明 \_init()  
    stateMixin(Vue) // 和状态相关的实例方法 $set/$delete/$watch /.....  
    eventsMixin(Vue) // 和事件相关的方法 $on/$off/$once/$emit  
    lifecycleMixin(Vue) // 和生命周期相关的方法  
    renderMixin(Vue) // 渲染相关：声明和实现 $nextTick /\_render
initMixin(Vue) 声明_init

路径：src/core/instance/init.js 

 export function initMixin (Vue(将 vue 进行传入): Class<Component>) {.....  
    // \_init 做一个实例方法：\_init 用下划线的目的是，内部使用  
    Vue.prototype.\_init = function (options（传进来的选项）?: Object) {.....  
       初始化的核心代码在这里 
       // 选项的合并：vue 会有默认选项，和用户传进来的选项，进行合并，比如用户传进来的 el  
       if (options && options.\_isComponent) {.....}            else {.....}  
    }  
}
stateMixin(Vue) // 和状态相关的实例方法 **

路径：src/core/instance/state.js 

 export function stateMixin (Vue: Class<Component>){.....  
//$set  
 Vue.prototype.$set = set  
//$del  
 Vue.prototype.$delete = del  
//$watch  
Vue.prototype.$watch = function (....){....}  
}
lifecycleMixin(Vue) // 和生命周期相关的方法

路径：src/core/instance/lifecycle.js

 export function lifecycleMixin (Vue: Class<Component>) {......  
       // 定义例如 \_update：更新 将虚拟 dome 转化为真实 dome；Vue.prototype.\_update = function (vnode: VNode, hydrating?: boolean) {}  
       .......  
       // 强制更行  
       Vue.prototype.**$forceUpdate**\= function () {  
          const vm: Component = this  
          if (vm.\_watcher) {  
           // 主要就是将所有的 watcher 更新一遍  
            vm.\_watcher.update()}  
       }  
        // 实例销毁  
        Vue.prototype.**$destroy**\= function () {}             ..... 等等  
}
initMixin(Vue) 声明_init 里面完成的事情
nitLifecycle(vm) // $parent $root $children  
initEvents(vm) // 事件监听
initRender(vm) // vm.$slots // vm.$createElement
// 在 beforeCreate 之前，上面的是一个初始准备  
声明周期调用的统一方法是 callHook，这个方法  
callHook(vm, 'beforeCreate') // 去派发注册事件，所以在 beforeCreate 中，是可以访问到上面三个内容的  
initInjections(vm) // resolve injections before data/props   
initState(vm) // 核心：数据初始化  
// 为什么 Injections 会在 Provide 之前去注册？因为继承问题，Injec 可以拿到之前的祖辈的，之后在进行分发下去，这样，Provide 就可以拿到祖辈传过来了，以及在 state 里面注册的数据 
initProvide(vm) // resolve provide after data/props  
callHook(vm, 'created') // 所有数据相关的，都在 beforCreate 和 created 之间，上面三个内容，才会将数据变成响应式。
initLifecycle(vm)

路径：src/core/instance/lifecycle.js 

export function initLifecycle (vm: Component) {.....  
初始化的时候，只有根组建和父组建
}
initEvents(vm)

路径：src/core/instance/events.js 

export function initEvents (vm: Component（当前组建）) {vm.\_events = Object.create(null)  
    vm.\_hasHookEvent = false  
    // init parent attached events  
    // 事件处理 - 谁派发，谁监听；// vm.$options.\_parentListeners：从选项中拿到，在 parent（父级）中去声明的事件监听器  
    const listeners = vm.$options.\_parentListeners // 初始化父组件添加的事件  
    if (listeners) { // 如果父组建注册是事件存在，监听器存在  
        // 子组建就去注册事件  
        updateComponentListeners(vm, listeners)  
    }  
}
initRender(vm)

路径：src/core/instance/render.js 

vm.$slots
vm.$createElement// 在 new Vue 中的“h”

vue 源码分析 - 数据响应式

数据响应式是 MVVM 的特点，vue 数据双向绑定的原理：是利用了 JS 语 言特性 Object.defineProperty()，通过定义对象属性 setter 方法拦截对象属性变更，从而将数值的变化 转换为 UI 的变化。
具体实现是在 Vue 初始化时，会调用 initState，它会初始化 data，props 等
initState(vm)

路径：src/core/instance/state.js 

export function initState (vm: Component) {.....  
    // 判断 data 是否存在  
    if (opts.data) { // 如果 data 存在，走这里，因为要看数据的双向绑定，所以找到 initData  
        initData(vm)  
     } else {observe(vm.\_data = {}, true /\* asRootData \*/)  
     }  
}
当前目录下 -initData(vm)
function initData (vm: Component) {....  
    // 传进来的 data 可能是函数，或者对象，目的是防止数据污染；let data = vm.$options.data  
   data = vm.\_data = typeof data === 'function'  
   ? getData(data, vm)  
   : data || {}  
  
....  
   // 代理、重复判断
   const keys = Object.keys(data)  
   while (i--) {....  
      // 属性和方法不能是重复的判断
      if (process.env.NODE\_ENV !== 'production') {}  
      if (props && hasOwn(props, key)) {}}  
    // 对 data 数据响应式处理  
    observe(data, true /\* asRootData \*/)  
}
对 data 数据响应式处理

observe(data, true /* asRootData */)
路径：src/core/observer/index.js 

export function observe (value: any, asRootData: ?boolean): Observer | void {....  
    // 为传进来的对象 value，创建一个 observer 实例；任何一个对象都伴随一个 observer 实例  
    // 返回一个 observer 实例  
    // 用 observer 实例，来判断类型 以及内部响应式处理  
  
    // 如果做过响应式，那么 \_ob\_ 存在，就直接返回  
    if (hasOwn(value, '\_\_ob\_\_') && value.\_\_ob\_\_ instanceof Observer) {ob = value.\_\_ob\_\_} else if (...）{...}else{...  
       // 如果未处理，就创建一个新的实例 ob 实例  
       ob = new Observer(value)  
     }  
}
new Observer(value)

路径：src/core/observer/index.js 

export class Observer {constructor (value: any) {// 可以理解为小管家：比如在 data 中的数据是对象包对象的存在，data:{obj:{foo:foo}}, 对对象来说，是对对象新             增和删除的通知工作；由小管家来通知的。// 当需要修改 obj 里面的属性，是在肚子里发生的事情，所以需要小管家来进行处理  
       // 如果 obj 是一个数组，选项的删除也是需要小管家  
       // 对象属性变化或者数组元素变化需要小管家通知更新  
       this.dep = new Dep() // 小管家 
    // 判断传入的 value 类型，做相应的处理
       if (Array.isArray(value)) { // 当是 Array 时的处理  
             // 覆盖数组实例的原型  
        }else{  
            // 对象的处理
            this.walk(value)  
       }  
    }  
    walk (obj: Object) {....  
         const keys = Object.keys(obj)  
         // 遍历当前的所有 keys  
         for (let i = 0; i < keys.length; i++) {  
            // 对每个 key 进行拦截  
            defineReactive(obj, keys\[i\])  
         }  
    }  
}
defineReactive
export function defineReactive (  
   obj: Object,  
  key: string,  
  val: any,  
  customSetter?: ?Function,  
  shallow?: boolean  
) {......  
  
    // 大管家 和 key 一对一的关系  
    const dep = new Dep()  
   // 用户自定义一些属性  
   const property = Object.getOwnPropertyDescriptor(obj, key)  
   ..............  
  
  // 核心：递归，如果 val 是对象，则获取一个子 oberser 实例，一个对象就会有一个 observer 实例  
  
  let childOb = !shallow && observe(val)  
  // 做递归处理  
  Object.defineProperty(obj, key, {  
      enumerable: true,  
      configurable: true,  
      get: function reactiveGetter () {  
          // 依赖收集  
          const value = getter ? getter.call(obj) : val  
          // Dep.target 可以理解为 watcher 的实例，每次触发 watcher 实例的时候，会手动触发，get 事件一下获取当前                 值，将实例放在 Dep.target 上；if (Dep.target) {// dep 和 watcher 是 n 对 n 的关系，除了页面渲染 {{name}} 会触发 watcher 以外；还有可能是 computed 或者 w                    atch 触发的事件监听；// 双向添加两者关系  
                dep.depend()  
               // 若存在子 ob  
               if (childOb) {  
               // 把当前的 watcher 和子 ob 中的 dep 建立关系  
               childOb.dep.depend()  
               if (Array.isArray(value)) {dependArray(value)  
               }  
           }  
        }  
        return value  
      },  
      set: function reactiveSetter (newVal) {}}  
}
dep.depend

路径：src/core/observer/dep.js 

depend () {if (Dep.target) {  
    // 执行的是当前 watcher 的 addDep 
    Dep.target.addDep(this)  
    }  
}
Dep.target.addDep

找到 watcher 的 addDep 事件
路径：src/core/observer/watcher.js 

addDep (dep: Dep) { //dep 和 wacter 相互保存的关系  
    const id = dep.id  
    if (!this.newDepIds.has(id)) { // 是否和当前的 dep 建立关系  
        // 没有就创建 dep 和 watcher 的关系  
        this.newDepIds.add(id)  
        this.newDeps.push(dep)  
        if (!this.depIds.has(id)) {  
            // 创建 dep 和 watcher  
            dep.addSub(this)  
        }  
    }  
}
dep.addSub

src/core/observer/dep.js 

export default class Dep {  
    // 往自己的 sub 里面去 push  
    addSub (sub: Watcher) {this.subs.push(sub)  
    }  
}

学习资料：

思维导图 vue 源码解析（一）：https://www.processon.com/vie…
获取 vue 源码项目地址:https://github.com/vuejs/vue
迁出项目: git clone https://github.com/vuejs/vue.git
当前版本号:2.6.11

我写的主要是梳理，初始化流程和响应式过程的一个学习思路。如果有错误，欢迎补充。如果觉得在这里看文档不太清晰，可以去我写的思维导图的地址去看下。
接下来还会整理出源码的其他内容，尽情期待～～～拜拜

退出移动版