手写MVVM框架:发布订阅模式在JS双向绑定中的应用

作者:雾松时间:2026-11-18 10:25:15浏览:456

深入解析前端MVVM框架核心机制,手写实现发布订阅模式在JavaScript双向绑定中的具体应用,涵盖Observer数据劫持、Dep依赖收集、Watcher订阅者以及Compile模板解析。

实现前端双向绑定的核心机制在于:通过数据劫持拦截对象属性读写,结合“发布-订阅模式”在数据变动时精准通知所有依赖该属性的视图节点更新,同时借助输入控件的 DOM 事件将视图变更即时同步回数据模型。本文通过纯 JavaScript 从零拆解并手写一个完整的迷你 MVVM 框架,清晰还原发布订阅模式在数据与视图之间传递通知的完整工程链路。

手写MVVM框架:发布订阅模式在JS双向绑定中的应用
图 0: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)正是解决这一矛盾的核心设计:

  1. 每个被劫持的属性内部维护一个专有的调度中心(Dep 发布者),用于存储所有引用了该属性的订阅者名单。
  2. 页面上每一个引用了该数据的插值表达式或指令节点,都会实例化一个具体的订阅对象(Watcher 订阅者),持有关联 DOM 的细粒度更新函数。
  3. 在编译模板初次读取属性时,Watcher 将自己注册进该属性的 Dep 中(依赖收集);当数据发生写入赋值时,Dep 遍历通知其名下的所有 Watcher 执行更新(派发更新)。
手写MVVM框架:发布订阅模式在JS双向绑定中的应用
图 1:MVVM 核心模块结构与职责边界架构

二、调度中心与订阅者的契约设计: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 中植入依赖收集与事件派发逻辑。

手写MVVM框架:发布订阅模式在JS双向绑定中的应用
图 2:依赖收集与通知派发的运行细节与交互时序
// 数据劫持类:将普通对象转换为响应式对象
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,主要完成三件事:

  1. 将挂载根节点下的所有真实 DOM 转入 DocumentFragment(文档片段)中,在内存中进行解析,避免频繁引起页面重绘重排;
  2. 遍历子节点,识别普通文本插值 { key } 与指令属性 v-model,提取绑定的数据键名;
  3. 为匹配的节点赋予初始值,同时实例化 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框架:发布订阅模式在JS双向绑定中的应用
图 3:手写 MVVM 四步开发流水线与验证路径
// 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框架:发布订阅模式在JS双向绑定中的应用
图 4:双向绑定“双通道”流转全景总结

七、边界条件与工程落地要点

在实现上述极简 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 封装更新行为,使得数据模型在毫无视图侵入性的前提下,达成了高效、细粒度且可维护的双向数据流动。

作者最新文章
相关文章
更多