// src/core/instance/index.js
function Vue (options) {
 if (process.env.NODE_ENV !== 'production' &&
 !(this instanceof Vue)
 ) {
 warn('Vue is a constructor and should be called with the `new` keyword')
 }
 this._init(options)
}

// src/core/instance/init.js
Vue.prototype._init = function (options) {
 ...
 // a flag to avoid this being observed
 vm._isVue = true
 // merge options
 // 初始化vm实例的$options
 if (options && options._isComponent) {
  initInternalComponent(vm, options)
 } else {
  vm.$options = mergeOptions(
   resolveConstructorOptions(vm.constructor),
   options || {},
   vm
  )
 }
 ...
 initLifecycle(vm) // 梳理实例的parent、root、children和refs，并初始化一些与生命周期相关的实例属性
 initEvents(vm) // 初始化实例的listeners
 initRender(vm) // 初始化插槽，绑定createElement函数的vm实例
 callHook(vm, 'beforeCreate')
 initInjections(vm) // resolve injections before data/props
 initState(vm)
 initProvide(vm) // resolve provide after data/props
 callHook(vm, 'created')
 
 if (vm.$options.el) {
  vm.$mount(vm.$options.el) // 挂载组件到节点
 }
}

// src/core/instance/state.js
export function initState (vm) {
 vm._watchers = []
 const opts = vm.$options
 if (opts.props) initProps(vm, opts.props)
 if (opts.methods) initMethods(vm, opts.methods)
 if (opts.data) {
 initData(vm)
 } else {
 observe(vm._data = {}, true /* asRootData */)
 }
 if (opts.computed) initComputed(vm, opts.computed)
 if (opts.watch && opts.watch !== nativeWatch) {
 initWatch(vm, opts.watch)
 }
}

function initProps (vm, propsOptions) {
 const propsData = vm.$options.propsData || {}
 const props = vm._props = {}
 // cache prop keys so that future props updates can iterate using Array
 // instead of dynamic object key enumeration.
 const keys = vm.$options._propKeys = []
 const isRoot = !vm.$parent
 // root instance props should be converted
 if (!isRoot) {
 toggleObserving(false)
 }
 for (const key in propsOptions) {
 keys.push(key)
 const value = validateProp(key, propsOptions, propsData, vm)
 ...
 defineReactive(props, key, value)
 if (!(key in vm)) {
  proxy(vm, '_props', key)
 }
 }
 toggleObserving(true)
}

export default {
  ...
  props: {
    item: {
      type: Object,
      default: () => ({})
    }
  }
}

const value = validateProp(key, propsOptions, propsData, vm)

if (!(key in vm)) {
 proxy(vm, '_props', key)
}

function proxy (target, sourceKey, key) {
 sharedPropertyDefinition.get = function proxyGetter () {
  return this[sourceKey][key]
 }
 sharedPropertyDefinition.set = function proxySetter (val) {
  this[sourceKey][key] = val
 }
 Object.defineProperty(target, key, sharedPropertyDefinition)
}

// src/core/observer/index.js
export function defineReactive (
 obj,
 key,
 val,
 customSetter,
 shallow
) {
 const dep = new Dep()

 const property = Object.getOwnPropertyDescriptor(obj, key)
 if (property && property.configurable === false) {
  return
 }

 // cater for pre-defined getter/setters
 const getter = property && property.get
 const setter = property && property.set
 if ((!getter || setter) && arguments.length === 2) {
  val = obj[key]
 }

 let childOb = !shallow && observe(val)
 ...
}

if ((!getter || setter) && arguments.length === 2) {
  val = obj[key]
}

if (getter && !setter) return

let childOb = !shallow && observe(val)

// src/core/observer/index.js
export function observe (value, asRootData) {
 if (!isObject(value) || value instanceof VNode) {
  return
 }
 let ob
 if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
  ob = value.__ob__
 } else if (
  shouldObserve &&
  !isServerRendering() &&
  (Array.isArray(value) || isPlainObject(value)) &&
  Object.isExtensible(value) &&
  !value._isVue
 ) {
  ob = new Observer(value)
 }
 if (asRootData && ob) {
  ob.vmCount++
 }
 return ob
}

// src/core/observer/index.js
export class Observer {
 constructor (value) {
  this.value = value
  this.dep = new Dep()
  this.vmCount = 0
  def(value, '__ob__', this)
  if (Array.isArray(value)) {
   if (hasProto) {
    protoAugment(value, arrayMethods)
   } else {
    copyAugment(value, arrayMethods, arrayKeys)
   }
   this.observeArray(value)
  } else {
   this.walk(value)
  }
 }

 /**
  * Walk through all properties and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 walk (obj) {
  const keys = Object.keys(obj)
  for (let i = 0; i < keys.length; i++) {
   defineReactive(obj, keys[i])
  }
 }

 /**
  * Observe a list of Array items.
  */
 observeArray (items) {
  for (let i = 0, l = items.length; i < l; i++) {
   observe(items[i])
  }
 }
}

// src/core/observer/array.js
const arrayProto = Array.prototype
export const arrayMethods = Object.create(arrayProto)

const methodsToPatch = [
 'push',
 'pop',
 'shift',
 'unshift',
 'splice',
 'sort',
 'reverse'
]

methodsToPatch.forEach(function (method) {
 // cache original method
 const original = arrayProto[method]
 def(arrayMethods, method, function mutator (...args) {
  const result = original.apply(this, args)
  const ob = this.__ob__
  let inserted
  switch (method) {
   case 'push':
   case 'unshift':
    inserted = args
    break
   case 'splice':
    inserted = args.slice(2)
    break
  }
  if (inserted) ob.observeArray(inserted)
  // notify change
  ob.dep.notify()
  return result
 })
})

if (asRootData && ob) {
  ob.vmCount++
}

...
Object.defineProperty(obj, key, {
 enumerable: true,
 configurable: true,
 get: function reactiveGetter () {
  const value = getter "htmlcode">

// src/core/observer/dep.js
export default class Dep {
 static target: "htmlcode">

if (childOb) {
  childOb.dep.depend()
  if (Array.isArray(value)) {
    dependArray(value)
  }
}


这里可能会有疑惑，既然已经调用了 dep.depend ，为什么还要调用 childOb.dep.depend ？两个 dep 之间又有什么关系呢？
其实这两个 dep 的分工是不同的。对于数据的增、删，利用 childOb.dep.notify 来调用观察者方法，而对于数据的修改，则使用的 dep.notify ，这是因为 setter 访问器无法监听到对象数据的添加和删除。举个例子：


const data = {
  arr: [{
    value: 1
  }],
}

data.a = 1; // 无法触发setter
data.arr[1] = {value: 2}; // 无法触发setter
data.arr.push({value: 3}); // 无法触发setter
data.arr = [{value: 4}]; // 可以触发setter


还记得 Observer 构造函数里针对数组类型 value 的响应式转换吗？通过重写 value 原型链，使得对于新插入的数据：


if (inserted) ob.observeArray(inserted)
// notify change
ob.dep.notify()


将其转换为响应式数据，并通过 ob.dep.notify 来调用观察者的方法，而这里的观察者列表就是通过上述的 childOb.dep.depend 来收集的。同样的，为了实现对象新增数据的响应式，我们需要提供相应的 hack 方法，而这就是我们常用的 Vue.set/Vue.delete 。


// src/core/observer/index.js
export function set (target: Array<any> | Object, key: any, val: any): any {
 ...
 if (Array.isArray(target) && isValidArrayIndex(key)) {
  target.length = Math.max(target.length, key)
  target.splice(key, 1, val)
  return val
 }
 if (key in target && !(key in Object.prototype)) {
  target[key] = val
  return val
 }
 const ob = (target: any).__ob__
 if (target._isVue || (ob && ob.vmCount)) {
  process.env.NODE_ENV !== 'production' && warn(
   'Avoid adding reactive properties to a Vue instance or its root $data ' +
   'at runtime - declare it upfront in the data option.'
  )
  return val
 }
 if (!ob) {
  target[key] = val
  return val
 }
 defineReactive(ob.value, key, val)
 ob.dep.notify()
 return val
}



  
判断value是否为数组，如果是，直接调用已经hack过的splice即可。
  
是否已存在key，有的话说明已经是响应式了，直接修改即可。
  
接着判断target.__ob__是否存在，如果没有说明该对象无须深度观察，设置返回当前的值。
  
最后，通过defineReactive来设置新增的key，并调用ob.dep.notify通知到观察者。

现在我们了解了 childOb.dep.depend() 是为了将当前 watcher 收集到 childOb.dep ，以便在增、删数据时能通知到 watcher 。而在 childOb.dep.depend() 之后还有：


if (Array.isArray(value)) {
  dependArray(value)
}




/**
 * Collect dependencies on array elements when the array is touched, since
 * we cannot intercept array element access like property getters.
 */
function dependArray (value: Array<any>) {
 for (let e, i = 0, l = value.length; i < l; i++) {
  e = value[i]
  e && e.__ob__ && e.__ob__.dep.depend()
  if (Array.isArray(e)) {
   dependArray(e)
  }
 }
}


在触发 target[key] 的 getter 时，如果 value 的类型为数组，则递归将其每个元素都调用 __ob__.dep.depend ，这是因为无法拦截数组元素的 getter ，所以将当前 watcher 收集到数组下的所有 __ob__.dep ，这样当其中一个元素触发增、删操作时能通知到观察者。比如：


const data = {
  list: [[{value: 0}]],
};
data.list[0].push({value: 1});


这样在 data.list[0].__ob__.notify 时，才能通知到 watcher 。
target[key] 的 getter 主要作用：
将 Dep.target 收集到闭包中 dep 的观察者列表，以便在 target[key] 的 setter 修改数据时通知观察者
根据情况对数据进行遍历添加 __ob__ ，将 Dep.target 收集到 childOb.dep 的观察者列表，以便在增加/删除数据时能通知到观察者
通过 dependArray 将数组型的 value 递归进行观察者收集，在数组元素发生增、删、改时能通知到观察者
target[key] 的 setter 主要作用是对新数据进行观察，并通过闭包保存到 childOb 变量供 getter 使用，同时调用 dep.notify 通知观察者，在此就不再展开。
Watcher
在前面的篇幅中，我们主要介绍了 defineReactive 来定义响应式数据：通过闭包保存 dep 和 childOb ，在 getter 时来进行观察者的收集，使得在数据修改时能触发 dep.notify 或 childOb.dep.notify 来调用观察者的方法进行更新。但具体是如何进行 watcher 收集的却未做过多解释，现在我们将通过阅读 Watcher 来了解观察者背后的逻辑。


function initComputed (vm: Component, computed: Object) {
 const watchers = vm._computedWatchers = Object.create(null)
 const isSSR = isServerRendering()

 for (const key in computed) {
  const userDef = computed[key]
  const getter = typeof userDef === 'function' "htmlcode">

if (!(key in vm)) {
 defineComputed(vm, key, userDef)
}


defineComputed 主要将 userDef 转化为 getter/setter 访问器，并通过 Object.defineProperty 将 key 设置到 vm 上，使得我们能通过 this[key] 直接访问到计算属性。接下来我们主要看下 userDef 转为 getter 中的 createComputedGetter 函数：


function createComputedGetter (key) {
 return function computedGetter () {
  const watcher = this._computedWatchers && this._computedWatchers[key]
  if (watcher) {
   if (watcher.dirty) {
    watcher.evaluate()
   }
   if (Dep.target) {
    watcher.depend()
   }
   return watcher.value
  }
 }
}


利用闭包保存计算属性的 key ，在 getter 触发时，首先通过 this._computedWatchers[key] 获取到之前保存的 watcher ，如果 watcher.dirty 为 true 时调用 watcher.evaluate (执行 this.get() 求值操作，并将当前 watcher 的 dirty 标记为 false )，我们主要看下 get 操作：


get () {
 pushTarget(this)
 let value
 const vm = this.vm
 try {
  value = this.getter.call(vm, vm)
 } catch (e) {
  ...
 } finally {
  // "touch" every property so they are all tracked as
  // dependencies for deep watching
  if (this.deep) {
   traverse(value)
  }
  popTarget()
  this.cleanupDeps()
 }
 return value
}


可以看到，求值时先执行 pushTarget(this) ，通过查阅 src/core/observer/dep.js ，我们可以看到：


Dep.target = null
const targetStack = []

export function pushTarget (target: "htmlcode">

addDep (dep: Dep) {
 const id = dep.id
 if (!this.newDepIds.has(id)) {
  this.newDepIds.add(id)
  this.newDeps.push(dep)
  if (!this.depIds.has(id)) {
   dep.addSub(this)
  }
 }
}


先判断 newDepIds 是否包含 dep.id ，没有则说明尚未添加过这个 dep ，此时将 dep 和 dep.id 分别加到 newDepIds 和 newDeps 。如果 depIds 不包含 dep.id ，则说明之前未添加过此 dep ，因为是双向添加的(将 dep 添加到 watcher 的同时也需要将 watcher 收集到 dep )，所以需要调用 dep.addSub ，将当前 watcher 添加到新的 dep 的观察者队列。


if (this.deep) {
 traverse(value)
}


再接着根据 this.deep 来调用 traverse 。 traverse 的作用主要是递归遍历触发 value 的 getter ，调用所有元素的 dep.depend() 并过滤重复收集的 dep 。最后调用 popTarget() 将当前 watcher 移出栈，并执行 cleanupDeps ：


cleanupDeps () {
 let i = this.deps.length
 while (i--) {
  const dep = this.deps[i]
  if (!this.newDepIds.has(dep.id)) {
   dep.removeSub(this)
  }
 }
 ...
}


遍历 this.deps ，如果在 newDepIds 中不存在 dep.id ，则说明新的依赖里不包含当前 dep ，需要到 dep 的观察者列表里去移除当前这个 watcher ，之后便是 depIds 和 newDepIds 、 deps 和 newDeps 的值交换，并清空 newDepIds 和 newDeps 。到此完成了对 watcher 的求值操作，同时更新了新的依赖，最后返回 value 即可。
回到 createComputedGetter 接着看：


if (Dep.target) {
 watcher.depend()
}


当执行计算属性的 getter 时，有可能表达式中还有别的计算属性依赖，此时我们需要执行 watcher.depend 将当前 watcher 的 deps 添加到 Dep.target 即可。最后返回求得的 watcher.value 即可。
总的来说我们从 this[key] 触发 watcher 的 get 函数，将当前 watcher 入栈，通过求值表达式将所需要的依赖 dep 收集到 newDepIds 和 newDeps ，并将 watcher 添加到对应 dep 的观察者列表，最后清除无效 dep 并返回求值结果，这样就完成了依赖关系的收集。
Watcher 的更新
以上我们了解了 watcher 的依赖收集和 dep 的观察者收集的基本原理，接下来我们了解下 dep 的数据更新时如何通知 watcher 进行 update 操作。


notify () {
 // stabilize the subscriber list first
 const subs = this.subs.slice()
 for (let i = 0, l = subs.length; i < l; i++) {
  subs[i].update()
 }
}


首先在 dep.notify 时，我们将 this.subs 拷贝出来，防止在 watcher 的 get 时候 subs 发生更新，之后调用 update 方法：


update () {
 /* istanbul ignore else */
 if (this.lazy) {
  this.dirty = true
 } else if (this.sync) {
  this.run()
 } else {
  queueWatcher(this)
 }
}



  
如果是 lazy ，则将其标记为 this.dirty = true ，使得在 this[key] 的 getter 触发时进行 watcher.evaluate 调用计算。
  
如果是 sync 同步操作，则执行 this.run ，调用 this.get 求值和执行回调函数 cb 。
  
否则执行 queueWatcher ，选择合适的位置，将 watcher 加入到队列去执行即可，因为和响应式数据无关，故不再展开。

小结
因为篇幅有限，只对数据绑定的基本原理做了基本的介绍，在这画了一张简单的流程图来帮助理解 Vue 的响应式数据，其中省略了一些 VNode 等不影响理解的逻辑及边界条件，尽可能简化地让流程更加直观：

最后，本着学习的心态，在写作的过程中也零零碎碎的查阅了很多资料，其中难免出现纰漏以及未覆盖到的知识点，如有错误，还请不吝指教。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

                                
                                

                                    Vue,数据绑定 
                                

                                    标签：
                                        
Vue,数据绑定
                                     

                                
极乐门资源网 Design By www.ioogu.com