問題：

1.vue的響應(yīng)式原理是怎么實(shí)現(xiàn)的？

2.methods续挟、computed 和 watch 有什么區(qū)別紧卒？

• initState

• 源碼地址：/src/core/instance/state.js

export function initState (vm: Component) {
  vm._watchers = []
  const opts = vm.$options
  //處理props對(duì)象，為props的每個(gè)屬性設(shè)置響應(yīng)式诗祸，并將其代理的vm實(shí)例上
  if (opts.props) initProps(vm, opts.props)
  // 處理methods 對(duì)象跑芳，校驗(yàn)每個(gè)屬性的值是否為函數(shù)轴总，和props屬性對(duì)比進(jìn)行判重處理，最后得到vm[key]= methods[key]
  if (opts.methods) initMethods(vm, opts.methods)
  /*
  做了三件事：
    1.判重處理博个，data對(duì)象上的對(duì)象不能和props怀樟、methods對(duì)象上的屬性相同
    2.代理data對(duì)象上的屬性到vm實(shí)例上
    3.為data對(duì)象上的數(shù)據(jù)設(shè)置響應(yīng)式   
  */
  if (opts.data) {
    initData(vm)
  } else {
    observe(vm._data = {}, true /* asRootData */)
  }
  /*
  做了三件事：
    1.為computed[key]創(chuàng)建watch實(shí)例，默認(rèn)是執(zhí)行
    2.代理computed到vm實(shí)例
    3.判重盆佣，computed中key不能和data往堡、props中的屬性重
  */

  if (opts.computed) initComputed(vm, opts.computed)
  /*
  做了三件事：
    1.處理watch對(duì)象
    2.為每個(gè)watch.key創(chuàng)建watcher實(shí)例，key和watch實(shí)例可能是一對(duì)多的多關(guān)系
    3.如果設(shè)置了immediate共耍，則立即執(zhí)行回調(diào)函數(shù)
  */
  if (opts.watch && opts.watch !== nativeWatch) {
    initWatch(vm, opts.watch)
  }
}

• initProps

• 源碼地址：/src/core/instance/state.js

// 處理props對(duì)象虑灰，為props設(shè)置響應(yīng)式并且代理到vm實(shí)例上
function initProps (vm: Component, propsOptions: Object) {
  const propsData = vm.$options.propsData || {}
  const props = vm._props = {}
  // 緩存props每個(gè)key，性能優(yōu)化
  const keys = vm.$options._propKeys = []
  const isRoot = !vm.$parent

  if (!isRoot) {
    toggleObserving(false)
  }
  // 遍歷props對(duì)象
  for (const key in propsOptions) {
    //緩存key
    keys.push(key)
    // 獲取props[key]的默認(rèn)值
    const value = validateProp(key, propsOptions, propsData, vm)
    // 為props的每個(gè)key設(shè)置數(shù)據(jù)響應(yīng)式
    defineReactive(props, key, value)
    if (!(key in vm)) {
       // 代理vm到實(shí)例上
      proxy(vm, `_props`, key)
    }
  }
  toggleObserving(true)
}

• proxy

• 源碼地址：/src/core/instance/state.js

// 設(shè)置代理痹兜，將 key 代理到 target 上
export function proxy (target: Object, sourceKey: string, key: string) {
  sharedPropertyDefinition.get = function proxyGetter () {
    return this[sourceKey][key]
  }
  sharedPropertyDefinition.set = function proxySetter (val) {
    this[sourceKey][key] = val
  }
  // 攔截對(duì)this.key的訪問
  Object.defineProperty(target, key, sharedPropertyDefinition)
}

• initMethods

• 源碼地址：/src/core/instance/state.js

function initMethods (vm: Component, methods: Object) {
  //獲取props配置項(xiàng)
  const props = vm.$options.props
  //循環(huán)methods對(duì)象
  for (const key in methods) {
    if (process.env.NODE_ENV !== 'production') {
      // 校驗(yàn)methods[key]必須是一個(gè)函數(shù)
      if (typeof methods[key] !== 'function') {
        warn(
          `Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
          `Did you reference the function correctly?`,
          vm
        )
      }
      // methods中的key不能和props中的key相同
      if (props && hasOwn(props, key)) {
        warn(
          `Method "${key}" has already been defined as a prop.`,
          vm
        )
      }
      if ((key in vm) && isReserved(key)) {
        warn(
          `Method "${key}" conflicts with an existing Vue instance method. ` +
          `Avoid defining component methods that start with _ or $.`
        )
      }
    }
    //將methods中的方法賦值到veu實(shí)例上
    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm)
  }
}

• initData

• 源碼地址：/src/core/instance/state.js

/**
 * 做了三件事
 *   1穆咐、判重處理，data 對(duì)象上的屬性不能和 props佃蚜、methods 對(duì)象上的屬性相同
 *   2庸娱、代理 data 對(duì)象上的屬性到 vm 實(shí)例
 *   3、為 data 對(duì)象的上數(shù)據(jù)設(shè)置響應(yīng)式 
 */
function initData (vm: Component) {
  //獲取vue實(shí)例對(duì)象data的屬性
  let data = vm.$options.data
  data = vm._data = typeof data === 'function'
    ? getData(data, vm)
    : data || {}
  if (!isPlainObject(data)) {
    data = {}
    process.env.NODE_ENV !== 'production' && warn(
      'data functions should return an object:\n' +
      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
      vm
    )
  }
  // 獲取data的key
  const keys = Object.keys(data)
  // 獲取vue實(shí)例props
  const props = vm.$options.props
  //獲取vue實(shí)例methods
  const methods = vm.$options.methods
  let i = keys.length
  // 循環(huán)
  while (i--) {
    // data的key
    const key = keys[i] 
    if (process.env.NODE_ENV !== 'production') {
      // 判斷methods和data是否重復(fù)
      if (methods && hasOwn(methods, key)) {
        warn(
          `Method "${key}" has already been defined as a data property.`,
          vm
        )
      }
    }
     // 判斷methods和data是否重復(fù)
    if (props && hasOwn(props, key)) {
      process.env.NODE_ENV !== 'production' && warn(
        `The data property "${key}" is already declared as a prop. ` +
        `Use prop default value instead.`,
        vm
      )
    } else if (!isReserved(key)) {
      // 將實(shí)例攔截代理到vm實(shí)例上
      proxy(vm, `_data`, key)
    }
  }
 // 為data對(duì)象上的數(shù)據(jù)設(shè)置響應(yīng)式
  observe(data, true /* asRootData */)
}

• initComputed

• 源碼地址：/src/core/instance/state.js

function initComputed (vm: Component, computed: Object) {
  // $flow-disable-line
  //在vue實(shí)例上創(chuàng)建一個(gè)_computedWatchers實(shí)例對(duì)象
  const watchers = vm._computedWatchers = Object.create(null)
  // computed properties are just getters during SSR
  const isSSR = isServerRendering()
  //循環(huán)computed對(duì)象
  for (const key in computed) {
    //獲取computed屬性值
    const userDef = computed[key] 
    //取到兩種computed的function
    const getter = typeof userDef === 'function' ? userDef : userDef.get
    if (process.env.NODE_ENV !== 'production' && getter == null) {
      warn(
        `Getter is missing for computed property "${key}".`,
        vm
      )
    }

    if (!isSSR) {
      //實(shí)例化一個(gè)watcher谐算，其實(shí)computed的原理就是通過watcher來實(shí)現(xiàn)的
      watchers[key] = new Watcher(
        vm,
        getter || noop,
        noop,
        //配置項(xiàng)熟尉，computed 默認(rèn)是懶執(zhí)行
        computedWatcherOptions
      )
    }

    if (!(key in vm)) {
      defineComputed(vm, key, userDef)
    } else if (process.env.NODE_ENV !== 'production') {
      if (key in vm.$data) {
        warn(`The computed property "${key}" is already defined in data.`, vm)
      } else if (vm.$options.props && key in vm.$options.props) {
        warn(`The computed property "${key}" is already defined as a prop.`, vm)
      }
    }
  }
}
/**
 * 代理 computed 對(duì)象中的 key 到 target（vm）上
 */
export function defineComputed (
  target: any,
  key: string,
  userDef: Object | Function
) {
  const shouldCache = !isServerRendering()
  // 構(gòu)造屬性描述符(get、set)
  if (typeof userDef === 'function') {
    sharedPropertyDefinition.get = shouldCache
      ? createComputedGetter(key)
      : createGetterInvoker(userDef)
    sharedPropertyDefinition.set = noop
  } else {
    sharedPropertyDefinition.get = userDef.get
      ? shouldCache && userDef.cache !== false
        ? createComputedGetter(key)
        : createGetterInvoker(userDef.get)
      : noop
    sharedPropertyDefinition.set = userDef.set || noop
  }
  if (process.env.NODE_ENV !== 'production' &&
      sharedPropertyDefinition.set === noop) {
    sharedPropertyDefinition.set = function () {
      warn(
        `Computed property "${key}" was assigned to but it has no setter.`,
        this
      )
    }
  }
  // 攔截對(duì) target.key 的訪問和設(shè)置
  Object.defineProperty(target, key, sharedPropertyDefinition)
}

function createComputedGetter (key) {
  // computed 屬性值會(huì)緩存的原理也是在這里結(jié)合 watcher.dirty洲脂、watcher.evalaute斤儿、watcher.update 實(shí)現(xiàn)的
  return function computedGetter () {
    // 得到當(dāng)前 key 對(duì)應(yīng)的 watcher
    const watcher = this._computedWatchers && this._computedWatchers[key]
    if (watcher) {
      // 計(jì)算 key 對(duì)應(yīng)的值，通過執(zhí)行 computed.key 的回調(diào)函數(shù)來得到
      // watcher.dirty 屬性就是大家常說的 computed 計(jì)算結(jié)果會(huì)緩存的原理
      // <template>
      //   <div>{{ computedProperty }}</div>
      //   <div>{{ computedProperty }}</div>
      // </template>
      // 像這種情況下恐锦，在頁面的一次渲染中往果，兩個(gè) dom 中的 computedProperty 只有第一個(gè)
      // 會(huì)執(zhí)行 computed.computedProperty 的回調(diào)函數(shù)計(jì)算實(shí)際的值，
      // 即執(zhí)行 watcher.evalaute一铅，而第二個(gè)就不走計(jì)算過程了陕贮，
      // 因?yàn)樯弦淮螆?zhí)行 watcher.evalute 時(shí)把 watcher.dirty 置為了 false，
      // 待頁面更新后潘飘，wathcer.update 方法會(huì)將 watcher.dirty 重新置為 true肮之，
      // 供下次頁面更新時(shí)重新計(jì)算 computed.key 的結(jié)果
      if (watcher.dirty) {
        watcher.evaluate()
      }
      if (Dep.target) {
        watcher.depend()
      }
      return watcher.value
    }
  }
}
/**
 * 功能同 createComputedGetter 一樣
 */
function createGetterInvoker(fn) {
  return function computedGetter () {
    return fn.call(this, this)
  }

• initWatch

• 源碼地址：/src/core/instance/state.js

/**
 * 處理 watch 對(duì)象的入口，做了兩件事：
 *   1卜录、遍歷 watch 對(duì)象
 *   2戈擒、調(diào)用 createWatcher 函數(shù)
 * @param {*} watch = {
 *   'key1': function(val, oldVal) {},
 *   'key2': 'this.methodName',
 *   'key3': {
 *     handler: function(val, oldVal) {},
 *     deep: true
 *   },
 *   'key4': [
 *     'this.methodNanme',
 *     function handler1() {},
 *     {
 *       handler: function() {},
 *       immediate: true
 *     }
 *   ],
 *   'key.key5' { ... }
 * }
 */
function initWatch (vm: Component, watch: Object) {
  // 遍歷 watch 對(duì)象
  for (const key in watch) {
    const handler = watch[key]
    if (Array.isArray(handler)) {
      // handler 為數(shù)組，遍歷數(shù)組艰毒，獲取其中的每一項(xiàng)筐高，然后調(diào)用 createWatcher
      for (let i = 0; i < handler.length; i++) {
        createWatcher(vm, key, handler[i])
      }
    } else {
      createWatcher(vm, key, handler)
    }
  }
}
  
/**
 * 兩件事：
 *   1、兼容性處理，保證 handler 肯定是一個(gè)函數(shù)
 *   2柑土、調(diào)用 $watch 
 * @returns 
 */
function createWatcher (
  vm: Component,
  expOrFn: string | Function,
  handler: any,
  options?: Object
) {
  //判斷是不是一個(gè)對(duì)象蜀肘，如果是從hander獲取函數(shù)
  if (isPlainObject(handler)) {
    options = handler
    handler = handler.handler
  }
  //如果是個(gè)字符串就從methods中找對(duì)應(yīng)的方法
  if (typeof handler === 'string') {
    handler = vm[handler]
  }
  return vm.$watch(expOrFn, handler, options)
}


/**
 * 創(chuàng)建 watcher，返回 unwatch稽屏，共完成如下 5 件事：
 *   1幌缝、兼容性處理，保證最后 new Watcher 時(shí)的 cb 為函數(shù)
 *   2诫欠、標(biāo)示用戶 watcher
 *   3、創(chuàng)建 watcher 實(shí)例
 *   4浴栽、如果設(shè)置了 immediate荒叼，則立即執(zhí)行一次 cb
 *   5、返回 unwatch
 * @param {*} expOrFn key
 * @param {*} cb 回調(diào)函數(shù)
 * @param {*} options 配置項(xiàng)典鸡，用戶直接調(diào)用 this.$watch 時(shí)可能會(huì)傳遞一個(gè) 配置項(xiàng)
 * @returns 返回 unwatch 函數(shù)被廓，用于取消 watch 監(jiān)聽
 */
Vue.prototype.$watch = function (
  expOrFn: string | Function,
  cb: any,
  options?: Object
): Function {
  const vm: Component = this
  // 兼容性處理，因?yàn)橛脩粽{(diào)用 vm.$watch 時(shí)設(shè)置的 cb 可能是對(duì)象
  if (isPlainObject(cb)) {
    return createWatcher(vm, expOrFn, cb, options)
  }
  // options.user 表示用戶 watcher萝玷，還有渲染 watcher嫁乘，即 updateComponent 方法中實(shí)例化的 watcher
  options = options || {}
  options.user = true
  // 創(chuàng)建 watcher
  const watcher = new Watcher(vm, expOrFn, cb, options)
  // 如果用戶設(shè)置了 immediate 為 true，則立即執(zhí)行一次回調(diào)函數(shù)
  if (options.immediate) {
    try {
      cb.call(vm, watcher.value)
    } catch (error) {
      handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`)
    }
  }
  // 返回一個(gè) unwatch 函數(shù)球碉，用于解除監(jiān)聽
  return function unwatchFn () {
    watcher.teardown()
  }
}

• observe

• 源碼地址：/src/core/observer/index.js

/**
 * 響應(yīng)式處理的真正入口
 * 為對(duì)象創(chuàng)建觀察者實(shí)例蜓斧，如果對(duì)象已經(jīng)被觀察過，則返回已有的觀察者實(shí)例睁冬，否則創(chuàng)建新的觀察者實(shí)例
 * @param {*} value 對(duì)象 => {}
 */
export function observe (value: any, asRootData: ?boolean): Observer | void {
  //判斷穿件里的value是不是對(duì)象 不是對(duì)象直接停止
  if (!isObject(value) || value instanceof VNode) {
    return
  }
  let ob: Observer | void
  //判斷這個(gè)value有沒有 '_ob_'這個(gè)屬性，如果有就表示已經(jīng)經(jīng)過響應(yīng)式處理了
  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
  ) {
    //實(shí)例化一個(gè)observer豆拨，進(jìn)行響應(yīng)式處理
    ob = new Observer(value)
  }
  if (asRootData && ob) {
    ob.vmCount++
  }
  return ob
}

• Observer

• 源碼地址：/src/core/observer/index.js

/**
 * 觀察者類，會(huì)被附加到每個(gè)被觀察的對(duì)象上脚线，value.__ob__ = this
 * 而對(duì)象的各個(gè)屬性則會(huì)被轉(zhuǎn)換成 getter/setter，并收集依賴和通知更新
 */
export class Observer {
  value: any;
  dep: Dep;
  vmCount: number; 

  constructor (value: any) {
    this.value = value
    //實(shí)例化一個(gè)dep
    this.dep = new Dep()
    this.vmCount = 0
    //在value對(duì)象上設(shè)置_ob_屬性
    def(value, '__ob__', this)
   
    if (Array.isArray(value)) {
     /**
       * 處理數(shù)組響應(yīng)式
       * value 為數(shù)組
       * hasProto = '__proto__' in {}
       * 用于判斷對(duì)象是否存在 __proto__ 屬性邮绿，通過 obj.__proto__ 可以訪問對(duì)象的原型鏈
       * 但由于 __proto__ 不是標(biāo)準(zhǔn)屬性拓巧，所以有些瀏覽器不支持，比如 IE6-10肛度，Opera10.1
       * 為什么要判斷，是因?yàn)橐粫?huì)兒要通過 __proto__ 操作數(shù)據(jù)的原型鏈
       * 覆蓋數(shù)組默認(rèn)的七個(gè)原型方法，以實(shí)現(xiàn)數(shù)組響應(yīng)式
       */

      if (hasProto) {
        protoAugment(value, arrayMethods)
      } else {
        copyAugment(value, arrayMethods, arrayKeys)
      }
      this.observeArray(value)
    } else {
      //處理對(duì)象響應(yīng)式
      this.walk(value)
    }
  }

  /**
   * 遍歷對(duì)象上的key冠骄，為每一個(gè)key設(shè)置響應(yīng)式
   * 僅當(dāng)值為對(duì)象的時(shí)候走這里
   */
  walk (obj: Object) {
    const keys = Object.keys(obj)
    for (let i = 0; i < keys.length; i++) {
      defineReactive(obj, keys[i])
    }
  }

  /**
   *遍歷數(shù)組伪煤，為數(shù)組的每一項(xiàng)設(shè)置觀察，處理數(shù)組元素為對(duì)象的情況
   */
  observeArray (items: Array<any>) {
    for (let i = 0, l = items.length; i < l; i++) {
      observe(items[i])
    }
  }
}

• defineReactive(核心)

• 源碼地址：/src/core/observer/index.js

/**
 * 攔截 obj[key] 的讀取和設(shè)置操作：
 *   1凛辣、在第一次讀取時(shí)收集依賴抱既，比如執(zhí)行 render 函數(shù)生成虛擬 DOM 時(shí)會(huì)有讀取操作
 *   2、在更新時(shí)設(shè)置新值并通知依賴更新
 */
export function defineReactive (
  obj: Object,
  key: string,
  val: any,
  customSetter?: ?Function,
  shallow?: boolean
) {
  // 實(shí)例化 dep扁誓，一個(gè) key 一個(gè) dep
  const dep = new Dep()

  // 獲取 obj[key] 的屬性描述符防泵，發(fā)現(xiàn)它是不可配置對(duì)象的話直接 return
  const property = Object.getOwnPropertyDescriptor(obj, key)
  if (property && property.configurable === false) {
    return
  }

  // 記錄 getter 和 setter，獲取 val 值
  const getter = property && property.get
  const setter = property && property.set
  if ((!getter || setter) && arguments.length === 2) {
    val = obj[key]
  }

  // 遞歸調(diào)用蝗敢，處理 val 即 obj[key] 的值為對(duì)象的情況捷泞，保證對(duì)象中的所有 key 都被觀察
  let childOb = !shallow && observe(val)
  // 響應(yīng)式核心
  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    // get 攔截對(duì) obj[key] 的讀取操作
    get: function reactiveGetter () {
      const value = getter ? getter.call(obj) : val
      /**
       * Dep.target 為 Dep 類的一個(gè)靜態(tài)屬性，值為 watcher寿谴，在實(shí)例化 Watcher 時(shí)會(huì)被設(shè)置
       * 實(shí)例化 Watcher 時(shí)會(huì)執(zhí)行 new Watcher 時(shí)傳遞的回調(diào)函數(shù)（computed 除外锁右，因?yàn)樗鼞袌?zhí)行）
       * 而回調(diào)函數(shù)中如果有 vm.key 的讀取行為，則會(huì)觸發(fā)這里的 讀取 攔截讶泰，進(jìn)行依賴收集
       * 回調(diào)函數(shù)執(zhí)行完以后又會(huì)將 Dep.target 設(shè)置為 null咏瑟，避免這里重復(fù)收集依賴
       */
      if (Dep.target) {
        // 依賴收集，在 dep 中添加 watcher痪署，也在 watcher 中添加 dep
        dep.depend()
        // childOb 表示對(duì)象中嵌套對(duì)象的觀察者對(duì)象码泞，如果存在也對(duì)其進(jìn)行依賴收集
        if (childOb) {
          // 這就是 this.key.chidlKey 被更新時(shí)能觸發(fā)響應(yīng)式更新的原因
          childOb.dep.depend()
          // 如果是 obj[key] 是 數(shù)組，則觸發(fā)數(shù)組響應(yīng)式
          if (Array.isArray(value)) {
            // 為數(shù)組項(xiàng)為對(duì)象的項(xiàng)添加依賴
            dependArray(value)
          }
        }
      }
      return value
    },
    // set 攔截對(duì) obj[key] 的設(shè)置操作
    set: function reactiveSetter (newVal) {
      // 舊的 obj[key]
      const value = getter ? getter.call(obj) : val
      // 如果新老值一樣狼犯，則直接 return浦夷，不跟新更不觸發(fā)響應(yīng)式更新過程
      /* 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()
      }
      // setter 不存在說明該屬性是一個(gè)只讀屬性，直接 return
      // #7981: for accessor properties without setter
      if (getter && !setter) return
      // 設(shè)置新值
      if (setter) {
        setter.call(obj, newVal)
      } else {
        val = newVal
      }
      // 對(duì)新值進(jìn)行觀察辜王，讓新值也是響應(yīng)式的
      childOb = !shallow && observe(newVal)
      // 依賴通知更新
      dep.notify()
    }
  })
}

• dependArray

• 源碼地址：/src/core/observer/index.js

/**
 * 遍歷每個(gè)數(shù)組元素劈狐，遞歸處理數(shù)組項(xiàng)為對(duì)象的情況肥缔，為其添加依賴
 * 因?yàn)榍懊娴倪f歸階段無法為數(shù)組中的對(duì)象元素添加依賴
 */
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)
    }
  }
}

數(shù)組響應(yīng)式

• 源碼地址：src/core/observer/array.js

/**
 * 定義 arrayMethods 對(duì)象续膳，用于增強(qiáng) Array.prototype
 * 當(dāng)訪問 arrayMethods 對(duì)象上的那七個(gè)方法時(shí)會(huì)被攔截坟岔，以實(shí)現(xiàn)數(shù)組響應(yīng)式
 */
import { def } from '../util/index'

// 備份 數(shù)組 原型對(duì)象
const arrayProto = Array.prototype
// 通過繼承的方式創(chuàng)建新的 arrayMethods
export const arrayMethods = Object.create(arrayProto)

// 操作數(shù)組的七個(gè)方法社付，這七個(gè)方法可以改變數(shù)組自身
const methodsToPatch = [
  'push',
  'pop',
  'shift',
  'unshift',
  'splice',
  'sort',
  'reverse'
]

/**
 * 攔截變異方法并觸發(fā)事件
 */
methodsToPatch.forEach(function (method) {
  // cache original method
  // 緩存原生方法鸥咖，比如 push
  const original = arrayProto[method]
  // def 就是 Object.defineProperty啼辣，攔截 arrayMethods.method 的訪問
  def(arrayMethods, method, function mutator (...args) {
    // 先執(zhí)行原生方法鸥拧，比如 push.apply(this, args)
    const result = original.apply(this, args)
    const ob = this.__ob__
    // 如果 method 是以下三個(gè)之一富弦，說明是新插入了元素
    let inserted
    switch (method) {
      case 'push':
      case 'unshift':
        inserted = args
        break
      case 'splice':
        inserted = args.slice(2)
        break
    }
    // 對(duì)新插入的元素做響應(yīng)式處理
    if (inserted) ob.observeArray(inserted)
    // 通知更新
    ob.dep.notify()
    return result
  })
})

def

• 源碼地址：/src/core/util/lang.js

/**
 * Define a property.
 */
export function def (obj: Object, key: string, val: any, enumerable?: boolean) {
  Object.defineProperty(obj, key, {
    value: val,
    enumerable: !!enumerable,
    writable: true,
    configurable: true
  })
}

protoAugment

• 源碼地址：/src/core/observer/index.js

/**
 * 設(shè)置 target.__proto__ 的原型對(duì)象為 src
 * 比如 數(shù)組對(duì)象，arr.__proto__ = arrayMethods
 */
function protoAugment (target, src: Object) {
  /* eslint-disable no-proto */
  target.__proto__ = src
  /* eslint-enable no-proto */
}

copyAugment

• 源碼地址：/src/core/observer/index.js

/**
 * 在目標(biāo)對(duì)象上定義指定屬性
 * 比如數(shù)組：為數(shù)組對(duì)象定義那七個(gè)方法
 */
function copyAugment (target: Object, src: Object, keys: Array<string>) {
  for (let i = 0, l = keys.length; i < l; i++) {
    const key = keys[i]
    def(target, key, src[key])
  }
}

dep

• 源碼地址：/src/core/observer/dep.js

import type Watcher from './watcher'
import { remove } from '../util/index'
import config from '../config'

let uid = 0

/**
 * 一個(gè) dep 對(duì)應(yīng)一個(gè) obj.key
 * 在讀取響應(yīng)式數(shù)據(jù)時(shí)媳握，負(fù)責(zé)收集依賴蛾找，每個(gè) dep（或者說 obj.key）依賴的 watcher 有哪些
 * 在響應(yīng)式數(shù)據(jù)更新時(shí)打毛，負(fù)責(zé)通知 dep 中那些 watcher 去執(zhí)行 update 方法
 */
export default class Dep {
  static target: ?Watcher;
  id: number;
  subs: Array<Watcher>;

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

  // 在 dep 中添加 watcher
  addSub (sub: Watcher) {
    this.subs.push(sub)
  }

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

  // 像 watcher 中添加 dep
  depend () {
    if (Dep.target) {
      Dep.target.addDep(this)
    }
  }

  /**
   * 通知 dep 中的所有 watcher幻枉，執(zhí)行 watcher.update() 方法
   */
  notify () {
    // stabilize the subscriber list first
    const subs = this.subs.slice()
    if (process.env.NODE_ENV !== 'production' && !config.async) {
      // subs aren't sorted in scheduler if not running async
      // we need to sort them now to make sure they fire in correct
      // order
      subs.sort((a, b) => a.id - b.id)
    }
    // 遍歷 dep 中存儲(chǔ)的 watcher熬甫，執(zhí)行 watcher.update()
    for (let i = 0, l = subs.length; i < l; i++) {
      subs[i].update()
    }
  }
}

/**
 * 當(dāng)前正在執(zhí)行的 watcher椿肩，同一時(shí)間只會(huì)有一個(gè) watcher 在執(zhí)行
 * Dep.target = 當(dāng)前正在執(zhí)行的 watcher
 * 通過調(diào)用 pushTarget 方法完成賦值郑象，調(diào)用 popTarget 方法完成重置（null)
 */
Dep.target = null
const targetStack = []

// 在需要進(jìn)行依賴收集的時(shí)候調(diào)用厂榛，設(shè)置 Dep.target = watcher
export function pushTarget (target: ?Watcher) {
  targetStack.push(target)
  Dep.target = target
}

// 依賴收集結(jié)束調(diào)用噪沙，設(shè)置 Dep.target = null
export function popTarget () {
  targetStack.pop()
  Dep.target = targetStack[targetStack.length - 1]
}

Watcher

• 源碼地址：/src/core/observer/watcher.js

/**
 * 一個(gè)組件一個(gè) watcher（渲染 watcher）或者一個(gè)表達(dá)式一個(gè) watcher（用戶watcher）
 * 當(dāng)數(shù)據(jù)更新時(shí) watcher 會(huì)被觸發(fā)正歼，訪問 this.computedProperty 時(shí)也會(huì)觸發(fā) watcher
 */
export default class Watcher {
  vm: Component;
  expression: string;
  cb: Function;
  id: number;
  deep: boolean;
  user: boolean;
  lazy: boolean;
  sync: boolean;
  dirty: boolean;
  active: boolean;
  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.lazy = !!options.lazy
      this.sync = !!options.sync
      this.before = options.before
    } else {
      this.deep = this.user = this.lazy = this.sync = false
    }
    this.cb = cb
    this.id = ++uid // uid for batching
    this.active = true
    this.dirty = this.lazy // for lazy 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 = function() { return this.xx }
      // 在 this.get 中執(zhí)行 this.getter 時(shí)會(huì)觸發(fā)依賴收集
      // 待后續(xù) this.xx 更新時(shí)就會(huì)觸發(fā)響應(yīng)式
      this.getter = parsePath(expOrFn)
      if (!this.getter) {
        this.getter = noop
        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
        )
      }
    }
    this.value = this.lazy
      ? undefined
      : this.get()
  }

  /**
   * 執(zhí)行 this.getter喜爷，并重新收集依賴
   * this.getter 是實(shí)例化 watcher 時(shí)傳遞的第二個(gè)參數(shù)檩帐，一個(gè)函數(shù)或者字符串湃密，比如：updateComponent 或者 parsePath 返回的讀取 this.xx 屬性值的函數(shù)
   * 為什么要重新收集依賴泛源？
   *   因?yàn)橛|發(fā)更新說明有響應(yīng)式數(shù)據(jù)被更新了达箍，但是被更新的數(shù)據(jù)雖然已經(jīng)經(jīng)過 observe 觀察了缎玫，但是卻沒有進(jìn)行依賴收集解滓，
   *   所以洼裤，在更新頁面時(shí)逸邦，會(huì)重新執(zhí)行一次 render 函數(shù)，執(zhí)行期間會(huì)觸發(fā)讀取操作雷客，這時(shí)候進(jìn)行依賴收集
   */
  get () {
    // 打開 Dep.target搅裙，Dep.target = this
    pushTarget(this)
    // value 為回調(diào)函數(shù)執(zhí)行的結(jié)果
    let value
    const vm = this.vm
    try {
      // 執(zhí)行回調(diào)函數(shù)部逮，比如 updateComponent，進(jìn)入 patch 階段
      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)
      }
      // 關(guān)閉 Dep.target掐禁，Dep.target = null
      popTarget()
      this.cleanupDeps()
    }
    return value
  }

  /**
   * Add a dependency to this directive.
   * 兩件事：
   *   1傅事、添加 dep 給自己（watcher）
   *   2蹭越、添加自己（watcher）到 dep
   */
  addDep (dep: Dep) {
    // 判重响鹃，如果 dep 已經(jīng)存在則不重復(fù)添加
    const id = dep.id
    if (!this.newDepIds.has(id)) {
      // 緩存 dep.id买置，用于判重
      this.newDepIds.add(id)
      // 添加 dep
      this.newDeps.push(dep)
      // 避免在 dep 中重復(fù)添加 watcher，this.depIds 的設(shè)置在 cleanupDeps 方法中
      if (!this.depIds.has(id)) {
        // 添加 watcher 自己到 dep
        dep.addSub(this)
      }
    }
  }

  /**
   * Clean up for dependency collection.
   */
  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
  }

  /**
   * 根據(jù) watcher 配置項(xiàng)脆栋，決定接下來怎么走椿争，一般是 queueWatcher
   */
  update () {
    /* istanbul ignore else */
    if (this.lazy) {
      // 懶執(zhí)行時(shí)走這里秦踪，比如 computed

      // 將 dirty 置為 true椅邓，可以讓 computedGetter 執(zhí)行時(shí)重新計(jì)算 computed 回調(diào)函數(shù)的執(zhí)行結(jié)果
      this.dirty = true
    } else if (this.sync) {
      // 同步執(zhí)行景馁，在使用 vm.$watch 或者 watch 選項(xiàng)時(shí)可以傳一個(gè) sync 選項(xiàng)合住，
      // 當(dāng)為 true 時(shí)在數(shù)據(jù)更新時(shí)該 watcher 就不走異步更新隊(duì)列，直接執(zhí)行 this.run 
      // 方法進(jìn)行更新
      // 這個(gè)屬性在官方文檔中沒有出現(xiàn)
      this.run()
    } else {
      // 更新時(shí)一般都這里笨使，將 watcher 放入 watcher 隊(duì)列
      queueWatcher(this)
    }
  }

  /**
   * 由 刷新隊(duì)列函數(shù) flushSchedulerQueue 調(diào)用硫椰，完成如下幾件事：
   *   1最爬、執(zhí)行實(shí)例化 watcher 傳遞的第二個(gè)參數(shù)爱致，updateComponent 或者 獲取 this.xx 的一個(gè)函數(shù)(parsePath 返回的函數(shù))
   *   2寒随、更新舊值為新值
   *   3妻往、執(zhí)行實(shí)例化 watcher 時(shí)傳遞的第三個(gè)參數(shù)讯泣，比如用戶 watcher 的回調(diào)函數(shù)
   */
  run () {
    if (this.active) {
      // 調(diào)用 this.get 方法
      const value = this.get()
      if (
        value !== this.value ||
        // Deep watchers and watchers on Object/Arrays should fire even
        // when the value is the same, because the value may
        // have mutated.
        isObject(value) ||
        this.deep
      ) {
        // 更新舊值為新值
        const oldValue = this.value
        this.value = value

        if (this.user) {
          // 如果是用戶 watcher好渠，則執(zhí)行用戶傳遞的第三個(gè)參數(shù) —— 回調(diào)函數(shù)拳锚，參數(shù)為 val 和 oldVal
          try {
            this.cb.call(this.vm, value, oldValue)
          } catch (e) {
            handleError(e, this.vm, `callback for watcher "${this.expression}"`)
          }
        } else {
          // 渲染 watcher霍掺，this.cb = noop，一個(gè)空函數(shù)
          this.cb.call(this.vm, value, oldValue)
        }
      }
    }
  }

  /**
   * 懶執(zhí)行的 watcher 會(huì)調(diào)用該方法
   *   比如：computed牙丽，在獲取 vm.computedProperty 的值時(shí)會(huì)調(diào)用該方法
   * 然后執(zhí)行 this.get剩岳，即 watcher 的回調(diào)函數(shù)拍棕，得到返回值
   * this.dirty 被置為 false，作用是頁面在本次渲染中只會(huì)一次 computed.key 的回調(diào)函數(shù)骄噪，
   *   這也是大家常說的 computed 和 methods 區(qū)別之一是 computed 有緩存的原理所在
   * 而頁面更新后會(huì) this.dirty 會(huì)被重新置為 true链蕊，這一步是在 this.update 方法中完成的
   */
  evaluate () {
    this.value = this.get()
    this.dirty = false
  }

  /**
   * Depend on all deps collected by this watcher.
   */
  depend () {
    let i = this.deps.length
    while (i--) {
      this.deps[i].depend()
    }
  }

  /**
   * Remove self from all dependencies' subscriber list.
   */
  teardown () {
    if (this.active) {
      // remove self from vm's watcher list
      // this is a somewhat expensive operation so we skip it
      // if the vm is being destroyed.
      if (!this.vm._isBeingDestroyed) {
        remove(this.vm._watchers, this)
      }
      let i = this.deps.length
      while (i--) {
        this.deps[i].removeSub(this)
      }
      this.active = false
    }
  }
}

總結(jié)：

vue響應(yīng)式原理如何實(shí)現(xiàn)的滔韵？

• 響應(yīng)式原理的核心是通過object.defineProperty 對(duì)數(shù)據(jù)攔截的設(shè)置和訪問實(shí)現(xiàn)陪蜻。
• 響應(yīng)式的數(shù)據(jù)分為兩類：
  • 對(duì)象
    1.循環(huán)遍歷對(duì)象的所有屬性宴卖，為每個(gè)對(duì)象社設(shè)置getter症昏、setter已達(dá)到攔截訪問和設(shè)置的目的肝谭，如果屬性值依舊為對(duì)象攘烛，則遞歸屬性值key設(shè)置getter和setter医寿。
    2.訪問數(shù)據(jù)（obj.key）時(shí)進(jìn)行依賴收集,在dep存儲(chǔ)相關(guān)的watcher蘑斧。
    3.設(shè)置新數(shù)據(jù)時(shí)由dep通知watcher去更新竖瘾。
  • 數(shù)組
    1.增強(qiáng)數(shù)組那七個(gè)可以改變數(shù)組自身的原型方法捕传，然后攔截對(duì)這些方法操作庸论。
    2.添加新數(shù)組時(shí)進(jìn)行響應(yīng)式處理，然后由dep去通知watcher去更新域携。
    3.刪除時(shí)也是由dep去通知watcher更新秀鞭。

vue中的method锋边、computed编曼、watch的區(qū)別灵巧？

• 使用場(chǎng)景：
  methods：一般用于一些較為復(fù)雜的邏輯封裝刻肄。
  computed：一遍用于一些簡(jiǎn)單同步邏輯封裝，計(jì)算出結(jié)果然后展示在模板中卦羡，減小模板的重量绿饵。
  watch：一般用于在數(shù)據(jù)改變執(zhí)行的異步或者開銷較大的操作拟赊。
• 區(qū)別：
  methods VS compuetd：
  1.如果在一次渲染中吸祟，有多個(gè)地方使用了同一個(gè) methods 或 computed 屬性屋匕，methods 會(huì)被執(zhí)行多次借杰，而 computed 的回調(diào)函數(shù)則只會(huì)被執(zhí)行一次蔗衡。
  2.在通過通過閱讀源碼的時(shí)候我們可以知道，在一次渲染中多次調(diào)用computedPropperty逼纸，只會(huì)執(zhí)行第一次的computed的回調(diào)函數(shù)樊展，其他的訪問专缠，都會(huì)返回第一次執(zhí)行結(jié)果。而這其中的實(shí)現(xiàn)原理其實(shí)就是watcher.dirty的屬性來控制的哥力。而methods這是簡(jiǎn)單的調(diào)用吩跋。
  computed VS watch:
  1.通過閱讀源碼我們知道computed和watch本質(zhì)上是沒什么區(qū)別其實(shí)現(xiàn)原理都是通過實(shí)例化一個(gè)watcher去實(shí)現(xiàn)的锌钮。非要說區(qū)別那就兩點(diǎn)：1.使用場(chǎng)景上的區(qū)別梁丘；2.computed是默認(rèn)是懶執(zhí)行（有緩存）氛谜，并且不能改變結(jié)果值漫。
  methods VS watch：
  1.兩者沒有可比性织盼，根本就是兩個(gè)東西悔政。不過在watch中一些較為復(fù)雜的邏輯可以抽離卸載methods中谋国。

補(bǔ)充：

1.vue中的data為什么function不是object芦瘾？

• 因?yàn)榻M件的復(fù)用性，當(dāng)一個(gè)組件被多次復(fù)用的時(shí)候缅糟，每次被實(shí)例化時(shí)都會(huì)返回一份新的數(shù)據(jù)窗宦，為了避免數(shù)據(jù)的污染所以是function赴涵。從js的角度來說object是一個(gè)引用類型數(shù)據(jù)髓窜，里面保存的是內(nèi)存地址欺殿，當(dāng)復(fù)用組件的值發(fā)生了改變那么其他復(fù)用組件的值也會(huì)跟著發(fā)生改變從而導(dǎo)致數(shù)據(jù)污染的問題脖苏。