zoukankan      html  css  js  c++  java

  • vue 源码深入学习分析——史上超详细

    2017/6/2 15:27:50 第一次复习

    vue 框架号称五分钟就能上手，半小时就能精通，这是因为其使用非常简单，就像下面一样：
    1. let vm = new Vue({
    2. 	el: '#app',
    3. 	data: {
    4. 		a: 1,
    5. 		b: [1, 2, 3]
    6. 	}
    7. })
    在最开始，我传递了两个选项 el 以及 data ，很简单，官网上也是这样写的。
    你肯定注意到了，我使用了 new 操作符。这就很自然的想到，Vue 就是一个构造函数，vm是 Vue构造函数 生成的实例，我们的配置项是传入构造函数的参数，是一个包括 el 属性 和 data属性的对象，事实上在实例化 Vue 时，传入的选项对象可以包含数据、模板、挂载元素、方法、生命周期钩子等选项。全部的选项可以在 vue的官方API 文档中查看。；

    那么我们下面就要受好奇心的驱动，来看看 Vue构造函数 是什么样的？

    在  ode_modulesvuesrccoreinstanceindex.js 文件里面，是下面的代码：
    1. import { initMixin } from './init'
    2. import { stateMixin } from './state'
    3. import { renderMixin } from './render'
    4. import { eventsMixin } from './events'
    5. import { lifecycleMixin } from './lifecycle'
    6. import { warn } from '../util/index'
    8. function Vue (options) {
    9.   if (process.env.NODE_ENV !== 'production' &&
    10.     !(this instanceof Vue)) {
    11.     warn('Vue is a constructor and should be called with the `new` keyword')
    12.   }
    13.   this._init(options)
    14. }
    16. initMixin(Vue)
    17. stateMixin(Vue)
    18. eventsMixin(Vue)
    19. lifecycleMixin(Vue)
    20. renderMixin(Vue)
    22. export default V
    不用害怕，我带你捋一捋，我们首先关注第8行，我摘抄出来：
    1. function Vue (options) {
    2.   if (process.env.NODE_ENV !== 'production' &&         // 这个 if 判断，是当你不用new操作符来实例化Vue构造函数时，会爆出警告 
    3.     !(this instanceof Vue)) {
    4.     warn('Vue is a constructor and should be called with the `new` keyword')
    5.   }
    6.   this._init(options)    // 主要就是这一句，
    7. }
    发现了吧，Vue 的确是一个构造函数，和你平时使用的 Array, Object 等普普通通的构造函数，没有本质的区别。
    在构造函数里面，我们要关心的是 this._init( options ) , 稍微我会详细的来讲，我们先看  ode_modulesvuesrccoreinstanceindex.js 文件中的第16行~20行：
    1. initMixin(Vue)
    2. stateMixin(Vue)
    3. eventsMixin(Vue)
    4. lifecycleMixin(Vue)
    5. renderMixin(Vue)
    上面的代码调用了五个方法，这五个方法都是把Vue构造函数作为参数传入，其目的都是在  Vue .prototype  上挂载方法或属性，这个概念很好理解，我们在js 的原型链继承的学习中，经常把属性和方法丢到构造函数的原型上作为公有的属性和方法。
    1. // initMixin(Vue)	src/core/instance/init.js **************************************************
    2. Vue.prototype._init = function (options?: Object) {}
    4. // stateMixin(Vue)	src/core/instance/state.js **************************************************
    5. Vue.prototype.$data
    6. Vue.prototype.$set = set
    7. Vue.prototype.$delete = del
    8. Vue.prototype.$watch = function(){}
    10. // renderMixin(Vue)	src/core/instance/render.js **************************************************
    11. Vue.prototype.$nextTick = function (fn: Function) {}
    12. Vue.prototype._render = function (): VNode {}
    13. Vue.prototype._s = _toString
    14. Vue.prototype._v = createTextVNode
    15. Vue.prototype._n = toNumber
    16. Vue.prototype._e = createEmptyVNode
    17. Vue.prototype._q = looseEqual
    18. Vue.prototype._i = looseIndexOf
    19. Vue.prototype._m = function(){}
    20. Vue.prototype._o = function(){}
    21. Vue.prototype._f = function resolveFilter (id) {}
    22. Vue.prototype._l = function(){}
    23. Vue.prototype._t = function(){}
    24. Vue.prototype._b = function(){}
    25. Vue.prototype._k = function(){}
    27. // eventsMixin(Vue)	src/core/instance/events.js **************************************************
    28. Vue.prototype.$on = function (event: string, fn: Function): Component {}
    29. Vue.prototype.$once = function (event: string, fn: Function): Component {}
    30. Vue.prototype.$off = function (event?: string, fn?: Function): Component {}
    31. Vue.prototype.$emit = function (event: string): Component {}
    33. // lifecycleMixin(Vue)	src/core/instance/lifecycle.js **************************************************
    34. Vue.prototype._mount = function(){}
    35. Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {}
    36. Vue.prototype._updateFromParent = function(){}
    37. Vue.prototype.$forceUpdate = function () {}
    38. Vue.prototype.$destroy = function () {}
    经过上面5个方法对Vue构造函数的处理，vm实例上就可以使用这些属性和方法了。其实在其他地方，Vue 构造函数也被处理了：在src/core/index.js 文件中:
    1. import Vue from './instance/index'
    2. import { initGlobalAPI } from './global-api/index'
    3. import { isServerRendering } from 'core/util/env'
    5. initGlobalAPI(Vue)
    7. Object.defineProperty(Vue.prototype, '$isServer', {     //为 Vue.prototype 添加$isServer属性
    8.   get: isServerRendering
    9. })
    11. Vue.version = '__VERSION__'       // 在VUE 身上挂载了 version的静态属性
    13. export default Vue
    initGlobalAPI（） 的作用是在 Vue 构造函数上挂载静态属性和方法，Vue 在经过 initGlobalAPI 之后，会变成这样：
    1. Vue.config
    2. Vue.util = util
    3. Vue.set = set
    4. Vue.delete = del
    5. Vue.nextTick = util.nextTick
    6. Vue.options = {
    7.     components: {
    8.         KeepAlive
    9.     },
    10.     directives: {},
    11.     filters: {},
    12.     _base: Vue
    13. }
    14. Vue.use
    15. Vue.mixin
    16. Vue.cid = 0
    17. Vue.extend
    18. Vue.component = function(){}
    19. Vue.directive = function(){}
    20. Vue.filter = function(){}
    22. Vue.prototype.$isServer
    23. Vue.version = '__VERSION__'
    下一个就是 web-runtime.js 文件了，web-runtime.js 文件主要做了三件事儿：
    1. 1、覆盖 Vue.config 的属性，将其设置为平台特有的一些方法
    2. 2、Vue.options.directives 和 Vue.options.components 安装平台特有的指令和组件
    3. 3、在 Vue.prototype 上定义 __patch__ 和 $mount
    经过 web-runtime.js 文件之后，Vue 变成下面这个样子：
    1. // 安装平台特定的utils
    2. Vue.config.isUnknownElement = isUnknownElement
    3. Vue.config.isReservedTag = isReservedTag
    4. Vue.config.getTagNamespace = getTagNamespace
    5. Vue.config.mustUseProp = mustUseProp
    6. // 安装平台特定的 指令 和 组件
    7. Vue.options = {
    8.     components: {
    9.         KeepAlive,
    10.         Transition,
    11.         TransitionGroup
    12.     },
    13.     directives: {
    14.         model,
    15.         show
    16.     },
    17.     filters: {},
    18.     _base: Vue
    19. }
    20. Vue.prototype.__patch__
    21. Vue.prototype.$mount
    这里要注意的是Vue.options 的变化。
    最后一个处理 Vue 的文件就是入口文件 web-runtime-with-compiler.js 了，该文件做了两件事：
    1、缓存来自 web-runtime.js 文件的 $mount 函数
    1. const mount = Vue.prototype.$mount
    2、在 Vue 上挂载 compile
    1. Vue.compile = compileToFunctions
    上面 compileToFunctions 函数可以将模板 template 编译为render函数。
    至此，我们算是还原了 Vue 构造函数，总结一下：
    1. 1、Vue.prototype 下的属性和方法的挂载主要是在 src/core/instance 目录中的代码处理的
    2. 2、Vue 下的静态属性和方法的挂载主要是在 src/core/global-api 目录下的代码处理的
    3. 3、web-runtime.js 主要是添加web平台特有的配置、组件和指令，web-runtime-with-compiler.js 给Vue的 $mount 方法添加 compiler 编译器，支持 template。

    好了，我们再回过头来看 this._init() 方法，_init() 方法就是Vue调用的第一个方法，然后将我们的参数 options 传了过去。_init() 是在   ode_modulesvuesrccoreinstanceinit.js 文件中被声明的：
    1.  Vue.prototype._init = function (options?: Object) {
    2.     const vm: Component = this
    3.     // a uid
    4.     vm._uid = uid++
    6.     let startTag, endTag
    7.     /* istanbul ignore if */
    8.     if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
    9.       startTag = `vue-perf-init:${vm._uid}`
    10.       endTag = `vue-perf-end:${vm._uid}`
    11.       mark(startTag)
    12.     }
    14.     // a flag to avoid this being observed
    15.     vm._isVue = true
    16.     // merge options
    17.     if (options && options._isComponent) {
    18.       // optimize internal component instantiation
    19.       // since dynamic options merging is pretty slow, and none of the
    20.       // internal component options needs special treatment.
    21.       initInternalComponent(vm, options)
    22.     } else {              // 大部分情况下是走了这个分支，也是vue第一步要做的事情，使用mergeOptions来合并参数选项
    23.       vm.$options = mergeOptions(   
    24.         resolveConstructorOptions(vm.constructor),
    25.         options || {},
    26.         vm
    27.       )
    28.     }
    29.     /* istanbul ignore else */
    30.     if (process.env.NODE_ENV !== 'production') {
    31.       initProxy(vm)
    32.     } else {
    33.       vm._renderProxy = vm
    34.     }
    35.     // expose real self
    36.     vm._self = vm
    37.     initLifecycle(vm)
    38.     initEvents(vm)
    39.     initRender(vm)
    40.     callHook(vm, 'beforeCreate')
    41.     initInjections(vm) // resolve injections before data/props
    42.     initState(vm)
    43.     initProvide(vm) // resolve provide after data/props
    44.     callHook(vm, 'created')
    46.     /* istanbul ignore if */
    47.     if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
    48.       vm._name = formatComponentName(vm, false)
    49.       mark(endTag)
    50.       measure(`${vm._name} init`, startTag, endTag)
    51.     }
    53.     if (vm.$options.el) {
    54.       vm.$mount(vm.$options.el)
    55.     }
    56.   }
    好了，我们一开始不需要关心那么多边边角角，直接从23行代码开始看，因为大部分情况下是走了这条分支，也就是执行了下面的代码：
    1.       vm.$options = mergeOptions(   
    2.         resolveConstructorOptions(vm.constructor),
    3.         options || {},
    4.         vm
    5.       )
    这里是执行了 mergeOptions 函数，并将返回值赋值给 vm.$options  属性。 mergeOptions 函数接受三个参数，分别是 resolveContructorOptions方法,  我们调用 vue 构造函数传入的配置对象（如果没有就是空对象），以及 vm 实例 本身。

    我们先看 resovleContructorOptions 方法， 传入的参数是 vm.constructor 。 vm.constructor 代表的是啥？ const vm: Component = this 人家_init(） 函数第一行就定义了，是指向_init() 函数内部的this， _init( ) 函数是 Vue.prototype上的一个方法，所以在其身上调用的时候，this 指向本身 Vue.prototype， 那么 vm.constructor 也就是指向 Vue 构造函数.
    1. export function resolveConstructorOptions (Ctor: Class<Component>) {   //ctor 就是 VUE 构造函数
    2.   let options = Ctor.options           // vue 构造函数身上的 options 属性
    3.   if (Ctor.super) {                     // 判断是否定义了 Vue.super ，这个是用来处理继承的，我们后续再讲
    4.     const superOptions = resolveConstructorOptions(Ctor.super)
    5.     const cachedSuperOptions = Ctor.superOptions
    6.     if (superOptions !== cachedSuperOptions) {
    7.       // super option changed,
    8.       // need to resolve new options.
    9.       Ctor.superOptions = superOptions
    10.       // check if there are any late-modified/attached options (#4976)
    11.       const modifiedOptions = resolveModifiedOptions(Ctor)
    12.       // update base extend options
    13.       if (modifiedOptions) {
    14.         extend(Ctor.extendOptions, modifiedOptions)
    15.       }
    16.       options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions)
    17.       if (options.name) {
    18.         options.components[options.name] = Ctor
    19.       }
    20.     }
    21.   }
    22.   return options
    23. }
    第22行，resolveConstructorOptions 方法直接返回了 Vue.options。也就是说，传递给 mergeOptions 方法的第一个参数其实是 Vue.options。那么，实际上原来的代码就变成了下面这样：
    1.      
    2.    // 这是原来的代码
    3.     vm.$options = mergeOptions(   
    4.         resolveConstructorOptions(vm.constructor),
    5.         options || {},
    6.         vm
    7.       )
    8.    
    9.   
    10.  // 实际上传过去的参数是下面这些
    11.      vm.$options = mergeOptions(
    12.  	// Vue.options
    13.    {
    14.     components: {
    15.         KeepAlive,
    16.         Transition,
    17.         TransitionGroup
    18.     },
    19.     directives: {
    20.         model,
    21.         show
    22.     },
    23.     filters: {},
    24.     _base: Vue
    25. },
    26.   // 调用Vue构造函数时传入的参数选项 options
    27.    {
    28.    	el: '#app',
    29. 	data: {
    30. 		a: 1,
    31. 		b: [1, 2, 3]
    32. 	}
    33.    },
    34.    // this
    35.    vm
    36.  )
    为什么要使用 mergeOptions 方法呢？ 是为了 合并策略， 对于子组件和父组件如果有相同的属性(option)时要进行合并，相关文章：
    那么我们继续查看 _init() 方法在合并完选项之后，Vue 第二部做的事情就来了：初始化工作与Vue实例对象的设计：





    通过initData 看vue的数据响应系统
    Vue的数据响应系统包含三个部分： Observer 、 Dep 、 Watcher 。我们还是先看一下 initData 中的代码：
    1. function initData (vm: Component) {
    2.   let data = vm.$options.data        // 第一步还是要先拿到数据，vm.$options.data 这时候还是通过 mergeOptions 合并处理后的 mergedInstanceDataFn 函数
    3.   data = vm._data = typeof data === 'function'
    4.     ? data.call(vm)
    5.     : data || {}
    6.   if (!isPlainObject(data)) {
    7.     data = {}
    8.     process.env.NODE_ENV !== 'production' && warn(
    9.       'data functions should return an object:
' +
    10.       'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
    11.       vm
    12.     )
    13.   }
    14.   // proxy data on instance
    15.   const keys = Object.keys(data)
    16.   const props = vm.$options.props
    17.   let i = keys.length
    18.   while (i--) {
    19.     if (props && hasOwn(props, keys[i])) {
    20.       process.env.NODE_ENV !== 'production' && warn(
    21.         `The data property "${keys[i]}" is already declared as a prop. ` +
    22.         `Use prop default value instead.`,
    23.         vm
    24.       )
    25.     } else {
    26.       proxy(vm, keys[i])      // 目的是在实例对象上对数据进行代理，这样我们就能通过 this.a 来访问 data.a 了
    27.     }
    28.   }
    29.   // observe data
    30.   observe(data)
    31.   data.__ob__ && data.__ob__.vmCount++
    32. }
    上面 proxy 方法非常简单，仅仅是在实例对象上设置与 data 属性同名的访问器属性，然后使用 _data 做数据劫持，如下：
    1. function proxy (vm: Component, key: string) {
    2.   if (!isReserved(key)) {
    3.     Object.defineProperty(vm, key, {             // vm是实例，key是data属性上的属性，
    4.       configurable: true,
    5.       enumerable: true,
    6.       get: function proxyGetter () {
    7.         return vm._data[key]
    8.       },
    9.       set: function proxySetter (val) {
    10.         vm._data[key] = val
    11.       }
    12.     })
    13.   }
    14. }
    做完数据的代理，就正式进入响应系统：
    1. observe(data)
    我们说过，数据响应系统主要包含三部分： Observer  、Dep、Watcher，

    我们首先思考，我们应该如何观察一个数据对象的变化？
    vue.js和avalon.js 都是通过 Object.definedProperty() 方法来实现的， 下面我们主要来介绍一下这个方法为什么可以实现对对象属性改变的监听。
    Object.defineProperty ( )有三个参数， 三个参数都需要，分别是对象，属性，属性的属性
    1. var o = {};
    2. Object.definedProperty(o, 'a', { 
    3.    value: 'b'
    4.  })
    属性的属性有下面这些：
    1.     configurable:true | false,
    2.     enumerable:true | false,
    3.     value:任意类型的值,
    4.     writable:true | false
    writable
    该属性的值是否可以修改；如果设置为false，则不能被修改，修改不会报错，只是默默的不修改；
    1. var obj = {}
    2. //第一种情况：writable设置为false，不能重写。
    3. Object.defineProperty(obj,"newKey",{
    4.     value:"hello",
    5.     writable:false
    6. });
    7. //更改newKey的值
    8. obj.newKey = "change value";
    9. console.log( obj.newKey );  //hello
    11. //第二种情况：writable设置为true，可以重写
    12. Object.defineProperty(obj,"newKey",{
    13.     value:"hello",
    14.     writable:true
    15. });
    16. //更改newKey的值
    17. obj.newKey = "change value";
    18. console.log( obj.newKey );  //change value
    enumerable
    是否该属性可以被for……in 或者Object.keys( ) 枚举
    1. var obj = {}
    2. //第一种情况：enumerable设置为false，不能被枚举。
    3. Object.defineProperty(obj,"newKey",{
    4.     value:"hello",
    5.     writable:false,
    6.     enumerable:false
    7. });
    9. //枚举对象的属性
    10. for( var attr in obj ){
    11.     console.log( attr );  
    12. }
    13. //第二种情况：enumerable设置为true，可以被枚举。
    14. Object.defineProperty(obj,"newKey",{
    15.     value:"hello",
    16.     writable:false,
    17.     enumerable:true
    18. });
    20. //枚举对象的属性
    21. for( var attr in obj ){
    22.     console.log( attr );  //newKey
    23. }

    configurable
    是否可以删除目标属性或是否可以再次修改属性的特性（writable, configurable, enumerable）。设置为true可以被删除或可以重新设置特性；设置为false，不能被可以被删除或不可以重新设置特性。默认为false。
    这个属性起到两个作用：
     1、 目标属性是否可以使用delete删除
     2、目标属性是否可以再次设置特性
    1. //-----------------测试目标属性是否能被删除------------------------
    2. var obj = {}
    3. //第一种情况：configurable设置为false，不能被删除。
    4. Object.defineProperty(obj,"newKey",{
    5.     value:"hello",
    6.     writable:false,
    7.     enumerable:false,
    8.     configurable:false
    9. });
    10. //删除属性
    11. delete obj.newKey;                   //可以用delete 关键字来删除某一个对象上的属性
    12. console.log( obj.newKey ); //hello
    14. //第二种情况：configurable设置为true，可以被删除。
    15. Object.defineProperty(obj,"newKey",{
    16.     value:"hello",
    17.     writable:false,
    18.     enumerable:false,
    19.     configurable:true
    20. });
    21. //删除属性
    22. delete obj.newKey;
    23. console.log( obj.newKey ); //undefined
    25. //-----------------测试是否可以再次修改特性------------------------
    26. var obj = {}
    27. //第一种情况：configurable设置为false，不能再次修改特性。
    28. Object.defineProperty(obj,"newKey",{
    29.     value:"hello",
    30.     writable:false,
    31.     enumerable:false,
    32.     configurable:false
    33. });
    35. //重新修改特性
    36. Object.defineProperty(obj,"newKey",{
    37.     value:"hello",
    38.     writable:true,
    39.     enumerable:true,
    40.     configurable:true
    41. });
    42. console.log( obj.newKey ); //报错：Uncaught TypeError: Cannot redefine property: newKey
    44. //第二种情况：configurable设置为true，可以再次修改特性。
    45. Object.defineProperty(obj,"newKey",{
    46.     value:"hello",
    47.     writable:false,
    48.     enumerable:false,
    49.     configurable:true
    50. });
    52. //重新修改特性
    53. Object.defineProperty(obj,"newKey",{
    54.     value:"hello",
    55.     writable:true,
    56.     enumerable:true,
    57.     configurable:true
    58. });
    59. console.log( obj.newKey ); //hello
    一旦使用 Object.defineProperty 给对象添加属性，那么如果不设置属性的特性，那么configurable、enumerable、writable这些值都为默认的false

    存取器描述：get set
    不能 同时设置访问器 (get 和 set) 和 wriable 或 value，否则会错，就是说想用(get 和 set)，就不能用（wriable 或 value中的任何一个）
    注意：get seｔ是加在对象属性上面的，不是对象上面的；赋值或者修改该对象属性，会分别触发get 和 set 方法；
    正规用法：
    1. var o = {};    // 不能是O.name=" dudu "了
    3. var val = 'dudu';                // o 对象上的属性是其他人家的一个变量
    5. Object.definedProperty(o,'name',{       // Object.definedProperty( ) 方法通过定set get 方法，强行给拉郎配
    6.   get:function(){ return val };           //get: return val           把人家变量给返回了，就是人家的人了
    7.   set;function(value){ val = value }       //set: val = value         把人家变量赋值为传进来的参数，就是人间人了
    8. })
    实验性代码：
    1. var O = {}；
    3. Object.definedProperty(o,"name",{
    4.   set:function(){console.log('set')};   //在获取对象该属性的时候触发，
    5.   get:function(){console.log('get')};   // 在设置对象该属性的时候触发 ， 并不会真正的设置；因为冲突了value，默认是falue
    6. })

    所以，你看到这里，基本上就能够明白，通过Object.defineProperty（）来重写对象的get, set 方法，就可以在对象属性被访问和修改的时候获知 ，从而触发响应的回调函数，但是同一个数据属性，很可能有多个 watcher 来订阅的 ，所触发的回调函数可能有很多，不可能都写在 get set 里面，我们更希望更通过这样的方式：
    1. var data = {
    2.     a: 1,
    3.     b: {
    4.         c: 2
    5.     }
    6. }
    8. observer(data)           // 在这里遍历改写了get,set 
    10. new Watch('a', () => {
    11.     alert(9)
    12. })
    13. new Watch('a', () => {
    14.     alert(90)
    15. })
    16. new Watch('b.c', () => {
    17.     alert(80)
    18. })
    现在的问题是， Watch 构造函数要怎么写？
    在 Watch 构造函数里面，我们已经可以获取到 data，当我们访问的时候，就会触发 data 的改写的get 方法：
    1. class Watch {
    2.   constructor (exp, fn) {
    3.     // ……
    4.     data[exp]      // 触发了data 身上的get 方法
    5.  }
    6. }
    当我们每实例化一个 Watch来订阅data上的a属性  ， data.a 上的get 方法就会被触发一次， data.a 就多了一个订阅器。那么问题来了，这么多的订阅器watcher，我们肯定希望放在一个数组上进行管理，同时我们还希望有，向数组中 push 新的订阅器watcher的方法,  逐个触发数组中各个watcher的方法等等。这样，我们的data 上的每一个属性，它都有一个数组来放订阅器，都有相应的方法来操作这个数组。根据面向对象中的思想，我们可以把这个数组和操作数组的方法放进一个对象中, 这个对象就叫dep吧 ：
    1. dep {
    2.   subs: [watcher1,watcher2,watcher3],     // subs 属性是一个数组，用来维护众多订阅器
    3.   addSubs: function(){ this.subs.push( …… ) },  
    4.   notify: function() { 
    5.     for(let i = 0; i< this.subs.length; i++){
    6.          this.subs[i].fn()
    7.       }
    8.    }
    9. }
    dep 对象我们希望用构造函数来生成，这样会比较方便：
    1. class Dep {
    2.     constructor () {
    3.         this.subs = []
    4.     }
    5.     addSub () {
    6.         this.subs.push(……)
    7.     }
    8.     notify () {
    9.         for(let i = 0; i < this.subs.length; i++){
    10.             this.subs[i].fn()
    11.         }
    12.     }
    13. }
    接下来，我们要在每一个data 属性上生成一个dep实例对象：
    1. function defineReactive (data, key, val) {      // 这个函数就是用来重写对象属性的get set 方法
    2.     observer(val)     // 递归的调用从而遍历
    3.     let dep = new Dep()		// 在这里实例化一个dep实例
    4.     Object.defineProperty(data, key, {
    5.         enumerable: true,
    6.         configurable: true,
    7.         get: function () {
    8.             dep.addSub()	       //每当有订阅者订阅，我就新增一个 
    9.             return val
    10.         },
    11.         set: function (newVal) {
    12.             if(val === newVal){
    13.                 return
    14.             }
    15.             observer(newVal)
    16.             dep.notify()	  // 新增
    17.         }
    18.     })
    19. }
    等等，在第8行，执行 dep.addSub ， 我怎么知道是要push 进去哪个 watcher 呢？ 我们需要改写一下 watch 的构造函数：

    1. Dep.target = null   //类似于全局变量的一个东西，用来放 这次实例化的watcher 
    2. function pushTarget(watch){
    3.     Dep.target = watch
    4. }
    6. class Watch {
    7.     constructor (exp, fn) {
    8.         this.exp = exp
    9.         this.fn = fn
    10.         pushTarget(this)   // 让Dep.target赋值为本次实例化的实例
    11.         data[exp]    //紧接着就触发get 方法
    12.     }
    13. }
    被触发的get 方法在下面：
    1.  get: function () {
    2.             dep.addSub()	       //好吧，我又被触发了一次，
    3.             return val
    4.         },
    dep.addSub() 方法的庐山真面目：
    1. class Dep {
    2.     constructor () {
    3.         this.subs = []
    4.     }
    5.     addSub () {
    6.         this.subs.push(Dep.target)
    7.     }
    8.     notify () {
    9.         for(let i = 0; i < this.subs.length; i++){
    10.             this.subs[i].fn()
    11.         }
    12.     }
    13. }
  • 相关阅读:
    使用ueditor实现多图片上传案例——Servlet层（UploadServlet）
    使用ueditor实现多图片上传案例——截取字符串层Util（SubString_text）
    [转载]oracle删除数据后的恢复
    [转载]oracle删除数据后的恢复
    为什么在定义hashcode时要使用31这个数呢？
    为什么在定义hashcode时要使用31这个数呢？
    [转载]hashCode和equals
    [转载]hashCode和equals
    Oracle HINT的用法
    Oracle HINT的用法
  • 原文地址：https://www.cnblogs.com/dujuncheng/p/6934786.html
Copyright © 2011-2022 走看看