JavaScript 实现一个响应式系统的解决方案_Javascript

第一阶段目标

数据变化重新运行依赖数据的过程

第一阶段问题

如何知道数据发生了变化
如何知道哪些过程依赖了哪些数据

第一阶段问题的解决方案

我们可用参考现有的响应式系统（vue）
vue2 是通过 object.defineproperty实现数据变化的监控，详细查看 vue2官网。

vue3 是通过proxy实现数据变化的监控，详细查看 vue3官网。
本次示例使用proxy实现数据监控,proxy详细信息查看官网。
根据解决方案，需要改变第一阶段目标为-> proxy对象变化重新运行依赖数据的过程
问题变更->如何知道proxy发生了变化
问题变更->如何知道哪些函数依赖了哪些proxy

如何知道 proxy 对象发生了变化，示例代码

//这里传入一个对象，返回一个proxy对象，对proxy对象的属性的读取和修改会触发内部的get，set方法
function relyoncore(obj) {
  if (typeof obj !== "object" || obj === null) {
    return obj;
  }
  return new proxy(obj, {
    get(target, key, receiver) {
      return target[key];
    },
    set(target, key, value, receiver) {
      //这里需要返回是否修改成功的boolean值
      return reflect.set(target, key, value);
    },
  });
}

数据监控初步完成，但是这里只监控了属性的读取和设置，还有很多操作没有监控，以及数据的 this 指向，我们需要完善它

//完善后的代码
export function relyoncore(obj) {
  if (typeof obj !== "object" || obj === null) {
    return obj;
  }
  return new proxy(obj, {
    get(target, key, receiver) {
      if (typeof target[key] === "object" && target[key] !== null) {
        //当读取的值是一个对象，需要重新代理这个对象
        return relyoncore(target[key]);
      }
      return reflect.get(target, key, receiver);
    },
    set(target, key, value, receiver) {
      return reflect.set(target, key, value, receiver);
    },
    ownkeys(target) {
      return reflect.ownkeys(target);
    },
    getownpropertydescriptor(target, key) {
      return reflect.getownpropertydescriptor(target, key);
    },
    has(target, p) {
      return reflect.has(target, p);
    },
    deleteproperty(target, key) {
      return reflect.deleteproperty(target, key);
    },
    defineproperty(target, key, attributes) {
      return reflect.defineproperty(target, key, attributes);
    },
  });
}

如何知道哪些函数依赖了哪些 proxy 对象

问题：依赖 proxy 对象的函数要如何收集

在收集依赖 proxy 对象的函数的时候出现了一个问题：无法知道数据在什么环境使用的，拿不到对应的函数

解决方案

既然是因为无法知道函数的执行环境导致的无法找到对应函数，那么我们只需要给函数一个固定的运行环境就可以知道函数依赖了哪些数据。

示例

//定义一个变量
export let currentfn;
export function trackfn(fn) {
  return function fntrackenv() {
    currentfn = fntrackenv;
    fn();
    currentfn = null;
  };
}

自此，我们的函数调用期间 proxy 对象监听到的数据读取在 currentfn 函数内部发生的。

同样，我们的目标从最开始的数据变化重新运行依赖数据的过程 -> proxy 对象变化重新运行依赖收集完成的函数

完善函数调用环境

直接给全局变量赋值，在函数嵌套调用的情况下，这个依赖收集，会出现问题

let obj1 = relyoncore({ a: 1, b: 2, c: { d: 3 } });
function fn1() {
  let a = obj1.a;
  function fn2() {
    let b = obj1.b;
  }
  //这里的c会无法收集依赖
  let c = obj1.c;
}

我们修改一下函数收集

export const fnstack = [];
export function trackfn(fn) {
  return function fntrackenv() {
    fnstack.push(fntrackenv);
    fn();
    fnstack.pop(fntrackenv);
  };
}

第二阶段目标

在合适的时机触发合适的函数

第二阶段问题

在什么时间触发函数
到达触发时间时，应该触发什么函数

第一个问题：在什么时间触发函数

必然是在修改数据完成之后触发函数

第二个问题：应该触发什么函数

当操作会改变函数读取的信息的时候，需要重新运行函数。因此，我们需要建立一个映射关系

{
  //对象
  "obj": {
    //属性
    "key": {
      //对属性的操作
      "handle": ["fn"] //对应的函数
    }
  }
}

在数据改变的时候，我们只需要根据映射关系，循环运行 handle 内的函数

数据读取和函数建立联系

我们可以创建一个函数用于建立这种联系

export function track(object, handle, key, fn) {}

这个函数接收 4 个参数，object(对象),handle(对数据的操作类型) key(操作了对象的什么属性)，fn(需要关联的函数)

我们现在来创建映射关系

export const objmap = new weakmap();
export const handletype = {
  get: "get",
  set: "set",
  delete: "delete",
  define: "define",
  has: "has",
  getownpropertydescriptor: "getownpropertydescriptor",
  ownkeys: "ownkeys",
};
export function track(object, handle, key, fn) {
  setobjmap(object, key, handle, fn);
}
function setobjmap(obj, key, handle, fn) {
  if (!objmap.has(obj)) {
    objmap.set(obj, new map());
  }
  setkeymap(obj, key, handle, fn);
}
const setkeymap = (obj, key, handle, fn) => {
  let keymap = objmap.get(obj);
  if (!keymap.has(key)) {
    keymap.set(key, new map());
  }
  sethandle(obj, key, handle, fn);
};
const sethandle = (obj, key, handle, fn) => {
  let keymap = objmap.get(obj);
  let handlemap = keymap.get(key);
  if (!handlemap.has(handle)) {
    handlemap.set(handle, new set());
  }
  setfn(obj, key, handle, fn);
};
const setfn = (obj, key, handle, fn) => {
  let keymap = objmap.get(obj);
  let handlemap = keymap.get(key);
  let fnset = handlemap.get(handle);
  fnset.add(fn);
};

现在已经实现了数据和函数之间的关联只需要在读取数据时调用这个方法去收集依赖就可以，代码如下：

export function relyoncore(obj) {
  if (typeof obj !== "object" || obj === null) {
    return obj;
  }
  return new proxy(obj, {
    get(target, key, receiver) {
      track(target, handletype.get, key, fnstack[fnstack.length - 1]);
      if (typeof target[key] === "object" && target[key] !== null) {
        return relyoncore(target[key]);
      }
      return reflect.get(target, key, receiver);
    },
    //....这里省略剩余代码
  });
}

接下来我们需要建立数据改变->影响哪些数据的读取之间的关联

export const triggertotrackmap = new map([
  [handletype.set, [handletype.get, handletype.getownpropertydescriptor]],
  [
    handletype.delete,
    [
      handletype.get,
      handletype.ownkeys,
      handletype.has,
      handletype.getownpropertydescriptor,
    ],
  ],
  [handletype.define, [handletype.ownkeys, handletype.has]],
]);

建立这样关联后，我们只需要在数据变动的时候，根据映射关系去寻找需要重新运行的函数就可以实现响应式。

export function trigger(object, handle, key) {
  let keymap = objmap.get(object);
  if (!keymap) {
    return;
  }
  let handlemap = keymap.get(key);
  if (!handlemap) {
    return;
  }
  let triggertotrack = triggertotrackmap.get(handle);
  let fnset = new set();
  triggertotrack.foreach((handle) => {
    let fnsetchiren = handlemap.get(handle);
    if (fnsetchiren) {
      fnsetchiren.foreach((fn) => {
        if (fn) {
          fnset.add(fn);
        }
      });
    }
  });
  fnset.foreach((fn) => {
    fn();
  });
}