JavaScript如何监测数组的变化

前言

之前介绍defineproperty的时候说到，其只能监测对象的变化，并不能监测数组的变化。

本文致力于说清楚怎么实现监测数组的变化。

核心思路：找到改变原数组的方法，然后对这些方法进行劫持处理。

上面这句话，是重中之重，务必读三遍，记住了，再往下走。

改变原数组，常用到的方法有push pop shift unshift reverse sort splice。

换言之，这些方法是改变数组的入口。

在数组实例和数组原型之间，加一个新的原型

直接修改array.prototype，是极其危险的。

换一个思路，复制已有的数组原型，然后修改其中的方法，但这里因为原型上的方法不可枚举，自然也就没法复制。

于是再换一个思路，在数组和数组的原型之间，插入一个原型，形成原型链，数组 => 新原型 => 数组的原型，可以在新原型上增加同名的方法就可以了。

先借助伪代码理解：

// 伪代码
let arr = [];
arr.__proto__ = newprototype;
newprototype.__proto__ = array.prototype;
// 然后可以在新原型上添加同名的方法就可以了
newprototype.push = xxx;

转换成真实的代码如下，核心使用了object.create，

// object.create返回一个新对象，而来新对象的__proto__就是传进去的参数。
let newprototype = object.create(array.prototype);
// 然后可以在新原型上添加同名的方法就可以了
newprototype.push = xxx;

// 需要监测的数组，绑定新的原型就可以了
let arr = [];
arr.__proto__ = newprototype;

以 push 为例，劫持 push

就是在新原型上重新写一个 push 的方法，里面执行老的 push，但除此之外还可以做点别的事。

let newprototype = object.create(array.prototype);

// 在新原型上添加同名push
newprototype.push = function(...args) {
  // 语义化this
  let curarr = this;
  console.log("使用了push");
  // 最后还是会执行原始的push
  return array.prototype.push.call(curarr, ...args);
};

// 需要监测的数组，绑定新的原型就可以了
let arr = [];
arr.__proto__ = newprototype;

// 执行push的时候，就会打印了
arr.push(1);

然后其他的方法也是类似的，试着写写其他的方法

劫持其他的方法

将其他方法也一起写了，因为逻辑一样，直接遍历即可。

let newprototype = object.create(array.prototype);

let methods = ["push", "pop", "shift", "unshift", "reverse", "sort", "splice"];

methods.foreach(method => {
  newprototype[method] = function(...args) {
    console.log(`使用了${method}`);
    return array.prototype[method].call(this, ...args);
  };
});

// 需要监测的数组，绑定新的原型就可以了
let arr = [];
arr.__proto__ = newprototype;

// 执行的时候，就会打印了
arr.push(1);
arr.pop();

数组里有数组项的话，也是需要监测的

这里数组里可能也是有数组的，需要遍历数组的每项，如果是数组的话依然需要指向新的原型。

嗯，对，用到递归了。

let newprototype = object.create(array.prototype);

let methods = ["push", "pop", "shift", "unshift", "reverse", "sort", "splice"];

methods.foreach(method => {
  newprototype[method] = function(...args) {
    console.log(`使用了${method}`);
    return array.prototype[method].call(this, ...args);
  };
});

function observearr(arr) {
  // 既是条件限制，也是递归的终止条件
  if (!array.isarray(arr)) {
    return;
  }
  // 整个数组指向新的原型
  arr.__proto__ = newprototype;
  // 数组的每项，如果是数组，也指向新的原型。
  arr.foreach(observearr);
}
// 需要监测的数组，绑定新的原型就可以了
let arr = [[1, 2, 3]];
observearr(arr);

// 执行的时候，就会打印了
arr[0].push(1);
arr[1].pop();

数组新添加的项，如果是数组也需要指向新的原型

能添加元素的方法：push unshift splice。

找到新加的元素，然后是数组的也同样指向新的原型

let newprototype = object.create(array.prototype);

let methods = ["push", "pop", "shift", "unshift", "reverse", "sort", "splice"];

methods.foreach(method => {
  newprototype[method] = function(...args) {
    console.log(`使用了${method}`);
    let inserted;
    switch (method) {
      case "push":
      case "unshift":
        inserted = args;
        break;
      case "splice":
        inserted = args.slice(2);
        break;
      default:
        break;
    }
    inserted && observearr(inserted);
    return array.prototype[method].call(this, ...args);
  };
});

function observearr(arr) {
  // 即是条件限制，也是递归的终止条件
  if (!array.isarray(arr)) {
    return;
  }
  // 整个数组指向新的原型
  arr.__proto__ = newprototype;
  // 数组的每项，如果是数组，也指向新的原型。
  arr.foreach(observearr);
}
// 这里可以导出去，方便别的文件使用
export default observearr;
// 需要监测的数组，绑定新的原型就可以了
let arr = [];
observearr(arr);
let additem = [1, 2, 3];
arr.push(additem);
// 执行的时候，就会打印了
additem.push(1);
additem.pop();

综合使用 defineproperty 监测对象和数组

现在已经有了监测对象的方法，也有了监测数组的方法，将两个综合起来，就能监测数组里面的对象，对象里面的数组了。

将监测数组和监测对象的的可以单独写成一个文件，方便之后使用。

这里为了方便直接运行代码，直接放在一块了。

/**
 * observearr的部分
 **/
// 生成新的原型
let newprototype = object.create(array.prototype);

let methods = ["push", "pop", "shift", "unshift", "reverse", "sort", "splice"];
// 在新原型上面添加以上方法，实现劫持
methods.foreach(method => {
  newprototype[method] = function(...args) {
    console.log(`使用了${method}`);
    let inserted;
    switch (method) {
      case "push":
      case "unshift":
        inserted = args;
        break;
      case "splice":
        inserted = args.slice(2);
        break;
      default:
        break;
    }
    inserted && observearr(inserted);
    return array.prototype[method].call(this, ...args);
  };
});

function observearr(arr) {
  // 新加！！！是对象的话，需要用对象
  if (object.prototype.tostring.call(arr) === "[object object]") {
    observeobj(arr);
    return;
  }

  if (array.isarray(arr)) {
    // 整个数组指向新的原型
    arr.__proto__ = newprototype;
    // 数组的每项，如果是数组，也指向新的原型。
    arr.foreach(observearr);
  }

  // 不是对象或者数组的，什么都不做
}

/**
 * observeobj的部分
 **/
function observeobj(obj) {
  // 加上参数限制，必须是对象才有劫持，也是递归的终止条件
  if (typeof obj !== "object" || obj == null) {
    return;
  }
  // 新加！！！数组交给数组处理
  if (array.isarray(obj)) {
    observearr(obj);
    return;
  }
  // 是对象的话 才开始递归
  for (let key in obj) {
    // 直接使用 obj.hasownproperty会提示不规范
    if (object.prototype.hasownproperty.call(obj, key)) {
      observekey(obj, key);
      // 这里劫持该属性的属性值，如果不是对象直接返回，不影响
      observeobj(obj[key]);
    }
  }
  return obj;
}
function observekey(obj, key) {
  let value = obj[key];
  object.defineproperty(obj, key, {
    get() {
      console.log("读取属性", value);
      return value;
    },
    set(newvalue) {
      console.log("设置属性", newvalue);
      value = newvalue;
    }
  });
}

/**
 * demo试试
 **/
let data = { a: 1, b: [1, 2, { c: 2 }] };
observeobj(data);
data.a = 2;
data.b.push([2, 3]);

let arr = [{ a: "数组里的对象" }, 3, 4];
observearr(arr);
arr[0].a = 3;

缺陷

当然数组其实可以不通过方法改变，比如直接删除数组可以直接使用 length 属性，或者直接arr[0]=xxx改变数组。

但只有当使用"push","pop", "shift","unshift","reverse","sort","splice"才能检测到数组变化。

这也是 vue 的缺陷，当然新版的 proxy 将干掉这个缺陷。

所以在使用 vue 的过程中，要尽量使用以上方法操作数组~~~

附注：查看数组的所有属性和方法

在控制台可以输入dir([])，然后能看到数组所有的属性和方法。

具体用法，可以直接到到mdn 上细看，点击侧边栏看对应的方法

总结

到此这篇关于javascript如何监测数组变化的文章就介绍到这了,更多相关js监测数组变化内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！