深入解析前端MVVM框架核心机制,手写实现发布订阅模式在JavaScript双向绑定中的具体应用,涵盖Observer数据劫持、Dep依赖收集、Watcher订阅者以及Compile模板解析。
手写MVVM框架:发布订阅模式在JS双向绑定中的应用
时间:2026-11-18
浏览:457
文章目录
实现前端双向绑定的核心机制在于:通过数据劫持拦截对象属性读写,结合“发布-订阅模式”在数据变动时精准通知所有依赖该属性的视图节点更新,同时借助输入控件的 DOM 事件将视图变更即时同步回数据模型。本文通过纯 JavaScript 从零拆解并手写一个完整的迷你 MVVM 框架,清晰还原发布订阅模式在数据与视图之间传递通知的完整工程链路。
一、MVVM 双向绑定的本质与发布订阅机制的核心价值
在传统的命令式前端开发中,若要更新页面显示,开发者必须手动获取 DOM 节点并修改其属性;若用户在表单控件中输入内容,又必须通过监听事件手动提取控件的最新值并赋给业务变量。这种手动同步方式让业务代码与 DOM 操作紧密耦合,当页面状态复杂时极易出现状态与界面不同步的问题。
MVVM(Model-View-ViewModel)架构将界面与数据解耦为三个层次:
- Model(数据模型):纯粹的 JavaScript 对象,负责存储业务状态与数据实体。
- View(视图层):声明式的 DOM 模板(如包含
v-model或{ message }插值的 HTML),负责渲染用户界面。 - ViewModel(视图模型中枢):连接 Model 与 View 的通信桥梁。它一方面把 Model 转换为响应式数据,另一方面将 View 上的交互事件转化为对 Model 的修改。
在实现“数据变动驱动视图更新(Model → View)”的过程中,开发者面临的核心问题是:当某个属性发生赋值时,如何得知究竟是页面上的哪些具体 DOM 节点需要被更新?
如果每次属性变化都全量扫描整个 DOM 树并重新渲染,性能开销不可接受;如果在数据拦截的 setter 中硬编码特定 DOM 节点的操作,数据模型便丧失了通用性与独立性。发布订阅模式(Publish-Subscribe Pattern)正是解决这一矛盾的核心设计:
- 每个被劫持的属性内部维护一个专有的调度中心(Dep 发布者),用于存储所有引用了该属性的订阅者名单。
- 页面上每一个引用了该数据的插值表达式或指令节点,都会实例化一个具体的订阅对象(Watcher 订阅者),持有关联 DOM 的细粒度更新函数。
- 在编译模板初次读取属性时,Watcher 将自己注册进该属性的 Dep 中(依赖收集);当数据发生写入赋值时,Dep 遍历通知其名下的所有 Watcher 执行更新(派发更新)。
二、调度中心与订阅者的契约设计:Dep 与 Watcher
要实现发布订阅体系,首先需要定义两个核心角色:作为发布中心的 Dep 类与作为订阅者的 Watcher 类。两者之间通过静态属性建立了巧妙的单线程通信握手机制。
1. 依赖管理中心:Dep 类
每个属性闭包内都会生成一个独立的 Dep 实例。它提供 addSub 用于登记订阅者,以及 notify 用于广播通知。此外,Dep.target 作为全局静态变量,是依赖收集期间指向当前正在初始化的 Watcher 实例的关键指针。
// 依赖收集与发布调度中心
class Dep {
constructor() {
// 存储当前属性的所有订阅者 (Watcher 实例)
this.subs = [];
}
// 添加订阅者
addSub(sub) {
if (sub && typeof sub.update === 'function') {
this.subs.push(sub);
}
}
// 广播通知所有订阅者执行更新
notify() {
this.subs.forEach(sub => sub.update());
}
}
// 全局静态属性,作为当前活跃 Watcher 的临时指针
Dep.target = null;
2. 视图更新桥梁:Watcher 类
Watcher 充当具体 DOM 节点与数据属性之间的观察者。它的核心职责是:在初始化时把自己挂载到全局 Dep.target 上,主动读取一次对应的属性值,从而无感知地触发该属性的 getter 完成依赖收集;之后立刻清空 Dep.target。当收到 Dep.notify() 的呼叫时,执行对应的更新回调函数。
// 订阅者:作为视图节点与数据之间的更新纽带
class Watcher {
/**
* @param {Object} vm MVVM 实例
* @param {string} key 绑定的属性名 (支持 'user.name' 嵌套路径)
* @param {Function} cb 视图刷新回调函数
*/
constructor(vm, key, cb) {
this.vm = vm;
this.key = key;
this.cb = cb;
// 触发依赖收集,并缓存初始值
this.value = this.get();
}
// 获取属性最新值,并把自身注册到 Dep
get() {
// 将自身赋给 Dep 全局静态指针
Dep.target = this;
// 读取属性,触发 Object.defineProperty 的 getter
const value = this.getVMValue(this.vm, this.key);
// 依赖收集完毕,必须重置指针,避免无关联的 getter 误收集
Dep.target = null;
return value;
}
// 解析并读取嵌套属性值,如 'user.name'
getVMValue(vm, key) {
let data = vm;
const keys = key.split('.');
keys.forEach(k => {
if (data != null) {
data = data[k];
}
});
return data;
}
// 供 Dep.notify() 调用的标准更新接口
update() {
const newVal = this.getVMValue(this.vm, this.key);
const oldVal = this.value;
if (newVal !== oldVal) {
this.value = newVal;
// 执行节点更新逻辑,如 node.textContent = newVal
this.cb(newVal, oldVal);
}
}
}
Watcher.get() 执行期间,Dep.target = this 的赋值与随后 this.getVMValue() 的属性读取必须紧密衔接,读取完成后立即置为 null。这保证了只有在显式编译模板或创建观察者时才会收集依赖,普通业务逻辑中读取属性绝不会发生误收集。
三、数据拦截系统:Observer 与 defineReactive
有了发布订阅的基础协议后,需要让 JavaScript 数据对象具备感知读取与修改的能力。在 Vue 2 等经典实现中,核心工具是 Object.defineProperty。
Observer 类的任务是深度递归遍历数据对象的所有属性,通过闭包为每个属性分配专属的 Dep 实例,并在 getter 和 setter 中植入依赖收集与事件派发逻辑。
// 数据劫持类:将普通对象转换为响应式对象
class Observer {
constructor(data) {
this.observe(data);
}
// 递归观察数据
observe(data) {
if (!data || typeof data !== 'object') {
return;
}
// 遍历当前对象的所有属性
Object.keys(data).forEach(key => {
this.defineReactive(data, key, data[key]);
});
}
// 响应式属性拦截定义
defineReactive(obj, key, val) {
// 若属性值为对象,继续递归深入劫持
this.observe(val);
// 为当前属性实例化一个闭包 Dep,专门管理本属性名下的订阅者
const dep = new Dep();
Object.defineProperty(obj, key, {
enumerable: true,
configurable: true,
get: () => {
// 关键:若当前存在活跃的 Watcher (由 Watcher.get() 触发),加入闭包 dep
if (Dep.target) {
dep.addSub(Dep.target);
}
return val;
},
set: (newVal) => {
if (newVal === val) {
return;
}
val = newVal;
// 如果新赋值的是一个对象,对其重新递归劫持
this.observe(newVal);
// 数据变化,通知所有订阅了该属性的 Watcher
dep.notify();
}
});
}
}
在上述代码中,每个属性内部的 dep 实例由于 JavaScript 闭包机制得以持久保存在内存中。当多个 DOM 节点使用同一个数据属性(例如页面顶部和底部都渲染了 { message })时,该属性对应的 dep.subs 数组将按顺序容纳多个 Watcher 实例,形成严格的一对多订阅映射。
四、模板编译器与双向事件绑定:Compile 类
Compile 负责解析视图模板。它直接操作 DOM,主要完成三件事:
- 将挂载根节点下的所有真实 DOM 转入
DocumentFragment(文档片段)中,在内存中进行解析,避免频繁引起页面重绘重排; - 遍历子节点,识别普通文本插值
{ key }与指令属性v-model,提取绑定的数据键名; - 为匹配的节点赋予初始值,同时实例化
Watcher;针对输入框等表单控件,额外绑定input原生事件,实现视图向数据(View → Model)的写回。
// 模板编译器:解析 DOM 模板指令与插值表达式
class Compile {
constructor(el, vm) {
this.vm = vm;
this.el = this.isElementNode(el) ? el : document.querySelector(el);
if (this.el) {
// 1. 将宿主元素的全部子节点移入文档片段
const fragment = this.node2Fragment(this.el);
// 2. 编译模板中的指令与插值表达式
this.compile(fragment);
// 3. 将解析后的文档片段重新追加至宿主元素
this.el.appendChild(fragment);
}
}
// DOM 转入内存片段
node2Fragment(el) {
const fragment = document.createDocumentFragment();
let firstChild;
while ((firstChild = el.firstChild)) {
fragment.appendChild(firstChild);
}
return fragment;
}
// 递归遍历所有层级节点
compile(node) {
const childNodes = Array.from(node.childNodes);
childNodes.forEach(child => {
if (this.isElementNode(child)) {
// 解析元素节点指令 (如 v-model)
this.compileElement(child);
} else if (this.isTextNode(child)) {
// 解析文本节点插值 (如 {{ message }})
this.compileText(child);
}
// 深度递归子节点
if (child.childNodes && child.childNodes.length) {
this.compile(child);
}
});
}
// 解析元素属性中的指令
compileElement(node) {
const attrs = Array.from(node.attributes);
attrs.forEach(attr => {
const attrName = attr.name;
if (attrName.startsWith('v-')) {
const expr = attr.value;
const directive = attrName.slice(2);
if (directive === 'model') {
// 初始化渲染 input 初始值并注册 Watcher
this.modelHandler(node, this.vm, expr);
}
}
});
}
// 处理 v-model 双向绑定
modelHandler(node, vm, expr) {
// 1. 初次渲染控件值
node.value = this.getVMValue(vm, expr);
// 2. 实例化 Watcher 监听数据变动 -> 更新视图 (Model -> View)
new Watcher(vm, expr, newVal => {
node.value = newVal;
});
// 3. 监听 input 原生事件 -> 写入数据 (View -> Model)
node.addEventListener('input', e => {
this.setVMValue(vm, expr, e.target.value);
});
}
// 解析文本节点 { expr }
compileText(node) {
const reg = /\{\{(.*?)\}\}/g;
const text = node.textContent;
if (reg.test(text)) {
// 处理文本插值
const expr = text.match(/\{\{(.*?)\}\}/)[1].trim();
// 初次替换渲染
node.textContent = text.replace(/\{\{(.*?)\}\}/, this.getVMValue(this.vm, expr));
// 注册 Watcher
new Watcher(this.vm, expr, newVal => {
node.textContent = newVal;
});
}
}
getVMValue(vm, expr) {
let data = vm;
expr.split('.').forEach(k => {
if (data != null) data = data[k];
});
return data;
}
setVMValue(vm, expr, value) {
let data = vm;
const keys = expr.split('.');
keys.forEach((k, index) => {
if (index === keys.length - 1) {
data[k] = value;
} else {
data = data[k];
}
});
}
isElementNode(node) {
return node.nodeType === 1;
}
isTextNode(node) {
return node.nodeType === 3;
}
}
五、装配 MVVM 主类与数据代理
在开发体验中,开发者通常直接通过 vm.message = '新内容' 修改数据,而不是繁琐地编写 vm.$data.message = '新内容'。这就需要在 MVVM 主入口类中实现数据代理(Data Proxy)。
// MVVM 框架入口主类
class MVVM {
constructor(options = {}) {
this.$options = options;
this.$data = options.data || {};
this.$el = options.el;
// 1. 将 $data 上的属性代理到 MVVM 实例上 (this.key -> this.$data.key)
this.proxyData(this.$data);
// 2. 启动数据劫持观察系统
new Observer(this.$data);
// 3. 启动模板解析与依赖绑定
if (this.$el) {
new Compile(this.$el, this);
}
}
// 属性代理实现
proxyData(data) {
Object.keys(data).forEach(key => {
Object.defineProperty(this, key, {
enumerable: true,
configurable: true,
get: () => {
return this.$data[key];
},
set: (newVal) => {
this.$data[key] = newVal;
}
});
});
}
}
六、完整实测验证与双向流转闭环表现
将上述模块组装成完整的 HTML 测试页面,即可直观检验发布订阅模式驱动的双向数据流:
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MVVM 测试用例</title>
</head>
<body>
<div id="app">
<h3>用户输入测试</h3>
<p>双向输入框:<input type="text" v-model="message"></p>
<p>实时同步展示:<span>{{ message }}</span></p>
</div>
<script>
// 引入上文编写的 Dep, Watcher, Observer, Compile, MVVM 类
const vm = new MVVM({
el: '#app',
data: {
message: 'Hello MVVM'
}
});
</script>
</body>
</html>
在浏览器中运行该用例,可以观察到以下双向验证表现:
- View → Model 验证:当在输入框键入任意字符时,触发
input事件,执行vm.message = e.target.value;数据写入随即触发setter,代理访问将值写入$data.message。 - Model → View 验证:在控制台手动执行
vm.message = '代码驱动修改',触发属性的setter,setter激活内部闭包dep.notify(),订阅了该属性的两个 Watcher(输入框 Watcher 和文本节点 Watcher)分别收到广播并更新自身视图,界面立刻精准刷新。
七、边界条件与工程落地要点
在实现上述极简 MVVM 后,若要应用于更复杂的生产场景,还需要考虑以下关键边界与设计限制:
| 技术边界问题 | 具体原因与限制表现 | 工程解决思路 |
|---|---|---|
| 新增或删除属性拦截失效 | Object.defineProperty 只能对对象在初始化时已存在的属性进行拦截,后来直接 vm.newProp = 123 无法触发 getter/setter。 |
经典实现提供 Vue.set() / vm.$set() 手动创建新 Dep 并绑定响应;现代前端框架(如 Vue 3)则全面迁移至 ES6 Proxy。 |
| 数组索引与长度修改无法感知 | 直接对大数组所有下标定义 getter/setter 存在巨大性能消耗,且 arr[0] = x 或修改 length 无法被感知。 |
重写数组原型链方法(push、pop、shift、splice 等 7 个变异方法),在方法调用时主动触发 dep.notify()。 |
| 频繁修改导致的 DOM 性能抖动 | 若在同一个循环中连续执行 vm.count++ 一千次,若每次都同步触发 Watcher.update() 将产生一千次真实 DOM 操作。 |
引入异步缓冲更新队列(如 nextTick 机制)。在 Watcher.update() 时并不立即渲染,而是将 Watcher 推入基于微任务(Promise)的全局批处理队列并根据 ID 去重,在当前事件循环结束时仅批量刷新一次 DOM。 |
综上所述,发布订阅模式在 MVVM 双向绑定中扮演了解耦调度核心的角色。它通过 Dep 管理依赖清单,通过 Watcher 封装更新行为,使得数据模型在毫无视图侵入性的前提下,达成了高效、细粒度且可维护的双向数据流动。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。