首页 > 资讯 > 前端开发 > JavaScript >Vue响应式原理深入分析

267

分享到

Vue响应式原理深入分析

Vue响应式原理 Vue响应式框架 Vue响应式数据 2022-12-30 12:12:54 267人浏览泡泡鱼

摘要

目录1.响应式数据和副作用函数2.响应式数据的基本实现3.设计一个完善的响应式系统1.响应式数据和副作用函数（1）副作用函数副作用函数就是会产生副作用的函数。 function

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("结束");

// 这段代码本来会输出的结果是:

// 现在我们想让它变成

这里我们可以通过给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 ++;
// 这段代码本来会输出的结果是:

// 现在我们想让它变成

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

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);
    }
}

到此这篇关于Vue响应式原理深入分析的文章就介绍到这了,更多相关Vue响应式原理内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Vue响应式原理深入分析

本文链接: https://www.lsjlt.com/news/176266.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341