深入浅出Vue.js阅读——变化侦测——Array

Array的变化侦测

1. 如何追踪变化

  用自定义的方法去覆盖原生的原型方法：
  使用一个拦截器覆盖Array.prototype,每当使用Array原型上的方法操作数组时，其实执行的方法都是拦截器中提供的，然后在拦截器中使用原生Array的原型方法去操作数组。

2. 拦截器

  拦截器其实就是一个和Array.prototype一样的Object，里面包含的属性一毛一样，只不过这个Object中某些可以改变数组自身内容的方法是我们处理过的。 Array原型上可以改变数组自身内容的方法有7个：push,pop,shift,unshift,splice,sort,reverse。

const arrayProto = Array.prototype;
export const arrayMethods = Object.create(arrayProto);
['push','pop','shift','unshift','splice','sort','reverse'].forEach(function(method){
    //缓存原始方法
    const original = arrayProto[method];
    Object.defineProperty(arrayMethods,method,{
        value:function mutator(...args){
            return original.apply(this,args);
        },
        enumerable:true,
        writable:true,
        configurable:true
    })
})

对以上代码进行解读：
  创建了变量arrayMethods,它继承自Array.prototype，具备其所有功能。
  在arrayMethods上使用Object.defineProperty方法将那些=可以改变数组自身内容的方法进行封装。
  所以在使用数组的原型方法push时，其实调用的是arrayMethods上的push方法，而arrayMethods.push是函数mustator，也就是说，实际上执行的是mustator函数。
  在mustator中执行original(它是原生Array.prototype上的方法)来做它应该做的事。
  可以在mustator函数中发送变化通知。

3. 使用拦截器覆盖Array原型

  拦截器想要生效，就必须去覆盖Array.prototype,但是又不能直接覆盖，会污染全局的Array。只希望拦截操作只针对那些被侦测了变化的数据生效，也就是说希望拦截器只覆盖那些响应式数组的原型。
  而将一个数据转换成响应式的，需要通过Observer，所以我们只需要在Observer中使用拦截器覆盖那些即将被转换成响应式Array类型数据的原型就好了。

export  class Observer{
    constructor(value){
        this.value = value;
        if(Array.isArray(value)){
            value.__proto__ = arrayMethods; //新增
        }else{
            this.walk(value);
        }
    }
}  

  新增代码的作用是将拦截器(加工后具备拦截功能的arrayMethods)赋值给value.__proto__,通过__proto__可以很巧妙地实现覆盖value原型的功能。

4. 将拦截器方法挂载到数组的属性上

  Vue的做法非常的粗暴，如果不能使用__proto__,就直接将arrayMthods身上的这些方法设置到被侦测的数组上：

import {arrayMethods} from './js/array'
// __proto__是否可用
const hasProto = `__proto__` in {}
const arrayKeys = Object.getOwnPropertyNames(arrayMethods) 
export class Observer{
    constructor(value){
        this.value = value;
        if(Array.isArray(value)){
            //修改
            const augment = hasProto ? protoAugment : copyAugment;
            augment(value,arrayMethods,arrayKeys)
        }else{
            this.walk(value)
        }
    }
}

function protoAugment(target,src,keys){
    target.__proto__ = src;
}

function copyAugment(target,src,keys){
    for(let i = 0;i<keys.length;i++){
        const key = keys[i];
        def(target,key,src[key]);
    }
}

  新增hasProto来判断当前浏览器是否支持__proto__，新增copyAugment函数，用来将已经加工了拦截操作的原型方法直接添加到value的属性中。hasProto判断浏览器是否支持__proto__：如果支持，只用protoAugment函数来覆盖原型；如果不支持，调用copyAugment函数将拦截器中的方法挂载到value上。
  在浏览器不支持__propt__的情况下，会在数组上挂载一些方法，当用户使用这些方法时，其实执行的并不是浏览器原生提供的Array.prototype上的方法，而是拦截器中提供的方法。

5. 如何收集依赖

  Array的依赖和Object一样，也在defineReactive中收集:

function defineReactive(data,key,val){
    if(typeof  val === "object") new Observer(val);
    let dep = new Dep();
    Object.defineProperty(data,key,{
        enumerable:true,
        configurable:true,
        get:function(){
            dep.depend();
            
            // 这里收集Array的依据
            
            return val;
        },
        set:function(newVal){
            if(val == newVal){
                return;
            }
            dep.notify()
            val = newVal
        }
    })
}

上面的代码增加了一行注释，就在这个位置上收集Array的依赖
  Array在getter中收集依赖，在拦截器中触发依赖

6. 依赖列表存在哪里？

  Vue.js把Array的依赖存放在Observer中：

export class Observer{
    constructor(value){
        this.value = value;
        
        this.dep = new Dep() //新增dep
        
        if(Array.isArray(value)){
            const augment = hasProto?protoAugment:copyAugment
            augment(value,arrayMethods,arrayKeys)
        }else{
            this.walk(value);
        }
    }
}  

  之所以将依赖保存在Observer实例上，是因为在getter中可以访问到Observer实例，同时在Array拦截器中也可以访问到Observer实例。

7. 收集依赖

  把Dep实例保存在Observer的属性上之后，我们可以在getter中像下面这样访问并收集依赖：

function defineReactive(data,key,val ){
    let childOb = observer(val) //修改
    /* 调用observer，把val当作参数传进去得到一个返回值Observer */
    let dep = new  Dep();
    Object.defineProperty(data,key,{
        enumerable:true,
        configurable:true,
        get:function(){
            dep.depend()
            // \新增
            if(childOb){
                childOb.dep.depend()
            }
        },
        set:function(newVal){
            if(val = newVal){
                return
            }
            dep.notify()
            val = newVal
        }
    })
}
/* 
尝试为value创建一个Observer实例
如果创建成功，直接返回新创建的Observer实例
如果value已经存在一个Observer实例，则直接返回它
*/

export function observer(value,asRootData){
    if(!isObject(value)){
        return;
    }
    let ob;
    if(hasOwn(value,'__ob__')&&value.__ob__ instanceof Observer){
        ob = value.__ob__
    }else{
        ob = new observer()
    }
    return ob;
}

  新增observer函数，它尝试创建一个Observer实例。如果value已经是响应式数据，不需要再次创建Observer实例，直接返回已经创建的Observer实例，避免了重复侦测value变化的问题。
  在defineReactive函数中调用了observer，它把val当作参数传了进去并且拿到一个返回值，那就是Observer实例。
   通过observer得到了数组的Observer实例(childOb),最后通过childOb的dep执行depend方法来收集依赖。
  通过这种方式，我们就可以实现getter中将依赖收集到Observer的实例dep中。

8. 在拦截器中获取Observer实例

  因为Array拦截器是对原型的一种封装，所以可以在拦截器中访问到this(当前正在被操作的数组)。而dep保存在Observer中，所以需要在this上读到Observer的实例：

// 工具函数  
function def(obj,key,val,enumerable){
    Object.defineProperty(obj,key,{
        value:val,
        enumerable:!!enumerable,
        configurable:true,
        writable:true
    })
}

export class Observer{
    constructor(value){
        this.value = value;
        this.dep = new Dep();
        def(value,"__ob__",this);//新增    
        if(Array.isArray(value)){
            const augment = hasProto?protoAugment:copyAugment
            augment(value,arrayMethods,arrayKeys);
        }else{
            this.walk(value)
        }
    }
}

  当value身上被标记了__ob__之后，就可以通过value.__ob__来访问Observer实例。如果是Array拦截器，因为拦截器是原型方法，所以可以直接通过this.__ob__来访问Observer实例：

['push','pop','shift','unshift','splice','sort','reverse'].forEach(function(method){
    // 缓存原始方法
    const original = arrayProto[method];
    Object.defineProperty(arrayMethods,method,{
        value:function mutator(..args){
            const ob = this.__ob__; //新增
        },
        enumerable:true,
        writable:true,
        configurable:true

    })
})

9. 向数组的依赖发送通知

  当侦测到数组发生变化时，会向依赖发送通知。首先要能访问到依赖，只需要在Observer实例中拿到dep属性，然后直接发送通知：

['push','pop','shift','unshift','splice','sort','reverse'].forEach(function(method){
    // 缓存原始方法
    const original = arrayProto[method];
    def(arrayMethods,method,function mutator(..args){
        const result = original.apply(this,args);
        const ob = this.__ob__;
        ob.dep.notify() //向依赖发送消息
        return result;
    })
})

  调用了ob.dep.notify()去通知依赖(Watcher)数据发生了变化。

10.侦测数组中元素的变化

  所有响应式数据的子数据都要侦测，不论是Object中的数据还是Array中的数据。

export class Observer{
    constructor(value){
        this.value = value;
        def(value,"__ob__",this)

        // 新增
        if(Array.isArray(value)){
            this.observeArray(value)
        }else{
            this.walk()
        }
    }

    /* 
    侦测Array中的每一项
    */
   observerArray(items){
       for(let i= 0;i<items.length;i++){
        observer(items[i])
       }
   }
        // ...   
}

  新增observerArray方法，作用是循环Array中的每一项，执行observer函数来侦测变化。

11. 侦测新增元素的变化

  新增的内容需要转换成响应式来侦测变化，否则会出现修改数据时无法触发消息等问题。我们必须侦测数组中新增元素的变化。只需要在拦截器中对数组方法的类型进行判断。

1. 获取新增元素

  如果操作数组的方法是push,unshift,splice（可以新增数组元素的方法）则把参数中新增的元素拿过来，用Observer来侦测：

['push','pop','shift','unshift','splice','sort','reverse'].forEach(function(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;
        }
        ob.dep.notify();
        return result;
    })
}) 

  通过switch对methos进行判断，如果method是push,unshift,splice这种可以新增数组元素的方法，那么args中将新增元素取出来，暂存在inserted中。

2. 使用Observer侦测新增元素

  前面介绍过Observer会将自身的实例附加到value的__ob__属性上，所有被侦测了变化的数据都有一个__ob__属性，数组元素也不例外。 我们可以在拦截器中通过this访问到__ob__，然后调用__ob__上的observerArray方法：

['push','pop','shift','unshift','splice','sort','reverse'].forEach(function(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 'shift':
                inserted = args
                break;
            case 'splice':
                inserted = args.slice(2);
                break;
        }
        if(observer){
            ob.onserverArray(inserted);//新增
        }
        ob.dep.notify();
        return result;
    })
})

  从this.__ob__上拿到Observer实例后，如果有新增元素，则使用ob,observerArray来侦测这些新增元素的变化。

12. 关于Array的问题

  对Array的变化侦测是通过拦截原型的方式实现的，正是因为这种实现方式，其实有些数组操作Vue.js是拦截不到的，例如：

this.list[0] = 2;

修改数组的第一个元素的值时，无法侦测到数组的变化，所以并不会触发re-render或者watch等。
  例如：

this.list.length = 0

清空数组的操作也无法侦测到数组的变化，所以也不会触发re-render或者watch等。
  因为Vue.js无法对以上的例子做拦截，就没有办法响应。作者猜测未来会使用到ES6提供的Proxy来实现，现在这个猜测被证实了，Vue.js 3.0确实使用了Proxy进行了处理，不得不佩服作者的高瞻远瞩。

13. 总结

  Array追踪变化的方式和Object的不一样。因为它是通过方法来改变内容的，所以我们通过创建拦截器去覆盖数组原型的方法来追踪变化。
  为了不污染全局Array.prototypy,我们在Observer中只针对那些需要侦测变化的数组使用__proto__来覆盖原型方法，但__proto__在ES6之前并不是标准属性，不是所有的浏览器都支持它。因此，针对不支持__proto__属性的浏览器，我们直接循环拦截器，把拦截器中的方法直接设置到数组身上来拦截Array.prototype上的原生方法。
  Array收集依赖的方式和Object一样，都是在getter中收集。但是由于使用依赖的位置不同，数组要在拦截器中向依赖发消息，所以依赖不能像Obhect一样保存在defineReactive中，而是把依赖保存在Observer实例上。
  在Observer中，我们对每个侦测了变化的数组都标记上__ob__,把this(Observer实例)保存到__ob__上。作用有两点：1.为了标记数据是否被侦测了变化（保证一个数据只被侦测一次），2.可以很方便的通过数据取到__ob__,从而拿到Observer实例上保存的依赖。当拦截到数组发生变化时，向依赖发送通知。
  除了侦测数组自身的变化外，数组中元素发生的变化也要侦测。我们在Observer判断如果当前被侦测的数据是数组，则调用observerArray方法将数组每一个元素都转换成响应式的并侦测变化。
  除了侦测已有数据外，当用户使用push等方法向数组中新增数据时，新增的数据也要进行变化侦测。我们使用当前操作数组的方法来进行判断，如果是push、ubshift、splice方法，则从参数中将新增数组提取出来，然后使用observerArray对新增数据进行变化侦测。
  由于在ES6之前，JavaScript并没有提供元编程的能力，所以对于数组类型的数据，一些语法无法追踪到变化，只能拦截原型上的方法，而无法拦截数组特有的语法，例如使用length清空数组的操作就无法拦截。