文章目录

• 1.响应式数据和副作用函数
• 2.响应式数据的基本实现
• 3.设计一个完善的响应式系统

1.响应式数据和副作用函数

（1）副作用函数

副作用函数就是会产生副作用的函数。

function effect() {document.body.innerText = 'hello world.'
}

​ 当effect函数执行时，它会设置body的内容，而body是一个全局变量，除了effect函数外任何地方都可以访问到，也就是说effect函数的执行会对其他操作产生影响，即effect函数是一个副作用函数。

（2）响应式数据

const obj = { text: 'hello world.'};
function effect() {document.body.innerText = obj.text;
}
obj.text = 'text';

​ 当 obj.text = 'text' 这条语句执行之后，我们期望 document.body.innerText 的值也能够随之修改，这就是通常意义上的响应式数据。

2.响应式数据的基本实现

​ 上文中，对响应式数据进行描述的代码段，并未实现真正的响应式数据。而通过观察我们可以发现，要实现真正的响应式数据，我们需要对数据的读取和设置进行拦截。当有操作对响应式数据进行读取中，我们将其添加至一个依赖队列，当修改响应式数据的值时，将依赖队列中的操作依次取出，并执行。以下使用Proxy对该思路进行实现。

const bucket = new Set();
const data = { text: "hello world." };const obj = new Proxy(data, {get(target, key) {bucket.add(effect);return target[key];},set(target, key, newVal) {target[key] = newVal;bucket.forEach((fn) => fn());return true;},
});const body = {innerText: "",
};function effect() {body.innerText = obj.text;
}effect();
console.log(body.innerText); // hello world
obj.text = "text";
console.log(body.innerText); // text

​ 但是，该实现仍然存在缺陷，比如说只能通过effect函数的名字实现依赖收集。

3.设计一个完善的响应式系统

（1）消除依赖收集的硬绑定

​ 这里我们使用一个active变量来保存当前需要进行依赖收集的函数。

const bucket = new Set();
const data = { text: "hello world." };
let activeEffect; // 新增一个active变量const obj = new Proxy(data, {get(target, key) {if (activeEffect) {bucket.add(activeEffect); // 添加active变量保存的函数}return target[key];},set(target, key, newVal) {target[key] = newVal;bucket.forEach((fn) => fn());return true;},
});function effect(fn) {activeEffect = fn; // 将当前函数赋值给active变量fn();
}const body = {innerText: "",
};effect(() => {body.innerText = obj.text;
});
console.log(body.innerText); // hello world
obj.text = "text";
console.log(body.innerText); // text

​ 但是该设计仍然存在很多问题，比如说，当访问一个obj对象上并不存在的属性假设为val时，逻辑上并没有存在对obj.val的访问，因此该操作不会产生任何响应，但实际上，当val的值被修改后，传入effect的匿名函数会再次执行。

（2）基于属性的依赖收集

​ 上一个版本的响应式系统只能对拦截对象所有的get和set操作进行响应，并不能做到细粒度的控制。考虑针对属性进行依赖拦截，主要有三个角色，对象、属性和依赖方法。因此考虑修改bucket的结构，由原来的Set修改为WeakMap(target,Map(key,activeEffect));这样就可以针对属性进行细粒度的依赖收集了。

ps.使用WeakMap是因为WeakMap是对key的弱引用，不会影响垃圾回收机制的工作，当target对象不存在任何引用时，说明target对象已不被需要，这时target对象将会被垃圾回收。如果换成Map，即时target不存在任何引用，Map已然会保持对target的引用，容易造成内存泄露。

// bucket的数据结构修改为WeakMap
const bucket = new WeakMap();
const data = { text: "hello world." };
let activeEffect;const obj = new Proxy(data, {get(target, key) {track(target, key);return target[key];},set(target, key, newVal) {target[key] = newVal;trigger(target, key);},
});function track(target, key) {if (!activeEffect) {return;}let depsMap = bucket.get(target);if (!depsMap) {bucket.set(target, (depsMap = new Map()));}let deps = depsMap.get(key);if (!deps) {depsMap.set(key, (deps = new Set()));}deps.add(activeEffect);
}function trigger(target, key) {const depsMap = bucket.get(target);if (!depsMap) return;const effects = depsMap.get(key);effects && effects.forEach((fn) => fn());
}function effect(fn) {activeEffect = fn;fn();
}const body = {innerText: "",
};effect(() => {body.innerText = obj.text;
});
console.log(body.innerText); // hello world
obj.text = "text";
console.log(body.innerText); // text

（3）分支切换和cleanup

​ 对于一段三元运算符 obj.flag? obj.text : 'text',我们所期望的结果是，当obj.flag的值为false时，不会对obj.text属性进行响应操作。 如果是上面那段程序，当obj.flag的值为false时，操作obj.text仍然会进行相应操作，因为obj.text对应的依赖仍然存在。对此如果我们能够在每次的函数执行之前，将其从之前相关联的依赖集合中移除，就可以达到目的了。这里通过修改副作用函数来实现：

function effect(fn) {const effectFn = () => {// 在依赖函数执行之前，清除依赖函数之前的依赖项cleanup(effectFn);activeEffect = effectFn;fn();};// 给副作用函数添加一个deps数组用来收集和该副作用函数相关联的依赖effectFn.deps = [];effectFn();
}// cleanup函数实现
function cleanup(effectFn) {for (let i = 0; i < effectFn.deps.length; i++) {const deps = effectFn.deps[i];deps.delete(effectFn);}effectFn.deps.length = 0;
}function track(target, key) {if (!activeEffect) {return;}let depsMap = bucket.get(target);if (!depsMap) {bucket.set(target, (depsMap = new Map()));}let deps = depsMap.get(key);if (!deps) {depsMap.set(key, (deps = new Set()));}deps.add(activeEffect);activeEffect.deps.push(deps); // 在这里收集相关联的依赖
}function trigger(target, key) {const depsMap = bucket.get(target);if (!depsMap) return;const effects = depsMap.get(key);const effectToRun = new Set(effects); // 这里需要创建一个新集合来遍历，因为foreach循环会对新加入序列的元素也执行遍历，若遍历直接原集合，会出现死循环。effectToRun.forEach((fn) => fn());
}

（4）嵌套effect

​ 虽然我们已经解决了很多问题，但是作为响应式系统中比较常见的场景之一的嵌套，我们还不能实现。因为我们定义的activeEffect是一个变量，当嵌套操作时，无论怎样，最后activeEffect变量中存放的都是操作的最后一个副作用函数。这里，我们通过加入一个effect栈的方式，来给这套响应式系统添加嵌套功能。

// 定义一个effect栈
const effectStack = [];function effect(fn) {const effectFn = () => {cleanup(effectFn);activeEffect = effectFn;effectStack.push(effectFn); // 在effect执行之前，放入栈中fn();effectStack.pop(); // 执行完毕立即弹出activeEffect = effectStack[effectStack.length - 1]; // activeEffect指向新的effect};effectFn.deps = [];effectFn();
}

（5）避免产生死循环

​ 试看obj.val++这条语句，它实际上相当于obj.val = obj.val+1，也就是进行了一次读取操作和一次赋值操作，共两次操作。而若将该操作运行在我们前面的响应式系统中，它将会产生死循环，因为当我们进行了读取操作后，会立即进行赋值操作，而在赋值操作中，读取操作再次被触发，然后循环的执行这一系列操作。这里我们在trigger函数中判断trigger触发的副作用函数，是否与当前正在执行的副作用函数相同，若相同，则不执行当前副作用函数。这样就能避免无限递归调用，避免内存溢出。

function trigger(target, key) {const depsMap = bucket.get(target);if (!depsMap) return;const effects = depsMap.get(key);const effectToRun = new Set();effects &&effects.forEach((fn) => {// 若正在执行的副作用函数与当前触发的副作用函数相同，则不执行if (fn !== activeEffect) {effectToRun.add(fn);  }});effectToRun.forEach((fn) => fn());
}

（6）实现调度实行

现在要实现一个这样的效果：

effect(()=> {console.log(obj.val);
});obj.val ++;
console.log("结束");
// 这段代码本来会输出的结果是:
/**12结束**/// 现在我们想让它变成
/**1结束2**/

这里我们可以通过给effect函数添加一个配置项来实现：

effect(()=> {console.log(obj.val);},{scheduler(fn) {setTimeout(fn);}}function effect(fn,options = {}) {const effectFn = ()=> {...}effectFn.deps = [];effectFn.options = options; // 为副作用函数添加配置项effectFn();
}function trigger(target, key) {const depsMap = bucket.get(target);if (!depsMap) return;const effects = depsMap.get(key);const effectToRun = new Set();effects &&effects.forEach((fn) => {if (fn !== activeEffect) {effectToRun.add(fn);}});effectToRun.forEach((fn) => {// 若当前依赖函数含有调度执行，将当前函数传递给调度函数执行if (fn.options.scheduler) {fn.options.scheduler(fn); //将当前函数传递给调度函数} else {fn();}});
}

如果还要实现一下效果：

effect(()=> {console.log(obj.val);
});obj.val ++;
obj.val ++;
// 这段代码本来会输出的结果是:
/**123**/// 现在我们想让它变成
/**13**/

这里通过添加一个任务执行队列来实现：

const jobQueue = new Set();
const p = Promise.resolve(); 
let isFlushing = false;effect(()=> {console.log(obj.val);},{scheduler(fn){jobQueue.add(fn);flushJob();}}
);function flushJob() {if(isFlushing) return;isFlushing = true;p.then(()=> {jobQueue.forEach(job=>job());}).finally(()=> {isFlushing = false;})
}

​ 像这样，由于Set保证了任务的唯一性，也就是jobQueue中只会保存唯一的一个任务，即当前执行的任务。而isFlushing标记则保证任务只会执行一次。而因为通过Promise将任务添加到了微任务队列中，当任务最后执行的时候，obj.val的值已经是3了。

（7）computed和lazy

​ 计算属性是vue中一个比较有特色的属性，它会缓存表达式的计算结果，只有当表达式依赖的变量发生变化时，它才会进行重新计算。实现计算属性的前提是实现懒加载标记，这里我们可以通过之前effect函数的配置项来实现。

effect(()=> {return ()=>obj.val * 2;},{lazy: true; // 设置 lazy 标记}
);effect(fn, options = {}) {const effectFn = () => {cleanup(effectFn);activeEffect = effectFn;effectStack.push(effectFn);const res = fn();effectStack.pop();activeEffect = effectStack[effectStack.length - 1];return res;};effectFn.deps = [];effectFn.options = options;if (!effectFn.options.lazy) { // 若副作用函数持有lazy标记，则直接将副作用函数返回effectFn();}return effectFn;
}

通过上面对lazy标记的设置，现在可以实现下面的效果：

const effectFn = effect(()=> {return ()=>obj.val * 2;},{lazy: true; // 设置 lazy 标记}
)();console.log(effectFn); // 2

在此基础上，我们来实现computed

function computed(getter) {let value;let dirty = false;const effectFn = effect(getter, {lazy: true,scheduler(){if(!dirty) {dirty = true;tirgger(obj, 'value');}}});const obj = {get value() {if(!dirty) {value = effectFn();dirty = true;}track(target, 'value');return value;}};return obj;
}

（8）watch

​ 想要实现watch，其实只需要添加一个scheduler()，像是这样:

effect(()=> {consoloe.log(obj.val);},{scheduler() {console.log("数值发生了变化");}}
)

就可以实现一个基本的watch效果，现在来编写一个功能完整的watch函数

function watch(source, cb) {let getter;if(typeof source === "function") { //若传入()=> obj.val，则直接使用该匿名函数getter = source;} else {getter = traverse(source); // 否则递归遍历该对象的所有属性，从而达到监听所有属性的目的}let oldValue, newValue; // 保存新旧值const effectFn = effect(getter, {lazy: true,scheduler() {newValue = effectFn(); // 获取新值cb(oldValue, newValue);oldValue = newValue; // 函数执行完后，更新旧值。}});oldValue = effectFn(); // 获取初始旧值
}function traverse(value, seen = new Set()) {if(typeof value !== 'object' || value !== null || seen.has(value)) return ;seen.add(value);for(const k in seen) {traverse(seen[k],seen);}
}