依賴收集就是訂閱資料變化watcher的收集，依賴收集的目的是當響應式資料發生變化時，能夠通知相應的訂閱者去處理相關的邏輯。

在上一章，介紹了Vue將普通物件變成響應式物件是利用defineReactive()（定義在'core/observer/index.js'中）函式，defineReactive()函式中主要關注的是新建一個dep = new Dep()，以及在設定屬性的getter時，對其做依賴收集：dep.depend()

export function defineReactive (
  obj: Object,
  key: string,
  val: any,
  customSetter?: ?
 
Function,
  shallow?: boolean
) {
  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)
  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    get: function reactiveGetter () {
      const value = getter 
 
? getter.call(obj) : val
      if (Dep.target) {
        dep.depend()
        if (childOb) {
          childOb.dep.depend()
          if (Array.isArray(value)) {
            dependArray(value)
          }
        }
      }
      return value
},
    set: function reactiveSetter (newVal) {
      const value = getter ? getter.call(obj) : val
      /* eslint-disable no-self-compare */
if (newVal === value || (newVal !== newVal && value !== value)) {
        return
}
      /* eslint-enable no-self-compare */
if (process.env.NODE_ENV !== 'production' && customSetter) {
        customSetter()
      }
      if (setter) {
        setter.call(obj, newVal)
      } else {
        val = newVal
      }
      childOb = !shallow && observe(newVal)
      dep.notify()
    }
  })
}

定義在'core/obersver/dep.js'中的Dep類，主要功能是建立了observer與watcher之間的橋樑。depend()函式的作用是在呼叫Dep.target的addDep（）函式。

這裡的Dep.target是一個靜態屬性，在全域性中唯一儲存著一個Watcher，因為在同一時間應該只有一個Watcher被計算。

export default class Dep {
  static target: ?Watcher;
  id: number;
  subs: Array<Watcher>;

  constructor () {
    this.id = uid++
    this.subs = []
  }

  addSub (sub: Watcher) {
    this.subs.push(sub)
  }

  removeSub (sub: Watcher) {
    remove(this.subs, sub)
  }

  depend () {
    if (Dep.target) {
      Dep.target.addDep(this)
    }
  }

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

在watcher.js中定義了Watcher類，其中的deps和newDeps陣列中儲存了用來儲存watcher的依賴類。

其中的addDep()函式主要是先通過id判斷在新收集的依賴中是否有相同的依賴，沒有的話，將其儲存在newDeps陣列中，然後再判斷在以前儲存的依賴中是否有相同的，沒有則呼叫dep的addSub函式，將依賴的Watcher收集起來。這個過程主要是為了去重。

export default class Watcher {
  vm: Component;
  expression: string;
  cb: Function;
  id: number;
  deep: boolean;
  user: boolean;
  computed: boolean;
  sync: boolean;
  dirty: boolean;
  active: boolean;
  dep: Dep;
  deps: Array<Dep>;
  newDeps: Array<Dep>;
  depIds: SimpleSet;
  newDepIds: SimpleSet;
  before: ?Function;
  getter: Function;
  value: any;

  constructor (
    vm: Component,
    expOrFn: string | Function,
    cb: Function,
    options?: ?Object,
    isRenderWatcher?: boolean
) {
    this.vm = vm
    if (isRenderWatcher) {
      vm._watcher = this
}
    vm._watchers.push(this)
    // options
if (options) {
      this.deep = !!options.deep
      this.user = !!options.user
      this.computed = !!options.computed
      this.sync = !!options.sync
      this.before = options.before
    } else {
      this.deep = this.user = this.computed = this.sync = false
}
    this.cb = cb
    this.id = ++uid // uid for batching
this.active = true
    this.dirty = this.computed // for computed watchers
this.deps = []
    this.newDeps = []
    this.depIds = new Set()
    this.newDepIds = new Set()
    this.expression = process.env.NODE_ENV !== 'production'
? expOrFn.toString()
      : ''
// parse expression for getter
if (typeof expOrFn === 'function') {
      this.getter = expOrFn
    } else {
      this.getter = parsePath(expOrFn)
      if (!this.getter) {
        this.getter = function () {}
        process.env.NODE_ENV !== 'production' && warn(
          `Failed watching path: "${expOrFn}" ` +
'Watcher only accepts simple dot-delimited paths. ' +
'For full control, use a function instead.',
          vm
        )
      }
    }
    if (this.computed) {
      this.value = undefined
      this.dep = new Dep()
    } else {
      this.value = this.get()
    }
  }

  /**
   * Evaluate the getter, and re-collect dependencies.
   */
get () {
    pushTarget(this)
    let value
const vm = this.vm
try {
      value = this.getter.call(vm, vm)
    } catch (e) {
      if (this.user) {
        handleError(e, vm, `getter for watcher "${this.expression}"`)
      } else {
        throw 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
}

  /**
   * Add a dependency to this directive.
   */
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)
      }
    }
  }

以渲染watcher為例說明一下過程。在執行$mount函式的過程中，最後會呼叫mountComponent函式，其中有一段這樣的程式碼。

在例項化Watcher是，將updateComponent函式傳入作為getter。

let updateComponent
/* istanbul ignore if */
if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
  updateComponent = () => {
    const name = vm._name
    const id = vm._uid
    const startTag = `vue-perf-start:${id}`
const endTag = `vue-perf-end:${id}`
mark(startTag)
    const vnode = vm._render()
    mark(endTag)
    measure(`vue ${name} render`, startTag, endTag)

    mark(startTag)
    vm._update(vnode, hydrating)
    mark(endTag)
    measure(`vue ${name} patch`, startTag, endTag)
  }
} else {
  updateComponent = () => {
    vm._update(vm._render(), hydrating)
  }
}

// we set this to vm._watcher inside the watcher's constructor
// since the watcher's initial patch may call $forceUpdate (e.g. inside child
// component's mounted hook), which relies on vm._watcher being already defined
new Watcher(vm, updateComponent, noop, {
  before () {
    if (vm._isMounted) {
      callHook(vm, 'beforeUpdate')
    }
  }
}, true /* isRenderWatcher */)
hydrating = false
// manually mounted instance, call mounted on self
// mounted is called for render-created child components in its inserted hook
if (vm.$vnode == null) {
  vm._isMounted = true
callHook(vm, 'mounted')
}

在watcher中，會呼叫get函式

} else {
  this.value = this.get()
}

可以看到，在get函式中，首先會pushTarget()，這個函式的功能是在將當前執行的Dep.target儲存起來。以便在元件巢狀時能夠恢復上一輪執行的Dep.target。

然後呼叫this.getter.call(vm,vm)，這裡的getter就是updateComponent()函式，於是它會執行render函式。render函式在執行過程中會存在訪問資料的情況，於是就觸發getter。

get () {
  pushTarget(this)
  let value
const vm = this.vm
try {
    value = this.getter.call(vm, vm)
  } catch (e) {
    if (this.user) {
      handleError(e, vm, `getter for watcher "${this.expression}"`)
    } else {
      throw 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
}

export function pushTarget (_target: ?Watcher) {
  if (Dep.target) targetStack.push(Dep.target)
  Dep.target = _target
}

在每個物件的屬性中都持有一個dep，在觸發getter之後，就會呼叫dep.depend( )函式，然後呼叫Dep.target.addDep( )函式，該函式中經過去重判斷之後，呼叫dep.addSub將渲染watcher儲存在subs陣列中。

回到watcher中的get( )函式，在執行完getter之後，還會執行traverse( )函式，這是為了將value中存在的屬性遞迴執行。

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

以及popTarget( )函式，該函式的作用是恢復上一輪執行的Dep.target。

popTarget()

然後執行cleanupDeps( ) 函式。其功能是判斷在新收集的依賴中是否出現在之前的依賴收集中，此前在addDep( ) 函式中也判斷過一次，但那個判斷的目的是為了在deps陣列和newDeps陣列中去重。這次判斷是為了丟掉不需要再監聽的屬性，避免重複觸發渲染。然後再將

this.cleanupDeps()

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

總結

在觸發資料的getter之後，會收集當前執行的watcher儲存在dep的subs陣列中。同時，在watcher類中，儲存了相關的deps和newDeps，用來到達去重的同時，還可以清除不再需要觀察的依賴。