阅读视图

发现新文章,点击刷新页面。

Vue createRenderer 自定义渲染器从入门到实战

Vue createRenderer 自定义渲染器从入门到实战

🔥 Vue 3它不仅能高效渲染浏览器 DOM,还能实现小程序、Native 等多端运行。而支撑这一切的核心,就是 createRenderer 函数。它允许我们自定义渲染逻辑,摆脱 Vue 内置 DOM 渲染的限制,打造适配任意平台的渲染器

一、自定义 DOM 渲染器

示例重点实现支持事件绑定的 patchProp 方法,还会加入虚拟节点更新案例,直观看到渲染器的更新流程。

完整可运行代码

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <title>Vue 自定义渲染器入门示例</title>
  <!-- 引入 Vue 3 完整版,方便浏览器直接运行 -->
  <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
</head>
<body>
  <!-- 渲染挂载容器 -->
  <div id="app"></div>

  <script>
    // 从 Vue 中解构出 createRenderer 和 h 函数
    const { createRenderer, h } = Vue;

    // 1. 创建自定义渲染器:传入平台渲染配置对象
    const renderer = createRenderer({
      // 创建元素节点:根据标签名创建 DOM 元素
      createElement(tag) {
        console.log(`[渲染步骤] 创建元素节点:<${tag}>`);
        return document.createElement(tag);
      },

      // 更新元素属性:核心改造!支持普通属性 + 事件绑定(onXXX 格式)
      patchProp(el, key, prevValue, nextValue) {
        // 判断是否是事件属性(以 on 开头,且第二个字母大写,如 onClick、onInput)
        const isEvent = key.startsWith('on') && /^on[A-Z]/.test(key);
        
        if (isEvent) {
          // 提取事件名(去掉 on 前缀,转为小写,如 onClick -> click)
          const eventName = key.slice(2).toLowerCase();
          
          // 移除旧的事件监听(如果有旧值)
          if (prevValue) {
            el.removeEventListener(eventName, prevValue);
          }
          
          // 绑定新的事件监听(如果有新值)
          if (nextValue) {
            el.addEventListener(eventName, nextValue);
            console.log(`[渲染步骤] 绑定事件:${eventName},回调函数已挂载`);
          }
        } else {
          // 普通属性:直接用 setAttribute 处理
          if (nextValue === undefined || nextValue === null) {
            el.removeAttribute(key);
            console.log(`[渲染步骤] 移除普通属性:${key}`);
          } else {
            el.setAttribute(key, nextValue);
            console.log(`[渲染步骤] 更新普通属性:${key} = ${nextValue}`);
          }
        }
      },

      // 插入元素:将子元素插入到父元素的指定位置
      insert(el, parent, anchor) {
        console.log(`[渲染步骤] 插入元素:将 <${el.tagName.toLowerCase()}> 插入到 <${parent.tagName.toLowerCase()}>`);
        parent.insertBefore(el, anchor || null);
      },

      // 移除元素:从父节点中移除当前元素
      remove(el) {
        console.log(`[渲染步骤] 移除元素:<${el.tagName.toLowerCase()}>`);
        el.parentNode.removeChild(el);
      },

      // 创建文本节点:创建 DOM 文本节点
      createText(text) {
        console.log(`[渲染步骤] 创建文本节点:${text}`);
        return document.createTextNode(text);
      },

      // 更新文本节点:修改文本节点的内容
      setText(node, text) {
        console.log(`[渲染步骤] 更新文本节点:${node.nodeValue}${text}`);
        node.nodeValue = text;
      }
    });

    // 2. 获取挂载容器
    const app = document.getElementById('app');

    // 3. 初始虚拟节点(无事件)
    const vnode1 = h('div', { title: '初始节点' }, 'Hello initial vnode');

    // 4. 1秒后更新的虚拟节点(带 onClick 事件)
    const vnode2 = h(
      'div',
      {
        onClick() {
          console.log('更新了!点击事件触发成功~');
        },
        title: '更新后节点(带点击事件)' // 同时更新普通属性
      },
      'hello world'
    );

    // 5. 先渲染初始虚拟节点
    renderer.render(vnode1, app);

    // 6. 1秒后更新虚拟节点,触发 patchProp 处理事件和属性更新
    setTimeout(() => {
      console.log('==== 开始更新虚拟节点 ====');
      renderer.render(vnode2, app);
    }, 1000);
  </script>
</body>
</html>

运行效果

  1. 打开浏览器运行该 HTML 文件,页面先显示 Hello initial vnode,鼠标悬浮弹出「初始节点」提示;
  2. 1秒后,文本自动更新为 hello world,悬浮提示变为「更新后节点(带点击事件)」;
  3. 点击文本所在的 div,控制台打印 更新了!点击事件触发成功~
  4. 全程控制台会清晰打印渲染、更新、事件绑定的日志,直观看到自定义渲染器的完整执行流程。

二、核心拆解:这段代码到底在做什么?

我们逐部分拆解代码,理解 createRenderer 的核心组成和工作逻辑,重点解析新增的虚拟节点更新案例。

1. 核心引入:createRendererh 函数

const { createRenderer, h } = Vue;

这两个函数是实现自定义渲染的关键,各自承担核心职责:

  • createRenderer:Vue 3 提供的渲染器工厂函数,接收一套「平台渲染接口」,返回一个具备完整渲染能力的自定义渲染器实例。这个实例拥有 createApprender 方法,和 Vue 默认的 DOM 渲染器功能一致,只是渲染逻辑由我们自定义。
  • h 函数:全称 createVNode,核心作用是构建虚拟 DOM 节点(VNode)。它接收标签名/组件、属性对象、子节点/文本内容,返回一个标准的 VNode 对象,作为渲染器的输入数据。

2. 核心步骤:创建自定义渲染器(createRenderer

const renderer = createRenderer({ /* 渲染配置对象 */ });

createRenderer 接收一个配置对象作为唯一参数,这个对象必须实现 6 个核心方法,它们是渲染器与「目标平台」的交互桥梁,负责将 VNode 转换为目标平台的真实节点(这里是浏览器 DOM)。

6 个核心渲染方法详解(DOM 平台)
方法名 核心作用 入参说明
createElement 创建元素节点 tag:标签名(如 'div'、'p'),返回创建好的 DOM 元素
patchProp 更新元素属性 el:真实 DOM 元素、key:属性名、prevValue:旧属性值、nextValue:新属性值
insert 插入元素 el:要插入的 DOM 元素、parent:父 DOM 元素、anchor:插入参考节点(null 则插入末尾)
remove 移除元素 el:要移除的 DOM 元素
createText 创建文本节点 text:文本内容,返回创建好的 DOM 文本节点
setText 更新文本节点 node:真实 DOM 文本节点、text:新的文本内容
关键亮点:patchProp 支持事件绑定

本次改造的核心是 patchProp 方法,它不仅能处理 title 这类普通属性,还能识别 onClick 这类事件属性,实现 DOM 事件的绑定与移除:

  • 先判断属性是否为 onXXX 格式的事件;
  • 提取原生事件名(onClickclick);
  • 遵循「先清后绑」原则,避免重复绑定导致多次触发。

3. 新增亮点:虚拟节点更新案例(核心解析)

自定义渲染器如何处理 VNode 更新,这也是 Vue 响应式更新的底层缩影:

// 2. 获取挂载容器
const app = document.getElementById('app');

// 3. 初始虚拟节点(无事件)
const vnode1 = h('div', { title: '初始节点' }, 'Hello initial vnode');

// 4. 1秒后更新的虚拟节点(带 onClick 事件)
const vnode2 = h(
  'div',
  {
    onClick() {
      console.log('更新了!点击事件触发成功~');
    },
    title: '更新后节点(带点击事件)' // 同时更新普通属性
  },
  'hello world'
);

// 5. 先渲染初始虚拟节点
renderer.render(vnode1, app);

// 6. 1秒后更新虚拟节点,触发 patchProp 处理事件和属性更新
setTimeout(() => {
  console.log('==== 开始更新虚拟节点 ====');
  renderer.render(vnode2, app);
}, 1000);
这段代码的核心逻辑:
  1. 初始渲染:调用 renderer.render(vnode1, app),渲染器将 vnode1 转换为真实 DOM,插入到挂载容器中,完成首次渲染;
  2. 延迟更新:1 秒后调用 renderer.render(vnode2, app),渲染器会自动对比 vnode1vnode2 的差异(属性、文本内容);
  3. 差异更新
    • 对于 title 属性:触发 patchProp 方法,将旧值「初始节点」更新为新值「更新后节点(带点击事件)」;
    • 对于 onClick 事件:触发 patchProp 方法,绑定新的点击事件回调;
    • 对于文本内容:触发 setText 方法,将「Hello initial vnode」更新为「hello world」;
  4. 无全量重建:整个更新过程没有删除旧 DOM 再创建新 DOM,而是只更新有差异的部分,这也是 Vue 渲染高效的核心原因。

4. 挂载应用的两种方式

案例使用 renderer.render(vnode, container) 直接渲染 VNode,除此之外,也可以通过 renderer.createApp(component).mount(container) 挂载组件,两种方式均有效:

  • 直接渲染 VNode:更灵活,适合手动控制渲染流程(如本次的延迟更新案例);
  • 通过 createApp 挂载:更贴近日常 Vue 开发,适合组件化开发场景。

三、深入理解:自定义渲染器的工作流程

整个渲染与更新过程可以总结为 4 个核心步骤,形成一个完整的闭环:

  1. 生成 VNode:通过 h 函数创建标准 VNode,提供渲染的数据源;
  2. 首次渲染:渲染器调用 6 个核心方法,将 VNode 转换为真实节点,插入到挂载容器中;
  3. VNode 对比:更新时,渲染器对比新旧 VNode,找出属性、文本等差异;
  4. 差异更新:针对差异部分,调用对应的 patchPropsetText 等方法,更新真实节点,无需全量重建。

# Vue 事件系统核心:createInvoker 函数深度解析

Vue 事件系统核心:createInvoker 函数深度解析

🔥 用过 Vue 的都知道,写 @click、@input 这种事件绑定很简单,但你有没有想过:背后 Vue 是怎么处理这些事件的?尤其是当事件回调需要动态变化时,它是怎么做到不频繁绑定/解绑 DOM 事件,还能保证性能的?

答案就藏在 createInvoker 这个函数里。它是 Vue(特别是 Vue3)事件系统里的“事件调用器工厂”,核心作用就是创建一个能灵活更新逻辑的调用器。本文从代码结构开始,一步步把它扒明白。

一、先看核心代码:极简但藏玄机

先上 createInvoker 的核心实现(简化版,保留最关键的逻辑),我们逐行看它到底在做什么:

function createInvoker(value) { 
  // 1. 定义一个调用器函数,用箭头函数写的
  const invoker = (e) => { 
    invoker.value(e)  // 调用器内部,会去执行自己身上的 value 属性
  } 

  // 2. 给这个调用器函数挂个 value 属性,指向传入的事件回调
  invoker.value = value 

  // 3. 把调用器返回出去(函数末尾没写 return ,默认返回这个 invoker)
}

这段代码看着特别简单,但其实就做了三件核心事,理解了这三件事,就懂了一半:

  • 造一个“中间层”:invoker 是个箭头函数,后续 DOM 事件实际绑的就是它;
  • 存真实逻辑:把我们写的事件回调(比如 onClick 里的 handleClick),挂在 invoker 的 value 属性上;
  • 返回中间层:把这个 invoker 返回出去,用于后续的 DOM 事件绑定。

二、三个关键设计:为啥这函数这么好用?

createInvoker 之所以能成为 Vue 事件系统的核心,全靠三个特别巧妙的设计。这些设计不是凭空来的,都是为了解决实际开发中的问题。

1. 函数居然也是对象?这是基础

首先要明确一个 JavaScript 里的核心知识点:函数本质上也是对象。正因为函数是对象,我们才能给它“挂属性”——就像上面代码里,给 invoker 挂了个 value 属性。

所以在 createInvoker 里,invoker 其实有两个身份:

  • 作为“函数”:它是 DOM 事件的回调入口,点击、输入这些事件触发时,第一个被执行的就是它;
  • 作为“对象”:它身上能存东西,这里的 value 就是用来存我们真正要执行的业务回调(比如 handleClick);
  • 这个设计的妙处在于:把“事件触发的入口”和“真实的处理逻辑”分开了。后面要改逻辑的时候,不用动入口,只改存的逻辑就行。

2. 箭头函数:解决 this 乱指的坑

invoker 用箭头函数定义,而不是普通函数,核心目的就是保证 this 能正确指向组件实例。

用过普通函数当事件回调的同学都知道,this 很容易乱指——比如绑在 DOM 上的普通函数,this 会指向触发事件的 DOM 元素,而不是我们的 Vue 组件。但箭头函数没有自己的 this,它会“继承”外层作用域的 this。

在 Vue 里,这个外层作用域的 this 就是组件实例。所以用箭头函数写 invoker,就能确保事件触发时,this 刚好指向我们的组件,不用再手动用 bind 绑定,也不用在业务代码里额外处理 this 问题。

举个反例:如果 invoker 是普通函数,点击 DOM 时 this 会指向那个 DOM 元素,这时候在回调里想访问 this.data、this.methods 都会报错,完全不符合我们的开发预期。

3. 闭包 + 动态更新:不用反复操作 DOM

这是 createInvoker 最核心的优势——支持动态更新事件逻辑,还不用频繁绑解绑 DOM 事件。

我们知道,DOM 操作是前端性能的大瓶颈。如果每次事件回调变了,都要先 removeEventListener 解绑旧的,再 addEventListener 绑定新的,频繁操作下来性能会很差。

而 createInvoker 用了个巧招:因为 invoker 是闭包(内部引用了自身的 value 属性),当我们需要更新事件逻辑时,直接改 invoker.value 的指向就行,不用动 DOM 上的事件绑定。

比如原来 invoker.value 指向 handleClick1,现在要改成 handleClick2,直接写 invoker.value = handleClick2 就搞定了。后续事件触发时,invoker 会自动执行新的 handleClick2,全程不用碰 addEventListener 和 removeEventListener。

三、实际执行流程:从创建到更新全梳理

  1. 创建调用器:Vue 解析模板里的 @click="handleClick" 时,调用 createInvoker 传入 handleClick,生成 invoker,此时 invoker.value = handleClick;
  2. 绑定到 DOM:Vue 将 invoker 通过 addEventListener 绑定到对应的 DOM 元素上(DOM 绑定的是 invoker,而非直接绑定 handleClick);
  3. 事件触发执行:用户触发事件时,invoker 被执行,内部调用 invoker.value(e),最终执行我们写的 handleClick(e);
  4. 动态更新逻辑:需要修改事件回调时,直接修改 invoker.value = 新回调函数即可,无需重新绑定 DOM 事件。

四、简单实用案例:看完就能上手

不用搞复杂的源码场景,这两个简单案例,帮你快速理解 createInvoker 在实际开发中的用法:

案例 1:按钮点击逻辑动态切换

这是最基础的用法,模拟 Vue 里动态改事件回调的场景:

// 先实现 createInvoker 函数
function createInvoker(value) {
  const invoker = (e) => {
    invoker.value(e)
  }
  invoker.value = value
  return invoker
}

// 准备两个不同的点击逻辑
const clickLogic1 = (e) => {
  alert('点击逻辑1:你点了按钮')
}
const clickLogic2 = (e) => {
  alert('点击逻辑2:按钮被点击啦')
}

// 给按钮绑事件
const btn = document.querySelector('#myBtn')
// 创建调用器,初始用逻辑1
const btnInvoker = createInvoker(clickLogic1)
btn.addEventListener('click', btnInvoker)

// 2秒后自动切换成逻辑2(不用解绑事件)
setTimeout(() => {
  btnInvoker.value = clickLogic2
  console.log('已切换点击逻辑,再点按钮试试')
}, 2000)

效果:页面加载后点按钮弹“逻辑1”,2秒后点按钮弹“逻辑2”,全程只绑了一次点击事件。

案例 2:开关控制滚动监听

高频事件(比如 scroll)用这个方式优化特别香,不用反复绑解绑:

function createInvoker(value) {
  const invoker = (e) => {
    invoker.value(e)
  }
  invoker.value = value
  return invoker
}

// 滚动监听逻辑:打印滚动位置
const scrollLogic = () => {
  console.log('滚动位置:', window.scrollY)
}
// 空逻辑:暂停监听时用
const emptyLogic = () => {}

// 创建调用器,初始监听滚动
const scrollInvoker = createInvoker(scrollLogic)
window.addEventListener('scroll', scrollInvoker)

// 开关按钮:点一下暂停/恢复监听
const toggleBtn = document.querySelector('#toggleScroll')
let isListening = true
toggleBtn.onclick = () => {
  isListening = !isListening
  toggleBtn.textContent = isListening ? '暂停滚动监听' : '恢复滚动监听'
  // 只改 invoker.value 就行
  scrollInvoker.value = isListening ? scrollLogic : emptyLogic
}

效果:默认滚动页面会打印位置,点按钮就能暂停,再点恢复,不用动 scroll 事件的绑定状态。

五、最后总结一下

createInvoker 函数看着简单,但核心是三个设计巧思:利用“函数是对象”存逻辑、用箭头函数保 this、靠闭包实现动态更新。最终实现了“高效、灵活、低性能损耗”的事件处理机制,这也是 Vue 事件系统的灵魂。

记住三个关键点,就算真的懂了:

  • invoker 既是事件回调入口(函数),也是逻辑存储容器(对象);
  • 更新事件逻辑,直接改 invoker.value 就行,不用碰 DOM;
  • 箭头函数确保 this 指向组件实例,不用额外处理 this 问题。

理解了 createInvoker 之后,再去看 Vue 源码里和事件相关的部分(比如 patchEvent),就会觉得豁然开朗。




六、最后总结一下

createInvoker 函数看着简单,但核心是三个设计巧思:利用“函数是对象”存逻辑、用箭头函数保 this、靠闭包实现动态更新。最终实现了“高效、灵活、低性能损耗”的事件处理机制,这也是 Vue 事件系统的灵魂。

记住三个关键点,就算真的懂了:

- invoker 既是事件回调入口(函数),也是逻辑存储容器(对象);

- 更新事件逻辑,直接改 invoker.value 就行,不用碰 DOM;

- 箭头函数确保 this 指向组件实例,不用额外处理 this 问题。

理解了 createInvoker 之后,再去看 Vue 源码里和事件相关的部分(比如 patchEvent),就会觉得豁然开朗。
❌