const app = new Vue({
    // options 傳入一個(gè)選項(xiàng)obj.這個(gè)obj即對于這個(gè)vue實(shí)例的初始化
  })

  const app = new Vue({
    el: '#app',
    props: {
     a: {
      type: Object,
      default () {
       return {
        key1: 'a',
        key2: {
          a: 'b'
        }
       }
      }
     }
    },
    data: {
     msg1: 'Hello world!',
     arr: {
      arr1: 1
     }
    },
    watch: {
     a (newVal, oldVal) {
      console.log(newVal, oldVal)
     }
    },
    methods: {
     go () {
      console.log('This is simple demo')
     }
    }
  })

// 構(gòu)造函數(shù)
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)
}

// 對Vue這個(gè)class進(jìn)行mixin,即在原型上添加方法
// Vue.prototype.* = function () {}
initMixin(Vue)
stateMixin(Vue)
eventsMixin(Vue)
lifecycleMixin(Vue)
renderMixin(Vue)

// 原型上提供_init方法,新建一個(gè)vue實(shí)例并傳入options參數(shù)
 Vue.prototype._init = function (options?: Object) {
  const vm: Component = this
  // a uid
  vm._uid = uid++

  let startTag, endTag
  // a flag to avoid this being observed
  vm._isVue = true
  // merge options
  if (options && options._isComponent) {
   // optimize internal component instantiation
   // since dynamic options merging is pretty slow, and none of the
   // internal component options needs special treatment.
   initInternalComponent(vm, options)
  } else {
   // 將傳入的這些options選項(xiàng)掛載到vm.$options屬性上
   vm.$options = mergeOptions(
    // components/filter/directive
    resolveConstructorOptions(vm.constructor),
    // this._init()傳入的options
    options || {},
    vm
   )
  }
  /* istanbul ignore else */
  if (process.env.NODE_ENV !== 'production') {
   initProxy(vm)
  } else {
   vm._renderProxy = vm
  }
  // expose real self
  vm._self = vm   // 自身的實(shí)例
  // 接下來所有的操作都是在這個(gè)實(shí)例上添加方法
  initLifecycle(vm) // lifecycle初始化
  initEvents(vm)   // events初始化 vm._events, 主要是提供vm實(shí)例上的$on/$emit/$off/$off等方法
  initRender(vm)   // 初始化渲染函數(shù),在vm上綁定$createElement方法
  callHook(vm, 'beforeCreate') // 鉤子函數(shù)的執(zhí)行, beforeCreate
  initInjections(vm) // resolve injections before data/props
  initState(vm)   // Observe data添加對data的監(jiān)聽, 將data轉(zhuǎn)化為getters/setters
  initProvide(vm) // resolve provide after data/props
  callHook(vm, 'created') // 鉤子函數(shù)的執(zhí)行, created

  // vm掛載的根元素
  if (vm.$options.el) {
   vm.$mount(vm.$options.el)
  }
 }

export function initState (vm: Component) {
 // 首先在vm上初始化一個(gè)_watchers數(shù)組，緩存這個(gè)vm上的所有watcher
 vm._watchers = []
 // 獲取options,包括在new Vue傳入的，同時(shí)還包括了Vue所繼承的options
 const opts = vm.$options
 // 初始化props屬性
 if (opts.props) initProps(vm, opts.props)
 // 初始化methods屬性
 if (opts.methods) initMethods(vm, opts.methods)
 // 初始化data屬性
 if (opts.data) {
  initData(vm)
 } else {
  observe(vm._data = {}, true /* asRootData */)
 }
 // 初始化computed屬性
 if (opts.computed) initComputed(vm, opts.computed)
 // 初始化watch屬性
 if (opts.watch) initWatch(vm, opts.watch)
}

  props: {
   a: {
    type: Object,
    default () {
     return {
      key1: 'a',
      key2: {
        a: 'b'
      }
     }
    }
   }
  }

function initProps (vm: Component, propsOptions: Object) {
 // propsData主要是為了方便測試使用
 const propsData = vm.$options.propsData || {}
 // 新建vm._props對象，可以通過app實(shí)例去訪問
 const props = vm._props = {}
 // cache prop keys so that future props updates can iterate using Array
 // instead of dynamic object key enumeration.
 // 緩存的prop key
 const keys = vm.$options._propKeys = []
 const isRoot = !vm.$parent
 // root instance props should be converted
 observerState.shouldConvert = isRoot
 for (const key in propsOptions) {
  // this._init傳入的options中的props屬性
  keys.push(key)
  // 注意這個(gè)validateProp方法，不僅完成了prop屬性類型驗(yàn)證的，同時(shí)將prop的值都轉(zhuǎn)化為了getter/setter,并返回一個(gè)observer
  const value = validateProp(key, propsOptions, propsData, vm)
  
  // 將這個(gè)key對應(yīng)的值轉(zhuǎn)化為getter/setter
   defineReactive(props, key, value)
  // static props are already proxied on the component's prototype
  // during Vue.extend(). We only need to proxy props defined at
  // instantiation here.
  // 如果在vm這個(gè)實(shí)例上沒有key屬性，那么就通過proxy轉(zhuǎn)化為proxyGetter/proxySetter, 并掛載到vm實(shí)例上，可以通過app._props[key]這種形式去訪問
  if (!(key in vm)) {
   proxy(vm, `_props`, key)
  }
 }
 observerState.shouldConvert = true
}

export function validateProp (
 key: string,
 propOptions: Object,  // $options.props屬性
 propsData: Object,   // $options.propsData屬性
 vm?: Component
): any {
 const prop = propOptions[key]
 // 如果在propsData測試props上沒有緩存的key
 const absent = !hasOwn(propsData, key)
 let value = propsData[key]
 // 處理boolean類型的數(shù)據(jù)
 // handle boolean props
 if (isType(Boolean, prop.type)) {
  if (absent && !hasOwn(prop, 'default')) {
   value = false
  } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
   value = true
  }
 }
 // check default value
 if (value === undefined) {
  // default屬性值，是基本類型還是function
  // getPropsDefaultValue見下面第一段代碼
  value = getPropDefaultValue(vm, prop, key)
  // since the default value is a fresh copy,
  // make sure to observe it.
  const prevShouldConvert = observerState.shouldConvert
  observerState.shouldConvert = true
  // 將value的所有屬性轉(zhuǎn)化為getter/setter形式
  // 并添加value的依賴
  // observe方法的分析見下面第二段代碼
  observe(value)
  observerState.shouldConvert = prevShouldConvert
 }
 if (process.env.NODE_ENV !== 'production') {
  assertProp(prop, key, value, vm, absent)
 }
 return value
}

// 獲取prop的默認(rèn)值
function getPropDefaultValue (vm: ?Component, prop: PropOptions, key: string): any {
 // no default, return undefined
 // 如果沒有default屬性的話，那么就返回undefined
 if (!hasOwn(prop, 'default')) {
  return undefined
 }
 const def = prop.default
 // the raw prop value was also undefined from previous render,
 // return previous default value to avoid unnecessary watcher trigger
 if (vm && vm.$options.propsData &&
  vm.$options.propsData[key] === undefined &&
  vm._props[key] !== undefined) {
  return vm._props[key]
 }
 // call factory function for non-Function types
 // a value is Function if its prototype is function even across different execution context
 // 如果是function 則調(diào)用def.call(vm)
 // 否則就返回default屬性對應(yīng)的值
 return typeof def === 'function' && getType(prop.type) !== 'Function'
  ? def.call(vm)
  : def
}

  props: {
   a: {
    type: Object,
    default () {
     return {
      key1: 'a',
      key2: {
        a: 'b'
      }
     }
    }
   }
  }

export default class Dep { 
 constructor () {
  this.id = uid++
  this.subs = []
 }
 addSub () {...} // 添加訂閱者(依賴)
 removeSub () {...} // 刪除訂閱者(依賴)
 depend () {...} // 檢查當(dāng)前Dep.target是否存在以及判斷這個(gè)watcher已經(jīng)被添加到了相應(yīng)的依賴當(dāng)中，如果沒有則添加訂閱者(依賴)，如果已經(jīng)被添加了那么就不做處理
 notify () {...} // 通知訂閱者(依賴)更新
}

export class Observer {
 value: any;
 dep: Dep;
 vmCount: number; // number of vms that has this object as root $data

 constructor (value: any) {
  this.value = value
  // dep記錄了和這個(gè)value值的相關(guān)依賴
  this.dep = new Dep()
  this.vmCount = 0
  // value其實(shí)就是vm._data, 即在vm._data上添加__ob__屬性
  def(value, '__ob__', this)
  // 如果是數(shù)組
  if (Array.isArray(value)) {
   // 首先判斷是否能使用__proto__屬性
   const augment = hasProto
    ? protoAugment
    : copyAugment
   augment(value, arrayMethods, arrayKeys)
   // 遍歷數(shù)組，并將obj類型的屬性改為getter/setter實(shí)現(xiàn)
   this.observeArray(value)
  } else {
   // 遍歷obj上的屬性，將每個(gè)屬性改為getter/setter實(shí)現(xiàn)
   this.walk(value)
  }
 }

 /**
  * Walk through each property and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 // 將每個(gè)property對應(yīng)的屬性都轉(zhuǎn)化為getter/setters,只能是當(dāng)這個(gè)value的類型為Object時(shí)
 walk (obj: Object) {
  const keys = Object.keys(obj)
  for (let i = 0; i < keys.length; i++) {
   defineReactive(obj, keys[i], obj[keys[i]])
  }
 }

 /**
  * Observe a list of Array items.
  */
 // 監(jiān)聽array中的item
 observeArray (items: Array<any>) {
  for (let i = 0, l = items.length; i < l; i++) {
   observe(items[i])
  }
 }
}

/**
 * Define a reactive property on an Object.
 */
export function defineReactive (
 obj: Object,
 key: string,
 val: any,
 customSetter?: Function
) {
 // 每個(gè)屬性新建一個(gè)dep實(shí)例，管理這個(gè)屬性的依賴
 const dep = new Dep()
  
 // 或者屬性描述符
 const property = Object.getOwnPropertyDescriptor(obj, key)
 // 如果這個(gè)屬性是不可配的，即無法更改
 if (property && property.configurable === false) {
  return
 }

 // cater for pre-defined getter/setters
 const getter = property && property.get
 const setter = property && property.set

 // 遞歸去將val轉(zhuǎn)化為getter/setter
 // childOb將子屬性也轉(zhuǎn)化為Observer
 let childOb = observe(val)
 Object.defineProperty(obj, key, {
  enumerable: true,
  configurable: true,
  // 定義getter -->> reactiveGetter
  get: function reactiveGetter () {
   const value = getter ? getter.call(obj) : val
   // 定義相應(yīng)的依賴
   if (Dep.target) {
    // Dep.target.addDep(this)
    // 即添加watch函數(shù)
    // dep.depend()及調(diào)用了dep.addSub()只不過中間需要判斷是否這個(gè)id的dep已經(jīng)被包含在內(nèi)了
    dep.depend()
    // childOb也添加依賴
    if (childOb) {
     childOb.dep.depend()
    }
    if (Array.isArray(value)) {
     dependArray(value)
    }
   }
   return value
  },
  // 定義setter -->> reactiveSetter
  set: function reactiveSetter (newVal) {
   const value = getter ? getter.call(obj) : val
   /* eslint-disable no-self-compare */
   if (newVal === value || (newVal !== newVal && value !== value)) {
    return
   }
   if (setter) {
    setter.call(obj, newVal)
   } else {
    val = newVal
   }
   // 對得到的新值進(jìn)行observe
   childOb = observe(newVal)
   // 相應(yīng)的依賴進(jìn)行更新
   dep.notify()
  }
 })
}

Dep.target = null
const targetStack = []

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

export function popTarget () {
 Dep.target = targetStack.pop()
}

constructor (
  vm: Component,
  expOrFn: string | Function,
  cb: Function,
  options?: Object
 ) {
  // 緩存這個(gè)實(shí)例vm
  this.vm = vm
  // vm實(shí)例中的_watchers中添加這個(gè)watcher
  vm._watchers.push(this)
  // options
  if (options) {
   this.deep = !!options.deep
   this.user = !!options.user
   this.lazy = !!options.lazy
   this.sync = !!options.sync
  } 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
  ....
  // parse expression for getter
  if (typeof expOrFn === 'function') {
   this.getter = expOrFn
  } else {
   this.getter = parsePath(expOrFn)
   if (!this.getter) {
    this.getter = function () {}
   }
  }
  // 通過get方法去獲取最新的值
  // 如果lazy為true, 初始化的時(shí)候?yàn)閡ndefined
  this.value = this.lazy
   ? undefined
   : this.get()
 }
 get () {...}
 addDep () {...}
 update () {...}
 run () {...}
 evaluate () {...}
 run () {...}

get () {
 // pushTarget即設(shè)置當(dāng)前的需要被執(zhí)行的watcher
  pushTarget(this)
  let value
  const vm = this.vm
  if (this.user) {
   try {
    // $watch(function () {})
    // 調(diào)用this.getter的時(shí)候，觸發(fā)了屬性的getter函數(shù)
    // 在getter中進(jìn)行了依賴的管理
    value = this.getter.call(vm, vm)
    console.log(value)
   } catch (e) {
    handleError(e, vm, `getter for watcher "${this.expression}"`)
   }
  } else {
   // 如果是新建模板函數(shù)，則會動態(tài)計(jì)算模板與data中綁定的變量，這個(gè)時(shí)候就調(diào)用了getter函數(shù)，那么就完成了dep的收集
   // 調(diào)用getter函數(shù)，則同時(shí)會調(diào)用函數(shù)內(nèi)部的getter的函數(shù)，進(jìn)行dep收集工作
   value = this.getter.call(vm, vm)
  }
  // "touch" every property so they are all tracked as
  // dependencies for deep watching
  // 讓每個(gè)屬性都被作為dependencies而tracked, 這樣是為了deep watching
  if (this.deep) {
   traverse(value)
  }
  popTarget()
  this.cleanupDeps()
  return value  
}

  props: {
   a: {
    type: Object,
    default () {
     return {
      key1: 'a',
      key2: {
        a: 'b'
      }
     }
    }
   }
  },
  watch: {
    a (newVal, oldVal) {
      console.log(newVal, oldVal)
    }
  }, 

if (Dep.target) {
  // Dep.target.addDep(this)
  // 即添加watch函數(shù)
  // dep.depend()及調(diào)用了dep.addSub()只不過中間需要判斷是否這個(gè)id的dep已經(jīng)被包含在內(nèi)了
  dep.depend()
  // childOb也添加依賴
  if (childOb) {
   childOb.dep.depend()
  }
  if (Array.isArray(value)) {
   dependArray(value)
  }
 }

 depend () {
  if (Dep.target) {
   // Dep.target為一個(gè)watcher
   Dep.target.addDep(this)
  }
 }

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)
   }
  }
 }

const computedWatcherOptions = { lazy: true }

function initComputed (vm: Component, computed: Object) {
 // 新建_computedWatchers屬性
 const watchers = vm._computedWatchers = Object.create(null)

 for (const key in computed) {
  const userDef = computed[key]
  // 如果computed為funtion，即取這個(gè)function為getter函數(shù)
  // 如果computed為非function.則可以單獨(dú)為這個(gè)屬性定義getter/setter屬性
  let getter = typeof userDef === 'function' ? userDef : userDef.get
  // create internal watcher for the computed property.
  // lazy屬性為true
  // 注意這個(gè)地方傳入的getter參數(shù)
  // 實(shí)例化的過程當(dāng)中不去完成依賴的收集工作
  watchers[key] = new Watcher(vm, getter, noop, computedWatcherOptions)

  // component-defined computed properties are already defined on the
  // component prototype. We only need to define computed properties defined
  // at instantiation here.
  if (!(key in vm)) {
   defineComputed(vm, key, userDef)
  } 
 }
}

function createComputedGetter (key) {
 return function computedGetter () {
  const watcher = this._computedWatchers && this._computedWatchers[key]
  if (watcher) {
   // 是否需要重新計(jì)算
   if (watcher.dirty) {
    watcher.evaluate()
   }
   // 管理依賴
   if (Dep.target) {
    watcher.depend()
   }
   return watcher.value
  }
 }
}