function observer(value) {

	//給所有傳入進來的data 設置一個__ob__對象 一旦value有__ob__ 說明該value已經(jīng)做了響應式處理
	Object.defineProperty(value, '__ob__', {
		value: this, //當前實例 也就是new observer
		enumerable: false, //不可枚舉  即不可for in
		writable: true, // 可用賦值運算符改寫__ob__
		configurable: true //可改寫可刪除
	})

	//這里是判斷是對象 數(shù)組的話需要改造數(shù)組原型上的方法
	if (Object.prototype.toString.call(value) === "[object Array]") {
		//數(shù)組的話需要改造數(shù)組原型上的方法 下面會講解arrayMethods
		value.__proto__ = arrayMethods;
		//對數(shù)組進行響應式處理
		observeArray(value);
	} else {
		//如果是對象 遍歷對象屬性進行響應式處理
		iterate(value)
	}


}

// 遍歷對象屬性進行響應式處理
function iterate(data) {
	const keys = Object.keys(data);
	keys.forEach((key) => {
		defineReactive(data, key, data[key])
	})
}

//響應式處理 這里是核心
function defineReactive(data, key, value){
	//遞歸對象 這里是因為對象里面仍可能嵌套對象
	observe(value)

	//寫道這里 Object.defineProperty 我們主角出場了
 	// 這里實現(xiàn)了讀寫都能捕捉到，響應式的底層原理
	Object.defineProperty(data, key, {
		get() { 
			console.log('我被成功訪問啦！');
			return value
		},
		set(newValue) { 
			if (newValue === value) return
			console.log("我被變更啦")
			value = newValue
		}
	})
}

function  observeArray(data) { 
	data.forEach(item => { 
		observe(item)
	})
}

function observe(value) {
    // 如果傳進來的是對象或者數(shù)組，則進行響應式處理
    if (Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === "[object Array]") {
        return new Observer(value)
    }
}

function set (target, key, val) {
  //isValidArrayIndex 用來檢測是否合法索引
  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
  }
  //... 
  defineReactive$$1(ob.value, key, val);
  ob.dep.notify();
  return val
}

const arrayProto = Array.prototype
export const arrayMethods = Object.create(arrayProto)

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


methodsToPatch.forEach(method =>{
	// 緩存原來的方法
	def(arrayMethods, method)
})

function def(obj, key) {
	Object.defineProperties(obj, key, {
		enumerable: true,
		configurable: true,
		value: function (...args) {

			//獲取數(shù)組原生方法
			let original = arrayProto[key];

			//改變this指向 
			const result = original.apply(this, args)

			console.log('我被更新了');
			
			//result就是上文的arrayMethods
			return result;
		}
	})
}