普通视图

发现新文章,点击刷新页面。
昨天 — 2026年4月20日首页

后台管理项目中关于新增、编辑弹框使用的另一种展示形式

作者 只会写Bug
2026年4月20日 13:45

目前大家项目中使用的弹框是以什么形式展现的呢?不知还记不记得以前在使用layui时,使用的layer.open中的iframe形式的弹框。本文编写的就是复刻这一形式的弹框类型,感兴趣的话可以接着往下看哦。

业务背景:目前公司写的大多数页面是这种弹框的类型(都是基于一个老项目的vue2.0版本的模板开发,还有引入jQuery),弹框是基于layer.open二次封装实现的,所以后面我就自己仿照写了一个简易版本直接引入的,去掉不必要的依赖。

废话不多说直接上效果图! 9c830be5-c7a1-4c6d-918f-02e1e0565e81.png 可以全屏及拖动。目前我感觉比较麻烦的是需要维护更多的路由

代码展示: 在main.js中全局引入 31b8f2b4-dd0c-4f2b-b24d-78891be2d3c7.png页面使用: 列表页面中的新增及编辑按钮

// 新增及编辑按钮
const handleAdd = (row) => {
  openDialog(
    {
      title: row? "编辑" : "新增",
      path: "/#/testPageadd",
      width: "800px",
      height: "600px",
      fullscreen: true,
      drag: true,
      close: true,
    },
    (res) => {
      console.log(res, "resres");
    },
  );
};

新增testPageadd页面中回调事件:

//取消
const handleClose = (res) => {
  closeDialog();
};
//确定
const handleSubmit = async () => {
  closeDialog({ valid: true });
};

openDialog完整代码:

!(function (W) {
  ("use strict");
  const keyframes = `.zDialog{display: inline-block;box-sizing: border-box;border-radius: 6px;} 
    @keyframes zcentre_in {
    0% {
        opacity: 0;
         transform: scale(0);
        -webkit-transform: scale(0);
        -moz-transform: scale(0);
        -ms-transform: scale(0);
        -o-transform: scale(0);
    }100% {
        opacity: 1;
        transform: scale(1);
        -webkit-transform: scale(1);
        -moz-transform: scale(1);
        -ms-transform: scale(1);
        -o-transform: scale(1);
        }
    }
    @keyframes zcentre_out {
    0% {
        opacity: 1;
         transform: scale(1);
        -webkit-transform: scale(1);
        -moz-transform: scale(1);
        -ms-transform: scale(1);
        -o-transform: scale(1);
    }100% {
        opacity: 0;
        transform: scale(0);
        -webkit-transform: scale(0);
        -moz-transform: scale(0);
        -ms-transform: scale(0);
        -o-transform: scale(0);
        display:none
        }
    }`;
  // 创建style标签
  const stylekeyframes = document.createElement("style");
  // 设置style属性
  stylekeyframes.type = "text/css";
  // 将 keyframes样式写入style内
  stylekeyframes.innerHTML = keyframes;
  // 将style样式存放到head标签
  document.head.appendChild(stylekeyframes);
  // 样式合集
  let style = {
    Dialog: `position: fixed;top: 0;left: 0;height: 100vh;width: 100vw;overflow: hidden;`, // 主体样式
    Dialog2: `position: absolute;overflow: hidden;`, // 主体样式2
    Dialog3: `top: 50%;transform: translateY(-50%);`, // 主体样式3
    titleStyle: `justify-content: space-between;`,
    titleText: `padding: 10px 20px;width:0;flex:1;font-size: 16px;box-sizing: border-box;`,
    titleClose: `margin: 10px 20px;text-align: right;cursor: pointer;`,
    full: `margin: 10px 0;text-align: right;cursor: pointer;`,
    shade: `position: fixed;top: 0;bottom: 0;left: 0px;right: 0;`,
    iframe: `width: 100%;border: none; `,
  };
  //缓存常用字符
  var doms = [
    "zDialog",
    "zDialog-title",
    "zDialog-iframe",
    "zDialog-content",
    "zDialog-btn",
    "zDialog-close",
    "zDialog-iframe-box",
  ];
  // 弹框框数组
  let openArray = [];
  // 默认方法。
  let zDialog = {
    index: window.zDialog && window.zDialog.v ? 100000 : 0,
    open: "",
  };
  class openClass {
    constructor(setings, callback) {
      this.index = ++zDialog.index;
      this.dialogId = doms[0] + this.index;
      let csetings = JSON.parse(JSON.stringify(setings));
      this.setingsTop = setings.top;
      this.config = {
        v: "1.0.0",
        zIndex: 19961025,
        index: 0,
        closeShow: true, // 是否显示关闭
        needShade: true, // 遮罩
        shadoClick: false, // 遮罩关闭
        shadoColor: "rgba(0, 0, 0, .5)", // 遮罩颜色
        animationTime: 300, // 动画时间
        dtitleshow: true, // 弹框标题显示隐藏
        drag: false, // 拖拽
        fullscreen: false, // 全屏
        isFullscreen: false, // 是否全屏
        time: null, // 动画时间
        top: "100px", // 离顶高度
        left: "100px", // 离左宽度
        width: "800px", // 宽
        height: "600px", // 高
        close: false, // 关闭执行(点击右上角关闭也执行回调)
      };
      if (csetings.top && typeof csetings.top == "number") {
        csetings.top = csetings.top + "px";
      }
      if (csetings.width && typeof csetings.width == "number") {
        csetings.width = csetings.width + "px";
      }
      if (csetings.height && typeof csetings.height == "number") {
        csetings.height = csetings.height + "px";
      }
      this.config = { ...this.config, ...csetings };
      this.callback = callback;
      document.body
        ? this.creat()
        : setTimeout(function () {
            this.createanimation();
            this.creat();
          }, 30);
    }
    creat() {
      if (!this.config.path) {
        alert("请填写路径参数(path)");
        return;
      }
      // 判断黑白
      let scheme = localStorage.getItem("vueuse-color-scheme");
      const dark = "dark";
      let dialogBg = scheme == dark ? "rgba(41,34.2,24,0)" : "#fff"; //弹框背景
      let titleBg = scheme == dark ? "rgb(33.2, 61.4, 90.5)" : "#eee"; //标题背景
      let closeBg = scheme == dark ? "#fff" : "#000"; //标题背景

      // 添加动画样式 js创建@keyframes
      const closeSvg = `<svg t="1703816731858" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="6721" width="14" height="14"><path d="M927.435322 1006.57265l-415.903813-415.903814L95.627695 1006.57265a56.013982 56.013982 0 1 1-79.20377-79.231777l415.903814-415.875807L16.423925 95.58926A56.013982 56.013982 0 0 1 95.627695 16.357483l415.903814 415.903813L927.435322 16.357483a55.985975 55.985975 0 1 1 79.175763 79.231777L590.763286 511.465066l415.847799 415.875807a55.985975 55.985975 0 1 1-79.175763 79.231777z" fill="${closeBg}" p-id="6722"></path></svg>`;
      const fullScreenSvg = `<svg t="1703816632687" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="5441" width="16" height="16"><path d="M704 1024v-128h192v-192h128v320h-320z m192-808.064L215.936 896H448v128H0V576h128v232.064L808.064 128H576V0h448v448h-128V215.936zM128 320H0V0h320v128H128v192z" fill="${closeBg}" p-id="5442"></path></svg>`;

      const titleImgBgc =
        scheme == dark ? "" : `background: rgba(95, 119, 255, 0.51);`;

      this.config.time = this.config.animationTime / 1000;
      // 创建主体盒子
      let zDialogBox = `
            <div class="${doms[0]} ${doms[0] + this.index}" style='${
              style.Dialog2
            }z-index:${this.config.zIndex + this.index};animation: zcentre_in ${
              this.config.time
            }s;width: ${this.config.width};height: ${
              this.config.height
            };background: ${dialogBg}'>
                <div class='${doms[1] + this.index}' style='${
                  style.titleStyle
                }${titleImgBgc}display:${this.config.dtitleshow ? "flex" : "none"};user-select: none;'>
                    <div class='title${this.index}' style='${
                      style.titleText
                    };cursor: ${this.config.drag ? "move" : "initial"}'>${
                      this.config.title || "标题"
                    }</div>
                    <div class='fullScreen${this.index}' style='${
                      style.full
                    };display:${this.config.fullscreen ? "block" : "none"};user-select: none;'>${fullScreenSvg}</div>
                    <div class='close${this.index}' style='${
                      style.titleClose
                    };display:${this.config.closeShow ? "block" : "none"};user-select: none;'>${closeSvg}</div>
                </div>
                <div class="${
                  doms[6] + this.index
                }" style='background: var(--container-box-bg-color)'><iframe class="${
                  doms[2] + this.index
                }" style="${style.iframe}" src='${this.config.path}'></iframe></div>
            </div>`;
      openArray.push({ index: this.index, dialog: this });
      let div = document.createElement("div");
      div.id = doms[0] + this.index;
      this.config.needShade &&
        (div.style =
          style.Dialog + `z-index:` + (this.config.zIndex + this.index));
      !this.config.needShade && (div.style.position = "fixed");
      !this.config.needShade && (div.style.top = "0px");
      div.innerHTML = zDialogBox;
      if (W.parent) {
        W.parent.document.body.appendChild(div);
      } else {
        document.body.appendChild(div);
      }
      // 拖动
      let querySelector = div.querySelector(".title" + this.index);
      querySelector.onmousedown = (event) => {
        this.config.drag && this.move(event);
      };
      //关闭
      let querySelector2 = div.querySelector(".close" + this.index);
      querySelector2.onclick = () => {
        this.cancel();
      };
      // 全屏
      let querySelector3 = div.querySelector(".fullScreen" + this.index);
      querySelector3.onclick = () => {
        this.config.isFullscreen = !this.config.isFullscreen;
        this.isFullscreen();
      };

      // 执行计算宽度的方法
      this.calculatedHeight();
      W.addEventListener("resize", () => {
        this.calculatedHeight("resize");
      });
      this.config.needShade && this.shadeo();
    }
    // 添加遮罩
    shadeo() {
      setTimeout(() => {
        // 添加背景板,根据needShade判断是否显示蒙版 true/false
        let divs = document.getElementById(doms[0] + this.index);
        let div = [divs][0];
        let shade = document.createElement("div");
        shade.id = doms[2] + this.index;
        let shadeStyle =
          style.shade + "z-index:" + (this.config.zIndex + this.index - 1);
        shade.style = shadeStyle;
        shade.style.background = this.config.shadoColor;
        shade.onclick = () => {
          this.config.shadoClick && zDialog.close();
        };
        div.appendChild(shade);
      }, this.config.time - 100);
    }
    cancel() {
      if (this.config.close) {
        zDialog.close({ close: true });
      } else {
        zDialog.close();
      }
    }
    // 回调函数
    callback() {
      config.close && config.close();
    }
    // 拖动
    move(event) {
      let div = document.getElementsByClassName(doms[0] + this.index);
      let moveElement = div[0];
      let windowHeight = W.innerHeight;
      let windowWidth = W.innerWidth;
      document.onmousemove = function (ent) {
        let evt = ent || window.event;
        // 获取鼠标移动的坐标位置
        let ele_top = evt.clientY - event.offsetY;
        let ele_left = evt.clientX - event.offsetX;
        // 将移动的新的坐标位置进行赋值
        // 限制拖动范围
        if (ele_top < 0) {
          ele_top = 0;
        }
        if (ele_left < 0) {
          ele_left = 0;
        }
        // 右边和右下也限制拖动范围
        if (ele_top > windowHeight - moveElement.clientHeight) {
          ele_top = windowHeight - moveElement.clientHeight;
        }
        if (ele_left > windowWidth - moveElement.clientWidth) {
          ele_left = windowWidth - moveElement.clientWidth;
        }

        moveElement.style.top = ele_top + "px";
        moveElement.style.left = ele_left + "px";
      };
      document.onmouseup = function (ent) {
        document.onmousemove = function () {
          return false;
        };
      };
    }

    // 全屏
    isFullscreen() {
      let div = document.getElementsByClassName(doms[0] + this.index);
      let windowHeight = W.innerHeight;
      let windowWidth = W.innerWidth;
      if (this.config.isFullscreen) {
        div[0].style.width = "100%";
        div[0].style.height = "100%";
        div[0].style.top = "0px";
        div[0].style.left = "0px";
      } else {
        div[0].style.width = this.config.width;
        div[0].style.height = this.config.height;
        div[0].style.left = this.config.left;
        div[0].style.top = this.config.top;
      }
    }

    // 计算整个宽度,左右居中
    calculatedHeight(type) {
      let windowHeight = W.innerHeight;
      let windowWidth = W.innerWidth;
      let div = document.getElementsByClassName(doms[0] + this.index);
      if (div && div[0]) {
        let left = (windowWidth - div[0].clientWidth) / 2;
        div[0].style.left = left + "px";
        this.config.left = left + "px";
        // 计算iframe 的高度
        let title = document.getElementsByClassName(doms[1] + this.index);
        let t_h = title[0].clientHeight;
        let all = div[0].clientHeight;
        let iframeh2 = document.getElementsByClassName(doms[6] + this.index);
        let iframeh = document.getElementsByClassName(doms[2] + this.index);
        // 距离顶部
        if (!this.setingsTop) {
          let top = (windowHeight - div[0].clientHeight) / 2;
          div[0].style.top = top + "px";
          this.config.top = top + "px";
        } else {
          div[0].style.top = this.config.top;
        }
        if (!type) {
          iframeh[0].style.opacity = 0;
        }
        if (iframeh[0].attachEvent) {
          // IE 浏览器使用 attachEvent 方法
          iframeh[0].attachEvent("onload", function () {
            iframeh[0].style.opacity = 1;
          });
        } else {
          // 非 IE 浏览器使用 onload 事件
          iframeh[0].onload = function () {
            iframeh[0].style.opacity = 1;
          };
        }
        iframeh2[0].style.height = all - t_h + "px";
        iframeh[0].style.height = all - t_h + "px";
      }
    }
  }
  // 关闭当前
  zDialog.close = function (rcode) {
    let aindex = openArray.pop();
    let nindex = aindex.index;
    if (rcode && aindex.dialog.callback) {
      rcode && aindex.dialog.callback(rcode);
    }
    try {
      W.removeEventListener("resize", () => {});
    } catch (error) {}
    close(nindex);
  };
  // 关闭全部弹框
  zDialog.closeAll = function (callback) {
    openArray.forEach((ele) => {
      close(ele.index);
    });
    openArray = [];
    callback && callback();
  };
  // 根据索引关闭弹框
  close = function (index) {
    let div = document.getElementsByClassName(doms[0] + index);
    if (div && div[0]) {
      div[0].style.animation = "zcentre_out 0.3s";
    }
    setTimeout(() => {
      if (W.parent) {
        let re = W.parent.document.getElementById(doms[0] + index);
        W.parent.document.body.removeChild(re);
      } else {
        let re = document.getElementById(doms[0] + index);
        document.body.removeChild(re);
      }
    }, 200);
  };
  zDialog.open = function (deliver, callback) {
    let z = new openClass(deliver, callback);
    return z.index;
  };
  // 多层嵌套 只在父级添加
  if (W.parent.zDialog) {
    zDialog = W.parent.zDialog;
    zDialog.open = W.parent.zDialog.open;
    zDialog.close = W.parent.zDialog.close;
  }
  //暴露模块
  W.zDialog = zDialog;
  W.openDialog = zDialog.open;
  W.closeDialog = zDialog.close;
})(window);

至此结束!!!谢谢观看!!!

前端请求三部曲:Ajax / Fetch / Axios 演进与 Vue 工程化封装

作者 忆往wu前
2026年4月20日 12:33

从 Ajax → Fetch → Axios:前端网络请求演进史与工程化封装

前言

本篇是 Vue项目实战三板斧系列第一篇,专门聊聊前端最基础的网络请求。

不少同学上来就用 axios,会写但不太明白它到底是怎么来的。 这篇我就带大家简单走一遍进化路线:从最原始的 Ajax,到原生 Fetch,再到我们现在常用的 Axios,一步步看清它们的优缺点,最后一起封装一套简洁、好维护的工程化请求方案。 不求花里胡哨,只求看完能真正理解“我们为什么要这么写请求”。  

一、最原始的网络请求:原生 XMLHttpRequest

要说网络请求,老祖宗必须是 XMLHttpRequest,也就是我们常说的 Ajax。 它实现了页面不刷新就能拿数据,在当年简直是黑科技。

1.1 原生手写 Ajax(最底层写法)

// 1. 创建一个 ajax 实例
const xhr = new XMLHttpRequest();

// 2. 配置请求:请求方式、地址、异步(true)
xhr.open('GET','/api/data',true);

// 3. 监听请求状态变化(旧版常用写法)
xhr.onreadystatechange = function(){
  // readyState === 4 表示请求完成
  if(xhr.readyState === 4){
    // status 200~299 代表请求成功
    if(xhr.status >= 200 && xhr.status < 300){
      // 把后端返回的 JSON 字符串转成对象
      const result = JSON.parse(xhr.responseText);
      console.log('请求成功',result)
    }else{
      console.log('请求失败',xhr.status);
    }
  }
}

// 网络异常、跨域失败时触发
xhr.onerror = function(){
  console.log('网络异常或跨域错误')
}

// 4. 发送请求
xhr.send()

1.2 简单封装一下 Ajax

原生写法太啰嗦,我们简单封装一版,方便复用。

// 封装一个自己的 ajax 函数
function myajax(options) {
  // 1. 创建请求实例
  const xhr = new XMLHttpRequest()

  // 2. 解构配置参数,给默认值
  const {
    method = 'GET',  // 默认 GET 请求
    url,             // 请求地址
    data = null,     // 参数(这里演示无参)
    success,         // 成功回调
    error            // 失败回调
  } = options

  // 3. 初始化请求,转大写防止小写出错
  xhr.open(method.toUpperCase(), url, true)

  /*
    旧写法:onreadystatechange 需要判断 readyState
    新写法:onload 等价于 readyState=4,直接用更简单
  */
  xhr.onload = function () {
    // 判断 HTTP 状态码是否成功
    if (xhr.status >= 200 && xhr.status < 300) {
      // 解析后端返回的 JSON
      const res = JSON.parse(xhr.responseText)
      // 有成功回调就执行
      success && success(res)
    } else {
      // 失败把状态码抛出去
      error && error(xhr.status)
    }
  }

  // 网络异常触发
  xhr.onerror = function () {
    error && error('网络异常或跨域')
  }

  // 发送请求(这里不传参数,避免 GET 报错)
  xhr.send()
}

1.3 Ajax 的缺点(为啥我们不用它了)

缺点一:配置繁琐,全手动判断

详细解释:每发送一个请求,都要重复创建 XMLHttpRequest 实例、调用 open 配置请求、监听状态/错误、调用 send 发送请求,步骤多且冗余。而且要手动判断 readyState 请求状态、手动判断 status HTTP状态码、手动执行 JSON.parse 解析后端返回的字符串,没有任何自动处理逻辑,代码量极大,每写一个请求都要重复大量代码。

缺点二:回调一多直接回调地狱

详细解释: Ajax基于回调函数处理结果,一旦遇到连续多个依赖请求(比如先获取用户ID,再用ID获取详情,再用详情获取订单),就需要在success回调里嵌套下一个myajax请求。代码会层层嵌套、缩进不断加深,可读性极差,后期根本无法维护和修改,这就是典型的回调地狱问题。

  
// 回调地狱示例
myajax({
  url:'/api/user',
  success(res){
    // 第一层回调
    myajax({
      url:`/api/detail?id=${res.id}`,
      success(res){
        // 第二层回调
        myajax({
          url:`/api/order?did=${res.detailId}`,
          success(res){
            // 第三层回调,代码彻底混乱
          }
        })
      }
    })
  }
})
缺点三:没有拦截器、没有超时、没有统一处理

详细解释: 原生XHR没有全局请求/响应拦截机制,每个请求都要单独写错误处理、单独加请求头、单独处理返回结果。比如要给所有接口加token,必须在每个 xhr.open 之后,手动写 setRequestHeader ;想要设置请求超时,需要额外写定时器手动中断请求,无法做到一处配置、全局生效。

缺点四:不支持 Promise

详细解释: 原生Ajax不支持Promise语法,无法使用 async/await 、 then/catch 这种现代化异步写法,只能用传统回调函数。异步流程完全不可控,代码书写不优雅,也无法和现代前端的异步语法接轨,和后续的Fetch、Axios生态完全脱节。

总结:理解底层即可,真实项目没人直接写原生 Ajax。

 

二、现代浏览器原生:Fetch API

时代在进步,浏览器终于看不下去了,推出了Fetch。基于 Promise,告别回调,写法清爽多了。不用从头开始造,省时省力。

2.1 GET 请求(带参数拼接)

// 定义参数
const params = {
  id: 123,
  name: "text"
}

// 把对象转成 ?id=123&name=text 这种格式
const query = new URLSearchParams(params).toString();

// 发送请求
fetch(`/api/user?${query}`)
  .then(res => {
    // fetch 很坑:只有网络失败才 reject,404/500 依然走 then
    if (!res.ok) throw new Error("请求失败:" + res.status)
    // 解析 JSON
    return res.json()
  })
  .then(data => {
    console.log("获取数据成功", data)
  })
  .catch(err => {
    console.error("请求异常", err)
  })

2.2 POST 请求

// fetch 的 post 请求
fetch("/api/user", {
  method: "POST",
  headers: {
    // 必须声明传递 JSON 格式
    "Content-Type": "application/json"
  },
  // 对象转 JSON 字符串
  body: JSON.stringify({
    username: "admin",
    password: "123456"
  })
})
  .then(res => {
    if (!res.ok) throw new Error(res.status)
    return res.json()
  })
  .then(data => {
    console.log("请求成功", data)
  })
  .catch(err => {
    console.error("请求失败", err)
  }) 

2.3 async/await 语法糖更香

// 用 async/await 让代码看起来像同步
async function fetchData() {
  try {
    // 请求参数
    const postData = {
      username: "zhangsan",
      password: "123456"
    }

    // 发送请求
    const response = await fetch("/api/login", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(postData)
    })

    // 判断请求是否成功
    if (!response.ok) {
      throw new Error("请求失败,状态码:" + response.status)
    }

    // 解析数据
    const result = await response.json()
    console.log("请求成功", result)
  } catch (error) {
    // 统一捕获错误
    console.error("请求错误", error)
  }
}

// 执行
fetchData();

2.4 简单封装一版 Fetch

// 封装一个通用的 fetch 请求函数
async function request(url, options = {}) {
  // 解构参数
  const { method = 'GET', data, headers = {}, ...rest } = options;
  // 方法转大写
  const upperMethod = method.toUpperCase();
  // 最终请求地址
  let fetchUrl = url;

  // 配置 fetch 参数
  let fetchOptions = {
    method,
    headers,
    ...rest
  }

  // GET 请求:参数拼接到地址栏
  if (upperMethod === 'GET' && data) {
    const queryStr = new URLSearchParams(data).toString()
    fetchUrl += `?${queryStr}`
  }

  // POST/PUT/DELETE 处理 JSON 格式
  if (['POST', 'PUT', 'DELETE'].includes(upperMethod) && data) {
    // 设置请求头
    fetchOptions.headers['Content-Type'] = 'application/json';
    // 转 JSON 字符串
    fetchOptions.body = JSON.stringify(data)
  }

  try {
    // 发送请求
    const res = await fetch(fetchUrl, fetchOptions)
    // 判断状态
    if (!res.ok) { throw new Error(`请求错误:${res.status}`) }
    // 解析并返回数据
    return await res.json()
  } catch (err) {
    // 打印并抛出异常,外部可以继续 catch
    console.error('请求失败', err)
    throw err
  }
}

2.5 Fetch 有哪些硬伤?

硬伤一:网络错误才 reject,404 / 500 依然走 then,必须手动判断

详细解释: Fetch 的“成功”只看网络是否发出去,只要浏览器收到了 HTTP 响应,哪怕是 401、404、500 错误, fetch  依然认为请求“成功”,会走进  then  而不是  catch 。 所以你必须每次手动判断  res.ok ,否则会把错误当正常数据处理,导致页面报错。

// 不写这句,404/500 不会进 catch
if (!res.ok) throw new Error("请求失败")
硬伤二:没有请求、响应拦截器,所有逻辑必须手写重复

详细解释: Fetch 原生不支持拦截器。如果你想给所有接口加 token、加请求头、统一处理返回值、统一报错,每个 fetch 都要写一遍,无法像 axios 那样全局配置一次到处生效。

// 每个请求都要重复写一遍
headers: {
  "Content-Type": "application/json",
  Authorization: "Bearer " + token
}

 

硬伤三:无法取消请求,没有 abort 方案(必须额外用 AbortController)

详细解释: 原生 fetch 自身不支持取消请求。想要取消必须手动搭配  AbortController ,写一堆额外代码,切换页面、重复请求时无法自动中断,容易造成内存泄漏、重复请求、旧数据覆盖新数据等问题。

硬伤四:没有自带超时处理,超时要自己写定时器包装

详细解释: Axios 直接配置  timeout: 5000  就可以自动超时中断。Fetch 没有超时配置,想实现超时必须自己包一层  Promise.race  +  setTimeout ,每个请求都要重复造轮子,非常麻烦。

硬伤五:请求 body 不会自动处理,必须手动 JSON.stringify

详细解释: Axios 会自动帮你把对象转成 JSON、自动加  Content-Type: application/json 。 Fetch 完全不处理,你必须手动:

body: JSON.stringify(data)
headers: { "Content-Type": "application/json" }

少一句后端就收不到数据,非常容易漏写。

硬伤六:无法监听请求进度(上传/下载进度很难实现)

详细解释: Axios 自带  onUploadProgress  可以直接监听上传进度做进度条。 Fetch 原生不支持,只能通过  ReadableStream  自己手动解析流,实现复杂、成本极高,普通项目基本没法用。

结论:小 demo 能用,中大型项目顶不住。

三、项目主流方案:Axios 全面上手

前面我们了解了:

  • 最底层:XMLHttpRequest,功能强但写起来巨麻烦
  • 现代原生:Fetch,语法好看,但能力残缺

那有没有一个东西,既保留 XHR 的强大能力,又拥有 Fetch 的 Promise 优雅语法,还把所有坑都填了?

它就是我们现在前端项目的事实标准 —— Axios。

重点来了: Axios 并不是什么新底层技术,它本质上就是对原生 XMLHttpRequest 再次封装、增强、Promise 化之后的终极工具库。 相当于把我们刚才手写的简陋 myajax、简陋 fetch 封装,做到了工业级极致。

它解决了所有痛点:支持 Promise、自动处理 JSON、拦截器、取消请求、超时、进度监听…… 所以现在 Vue、React、小程序、Node 项目里,大家几乎都默认用 Axios。

3.1 基础使用

import axios from 'axios'

// 完整写法
axios({
  method: 'get',
  url: '/user',
  params: { id: 10 }
})
  .then(res => {
    // axios 自动帮你解析了 JSON,直接拿 data
    console.log(res.data)
  })
  .catch(err => {
    console.log('请求失败', err)
  }) 

3.2 简写 GET / POST

// 简写 GET
axios.get('/user', {
  params: { id: 10 }
}).catch(err => {
  console.log(err)
})

// 简写 POST(自动处理 JSON,不用自己 stringify)
axios.post('/login', {
  username: 'admin',
  password: '123456'
}).catch(err => {
  console.log(err)
})

3.3 async/await 优雅版

// 登录请求
async function login() {
  try {
    const res = await axios.post('/login', {
      username: 'admin',
      password: '123456'
    })
    console.log(res.data)
  } catch (err) {
    // 请求失败、状态码错误都会进这里
    console.log('请求失败', err)
  }
}

 

四、工程化核心:Axios 二次封装(重点)

真实项目里,我们不会到处直接写 axios.get, 必须封装一次,统一处理:token、超时、状态码、错误提示。

4.1 封装 request.js

import axios from 'axios'

// 创建 axios 实例
const request = axios.create({
  baseURL: '/api',    // 统一接口前缀
  timeout: 5000       // 超时时间 5 秒
})

// =================== 请求拦截器 ===================
request.interceptors.request.use(config => {
  // 从本地拿到 token
  const token = localStorage.getItem('token')
  // 如果有 token,就加到请求头里
  if (token) {
    config.headers.Authorization = `Bearer ${token}`
  }
  // 必须 return config
  return config
})

// =================== 响应拦截器 ===================
request.interceptors.response.use(
  res => {
    // 直接返回后端数据,页面不用再 .data
    return res.data
  },
  err => {
    // 统一错误提示
    console.log('请求出错', err)
    // 抛出异常,让页面可以自己 catch 处理
    return Promise.reject(err)
  }
)

// 导出实例,页面引入使用
export default request

这一封装,好处直接拉满:

- 统一 baseURL,后期改地址只改一处

- 所有接口自动带 token,不用每个请求写

- 统一错误处理,不用每个接口 catch

- 响应直接返回 data,代码更干净

 

五、接口模块化管理(真正工程化)

封装完 axios 还不够,工程化必须接口模块化。

5.1 按业务拆分文件

src/
└── api/
    ├── request.js   # axios 封装
    ├── user.js      # 用户相关接口
    ├── goods.js     # 商品相关接口
    └── order.js     # 订单相关接口

5.2 user.js 示例

import request from './request'

// 登录接口
export function loginApi(data) {
  return request({
    url: '/login',
    method: 'post',
    data
  })
}

// 获取用户信息
export function getUserInfo() {
  return request({
    url: '/user/info',
    method: 'get'
  })
}

5.3 组件中使用

import { loginApi } from '@/api/user'

async function login() {
  try {
    const res = await loginApi({
      username: 'admin',
      password: '123456'
    })
    console.log('登录成功', res)
  } catch (err) {
    console.log('登录失败')
  }
}

优点:

- 接口统一管理,便于维护

- 页面逻辑更干净

- 方便 mock、方便重复调用

六、在 Vue3 组件中实战使用

Vue

<template>
  <div>
    <button @click="getUser">获取用户信息</button>
  </div>
</template>

<script setup>
import { getUserInfo } from '@/api/user'
import { ref } from 'vue'

const userInfo = ref({})

// 获取数据
const getUser = async () => {
  try {
    const res = await getUserInfo()
    userInfo.value = res
  } catch (err) {
    console.log('请求失败')
  }
}
</script>

可以看到,组件中已经完全看不到底层的  axios  调用,只需要调用封装好的接口方法即可完成数据请求。代码更加简洁清晰,职责更加单一,真体现了前端工程化低耦合、高复用、易维护的优势。

七、总结

这一篇我们完整走完了前端请求进化之路:

1. Ajax(XMLHttpRequest):底层基石,所有请求的根

2. Fetch:浏览器原生 Promise 方案,但能力有限

3. Axios:基于 XHR 深度封装,现代前端工程化最佳实践

工具一直在变,但核心思路没变:

从繁琐难用,到语法简化,再到功能完善。 Axios 之所以成为主流,正是因为它在原生 XHR 的基础上做了大量贴心封装,让我们不用再重复处理各种细节。

而封装和工程化的意义,也远不止“省事”这么简单:

统一的配置、统一的错误处理、按模块拆分接口,本质上都是为了让代码更简洁、更好维护、更容易协作。 一个项目是否规范,往往从请求层就能看出来。

搞懂这些来龙去脉,以后再写接口、做封装,就不再是机械复制代码,而是真正知道自己在做什么、为什么这么做。

这也是 Vue 项目工程化的第一步。 下一篇我们继续三板斧第二篇:VueRouter 路由与路由守卫,配合今天的 token 实现登录鉴权。

你的 Vue KeepAlive 组件,VuReact 会编译成什么样的 React 代码?

作者 Ruihong
2026年4月20日 10:11

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中内置的 <KeepAlive> 组件经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中 <KeepAlive> 组件的用法。

编译对照

KeepAlive:组件缓存

<KeepAlive> 是 Vue 中用于缓存组件实例的内置组件,可以在动态切换组件时保留组件状态,避免重新渲染和数据丢失。

基础 KeepAlive 使用

  • Vue 代码:
<template>
  <KeepAlive>
    <component :is="currentView" />
  </KeepAlive>
</template>
  • VuReact 编译后 React 代码:
import { KeepAlive } from '@vureact/runtime-core';

<KeepAlive>
  <Component is={currentView} />
</KeepAlive>

从示例可以看到:Vue 的 <KeepAlive> 组件被编译为 VuReact Runtime 提供的 KeepAlive 适配组件,可理解为「React 版的 Vue KeepAlive」。

这种编译方式的关键特点在于:

  1. 语义一致性:完全模拟 Vue <KeepAlive> 的行为,实现组件实例缓存
  2. 状态保持:缓存被移除的组件实例,避免状态丢失
  3. 性能优化:减少不必要的组件重新渲染
  4. React 适配:在 React 环境中实现 Vue 的缓存语义

带 key 的 KeepAlive

为了确保缓存正确工作,建议为动态组件提供稳定的 key

  • Vue 代码:
<template>
  <KeepAlive>
    <component :is="currentComponent" :key="componentKey" />
  </KeepAlive>
</template>
  • VuReact 编译后 React 代码:
<KeepAlive>
  <Component is={currentComponent} key={componentKey} />
</KeepAlive>

key 的重要性

  1. 缓存标识key 用于标识和匹配缓存实例
  2. 稳定切换:确保组件切换时能正确命中缓存
  3. 性能优化:避免不必要的缓存创建和销毁
  4. 最佳实践:始终为动态组件提供稳定的 key

包含与排除控制

<KeepAlive> 支持通过 includeexclude 属性精确控制哪些组件需要缓存。

include:包含特定组件

  • Vue 代码:
<template>
  <KeepAlive :include="['ComponentA', 'ComponentB']">
    <component :is="currentView" />
  </KeepAlive>
</template>
  • VuReact 编译后 React 代码:
<KeepAlive include={['ComponentA', 'ComponentB']}>
  <Component is={currentView} />
</KeepAlive>

exclude:排除特定组件

  • Vue 代码:
<template>
  <KeepAlive :exclude="['GuestPanel', /^Temp/]">
    <component :is="currentView" />
  </KeepAlive>
</template>
  • VuReact 编译后 React 代码:
<KeepAlive exclude={['GuestPanel', /^Temp/]}>
  <Component is={currentView} />
</KeepAlive>

匹配规则

  1. 字符串匹配:精确匹配组件名
  2. 正则表达式:匹配符合模式的组件名
  3. 数组组合:支持字符串和正则的数组组合
  4. key 匹配:同时尝试匹配组件名和缓存 key

最大缓存实例数

通过 max 属性可以限制最大缓存数量,避免内存过度使用。

  • Vue 代码:
<template>
  <KeepAlive :max="3">
    <component :is="currentTab" />
  </KeepAlive>
</template>
  • VuReact 编译后 React 代码:
<KeepAlive max={3}>
  <Component is={currentTab} />
</KeepAlive>

缓存淘汰策略

  1. LRU 算法:淘汰最久未访问的缓存实例
  2. 内存管理:自动清理超出限制的缓存
  3. 性能平衡:在内存使用和性能之间取得平衡
  4. 智能管理:根据访问频率智能管理缓存

缓存生命周期

<KeepAlive> 缓存的组件有特殊的生命周期,可以通过相应的 Hook 监听。

激活与停用生命周期

  • Vue 代码:
<script setup>
import { onActivated, onDeactivated } from 'vue';

onActivated(() => {
  console.log('组件被激活');
});

onDeactivated(() => {
  console.log('组件被停用');
});
</script>
  • VuReact 编译后 React 代码:
import { useActived, useDeactivated } from '@vureact/runtime-core';

function MyComponent() {
  useActived(() => {
    console.log('组件被激活');
  });

  useDeactivated(() => {
    console.log('组件被停用');
  });

  return <div>组件内容</div>;
}

生命周期事件

  1. useActived:组件从缓存中恢复显示时触发
  2. useDeactivated:组件被缓存时触发
  3. 首次渲染:组件首次渲染时也会触发 activated
  4. 最终卸载:组件最终被销毁时触发 deactivated

编译策略总结

VuReact 的 KeepAlive 编译策略展示了完整的组件缓存转换能力

  1. 组件直接映射:将 Vue <KeepAlive> 直接映射为 VuReact 的 <KeepAlive>
  2. 属性完全支持:支持 includeexcludemax 等所有属性
  3. 生命周期适配:将 Vue 生命周期 Hook 转换为 React Hook
  4. 缓存语义保持:完全保持 Vue 的缓存行为和语义

KeepAlive 的工作原理

  1. 实例缓存:组件切出时保留实例在内存中
  2. 状态保持:保持组件的所有状态和数据
  3. DOM 保留:保留组件的 DOM 结构
  4. 智能恢复:切回时快速恢复之前的实例

性能优化策略

  1. 按需缓存:只缓存真正需要的组件
  2. 内存管理:智能管理缓存内存使用
  3. 快速恢复:优化缓存恢复性能
  4. 垃圾回收:及时清理不再需要的缓存

注意事项

  1. 单一子节点<KeepAlive> 只能有一个直接子节点
  2. 组件类型:只能缓存组件元素,不能缓存普通元素
  3. key 要求:缺少稳定 key 时会降级为非缓存渲染

VuReact 的编译策略确保了从 Vue 到 React 的平滑迁移,开发者无需手动实现组件缓存逻辑。编译后的代码既保持了 Vue 的缓存语义和性能优势,又符合 React 的组件设计模式,让迁移后的应用保持完整的组件缓存能力。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

你的 Vue slot 插槽,VuReact 会编译成什么样的 React 代码?

作者 Ruihong
2026年4月20日 09:17

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 <slot> 插槽经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的插槽用法。

编译对照

默认插槽:<slot>

默认插槽是 Vue 中最基本的插槽形式,用于接收父组件传递的默认内容。

  • Vue 代码:
<!-- 子组件 Child.vue -->
<template>
  <div class="container">
    <slot></slot>
  </div>
</template>

<!-- 父组件使用 -->
<Child>
  <p>这是插槽内容</p>
</Child>
  • VuReact 编译后 React 代码:
// 子组件 Child.jsx
function Child(props) {
  return (
    <div className="container">
      {props.children}
    </div>
  );
}

// 父组件使用
<Child>
  <p>这是插槽内容</p>
</Child>

从示例可以看到:Vue 的 <slot> 元素被编译为 React 的 children prop。VuReact 采用 children 编译策略,将插槽出口转换为 React 的标准 children 接收方式,完全保持 Vue 的默认插槽语义——接收父组件传递的子内容并渲染。

这种编译方式的关键特点在于:

  1. 语义一致性:完全模拟 Vue 默认插槽的行为,实现内容分发
  2. React 原生支持:使用 React 标准的 children 机制,无需额外适配
  3. 语法简洁:Vue 的 <slot> 简化为 {children} 表达式
  4. 性能优化:直接使用 React 的原生机制,无运行时开销

具名插槽:<slot name="xxx">

具名插槽允许组件定义多个插槽出口,父组件可以通过名称指定内容插入位置。

  • Vue 代码:
<!-- 子组件 Layout.vue -->
<template>
  <div class="layout">
    <header>
      <slot name="header"></slot>
    </header>
    <main>
      <slot></slot>
    </main>
    <footer>
      <slot name="footer"></slot>
    </footer>
  </div>
</template>

<!-- 父组件使用 -->
<Layout>
  <template #header>
    <h1>页面标题</h1>
  </template>
  
  <p>主要内容</p>
  
  <template #footer>
    <p>版权信息</p>
  </template>
</Layout>
  • VuReact 编译后 React 代码:
// 子组件 Layout.jsx
function Layout(props) {
  return (
    <div className="layout">
      <header>{props.header}</header>
      <main>{props.children}</main>
      <footer>{props.footer}</footer>
    </div>
  );
}

// 父组件使用
<Layout
  header={<h1>页面标题</h1>}
  footer={<p>版权信息</p>}
>
  <p>主要内容</p>
</Layout>

从示例可以看到:Vue 的具名插槽 <slot name="xxx"> 被编译为 React 的 props。VuReact 采用 props 编译策略,将具名插槽出口转换为组件的命名 props,完全保持 Vue 的具名插槽语义——通过不同的 prop 名称区分不同的插槽内容。

编译规则

  1. 插槽名映射<slot name="header">header prop
  2. 默认插槽<slot>children prop
  3. props 接收:在组件函数参数中解构接收所有插槽 props

作用域插槽:<slot :prop="value">

作用域插槽允许子组件向插槽内容传递数据,实现更灵活的渲染控制。

  • Vue 代码:
<!-- 子组件 List.vue -->
<template>
  <ul>
    <li v-for="(item, i) in props.items" :key="item.id">
      <slot :item="item" :index="i"></slot>
    </li>
  </ul>
</template>

<!-- 父组件使用 -->
<List :items="users">
  <template v-slot="slotProps">
    <div class="user-item">
      {{ slotProps.index + 1 }}. {{ slotProps.item.name }}
    </div>
  </template>
</List>
  • VuReact 编译后 React 代码:
// 子组件 List.jsx
function List(props) {
  return (
    <ul>
      {props.items.map((item, index) => (
        <li key={item.id}>
          {props.children?.({ item, index })}
        </li>
      ))}
    </ul>
  );
}

// 父组件使用
<List 
  items={users}
  children={(slotProps) => (
    <div className="user-item">
      {slotProps.index + 1}. {slotProps.item.name}
    </div>
  )}
/>

从示例可以看到:Vue 的作用域插槽被编译为 React 的函数 children。VuReact 采用 函数 children 编译策略,将作用域插槽出口转换为接收参数的函数,完全保持 Vue 的作用域插槽语义——子组件通过函数调用向父组件传递数据,父组件通过函数参数接收数据并渲染。

编译规则

  1. 插槽属性转换<slot :item="item" :index="i"> → 函数参数 { item, index }
  2. 函数调用:在渲染位置调用 children() 函数并传递数据
  3. 可选链保护:使用 ?. 避免未提供插槽内容时的错误

具名作用域插槽:<slot name="xxx" :prop="value">

具名作用域插槽结合了具名插槽和作用域插槽的特性。

  • Vue 代码:
<!-- 子组件 Table.vue -->
<template>
  <table>
    <thead>
      <tr>
        <slot name="header" :columns="props.columns"></slot>
      </tr>
    </thead>
    <tbody>
      <tr v-for="row in props.data" :key="row.id">
        <slot name="body" :row="row" :columns="props.columns"></slot>
      </tr>
    </tbody>
  </table>
</template>

<!-- 父组件使用 -->
<Table :columns="tableColumns" :data="tableData">
  <template #header="headerProps">
    <th v-for="col in headerProps.columns" :key="col.id">
      {{ col.title }}
    </th>
  </template>
  
  <template #body="bodyProps">
    <td v-for="col in bodyProps.columns" :key="col.id">
      {{ bodyProps.row[col.field] }}
    </td>
  </template>
</Table>
  • VuReact 编译后 React 代码:
// 子组件 Table.jsx
function Table(props) {
  return (
    <table>
      <thead>
        <tr>
          {props.header?.({ columns: props.columns })}
        </tr>
      </thead>
      <tbody>
        {props.data.map((row) => (
          <tr key={row.id}>
            {props.body?.({ row: props.row, columns: props.columns })}
          </tr>
        ))}
      </tbody>
    </table>
  );
}

// 父组件使用
<Table
  columns={tableColumns}
  data={tableData}
  header={(headerProps) => (
    <>
      {headerProps.columns.map((col) => (
        <th key={col.id}>{col.title}</th>
      ))}
    </>
  )}
  body={(bodyProps) => (
    <>
      {bodyProps.columns.map((col) => (
        <td key={col.id}>{bodyProps.row[col.field]}</td>
      ))}
    </>
  )}
/>

编译策略

  1. 具名函数 props:具名作用域插槽转换为函数 props
  2. 参数传递:正确传递作用域参数
  3. Fragment 包装:多个元素使用 Fragment 包装
  4. 类型安全:保持 TypeScript 类型定义的完整性

插槽默认内容

Vue 支持在插槽定义处提供默认内容,当父组件没有提供插槽内容时显示。

  • Vue 代码:
<!-- 子组件 Button.vue -->
<template>
  <button class="btn">
    <slot>
      <span class="default-text">点击我</span>
    </slot>
  </button>
</template>
  • VuReact 编译后 React 代码:
// 子组件 Button.jsx
function Button(props) {
  return (
    <button className="btn">
      {props.children || <span className="default-text">点击我</span>}
    </button>
  );
}

默认内容处理规则

  1. 条件渲染:使用 || 运算符检查 children 是否存在
  2. 默认值提供:当 children 为 falsy 值时渲染默认内容
  3. React 模式:使用标准的 React 条件渲染模式

动态插槽名

Vue 支持动态的插槽名称,用于更灵活的插槽选择。

  • Vue 代码:
<!-- 子组件 DynamicSlot.vue -->
<template>
  <div>
    <slot :name="dynamicSlotName"></slot>
  </div>
</template>
  • VuReact 编译后 React 代码:
// 子组件 DynamicSlot.jsx
function DynamicSlot(props) {
  return (
    <div>
      {props[dynamicSlotName]}
    </div>
  );
}

动态插槽处理

  1. 计算属性名:使用对象计算属性语法接收动态插槽
  2. 运行时确定:插槽名在运行时确定

编译策略总结

VuReact 的 <slot> 编译策略展示了完整的插槽系统转换能力

  1. 默认插槽:转换为 React 的 children
  2. 具名插槽:转换为组件的命名 props
  3. 作用域插槽:转换为函数 children 或函数 props
  4. 默认内容:支持插槽默认内容
  5. 动态插槽:支持动态插槽名称

插槽类型映射表

Vue 插槽类型 React 对应形式 说明
<slot> children 默认插槽,作为组件的子元素
<slot name="xxx"> xxx prop 具名插槽,作为组件的属性
<slot :prop="value"> 函数 children 作用域插槽,作为接收参数的函数
<slot name="xxx" :prop="value"> 函数 xxx prop 具名作用域插槽,作为函数属性

性能优化策略

  1. 静态插槽优化:对于静态插槽内容,编译为静态 JSX
  2. 函数缓存:对于作用域插槽,智能缓存渲染函数
  3. 按需生成:根据实际使用情况生成最简化的代码
  4. 类型推导:支持在 TypeScript 中智能推导插槽的类型定义

VuReact 的编译策略确保了从 Vue 到 React 的平滑迁移,开发者无需手动重写插槽逻辑。编译后的代码既保持了 Vue 的语义和灵活性,又符合 React 的组件设计模式,让迁移后的应用保持完整的内容分发能力。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

Vue v-slot → 用 VuReact 转换后变成这样的 React 代码

作者 Ruihong
2026年4月19日 20:39

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 v-slot 指令经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的 v-slot 指令用法。

编译对照

v-slot / #:基础插槽使用

v-slot(简写为 #) 是 Vue 中用于定义和使用插槽的指令,用于实现组件的内容分发和复用。

默认插槽

  • Vue 代码:
<!-- 父组件 -->
<MyComponent>
  <template #default>
    <p>默认插槽内容</p>
  </template>
</MyComponent>

<!-- 或简写 -->
<MyComponent>
  <p>默认插槽内容</p>
</MyComponent>
  • VuReact 编译后 React 代码:
// 父组件
<MyComponent>
  <p>默认插槽内容</p>
</MyComponent>

从示例可以看到:Vue 的默认插槽被直接编译为 React 的 children。VuReact 采用 children 编译策略,将模板插槽转换为 React 的标准 children 传递方式,完全保持 Vue 的默认插槽语义——将内容作为子元素传递给组件。

这种编译方式的关键特点在于:

  1. 语义一致性:完全模拟 Vue 默认插槽的行为,实现内容分发
  2. React 原生支持:使用 React 标准的 children 机制,无需额外适配
  3. 语法简化:Vue 的 <template #default> 简化为直接传递子元素
  4. 性能优化:直接使用 React 的原生机制,无运行时开销

具名插槽

Vue 支持多个具名插槽,用于更灵活的内容分发。

基础具名插槽

  • Vue 代码:
<!-- 父组件 -->
<Layout>
  <template #header>
    <h1>页面标题</h1>
  </template>
  
  <template #main>
    <p>主要内容区域</p>
  </template>
  
  <template #footer>
    <p>页脚信息</p>
  </template>
</Layout>
  • VuReact 编译后 React 代码:
// 父组件
<Layout 
  header={<h1>页面标题</h1>}
  main={<p>主要内容区域</p>}
  footer={<p>页脚信息</p>}
/>

从示例可以看到:Vue 的具名插槽被编译为 React 的 props。VuReact 采用 props 编译策略,将具名插槽转换为组件的 props 属性,完全保持 Vue 的具名插槽语义——通过不同的 prop 名称区分不同的插槽内容。


作用域插槽

Vue 的作用域插槽允许子组件向父组件传递数据,实现更灵活的渲染控制。

基础作用域插槽

  • Vue 代码:
<!-- 父组件 -->
<DataList :items="users">
  <template #item="slotProps">
    <div class="user-item">
      <span>{{ slotProps.user.name }}</span>
      <span>{{ slotProps.user.age }}岁</span>
    </div>
  </template>
</DataList>

<!-- 子组件 DataList.vue -->
<template>
  <ul>
    <li v-for="item in props.items" :key="item.id">
      <slot name="item" :user="item"></slot>
    </li>
  </ul>
</template>
  • VuReact 编译后 React 代码:
// 父组件
<DataList 
  items={users}
  item={(slotProps) => (
    <div className="user-item">
      <span>{slotProps.user.name}</span>
      <span>{slotProps.user.age}岁</span>
    </div>
  )}
/>

// 子组件 DataList.jsx
function DataList(props) {
  return (
    <ul>
      {props.items.map((itemData) => (
        <li key={itemData.id}>
          {props.item?.({ user: itemData })}
        </li>
      ))}
    </ul>
  );
}

从示例可以看到:Vue 的作用域插槽被编译为 React 的函数 props。VuReact 采用 函数 props 编译策略,将作用域插槽转换为接收参数的函数 prop,完全保持 Vue 的作用域插槽语义——子组件通过函数调用向父组件传递数据,父组件通过函数参数接收数据并渲染。


动态插槽名

Vue 支持动态的插槽名称,用于更灵活的插槽选择。

  • Vue 代码:
<BaseLayout>
  <template #[dynamicSlotName]>
    动态插槽内容
  </template>
</BaseLayout>
  • VuReact 编译后 React 代码:
<BaseLayout 
  {...{ [dynamicSlotName]: "动态插槽内容" }}
/>

编译策略

  1. 计算属性名:使用对象计算属性语法 { [key]: value }
  2. 对象展开:通过对象展开语法应用到组件上
  3. 运行时处理:动态插槽名需要在运行时确定

插槽默认内容

Vue 支持在插槽定义处提供默认内容,当父组件没有提供插槽内容时显示。

  • Vue 代码:
<!-- 子组件 Button.vue -->
<template>
  <button class="btn">
    <slot>
      <span>默认按钮文本</span>
    </slot>
  </button>
</template>
  • VuReact 编译后 React 代码:
// 子组件 Button.jsx
function Button(props) {
  return (
    <button className="btn">
      {props.children || <span>默认按钮文本</span>}
    </button>
  );
}

默认内容处理规则

  1. children 检查:检查 children 是否存在
  2. 默认值渲染:当 children 为 falsy 值时渲染默认内容
  3. React 兼容:使用标准的 React 条件渲染模式

编译策略总结

VuReact 的 v-slot 编译策略展示了完整的插槽系统转换能力

  1. 默认插槽:转换为 React 的 children
  2. 具名插槽:转换为组件的 props
  3. 作用域插槽:转换为函数 props
  4. 动态插槽:支持动态插槽名称
  5. 默认内容:支持插槽默认内容

插槽类型映射表

Vue 插槽类型 React 对应形式 说明
默认插槽 children 作为组件的子元素
具名插槽 prop 作为组件的属性
作用域插槽 函数prop 作为接收参数的函数属性
动态插槽 计算属性 使用对象计算属性语法

性能优化策略

  1. 静态插槽优化:对于静态插槽内容,编译为静态 JSX
  2. 函数缓存:对于作用域插槽,智能缓存渲染函数
  3. 按需生成:根据实际使用情况生成最简化的代码
  4. 类型推导:智能推导插槽的类型定义

VuReact 的编译策略确保了从 Vue 到 React 的平滑迁移,开发者无需手动重写插槽逻辑。编译后的代码既保持了 Vue 的语义和灵活性,又符合 React 的组件设计模式,让迁移后的应用保持完整的内容分发能力。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

你的 Vue v-model,VuReact 会编译成什么样的 React 代码?

作者 Ruihong
2026年4月19日 20:19

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 v-model 指令经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的 v-model 指令用法。

编译对照

v-model:基础表单双向绑定

v-model 是 Vue 中用于实现表单输入元素双向数据绑定的语法糖,它结合了 v-bindv-on 的功能。

文本输入框

  • Vue 代码:
<input v-model="keyword" />
  • VuReact 编译后 React 代码:
<input
  value={keyword.value}
  onChange={(value) => {
    keyword.value = value;
  }}
/>

从示例可以看到:Vue 的 v-model 指令被编译为 React 的受控组件模式。VuReact 采用 受控组件编译策略,将模板指令转换为 valueonChange 的组合,完全保持 Vue 的双向绑定语义——实现数据与视图的同步更新。

这种编译方式的关键特点在于:

  1. 语义一致性:完全模拟 Vue v-model 的行为,实现双向数据绑定
  2. 受控组件模式:使用 React 标准的受控组件实现
  3. 事件处理:自动处理输入事件和值更新
  4. 响应式集成:与 Vue 的响应式系统无缝集成

不同输入类型的 v-model

Vue 的 v-model 会根据输入元素的类型自动适配,VuReact 也保持了这种智能适配能力。

复选框

  • Vue 代码:
<input type="checkbox" v-model="checked" />
<input type="checkbox" value="vue" v-model="frameworks" />
  • VuReact 编译后 React 代码:
<input
  type="checkbox"
  checked={checked.value}
  onChecked={(e) => {
    checked.value = e.target.checked;
  }}
/>
<input
  type="checkbox"
  value="vue"
  checked={frameworks.value}
  onChange={(e) => {
    frameworks.value = e.target.checked;
  }}
/>

单选按钮

  • Vue 代码:
<input type="radio" value="male" v-model="gender" />
<input type="radio" value="female" v-model="gender" />
  • VuReact 编译后 React 代码:
<input
  type="radio"
  value="male"
  checked={gender.value === 'male'}
  onChange={() => { gender.value = 'male' }}
/>

<input
  type="radio"
  value="female"
  checked={gender.value === 'female'}
  onChange={() => { gender.value = 'female' }}
/>

下拉选择框

  • Vue 代码:
<select v-model="selected">
  <option value="a">选项A</option>
  <option value="b">选项B</option>
</select>
  • VuReact 编译后 React 代码:
<select
  value={selected.value}
  onChange={(e) => {
    selected.value = e.target.value;
  }}
>
  <option value="a">选项A</option>
  <option value="b">选项B</option>
</select>

v-model 修饰符

Vue 的 v-model 支持多种修饰符,用于控制数据更新的时机和格式。

.lazy 修饰符

  • Vue 代码:
<input v-model.lazy="message" />
  • VuReact 编译后 React 代码:
<input
  value={message.value}
  onBlur={(e) => {
    message.value = e.target.value;
  }}
/>

.number 修饰符

  • Vue 代码:
<input v-model.number="age" />
  • VuReact 编译后 React 代码:
<input
  value={age.value}
  onChange={(e) => {
    age.value = Number(e.target.value);
  }}
/>

.trim 修饰符

  • Vue 代码:
<input v-model.trim="username" />
  • VuReact 编译后 React 代码:
<input
  value={username.value}
  onChange={(e) => {
    username.value = e.target.value?.trim();
  }}
/>

修饰符组合

  • Vue 代码:
<input v-model.lazy.trim="search" />
  • VuReact 编译后 React 代码:
<input
  value={search.value}
  onBlur={(e) => {
    search.value = e.target.value?.trim();
  }}
/>

组件 v-model

Vue 3 对组件的 v-model 进行了重大改进,支持多个 v-model 绑定和自定义修饰符。

基础组件 v-model

  • Vue 代码:
<!-- 父组件 -->
<CustomInput v-model="inputValue" />

<!-- 子组件 CustomInput.vue -->
<script setup lang="ts">
  const props = defineProps(['modelValue']);
  const emits = defineEmits(['update:modelValue']);
</script>

<template>
  <input :value="props.modelValue" @input="(e) => emits('update:modelValue', e.target.value)" />
</template>
  • VuReact 编译后 React 代码:
// 父组件
<CustomInput
  modelValue={inputValue.value}
  onUpdateModelValue={(value) => {
    inputValue.value = value;
  }}
/>;

// 子组件 CustomInput.tsx
type ICustomInputProps = {
  modelValue?: any;
  onUpdateModelValue?: (...args: any[]) => any;
}

function CustomInput(props: ICustomInputProps) {
  return (
    <input value={props.modelValue} onChange={(e) => props.onUpdateModelValue?.(e.target.value)} />
  );
}

带参数的 v-model

  • Vue 代码:
<UserForm v-model:name="userName" v-model:email="userEmail" />
  • VuReact 编译后 React 代码:
<UserForm
  name={userName.value}
  onUpdateName={(value) => {
    userName.value = value;
  }}
  email={userEmail.value}
  onUpdateEmail={(value) => {
    userEmail.value = value;
  }}
/>

编译策略总结

VuReact 的 v-model 编译策略展示了完整的双向绑定转换能力

  1. 基础表单元素:将各种输入类型的 v-model 转换为对应的受控组件
  2. 修饰符支持:完整支持 .lazy.number.trim 等修饰符
  3. 组件 v-model:支持组件级别的双向绑定,包括多个 v-model 和自定义修饰符
  4. 事件映射:智能映射 Vue 事件到 React 事件(inputonChange 等)
  5. 类型安全:保持 TypeScript 类型定义的完整性

不同类型元素的编译映射

元素类型 Vue 事件 React 事件 值属性
input[type="text"] input onChange value
textarea input onChange value
input[type="checkbox"] change onChange checked
input[type="radio"] change onChange checked
select change onChange value

VuReact 的编译策略确保了从 Vue 到 React 的平滑迁移,开发者无需手动重写表单绑定逻辑。编译后的代码既保持了 Vue 的语义和便利性,又符合 React 的表单处理最佳实践,让迁移后的应用保持完整的表单交互能力。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

6.响应式系统比对:通过 Vue3 响应式库写 React 应用

作者 Cobyte
2026年4月20日 09:04

前言

鉴于 Vue3 已经把响应式库进行了独立,也就是 @vue/reactivity,既然 Mobx 也是一个响应式库都可以应用在 React 上,那么 @vue/reactivity 可不可以也应用在 React 上呢?很显然是可以的,社区里也有很多关于这么方面的实践。那么我们这里也提供一个参考 Mobx 实现的版本。

跟 Mobx 对比的话,@vue/reactivity 就相当于 mobx 库,所以我们只需要参考 mobx-react-lite 实现一个 vue-react-lite 即可。

实现 vue-react-lite

我们通过上一篇文章可以知道 Mobx 是通过 mobx-react-lite 实现与 React 进行链接的,其中最重要的函数就是 observer,那么我们也在 vue-react-lite 中实现一个 observer 函数。根据我们前篇所学的知识知道 observer 是一个高阶函数,所以我们初步把 observer 的基础架构搭建出来。

function observer(baseComponent) {
    return (props) => {
        return baseComponent(props)
    }
}

接下来我们知道 Mobx 中是通过 Reaction 这个订阅者中介来实现不同组件函数的代理的,而在 @vue/reactivity 中的跟 Reaction 相同角色的的则是 ReactiveEffect,那么我们就可以通过它来实现我们想要的功能。

代码实现如下:

import { useState, useRef } from "react"
import { ReactiveEffect  } from "@vue/reactivity"
function observer(baseComponent) {
    return (props) => {
        const [, setState] = useState()
        const admRef = useRef(null)
        if (!admRef.current) {
            admRef.current = new ReactiveEffect(() => {
                return baseComponent(props)
            }, () => {
                setState(Symbol())
            })
        }
        const effect = admRef.current
        return effect.run()
    }
}

那么我们就通过 ReactiveEffect 实现了一个跟 mobx-react-lite 中的 observer 一样的功能的函数。

如果大家对 Vue3 的 effect 函数熟悉的话,我们上述 observer 的实现过程跟 Vue3 的 effect 实现很类似的。我们可以回顾一下 Vue3 的 ReactiveEffect 类的功能,它本质是一个订阅者中介,跟 Vue2 的 Watcher 类是一样的角色。ReactiveEffect 的第一个参数就是具体的订阅者函数,而第二个参数则是一个叫 scheduler 的回调函数,在更新的时候如果存在 scheduler 回调函数则执行 scheduler 回调函数,否则执行第一个参数的函数。基于这个原理,我们就在 ReactiveEffect 的第二个参数中设置执行 React 的更新 setState(Symbol()),同时 ReactiveEffect 上存在一个 run 方法,需要通过手动执行进行初始化。

应用 vue-react-lite

那么我们上面通过 ReactiveEffect 实现了 observer 函数,这样我们就可以在 React 中应用 Vue3 的数据响应式库了。下面我们来测试一下:

import { reactive } from "@vue/reactivity";
import { observer } from "./vue-react-lite"

const proxy = reactive({ name: 'Cobyte', secondsPassed: 0 })

const TimerView = observer(({ proxy }) => <span>the content run in `@vue/reactivity` is "Seconds passed: {proxy.secondsPassed}"</span>)

function App() {
  return (
    <TimerView proxy={proxy}></TimerView>
  );
}

setInterval(() => {
  proxy.secondsPassed +=1
}, 1000)

export default App;

打印结果如下:

tutieshi_640x195_5s.gif

我们发现已经成功把 @vue/reactivity 库应用到 React 中了。

根据 Mobx 的启发实现 Vue 数据响应式的 OOP

我们知道 Mobx 的写法是更倾向 OOP 的,同时是严格遵守单向数据流,所以我们也可以在通过 Vue 响应式库提供的 shallowRef API 实现 OOP。

import { reactive, shallowRef } from "@vue/reactivity"
import { observer } from "./vue-react-lite"

class DataService {
  constructor(val) {
    this.r = shallowRef(val)
  }
  get count() {
    return this.r.value
  }
  setCount(val) {
    this.r.value = val
  }
}
const dataService = new DataService(0)
const TimerView = observer(({ proxy }) => <span>the content run in @vue/reactivity is "Seconds passed: {proxy.count}"</span>)

function App() {
  return (
    <TimerView proxy={dataService}></TimerView>
  );
}

setInterval(() => {
  dataService.setCount(Date.now())
}, 1000)

export default App;

但上述方式还是不能堵住别人可以通过直接修改对象的方式更改响应式的值,从而打破单向数据流的规则。

例如下面的例子:

setInterval(() => {
    dataService.r.value = Date.now()
}, 1000)

那么为了堵住这个漏洞,我们可以通过私有变量来解决:

class DataService {
  #r
  constructor(val) {
    this.#r = shallowRef(val)
  }
  get count() {
    return this.#r.value
  }
  setCount(val) {
    this.#r.value = val
  }
}
const dataService = new DataService(0)

这个时候我们就不能通过直接修改对象的方式更改响应式的值了。

setInterval(() => {
    dataService.#r.value = Date.now()
}, 1000)

我们上述这种方式比较适合基本数据类型的情况,如果是引用类型的话,就不太适用了。如果是引用类型我们不可能在上面写那么多属性访问器,我们可以像 Vue2 那样把所有的响应式数据代理到 Vue 的实例对象上,然后可以通过 this 进行访问。

修改如下:

import { shallowRef } from "@vue/reactivity";
class DataService {
  #r
  constructor(val) {
    this.#r = shallowRef(val)
    // 像 Vue2 一样把响应式数据代理到实例对象上
    return new Proxy(this, {
      get(target, key) {
        // 如果是响应式数据就返回响应式数据
        if (target.#r.value[key]) {
          return target.#r.value[key]
        } else {
          // 如果是自身的属性就返回自身属性,例如 setState
          return target[key]
        }
      },
      set(target, key, val) {
        throw new Error('请通过 setState 方法进行更新')
      }
    })
  }
  setState(val) {
    this.#r.value = val
  }
}

const dataService = new DataService({ name: 'Cobyte', date: '2024-03-22', now: { time: 123 } })
const TimerView = observer(({ proxy, now }) => <span>the content run in @vue/reactivity "author: {proxy.name}, the date is: {proxy.date} now is {proxy.now.time}"</span>)

function App() {
  return (
    <TimerView proxy={dataService} now={dataService.now}></TimerView>
  );
}

setInterval(() => {
  dataService.setState({ name: '掘金签约作者', date: '2024年3月22日', now: { time: Date.now() }})
}, 1000)

export default App;

我们通过把响应式数据代理到实例对象上,优化了引用类型的使用方式。

tutieshi_640x284_4s.gif

至此,我们受 Mobx 的启发实现了在 React 中使用 Vue3 的响应式数据库,同时跟 Mobx、Flux、Redux 一样实现单向数据流。不过我们目前采用的是最新的技术私有变量,这个方案目前兼容性并不好,但作为技术交流也可以给大家一个启发。

为什么 Vue 可以通过重新运行组件 render 函数进行更新?

我们在前篇文章通过相对比较简洁的代码实现了 Mobx 的核心原理,同时对比了同时响应式的 Vue 和 Mobx 的最大设计区别,在 Vue 中创建的响应式数据,是可以随意在任何地方通过普通属性访问器进行修改的,但 Mobx 中则不提倡这种可以随意修改 state 的方式,在 Mobx 中希望开发者通过 actions 来改变 state,本质是像 React 那样通过一个函数来修改 state,或者说是遵循 Flux 和 Redux 的单向数据流思想。同时 Mobx 中的订阅者中介 Reaction 和 Vue 中的订阅者中介实现则有比较大的区别,主要是因为 Mobx 主要的设计受 React 的影响,在更新的时候需要特别的设置,而不像 Vue 那样直接重新运行副作用函数就可以了,这个说到底也是因为 React 不是靠依赖追踪来实现响应式的缘故。

那么问题就来了,为什么 Vue 可以通过重新运行组件 render 函数进行更新,而 React 则不行?当然 React 在普通情况下,你在更新的时候是不知道哪个组件函数需要更新,但我们通过 Mobx 就可以实现了依赖收集,就可以知道更新的时候那些组件函数需要重新执行,但即便这样 React 也不能通过重新执行组件函数来实现更新,这是为什么呢?

一个组件要渲染到页面上需要哪些必备条件呢?我们先看看下面的一个 React 应用的渲染例子:

ReactDOM.render(App, document.getElementById("root")

那么从上述的 React 应用渲染的例子我们可以知道,一个组件渲染到页面上是一定要知道渲染到哪个元素容器中的,这一点无论是 React 还是 Vue 都是一样的。如果仅仅只是执行一个组件函数是不能实现渲染的,所以在实现 Mobx 的 Reaction 的时候,不能像 Vue 的订阅者中介那样实现。那么为什么在 Vue 中可以通过重新运行组件 render 函数进行更新呢,或者是直接重新运行组件函数进行更新呢?

这是因为在 Vue 中被收集到订阅者记录变量中的函数,并不是组件的 render 函数,而是一个高阶函数,在高阶函数内部才最后执行组件的 render 函数。我们这里以 Vue3 中的情况进分析,在 Vue3 中最后处理组件 render 函数的地方是在 setupRenderEffect 函数中,下面是 setupRenderEffect 的简洁实现代码结构。

function setupRenderEffect(instance, initialVNode, container, anchor, parentSusp) {
    const componentUpdateFn = () => {
        if (!instance.isMounted) {
            // 初始化走这里
            const subTree = (instance.subTree = renderComponentRoot(instance))
            // 通过 patch 函数进行挂载,第三个参数就要挂载的HTML容器
            patch(
                null,
                subTree,
                container, // 目标挂载点
                anchor,
                instance,
                parentSuspense,
                isSVG
            )
            instance.isMounted = true
        } else {
            // 更新走这里
            // 重新执行组件 render 函数
            const nextTree = renderComponentRoot(instance)
            // 上一次的生成的虚拟DOM为旧的虚拟DOM
            const prevTree = instance.subTree
            instance.subTree = nextTree
            // 更新也是通过 patch 函数进行挂载,也同样需要提供挂载的HTML容器,也就是第三个参数
            patch(
                prevTree,
                nextTree,
                // parent may have changed if it's in a teleport
                hostParentNode(prevTree.el!)!, // 更新的时候也需要提供渲染的目标挂载HTML元素
                // anchor may have changed if it's in a fragment
                getNextHostNode(prevTree),
                instance,
                parentSuspense,
                isSVG
            )
        }
    }
    // 从这我们可以看到被收集的依赖并不是组件的 render 函数,而是一个包装函数 componentUpdateFn
    const effect = (instance.effect = new ReactiveEffect(
      componentUpdateFn,
      () => queueJob(update), // 调度函数 scheduler,最后还是执行 update 方法
      instance.scope // track it in component's effect scope
    ))
    // 初始化的时候需要执行 run 方法
    const update = (instance.update = () => effect.run())
    // 执行
    update()
}

我们从上面的 Vue3 的 setupRenderEffect 的简洁实现代码中可以看到在 Vue 中所谓收集依赖的依赖并不是组件的渲染函数,而是一个包装函数,在包装函数中在初始化和更新阶段都是通过执行组件的 render 函数获得组件的虚拟DOM,然后再通过 patch 函数进行渲染挂载到具体的元素节点下。而在 Vue 的内部中是可以获取到具体需要渲染挂载的元素节点的,而我们在 React 的应用层首先是无法通过组件函数获得需要挂载的元素节点的,其次 React 的更新流程本质上就跟 Vue 这类型通过依赖收集的数据响应式框架不一样。

总结

本文受 Mobx 启发,利用 @vue/reactivity 的 ReactiveEffect 实现了类似 mobx-react-lite 的 observer 高阶函数,成功将 Vue 响应式库集成到 React 中,实现了单向数据流和依赖追踪。同时,通过私有变量和 Proxy 代理优化了 OOP 风格下的响应式数据访问,避免了直接修改状态。最后,从底层机制解释了 Vue 能够直接重新运行组件 render 函数更新,而 React 不能的根本原因:Vue 的依赖收集针对的是包含 patch 挂载逻辑的包装函数,可获取具体渲染容器;React 的更新流程不依赖此类追踪,且组件函数层面无法获取挂载节点。这揭示了两种框架在设计哲学与实现机制上的本质差异。

我是程序员Cobyte,现在已转向研究 AI Agent,欢迎添加 v: icobyte,学习交流 AI Agent 应用开发。

昨天以前首页

PDF无限制预览!Jit-Viewer V1.5.0开源文档预览神器正式发布

作者 徐小夕
2026年4月19日 21:30

下面和大家分享一下最近我们开源的文档预览SDK——Jit-Viewer,昨天刚发布 1.5.0 版本,和大家分享一下最新的功能更新。

图片

如果你是开发文档预览功能的开发者,一定经历过这种崩溃:txt文档预览乱码、PDF只能看前5页、大文件加载卡顿,代码文件预览毫无章法。

为了帮大家解决这些真实的使用痛点,提升开发体验,我们这段时间优化了 Jit-Viewer 开源文档预览SDK。上周刚帮不少开发者解决了PDF预览受限的问题——终于能完整查看所有PDF文档了。

今天,Jit-Viewer V1.5.0 正式发布,4大核心更新,让文档预览开发更高效、更省心。

文档地址:jitword.com/jit-viewer.…

开源地址:github.com/jitOffice/j…

这次更新,我们重点带来了以下功能:

1. 支持txt多编码格式预览兼容  

图片

之前很多开发者反馈,txt文档预览经常出现乱码,尤其是非UTF-8编码的文件,调试起来特别麻烦,浪费大量时间。

这次更新,我们优化了txt文档解析逻辑,全面兼容ANSI、UTF-8、GBK等多种常见编码格式,不管你导入的txt文件是什么编码,都能正常显示,再也不用手动转换编码、反复调试,帮大家节省更多开发时间。

2. 支持PDF文件完整预览,告别5页限制  

图片

这是本次更新最受期待的功能!之前版本的Jit-Viewer,PDF文件只能预览前5页,对于需要完整预览长文档的开发者来说,实用性大打折扣,很多场景下根本无法满足需求。

图片

这次我们彻底突破了这个限制,底层重构了PDF渲染能力,支持PDF文件全页完整预览,不管是几页的PDF,都能一次性加载完成,搭配原有缩放、翻页功能,完美适配各类PDF预览场景,再也不用为了查看完整PDF额外集成其他工具。

3. 优化SDK预览性能,搭载高性能文件预览引擎  

我们知道,开发者在集成文档预览SDK时,最在意的就是性能——大文件加载慢、切换页面卡顿,都会影响产品体验。这次更新,我们重新设计了文件预览引擎,优化了文件加载、渲染的全流程,大幅提升了预览速度和稳定性,即使是大文档,也能快速加载、流畅切换,不会出现卡顿、崩溃的情况,同时降低了资源占用,让你的应用运行更流畅。

4. 支持代码文件高亮预览  

针对开发类场景,我们新增了代码文件高亮预览功能。不管是Java、Python、JavaScript,还是HTML、CSS等常见编程语言,导入后都能自动识别语言类型,实现语法高亮,代码结构清晰可见,再也不用看着杂乱无章的纯文本代码发愁,尤其适合需要在应用中集成代码预览功能的开发者,大幅提升使用体验。

市面上很多商业文档预览SDK,只解决“能预览”的问题,而 Jit-Viewer 想解决的是“好用、省心、适配多场景”。

这次V1.5.0的更新,本质上是在“轻量高效”的核心定位上,进一步突破场景限制、优化使用体验——让复杂的文档预览开发,变得更简单,让不同需求的开发者,都能快速集成、高效使用,不用再为各类预览问题额外消耗精力。

简单来说,Jit-Viewer 是一个纯前端的文件预览引擎。不需要后端转换服务,不需要安装任何插件,几行代码就能让浏览器具备"专业软件"的预览能力。图片目前 jit-viewer 已经支持了:

  • docx / ppt / pdf / excel
  • csv
  • html
  • markdown
  • txt
  • 代码文件(如js,css, java, go, c#, php, ts等)
  • 音频 / 视频
  • CAD
  • 3D模型
  • OFD(国产格式)

同时我们还在持续迭代优化,帮助大家仅通过几行代码,就能让自己的web系统轻松拥有多种文档预览的能力。

github:github.com/jitOffice/j…

Vue v-bind 转 React:VuReact 怎么处理?

作者 Ruihong
2026年4月19日 15:30

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 v-bind/: 指令经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的 v-bind 指令用法。

编译对照

v-bind / ::基础属性绑定

v-bind(简写为 :)是 Vue 中用于动态绑定 HTML 属性、组件 propsclassstyle 的指令。

  • Vue 代码:
<img :src="imageUrl" :class="imageCls" />
  • VuReact 编译后 React 代码:
<img src={imageUrl} className={imageCls} />

从示例可以看到:Vue 的 :src:class 指令被编译为 React 的标准属性语法。VuReact 采用 属性直接编译策略,将模板指令转换为 React 的 JSX 属性,完全保持 Vue 的属性绑定语义——动态地将变量值绑定到元素属性。


class 和 style 的动态绑定

Vue 支持复杂的 classstyle 绑定表达式,VuReact 通过运行时辅助函数处理这些复杂场景。

动态 class 绑定

  • Vue 代码:
<div :class="['card', active && 'is-active', error ? 'has-error' : '']" />
  • VuReact 编译后 React 代码:
import { dir } from '@vureact/runtime-core';

<div className={dir.cls(['card', active && 'is-active', error ? 'has-error' : ''])} />

动态 style 绑定

  • Vue 代码:
<div :style="{ color: textColor, fontSize: size + 'px', 'background-color': bgColor }" />
  • VuReact 编译后 React 代码:
import { dir } from '@vureact/runtime-core';

<div style={dir.style({ color: textColor, fontSize: size + 'px', backgroundColor: bgColor })} />

从示例可以看到:复杂的 class 和 style 绑定被编译为使用 dir.cls()dir.style() 辅助函数。VuReact 采用 复杂绑定运行时处理策略,将 Vue 的复杂表达式转换为运行时函数调用,完全保持 Vue 的动态样式语义

运行时辅助函数的工作原理

  1. dir.cls()

    • 处理数组、对象、字符串等多种 class 格式
    • 自动过滤 falsy 值(false、null、undefined、'')
    • 合并重复的 class 名称
    • 生成最终的 className 字符串
  2. dir.style()

    • 处理对象格式的样式
    • 自动转换 kebab-case 为 camelCase(background-colorbackgroundColor
    • 处理带单位的数值(自动添加 px 等)
    • 生成 React 兼容的 style 对象

编译策略详解

// Vue: :class="{ active: isActive, 'text-danger': hasError }"
// React: className={dir.cls({ active: isActive, 'text-danger': hasError })}

// Vue: :class="[isActive ? 'active' : '', errorClass]"
// React: className={dir.cls([isActive ? 'active' : '', errorClass])}

// Vue: :style="style"
// React: style={dir.style(style)}

无参数 v-bind:对象展开

Vue 支持无参数的 v-bind,用于将整个对象展开为元素的属性。

  • Vue 代码:
<Comp v-bind="props">点击</Comp>
  • VuReact 编译后 React 代码:
import { dir } from '@vureact/runtime-core';

<Comp {...dir.keyless(props)}>点击</Comp>

从示例可以看到:无参数的 v-bind 被编译为使用 dir.keyless() 辅助函数和对象展开语法。VuReact 采用 对象展开编译策略,将 Vue 的对象绑定转换为 React 的对象展开,完全保持 Vue 的对象属性绑定语义

dir.keyless() 辅助函数的作用

  1. 属性冲突处理:处理对象属性与已有属性的冲突
  2. 特殊属性转换:自动转换 classclassNameforhtmlFor
  3. 样式对象处理:识别并正确处理 style 对象
  4. 事件处理:识别并转换事件属性(@clickonClick

布尔属性绑定

Vue 对布尔属性有特殊处理,VuReact 也保持了这种语义。

  • Vue 代码:
<button :disabled="isLoading">提交</button>
<input :checked="isChecked" />
<option :selected="isSelected">选项</option>
  • VuReact 编译后 React 代码:
<button disabled={isLoading}>提交</button>
<input checked={isChecked} />
<option selected={isSelected}>选项</option>

动态属性名绑定

Vue 支持使用动态表达式作为属性名,但不建议这么做,不过 VuReact 也能正确处理。

  • Vue 代码:
<div :[dynamicAttr]="value">内容</div>
  • VuReact 编译后 React 代码:
<div {...{ [dynamicAttr]: value }}>内容</div>

编译策略

  1. 计算属性名:使用对象计算属性语法 { [key]: value }
  2. 对象展开:通过对象展开语法应用到元素上

编译策略总结

VuReact 的 v-bind 编译策略展示了完整的属性绑定转换能力

  1. 基础属性映射:将 Vue 属性绑定精确映射到 React JSX 属性
  2. 复杂样式处理:通过运行时辅助函数支持复杂的 class 和 style 绑定
  3. 对象展开支持:完整支持无参数 v-bind 的对象展开语义
  4. 布尔属性处理:正确处理布尔属性的特殊行为
  5. 动态属性名:支持动态表达式作为属性名
  6. 组件 props 转换:正确处理组件间的 props 传递

性能优化策略

  1. 按需导入:只有使用复杂绑定时才导入 dir 辅助函数
  2. 缓存优化:智能缓存相同表达式的处理结果
  3. 编译期优化:对于简单表达式,直接生成内联逻辑

VuReact 的编译策略确保了从 Vue 到 React 的平滑迁移,开发者无需手动重写属性绑定逻辑。编译后的代码既保持了 Vue 的语义和功能,又符合 React 的属性处理最佳实践,让迁移后的应用保持完整的 UI 表现能力。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

Vue插槽用法全解析(Vue2+Vue3适配)| 组件复用必备

2026年4月19日 10:49

Vue插槽(Slot)是组件间内容分发的核心机制,用于解决“父组件向子组件传递模板片段”的需求,实现组件的灵活复用与结构解耦。简单来说,插槽就是子组件中预留的“内容占位符”,占位符的具体内容由父组件决定,子组件仅负责固定布局和逻辑,让组件既能保持统一风格,又能灵活适配不同场景。

本文将详细讲解Vue插槽的核心概念、3种核心用法(默认插槽、具名插槽、作用域插槽),明确Vue2与Vue3的语法差异,提供可直接复制的实战示例,同时梳理常见问题,兼顾新手入门与实战开发需求。

一、插槽核心基础(必懂)

插槽的核心逻辑可类比为“函数传参”:父组件向子组件传递“模板内容”(相当于函数参数),子组件通过<slot>标签(相当于函数接收参数的位置)接收并渲染内容,最终实现“子组件定结构、父组件定内容”的复用效果。

核心要点:

  • 插槽内容可是任意合法模板(文本、标签、组件等),不局限于简单文本;
  • 插槽内容的作用域:插槽内容定义在父组件,因此只能访问父组件的数据,无法直接访问子组件的数据(需用作用域插槽解决);
  • Vue2与Vue3插槽核心功能一致,仅在具名插槽、作用域插槽的语法上有差异,下文将分别标注适配版本。

二、Vue插槽3种核心用法(实战重点)

按“基础到复杂”排序,默认插槽适用于简单内容分发,具名插槽适用于多区域内容分发,作用域插槽适用于子组件向父组件传递数据后,父组件自定义渲染内容。

1. 默认插槽(匿名插槽)—— 最简单的内容分发

默认插槽是最基础的插槽形式,子组件中仅定义一个无名称的<slot>标签,父组件传入的所有未命名内容,都会自动填充到这个插槽中。Vue2与Vue3用法基本一致。

实战示例(Vue2+Vue3通用)

// 1. 子组件(SlotDefault.vue)—— 定义默认插槽
<template>
  <div class="slot-container">
    <!-- 插槽出口:未命名,即为默认插槽 --&gt;
    &lt;slot&gt;
      <!-- 后备内容(默认内容):父组件未传入内容时显示 -->
      这是默认插槽的后备内容(父组件未传内容时显示)
    </slot>
  </div>
</template>

<style scoped>
.slot-container {
  padding: 20px;
  border: 1px solid #eee;
  border-radius: 8px;
}
</style>

// 2. 父组件 —— 使用默认插槽
<template>
  <div>
    <h3>默认插槽用法</h3>
    <!-- 方式1:传入简单文本 -->
    <SlotDefault>父组件传入的简单文本内容</SlotDefault>

    <!-- 方式2:传入复杂内容(标签+组件) -->
    <SlotDefault>
      <span style="color: #42b983;">父组件传入的带样式文本</span>
      <button>父组件传入的按钮</button>
      <!-- 传入其他组件 -->
      <OtherComponent />
    </SlotDefault>

    <!-- 方式3:不传入内容(显示子组件的后备内容) -->
    <SlotDefault />
  </div>
</template>

<script setup>
// Vue3 需引入子组件
import SlotDefault from './SlotDefault.vue'
import OtherComponent from './OtherComponent.vue'
</script>

// Vue2 脚本写法(父组件)
<script>
import SlotDefault from './SlotDefault.vue'
import OtherComponent from './OtherComponent.vue'
export default {
  components: { SlotDefault, OtherComponent }
}
</script>

说明:子组件<slot>标签内的内容为“后备内容”,仅当父组件未传入任何插槽内容时才会显示,传入内容后会自动替换后备内容。

2. 具名插槽 —— 多区域内容精准分发

当子组件需要多个不同的内容占位区域(如页面布局的头部、主体、底部)时,默认插槽无法满足需求,此时需使用具名插槽。通过给<slot>标签添加name属性命名,父组件可精准将内容分发到对应插槽,Vue2与Vue3语法差异较大。

实战示例(Vue2 vs Vue3)

// 1. 子组件(SlotNamed.vue)—— 定义具名插槽(Vue2+Vue3通用)
<template>
  <div class="layout">
    <!-- 头部插槽:name="header" -->
    <slot name="header">默认头部</slot>
    
    <!-- 主体插槽:name="main" -->
    <slot name="main">默认主体</slot>
    
    <!-- 底部插槽:name="footer" -->
    <slot name="footer">默认底部</slot>
  </div>
</template>

<style scoped>
.layout {
  display: flex;
  flex-direction: column;
  gap: 10px;
}
.layout > div { padding: 10px; border: 1px solid #eee; }
</style>

// 2. 父组件使用 —— Vue2 写法
<template>
  <SlotNamed>
    <!-- 用 slot 属性指定插槽名称,已废弃(Vue2.6+推荐用v-slot) -->
    <div slot="header">Vue2 头部内容(自定义)</div>
    <div slot="main">Vue2 主体内容(自定义)</div>
    <div slot="footer">Vue2 底部内容(自定义)</div>
    
    <!-- Vue2.6+ 推荐写法:template + v-slot -->
    <template v-slot:header>
      <div>Vue2.6+ 头部内容(自定义)</div>
    </template>
    <template v-slot:main>
      <div>Vue2.6+ 主体内容(自定义)</div>
    </template>
    <template v-slot:footer>
      <div>Vue2.6+ 底部内容(自定义)</div>
    </template>
  </SlotNamed>
</template>

// 3. 父组件使用 —— Vue3 写法(核心:废弃slot属性,统一用v-slot)
<template>
  <SlotNamed>
    <!-- 语法:template + v-slot:插槽名,可简写为 #插槽名 -->
    <template #header>
      <div>Vue3 头部内容(自定义)</div>
    </template>
    <template #main>
      <div>Vue3 主体内容(自定义)</div>
    </template>
    <template #footer>
      <div>Vue3 底部内容(自定义)</div>
    </template>
    
    <!-- 未命名内容,自动分发到默认插槽(若子组件有默认插槽) -->
    <div>默认插槽内容(未命名)</div>
  </SlotNamed>
</template>

<script setup>
import SlotNamed from './SlotNamed.vue'
</script>

关键差异:Vue2支持slot属性和v-slot两种写法,Vue3仅支持v-slot(简写为#),且必须配合<template>标签使用(默认插槽可省略<template>)。

3. 作用域插槽 —— 子传父数据+父自定义渲染

默认插槽和具名插槽,只能实现“父组件向子组件传递内容”,无法让插槽内容访问子组件的数据。作用域插槽解决了这一问题:子组件通过v-bind将自身数据绑定到<slot>标签上(称为“插槽属性”),父组件接收这些数据后,可根据子组件数据自定义插槽内容的渲染方式。

核心场景:子组件有数据(如列表数据),但渲染样式由父组件决定(如列表项可渲染为文字、按钮、卡片)。

实战示例(Vue2 vs Vue3)

// 1. 子组件(SlotScoped.vue)—— 绑定子组件数据(Vue2+Vue3通用)
<template>
  <div class="list">
    <!-- 子组件数据:列表数组 -->
    <div v-for="(item, index) in list" :key="index">
      <!-- 绑定子组件数据到插槽::item="item" :index="index" -->
      <slot :item="item" :index="index"&gt;
        <!-- 后备内容父组件未自定义渲染时显示 -->
        {{ item.name }}(默认渲染)
      </slot>
    </div>
  </div>
</template>

<script setup>
// Vue3 脚本
import { ref } from 'vue'
const list = ref([
  { id: 1, name: 'Vue基础', type: '前端' },
  { id: 2, name: '插槽用法', type: '前端' },
  { id: 3, name: '路由跳转', type: '前端' }
])
</script>

// Vue2 脚本(子组件)
<script>
export default {
  data() {
    return {
      list: [
        { id: 1, name: 'Vue基础', type: '前端' },
        { id: 2, name: '插槽用法', type: '前端' },
        { id: 3, name: '路由跳转', type: '前端' }
      ]
    }
  }
}
</script>

// 2. 父组件使用 —— Vue2 写法
<template>
  <SlotScoped>
    <!-- 方式1:slot-scope 接收插槽属性(Vue2.6-) -->
    <div slot-scope="slotProps">
      索引:{{ slotProps.index }} | 名称:{{ slotProps.item.name }}
    </div>
    
    <!-- 方式2:v-slot 接收(Vue2.6+ 推荐,可解构) -->
    <template v-slot:default="slotProps">
      <!-- 解构简化:直接提取item和index -->
      <template v-slot:default="{ item, index }">
        索引{{ index + 1 }}:{{ item.name }}({{ item.type }})
      </template>
    </template>
  </SlotScoped>
</template>

// 3. 父组件使用 —— Vue3 写法(核心:废弃slot-scope,统一用v-slot接收)
<template>
  <SlotScoped>
    <!-- 方式1:完整写法,接收所有插槽属性 -->
    <template #default="slotProps">
      索引:{{ slotProps.index }} | 名称:{{ slotProps.item.name }}
    </template>
    
    <!-- 方式2:解构简化(推荐),可设置默认值避免报错 -->
    <template #default="{ item = { name: '默认名称' }, index = 0 }">
      索引{{ index + 1 }}:{{ item.name }}({{ item.type }})
      <button @click="handleClick(item.id)">查看详情</button>
    </template>
  </SlotScoped>
</template>

<script setup>
import SlotScoped from './SlotScoped.vue'
const handleClick = (id) => {
  console.log('查看ID为', id, '的详情')
}
</script>

关键差异:Vue2用slot-scopev-slot接收插槽属性,Vue3仅用v-slot接收,且支持ES6解构赋值,可设置默认值提升组件健壮性。

三、Vue2与Vue3插槽语法差异汇总

为方便快速区分和迁移,整理核心差异如下,重点关注Vue3的语法规范:

插槽类型 Vue2 语法 Vue3 语法 核心差异
默认插槽 直接在子组件标签内写内容;支持

Vue v-on 在 React 中 VuReact 会如何实现?

作者 Ruihong
2026年4月19日 10:34

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 v-on/@ 指令经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的 v-on 指令用法。

编译对照

v-on / @:基础事件绑定

v-on(简写为 @)是 Vue 中用于绑定事件监听器的指令,用于响应用户交互。

  • Vue 代码:
<button @click="increment">+1</button>
  • VuReact 编译后 React 代码:
<button onClick={increment}>+1</button>

从示例可以看到:Vue 的 @click 指令被编译为 React 的 onClick 属性。VuReact 采用 事件属性编译策略,将模板指令转换为 React 的标准事件属性,完全保持 Vue 的事件绑定语义——当按钮被点击时,调用 increment 函数。

这种编译方式的关键特点在于:

  1. 语义一致性:完全模拟 Vue v-on 的行为,实现事件监听功能
  2. 命名转换:Vue 的 @click 转换为 React 的 onClick(camelCase 命名)
  3. 函数传递:直接传递函数引用,保持事件处理逻辑
  4. React 原生支持:使用 React 标准的事件系统,无需额外适配

带事件修饰符:高级事件处理

Vue 的事件系统支持丰富的修饰符,用于控制事件行为。VuReact 通过运行时辅助函数处理这些修饰符。

  • Vue 代码:
<button @click.stop.prevent="submit">Submit</button>
  • VuReact 编译后 React 代码:
import { dir } from '@vureact/runtime-core';

<button onClick={dir.on('click.stop.prevent', submit)}>Submit</button>

从示例可以看到:带修饰符的 Vue 事件被编译为使用 dir.on() 辅助函数。VuReact 采用 修饰符运行时处理策略,将复杂的修饰符组合转换为运行时函数调用,完全保持 Vue 的事件修饰符语义

编译策略详解

// Vue: @click.stop.prevent="handler"
// React: onClick={dir.on('click.stop.prevent', handler)}

// Vue: @keyup.enter="search"
// React: onKeyUp={dir.on('keyup.enter', search)}

// Vue: @click.capture="captureHandler"
// React: onClickCapture={dir.on('click.capture', captureHandler)}

运行时辅助函数 dir.on() 的工作原理

  1. 解析修饰符:解析事件名称和修饰符字符串
  2. 创建包装函数:根据修饰符创建事件处理包装函数
  3. 应用修饰符逻辑:在包装函数中实现修饰符对应的行为
  4. 调用原始处理器:最终调用开发者提供的事件处理函数

内联事件处理与参数传递

Vue 支持在模板中直接编写内联事件处理逻辑,VuReact 也能正确处理。

  • Vue 代码:
<button @click="count++">增加</button>
<button @click="sayHello('world')">打招呼</button>
<button @click="handleEvent($event, 'custom')">带事件对象</button>
  • VuReact 编译后 React 代码:
<button onClick={() => count.value++}>增加</button>
<button onClick={() => sayHello('world')}>打招呼</button>
<button onClick={(event) => handleEvent(event, 'custom')}>带事件对象</button>

编译策略

  1. 表达式转换:将 Vue 模板表达式转换为 JSX 箭头函数
  2. 事件对象处理:Vue 的 $event 转换为 React 的事件参数
  3. 参数传递:保持函数调用的参数顺序和值
  4. 响应式更新:自动处理 .value 访问(对于 ref/computed 等变量)

defineEmits 事件与组件通信

对于组件自定义事件,VuReact 也有相应的编译策略。

  • Vue 代码:
<!-- 父组件 -->
<Child @custom-event="handleCustom" />

<!-- 子组件 Child.vue -->
<template>
  <button @click="emits('custom-event', data)">触发事件</button>
</template>

<script setup>
const emits = defineEmits(['custom-event']);
</script>
  • VuReact 编译后 React 代码:
// 父组件使用
<Child onCustomEvent={handleCustom} />;

// 子组件 Child.jsx
function Child(props) {
  return <button onClick={() => props.onCustomEvent?.(data)}>触发事件</button>;
}

编译规则

  1. 事件名转换kebab-case 转换为 camelCasecustom-eventonCustomEvent
  2. emit 调用转换$emit() 转换为 props 回调调用
  3. 可选链保护:添加 ?. 可选链操作符,避免未定义错误
  4. 类型安全:保持 TypeScript 类型定义的一致性

编译策略总结

VuReact 的事件编译策略展示了完整的事件系统转换能力

  1. 基础事件映射:将 Vue 事件指令精确映射到 React 事件属性
  2. 修饰符支持:通过运行时辅助函数完整支持 Vue 事件修饰符
  3. 内联处理:正确处理模板中的内联事件表达式
  4. 自定义事件:支持组件间的自定义事件通信
  5. 类型安全:保持 TypeScript 类型定义的完整性

VuReact 的编译策略确保了从 Vue 到 React 的平滑迁移,开发者无需手动重写事件处理逻辑。编译后的代码既保持了 Vue 的语义和功能,又符合 React 的事件处理最佳实践,让迁移后的应用保持完整的交互能力。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

📄 第三篇:Vue 3 命令式弹窗 Provide 污染与关闭动画修复

2026年4月19日 03:18

问题背景

在使用 useCommandComponent 封装命令式弹窗时,遇到了两个典型的底层机制问题:

  1. Provide/Inject 数据污染:多次打开弹窗后,子组件 inject 到了上一次残留的旧数据。
  2. 关闭动画丢失:弹窗关闭时 DOM 被过早销毁,导致过渡动画无法完整播放。

修复点1:AppContext 上下文污染

1. 问题复现

测试场景

<!-- TestModal.vue -->
<script setup>
import { provide, inject } from 'vue'

// 每次打开都 provide 一个随机值
provide('modalConfig', Math.random())

// 尝试 inject 同一个 key
const config = inject('modalConfig')
console.log('inject 结果:', config)
</script>
// App.vue
const showModal = useCommandComponent(TestModal)

操作流程与现象

操作 provide 的值 inject 预期 inject 实际 状态
第1次打开 0.123456 undefined undefined ✅ 正常
关闭弹窗 - - - -
第2次打开 0.789012 undefined 0.123456 ❌ 污染

关键特征:

  • 首次运行正常,第2次才出问题。
  • 不报错,只是数据不对(最难排查的 bug 类型)。
  • 拿到的不是本次 provide 的值,而是上一次的残留。

2. 根本原因分析

错误代码

// useCommandComponent.js - 有问题的版本
export const useCommandComponent = (Component) => {
  const instance = getCurrentInstance()
  
  // ❌ 直接修改全局 appContext.provides
  const appContext = instance?.appContext
  const currentProvides = instance?.provides
  
  if (appContext && currentProvides) {
    Reflect.set(appContext, 'provides', currentProvides)
  }
  
  // ...
}

污染链路详解

初始状态:

App.appContext.provides = {}

第1次注册(App.vue 中调用):

const showModal = useCommandComponent(TestModal)

// instance = App 实例
// currentProvides = App.provides = {}

// 覆盖全局(此时是空对象,暂时没问题)
Reflect.set(App.appContext, 'provides', {})

第1次打开弹窗:

showModal()

// 创建 TestModal 实例1
TestModal实例1.provides = Object.create(App.appContext.provides)

// setup 执行
provide('modalConfig', 0.123456)
// TestModal实例1.provides = { modalConfig: 0.123456 }

const config = inject('modalConfig')
// 查询链:TestModal实例1.provides → App.appContext.provides
// 结果:undefined ✅(符合预期)

// ⚠️ 如果内部嵌套调用 useCommandComponent
const showChild = useCommandComponent(ChildComponent)
// currentProvides = TestModal实例1.provides
// Reflect.set(App.appContext, 'provides', TestModal实例1.provides)
// App.appContext.provides = { modalConfig: 0.123456 } ❌ 被污染!

关闭弹窗:

// unmount(TestModal实例1)

// ❌ 但 App.appContext.provides 没有被恢复
// 仍然是:{ modalConfig: 0.123456 }

第2次打开弹窗:

showModal()

// 创建 TestModal 实例2
TestModal实例2.provides = Object.create(App.appContext.provides)
// TestModal实例2.provides.__proto__ = { modalConfig: 0.123456 } ❌ 原型链指向旧数据

// setup 执行
provide('modalConfig', 0.789012)
// TestModal实例2.provides = { modalConfig: 0.789012 }

const config = inject('modalConfig')
// 查询链:TestModal实例2.provides → App.appContext.provides
// 结果:0.123456 ❌ 拿到了第1次的残留数据!

核心问题

嵌套调用 useCommandComponent 
  ↓
覆盖全局 appContext.provides
  ↓
关闭后未恢复
  ↓
新实例的原型链指向旧数据
  ↓
inject 通过原型链查到残留值

3. 修复方案

修复代码

// useCommandComponent.js - 修复版本(第30-35行)
export const useCommandComponent = (Component) => {
  const instance = getCurrentInstance()
  
  // ✅ 先复制 appContext,再独立设置 provides
  const appContext = { ...instance?.appContext }
  Reflect.set(appContext, 'provides', currentProvides)
  
  // ...
}

修复原理对比

修复前(有问题):

const appContext = instance?.appContext
Reflect.set(appContext, 'provides', currentProvides)
// ❌ 所有调用共用同一个 appContext,互相覆盖

修复后(正确):

const appContext = { ...instance?.appContext }
Reflect.set(appContext, 'provides', currentProvides)
// ✅ 两步操作:
//    1. 创建完全独立的新对象
//    2. 单独设置 provides 属性
//    彻底隔离,互不影响

关键点:

  • { ...instance?.appContext } 创建全新的独立对象。
  • 新对象与原始 appContext 没有任何关联。

修复点2:onClosed 回调与关闭动画

1. Element Plus 的关闭事件机制

Element Plus 的 <el-dialog> 有两个关闭相关的事件:

事件 触发时机 说明
@close 用户点击关闭按钮时 动画开始前立即触发
@closed 关闭动画播放完成后 动画结束后触发

完整执行流程:

用户点击关闭按钮
  ↓
① @close 触发(此时动画还没开始)
  ↓
② 播放关闭动画(约 300ms)
  ↓
③ @closed 触发(动画已完全结束)

2. 为什么要用 onClosed 而不是 onClose?

关键问题:DOM 清理时机

命令式弹窗需要在关闭后清理 DOM:

const closed = () => {
  render(null, container)        // 卸载组件
  container.remove()             // 移除 DOM
}

如果在 @close 时清理:

用户点击关闭
  ↓
@close 触发
  ↓
立即执行 closed() → render(null, container)
  ↓
❌ 组件被销毁,动画无法继续播放
❌ 用户看到弹窗"瞬间消失",没有过渡效果

如果在 @closed 时清理:

用户点击关闭
  ↓
@close 触发(动画开始)
  ↓
播放关闭动画(300ms)✅ 动画完整播放
  ↓
@closed 触发(动画结束)
  ↓
执行 closed() → render(null, container) ✅ 安全清理

3. Vue 属性透传的作用

当弹窗组件作为根元素且未在 defineProps 中声明 onClosed 时,Vue 会自动将其透传给内部的 <el-dialog>

<!-- TestModal.vue -->
<template>
  <!-- el-dialog 是根元素 -->
  <el-dialog v-model="visible">
    弹窗内容
  </el-dialog>
</template>

<script setup>
// 没有声明 onClosed,Vue 自动透传
</script>

外部调用:

showModal({
  onClosed: () => console.log('用户回调')
})

结果: onClosed 被透传给 <el-dialog>,相当于:

<el-dialog v-model="visible" @closed="onClosed">

4. 实现方案

核心逻辑

// useCommandComponent.js(第42-60行)

// 清理函数
const closed = () => {
  render(null, container)
  container.parentNode?.removeChild(container)
}

const CommandComponent = (options = {}) => {
  // ... 其他逻辑
  
  // ✅ 统一处理 onClosed,确保动画完整 + DOM 清理
  if (typeof options.onClosed !== 'function') {
    // 用户没提供 onClosed,使用默认清理函数
    options.onClosed = closed
  } else {
    // 用户提供了 onClosed,包裹一层确保能清理 DOM
    const originOnClosed = options.onClosed
    options.onClosed = (...args) => {
      originOnClosed(...args)  // 先执行用户回调
      closed()                 // 再执行 DOM 清理
    }
  }
  
  // ...
}

📄 第一篇:Vue 3 命令式弹窗使用指南

📄 第二篇:Vue 3 命令式弹窗 provide/inject 机制解析

📄 第三篇:Vue 3 命令式弹窗 Provide 污染与关闭动画修复

📄 第二篇:Vue 3 命令式弹窗 provide/inject 机制解析

2026年4月19日 03:17

1. 标准组件 vs 命令式组件

什么是标准组件?

通过模板声明,由 Vue 自动管理。

<!-- App.vue -->
<template>
  <!-- ✅ 标准组件:在模板中声明 -->
  <ChildComponent />
</template>

特点:

  • 写在 <template>
  • parent 指向父组件实例

什么是命令式组件?

通过函数调用创建,手动挂载到 DOM。

// useCommandComponent.js
export const useCommandComponent = (Component) => {
  const container = document.createElement('div')
  
  return (options = {}) => {
    const vNode = createVNode(Component, options)
    render(vNode, container)  // ← 手动渲染
    document.body.appendChild(container)
  }
}
<!-- App.vue - 使用 -->
<script setup>
const showModal = useCommandComponent(TestModal)

function open() {
  showModal({ title: '弹窗' })  // ← 函数调用
}
</script>

特点:

  • 不在模板中声明
  • 通过函数调用(如 showModal()
  • parent = null(没有父组件)

2. 为什么 parent = null?

标准组件的渲染流程

// Vue 内部
patch(parentVNode, childVNode, container, parentComponent)
//                                        ^^^^^^^^^^^^^^
//                                        传入父组件实例

结果: ChildComponent.parent = App实例


命令式组件的渲染流程

// useCommandComponent 内部
render(vNode, container)

// Vue 内部
patch(null, vNode, container, null, ...)
//                          ^^^^
//                          parent 传的是 null

结果: TestModal.parent = null

原因: 命令式组件不是通过父组件模板渲染的,而是直接 render 到 DOM,Vue 将其视为"根组件"。


3. provides 初始化逻辑

Vue 源码(简化版)

function createComponentInstance(vnode, parent, suspense) {
  const instance = {
    parent: parent,
    appContext: vnode.appContext,
    
    // 关键:provides 的初始化方式
    provides: parent 
      ? parent.provides  // 有 parent:直接引用父组件的 provides
      : Object.create(vnode.appContext.provides)  // 无 parent:创建新对象
  }
  return instance
}

两种情况的内存结构

标准组件(ChildComponent 的父组件是 App)

App实例.provides = { config: 'app数据' }

ChildComponent实例.provides = App实例.provides  // ← 同一个对象引用

特点: 父子共用同一个 provides 对象。


命令式组件(TestModal 在 App 中创建)

appContext.provides = { config: 'app数据' }

TestModal实例.provides = {}  // 新空对象
TestModal实例.provides.__proto__ → appContext.provides

特点:

  • provides 是独立空对象
  • 原型链指向 appContext.provides

4. provide/inject 的逻辑

provide 的行为

function provide(key, value) {
  const instance = getCurrentInstance()
  
  // 如果 provides 和 parent.provides 是同一个对象
  if (instance.parent && instance.provides === instance.parent.provides) {
    // 写时复制:创建新对象,避免污染父组件
    instance.provides = Object.create(instance.provides)
  }
  
  // 写入自己的 provides
  instance.provides[key] = value
}

关键点: provide 总是写入当前实例自己的 provides


inject 的行为(核心差异)

function inject(key) {
  const instance = getCurrentInstance()
  
  if (instance.parent == null) {
    // ⚠️ 命令式组件走这里
    const provides = instance.vnode.appContext.provides
    // 查的是 appContext.provides,不是 instance.provides
    if (key in provides) {
      return provides[key]
    }
  } else {
    // 标准组件走这里
    const provides = instance.parent.provides
    // 查的是父组件的 provides
    if (key in provides) {
      return provides[key]
    }
  }
}

关键差异:

  • 标准组件injectparent.provides
  • 命令式组件injectappContext.provides

5. 实际示例

场景设置

// App.vue
provide('config', { theme: 'dark' })
const showModal = useCommandComponent(TestModal)
<!-- TestModal.vue -->
<script setup>
provide('modalConfig', { title: '我是弹窗' })
const config = inject('config')  // ← 能拿到吗?
</script>

执行流程

1. 创建 TestModal 实例

TestModal实例.provides = {}
TestModal实例.provides.__proto__ → appContext.provides = { config: { theme: 'dark' } }

2. TestModal setup 执行

// provide
provide('modalConfig', { title: '我是弹窗' })
// TestModal实例.provides = { modalConfig: { title: '我是弹窗' } }

// inject
const config = inject('config')
// 因为 parent === null
// 查的是 appContext.provides
// appContext.provides.config → ✅ 找到 { theme: 'dark' }

结果: config = { theme: 'dark' }


6. 子组件的情况

ChildTestModal(TestModal 的子组件)

<!-- TestModal.vue 模板 -->
<template>
  <ChildTestModal />
</template>
// ChildTestModal 实例
ChildTestModal.parent = TestModal实例
ChildTestModal.provides = TestModal实例.provides  // 初始时是同一个对象

ChildTestModal 调用 provide

<!-- ChildTestModal.vue -->
<script setup>
provide('childData', '子组件数据')
</script>
// provide 内部检测到 provides === parent.provides
ChildTestModal.provides = Object.create(TestModal实例.provides)
// 现在是一个新对象
ChildTestModal.provides.__proto__ → TestModal实例.provides

ChildTestModal.provides.childData = '子组件数据'

结果: 子组件不调用 provide 函数他的 provides 就等于父组件的 provides, 调用 provide 函数子组件的 provides 就是一个原型链指向父组件 provides 的新对象。


7. 小结

核心要点

  1. 命令式组件 parent = null:因为是直接 render 挂载,没有父组件
  2. provides 初始化不同:命令式组件用 Object.create 创建独立对象
  3. inject 查找链不同:命令式组件查 appContext.provides,标准组件查 parent.provides
  4. 子组件有无 provide 时结果不同:避免污染父组件的 provides

所以这是命令式组件可以 inject 到 App provide 提供的数据的原理 ✅

📄 第一篇:Vue 3 命令式弹窗使用指南

📄 第二篇:Vue 3 命令式弹窗 provide/inject 机制解析

📄 第三篇:Vue 3 命令式弹窗 Provide 污染与关闭动画修复

📄 第一篇:Vue 3 命令式弹窗使用指南

2026年4月19日 03:16

1. 快速开始

通过 useCommandComponent,你可以像调用函数一样打开一个弹窗,而无需在模板中写 <Dialog /> 标签。

import { useCommandComponent } from './composables/useCommandComponent'
import MyDialog from './components/MyDialog.vue'

// 1. 创建弹窗构造函数
const showDialog = useCommandComponent(MyDialog)

// 2. 调用函数打开弹窗
showDialog({
  title: '提示',
  content: '这是一个命令式弹窗',
  onClosed: (result) => {
    console.log('弹窗关闭,返回结果:', result)
  }
})

2. 两种核心用法

模式 A:Props 驱动(推荐简单场景)

适用于表单提交、确认框等一次性交互。你只需要传入参数并监听关闭回调。

组件定义 (ConfirmDialog.vue):

<template>
  <el-dialog :model-value="visible" :title="title" @closed="handleClosed">
    <p>{{ content }}</p>
    <template #footer>
      <el-button @click="handleCancel">取消</el-button>
      <el-button type="primary" @click="handleConfirm">确定</el-button>
    </template>
  </el-dialog>
</template>

<script setup>
defineProps(['visible', 'title', 'content'])
const emit = defineEmits(['closed'])

const handleConfirm = () => emit('closed', { action: 'confirm' })
const handleCancel = () => emit('closed', { action: 'cancel' })
const handleClosed = () => emit('closed', { action: 'close' })
</script>

调用方式:

const ConfirmDialog = useCommandComponent(ConfirmDialog)

ConfirmDialog({
  title: '删除确认',
  content: '确定要删除这条数据吗?',
  onClosed: (res) => {
    if (res.action === 'confirm') deleteItem()
  }
})

模式 B:Expose 驱动(推荐复杂交互)

适用于多步骤向导、需要外部触发更新或获取内部状态的复杂弹窗。

组件定义 (WizardDialog.vue):

<template>
  <el-dialog v-model="internalVisible" title="向导">
    <div>当前步骤: {{ step }}</div>
  </el-dialog>
</template>

<script setup>
import { ref } from 'vue'
const internalVisible = ref(false)
const step = ref(1)

// 暴露方法给外部调用
const open = (options) => {
  internalVisible.value = true
  step.value = options.startStep || 1
}

defineExpose({ open })
</script>

调用方式:

const WizardDialog = useCommandComponent(WizardDialog)

const dialogInstance = WizardDialog() // 此时弹窗未显示
dialogInstance.open({ startStep: 2 }) // 手动控制打开并传参

3. 常用配置项

属性 类型 说明
visible Boolean 默认为 true,控制弹窗显隐
appendTo String/HTMLElement 挂载点,默认为 body
onClosed Function 弹窗完全关闭(动画结束)后的回调

4. 核心源码实现

你可以直接将以下代码保存为 useCommandComponent.js。它封装了 Vue 3 的底层渲染逻辑,支持自动挂载、上下文传递以及实例方法暴露。

import { createVNode, getCurrentInstance, render } from 'vue'

export const useCommandComponent = (Component) => {
  // 1. 获取当前实例,提取 appContext 和 provides
  const instance = getCurrentInstance()
  let appContext = null

  if (instance) {
    // 创建一个关联的上下文对象
    // 目的:把父组件的 provides 传进去,否则动态渲染的弹窗会读不到父级数据
    appContext = {...instance.appContext}
    appContext.provides = instance.provides
  }

  // 2. 确定弹窗应该挂载到哪个 DOM 节点(默认是 body)
  const getAppendToElement = (props) => {
    let appendTo = document.body
    if (props.appendTo) {
      if (typeof props.appendTo === 'string') appendTo = document.querySelector(props.appendTo)
      else if (props.appendTo instanceof HTMLElement) appendTo = props.appendTo
      if (!(appendTo instanceof HTMLElement)) appendTo = document.body
    }
    return appendTo
  }

  // 3. 创建虚拟节点并渲染到临时容器中
  const initInstance = (Component, props, container, appContext = null) => {
    const vNode = createVNode(Component, props)
    vNode.appContext = appContext // 将准备好的上下文传给组件
    render(vNode, container)
    getAppendToElement(props).appendChild(container)
    return vNode
  }

  const container = document.createElement('div')

  // 4. 关闭函数:卸载组件实例并从 DOM 中移除容器
  const closed = () => {
    render(null, container)
    container.parentNode?.removeChild(container)
  }

  const CommandComponent = (options = {}) => {
    // 默认设置弹窗为显示状态
    if (!Reflect.has(options, 'visible')) options.visible = true

    // 包装 onClosed 回调:确保动画结束后再执行 DOM 清理
    if (typeof options.onClosed !== 'function') {
      options.onClosed = closed
    } else {
      const originOnClosed = options.onClosed
      options.onClosed = (...args) => {
        originOnClosed(...args)
        closed()
      }
    }

    const vNode = initInstance(Component, options, container, appContext)

    // 5. 返回一个代理对象,实现对组件实例的灵活控制
    return new Proxy(vNode, {
      get(target, prop) {
        if (prop === 'closed') return closed // 允许外部调用 .closed()
        const exposed = target.component?.exposed
        if (exposed && Reflect.has(exposed, prop)) {
          return Reflect.get(exposed, prop) // 允许访问 defineExpose 暴露的方法
        }
        return Reflect.get(target, prop)
      },
      has(target, prop) {
        if (prop === 'closed') return true
        const exposed = target.component?.exposed
        if (exposed && Reflect.has(exposed, prop)) return true
        return Reflect.has(target, prop)
      }
    })
  }

  CommandComponent.closed = closed
  return CommandComponent
}

5. 源码分段解析

为了让你更清楚每一块代码的作用,我们将上面的源码拆分为三个核心部分:

第一部分:上下文准备

const instance = getCurrentInstance()
let appContext = null
if (instance) {
  appContext = {...instance.appContext}
  appContext.provides = instance.provides
}

说明: 这一步是为了拿到父组件的 provides。因为弹窗是动态创建的,如果不手动把父级的数据传给它,弹窗里的 inject 就会失效。

第二部分:DOM 挂载与清理

const initInstance = (Component, props, container, appContext = null) => {
  const vNode = createVNode(Component, props)
  vNode.appContext = appContext
  render(vNode, container)
  getAppendToElement(props).appendChild(container)
  return vNode
}

const closed = () => {
  render(null, container)
  container.parentNode?.removeChild(container)
}

说明: 这里利用 createVNoderender 手动把组件渲染到一个临时的 div 里,然后把这个 div 塞进页面。关闭时则反向操作,彻底销毁组件。

第三部分:代理与交互控制

return new Proxy(vNode, {
  get(target, prop) {
    if (prop === 'closed') return closed
    const exposed = target.component?.exposed
    if (exposed && Reflect.has(exposed, prop)) return Reflect.get(exposed, prop)
    return Reflect.get(target, prop)
  },
  // ... has 拦截器
})

说明: 使用 Proxy 是为了让返回值既能当普通对象用(访问 expose 的方法),又能直接调用 .closed() 来关闭弹窗,使用起来非常灵活。

📄 第一篇:Vue 3 命令式弹窗使用指南

📄 第二篇:Vue 3 命令式弹窗 provide/inject 机制解析

📄 第三篇:Vue 3 命令式弹窗 Provide 污染与关闭动画修复

Vue 封装 Echarts 组件

作者 Fisschl
2026年4月18日 14:18

为了方便在不同页面使用 echarts,可以封装一个组件。如果不封装,也可以手动实例化 echarts,并且额外处理监听容器尺寸变化的功能。

<script setup lang="ts">
import { useResizeObserver } from "@vueuse/core";
import type { EChartsOption } from "echarts";
import { init, type ECharts, type ECElementEvent } from "echarts/core";

const props = defineProps<{
  /** Echarts 图表配置选项 */
  options?: EChartsOption;
  /** 图表渲染器类型,默认为 svg */
  renderer?: "canvas" | "svg";
}>();
const emit = defineEmits<{
  chartClick: [event: ECElementEvent];
}>();

/** 图表容器元素的引用 */
const container = useTemplateRef("figure-element");
/** Echarts 图表实例 */
const chart = shallowRef<ECharts>();

defineExpose({
  container,
  chart,
});

/**
 * 监听图表配置变化并更新图表
 */
watchEffect(() => {
  if (!chart.value || !props.options) return;
  chart.value.setOption(props.options);
});

/**
 * 监听容器尺寸变化并自动调整图表大小
 */
useResizeObserver(container, () => {
  if (!chart.value || chart.value.isDisposed()) return;
  chart.value.resize();
});

/**
 * 初始化图表实例
 */
watch(container, (container) => {
  if (!container) return;

  const instance = init(container, undefined, {
    renderer: props.renderer || "svg",
    locale: "ZH",
  });

  /** 绑定图表点击事件 */
  instance.on("click", (event) => {
    emit("chartClick", event);
  });

  chart.value = instance;
  onWatcherCleanup(() => instance.dispose());
});
</script>

<template>
  <figure ref="figure-element" :class="$style.figure" />
</template>

<style module>
.figure {
  overflow: hidden;
}
</style>

然后在页面中使用。

<script setup lang="ts">
import type { EChartsOption } from "echarts";
import { BarChart, LineChart, PieChart, ScatterChart } from "echarts/charts";
import {
  GridComponent,
  LegendComponent,
  TitleComponent,
  TooltipComponent,
} from "echarts/components";
import { use } from "echarts/core";
import { UniversalTransition } from "echarts/features";
import { SVGRenderer } from "echarts/renderers";
import EchartsContainer from "@/components/Echarts/EchartsContainer.vue";

use([
  GridComponent,
  LineChart,
  BarChart,
  SVGRenderer,
  PieChart,
  ScatterChart,
  UniversalTransition,
  TitleComponent,
  TooltipComponent,
  LegendComponent,
]);

/** 基础柱状图配置 */
const barChartOption: EChartsOption = {
  tooltip: {
    trigger: "axis",
    axisPointer: {
      type: "shadow",
    },
  },
  xAxis: {
    type: "category",
    data: ["一月", "二月", "三月", "四月", "五月", "六月"],
    axisTick: {
      alignWithLabel: true,
    },
  },
  yAxis: {
    type: "value",
  },
  series: [
    {
      name: "销售额",
      type: "bar",
      data: [120, 200, 150, 80, 70, 110],
    },
  ],
};

/** 折线图配置 */
const lineChartOption: EChartsOption = {
  tooltip: {
    trigger: "axis",
  },
  legend: {
    data: ["新用户", "活跃用户"],
  },
  xAxis: {
    type: "category",
    data: ["周一", "周二", "周三", "周四", "周五", "周六", "周日"],
  },
  yAxis: {
    type: "value",
  },
  series: [
    {
      name: "新用户",
      type: "line",
      data: [120, 132, 101, 134, 90, 230, 210],
      smooth: true,
      itemStyle: {
        color: "#67C23A",
      },
    },
    {
      name: "活跃用户",
      type: "line",
      data: [220, 182, 191, 234, 290, 330, 310],
      smooth: true,
      itemStyle: {
        color: "#E6A23C",
      },
    },
  ],
};

/** 饼图配置 */
const pieChartOption: EChartsOption = {
  tooltip: {
    trigger: "item",
    formatter: "{a} <br/>{b}: {c} ({d}%)",
  },
  legend: {
    orient: "vertical",
    left: "left",
  },
  series: [
    {
      name: "产品分类",
      type: "pie",
      radius: "50%",
      data: [
        { value: 1048, name: "电子产品" },
        { value: 735, name: "服装配饰" },
        { value: 580, name: "家居用品" },
        { value: 484, name: "食品饮料" },
        { value: 300, name: "其他" },
      ],
    },
  ],
};

/** 散点图配置 */
const scatterChartOption: EChartsOption = {
  tooltip: {
    trigger: "item",
  },
  xAxis: {
    type: "value",
    name: "X轴",
  },
  yAxis: {
    type: "value",
    name: "Y轴",
  },
  series: [
    {
      name: "数据点",
      type: "scatter",
      data: Array.from({ length: 50 }, () => [Math.random() * 100, Math.random() * 100]),
    },
  ],
};

/** 处理图表点击事件 */
const handleChartClick = (chartType: string) => {
  ElMessage.info(`点击了${chartType}图表`);
};
</script>

<template>
  <div :class="$style.container">
    <!-- 柱状图 -->
    <EchartsContainer
      :class="$style.chart"
      :options="barChartOption"
      @chart-click="handleChartClick('柱状图')"
    />

    <!-- 折线图 -->
    <EchartsContainer
      :class="$style.chart"
      :options="lineChartOption"
      @chart-click="handleChartClick('折线图')"
    />

    <!-- 饼图 -->
    <EchartsContainer
      :class="$style.chart"
      :options="pieChartOption"
      @chart-click="handleChartClick('饼图')"
    />

    <!-- 散点图 -->
    <EchartsContainer
      :class="$style.chart"
      :options="scatterChartOption"
      @chart-click="handleChartClick('散点图')"
    />
  </div>
</template>

<style module>
.container {
  padding: 2rem;
  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: 1rem;
}

.chart {
  height: 30rem;
}
</style>

Vue v-html 与 v-text 转 React:VuReact 怎么处理?

作者 Ruihong
2026年4月18日 14:06

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 v-html/v-text 指令经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的 v-html 和 v-text 指令用法。

编译对照

v-html:动态 HTML 内容渲染

v-html 是 Vue 中用于将 HTML 字符串动态渲染为 DOM 元素的指令,它会替换元素内的所有内容,并解析 HTML 标签。

  • Vue 代码:
<div v-html="htmlContent"></div>
  • VuReact 编译后 React 代码:
<div dangerouslySetInnerHTML={{ __html: htmlContent }} />

从示例可以看到:Vue 的 v-html 指令被编译为 React 的 dangerouslySetInnerHTML 属性。VuReact 采用 HTML 注入编译策略,将模板指令转换为 React 的特殊属性,完全保持 Vue 的 HTML 渲染语义——将 htmlContent 字符串解析为 HTML 并插入到 DOM 中。

这种编译方式的关键特点在于:

  1. 语义一致性:完全模拟 Vue v-html 的行为,直接渲染 HTML 字符串
  2. 安全警告:React 的 dangerouslySetInnerHTML 属性名本身就提醒开发者注意 XSS 攻击风险
  3. 内容替换:与 Vue 一样,会替换元素内的所有现有内容

v-text:纯文本内容渲染

v-text 是 Vue 中用于将纯文本内容设置到元素内的指令,它会替换元素内的所有内容,但不会解析 HTML 标签。

  • Vue 代码:
<p v-text="message"></p>
  • VuReact 编译后 React 代码:
<p>{message}</p>

从示例可以看到:Vue 的 v-text 指令被编译为 React 的 JSX 插值表达式。VuReact 采用 文本插值编译策略,将模板指令转换为 JSX 的大括号表达式,完全保持 Vue 的文本渲染语义——将 message 作为纯文本内容插入到元素中。

这种编译方式的关键特点在于:

  1. 语义一致性:完全模拟 Vue v-text 的行为,渲染纯文本内容
  2. 自动转义:React 的 JSX 插值会自动转义 HTML 特殊字符,防止 XSS 攻击
  3. 内容替换:与 Vue 一样,会替换元素内的所有现有内容

VuReact 的编译策略确保了从 Vue 到 React 的平滑迁移,开发者无需手动重写内容渲染逻辑。编译后的代码既保持了 Vue 的语义,又符合 React 的安全最佳实践。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

Vue路由跳转全场景实战(Vue2+Vue3适配)| 新手必看

2026年4月18日 12:50

Vue路由跳转是前端项目页面切换的核心操作,贯穿整个Vue项目开发(从简单页面跳转,到带参跳转、权限控制跳转)。本文将整合Vue2、Vue3路由跳转的所有常用方式,明确不同场景的使用选择,补充参数传递、导航守卫、常见问题及解决方案,提供可直接复制的实战示例,兼顾新手入门与实战适配。

一、Vue路由跳转核心前提(必看)

无论Vue2还是Vue3,路由跳转前需确保已完成路由配置(引入Vue Router、创建路由实例、挂载路由),基础配置如下(简化版,可直接复用):

// Vue2 基础路由配置(router/index.js)
import Vue from 'vue'
import VueRouter from 'vue-router'
Vue.use(VueRouter)

const routes = [
  { path: '/', name: 'Home', component: () => import('../views/Home.vue') },
  { path: '/about', name: 'About', component: () => import('../views/About.vue') },
  { path: '/user/:id', name: 'User', component: () => import('../views/User.vue') }
]

const router = new VueRouter({ mode: 'history', routes })
export default router

// Vue3 基础路由配置(router/index.js)
import { createRouter, createWebHistory } from 'vue-router'
const routes = [
  { path: '/', name: 'Home', component: () => import('../views/Home.vue') },
  { path: '/about', name: 'About', component: () => import('../views/About.vue') },
  { path: '/user/:id', name: 'User', component: () => import('../views/User.vue') }
]

const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes
})
export default router

说明:Vue2需通过Vue.use(VueRouter)注册路由,Vue3通过createRouter创建路由实例,二者跳转语法有细微差异,下文将分别说明并标注适配版本。

二、Vue路由跳转3种核心方式(实战常用)

Vue路由跳转主要分为「声明式跳转」和「编程式跳转」,其中编程式跳转更灵活,可结合业务逻辑(如登录判断)使用,声明式跳转适合简单页面切换。

方式1:声明式跳转( 标签,最简洁)

核心:通过Vue Router提供的<router-link>标签实现跳转,无需写JS逻辑,自动渲染为a标签(可通过tag属性修改标签类型),适配Vue2、Vue3,用法完全一致。

1. 基础跳转(无参数)

<!-- 方式1:通过path跳转(推荐,简洁直观) -->
<router-link to="/">首页</router-link>
<router-link to="/about">关于我们</router-link>

<!-- 方式2:通过name跳转(需配置路由name,适合路径较长场景) -->
<router-link :to="{ name: 'Home' }">首页</router-link>
<router-link :to="{ name: 'About' }">关于我们</router-link>

<!-- 可选:修改渲染标签(默认a标签,改为button) -->
<router-link to="/" tag="button">首页(按钮形式)</router-link>

2. 带参数跳转(query参数 / params参数)

跳转时传递参数,用于页面间数据交互,两种参数类型用法不同,需区分场景:

<!-- 1. query参数(暴露在URL上,可刷新保留,适合简单数据) -->
<!-- 方式:path/name + query对象 -->
<router-link :to="{ path: '/user', query: { id: 1, name: '张三' } }">
  进入用户页(query参数)
</router-link>
<router-link :to="{ name: 'User', query: { id: 1, name: '张三' } }">
  进入用户页(name+query)
</router-link>
<!-- 跳转后URL:http://localhost:8080/user?id=1&name=张三 -->

<!-- 2. params参数(不暴露在URL上,刷新丢失,适合敏感数据) -->
<!-- 注意:params必须配合name跳转,不能配合path -->
<router-link :to="{ name: 'User', params: { id: 1, name: '张三' } }">
  进入用户页(params参数)
</router-link>
<!-- 跳转后URL:http://localhost:8080/user/1(需配置路由path为/user/:id) -->

方式2:编程式跳转(router.push / router.replace,最灵活)

核心:通过JS代码调用router.push(保留历史记录)或router.replace(不保留历史记录,无法返回上一页)实现跳转,适合结合业务逻辑(如登录成功后跳转、按钮点击跳转),Vue2和Vue3用法略有差异。

1. Vue2 编程式跳转

// 1. 基础跳转(无参数)
this.$router.push('/') // path跳转
this.$router.push({ name: 'Home' }) // name跳转

// 2. 带参数跳转(query / params)
// query参数
this.$router.push({
  path: '/user',
  query: { id: 1, name: '张三' }
})
// params参数(需配合name)
this.$router.push({
  name: 'User',
  params: { id: 1, name: '张三' }
})

// 3. 替换跳转(不保留历史记录)
this.$router.replace('/about')

// 4. 后退/前进(操作历史记录)
this.$router.go(-1) // 后退1页(类似浏览器返回键)
this.$router.back() // 等同于go(-1)
this.$router.go(1) // 前进1页

2. Vue3 编程式跳转

Vue3 setup语法中,无this,需通过useRouter引入路由实例,用法如下:

// 1. 引入路由实例(必须先引入)
import { useRouter } from 'vue-router'
const router = useRouter()

// 2. 基础跳转(无参数)
router.push('/')
router.push({ name: 'Home' })

// 3. 带参数跳转(query / params)
router.push({
  path: '/user',
  query: { id: 1, name: '张三' }
})
router.push({
  name: 'User',
  params: { id: 1, name: '张三' }
})

// 4. 替换跳转(不保留历史记录)
router.replace('/about')

// 5. 后退/前进
router.go(-1)
router.back()
router.go(1)

方式3:路由重定向(redirect,自动跳转)

核心:在路由配置中通过redirect属性,实现页面自动跳转(无需用户操作),适合默认页面、404页面、旧路径跳转新路径场景,Vue2、Vue3用法一致。

// 路由配置中添加redirect
const routes = [
  // 1. 默认跳转(访问根路径,自动跳转到首页)
  { path: '/', redirect: '/home' },
  // 2. 通过name重定向
  { path: '/index', redirect: { name: 'Home' } },
  // 3. 旧路径跳转新路径(兼容旧链接)
  { path: '/old-user', redirect: '/user' },
  // 4. 404页面(匹配所有未定义路径,跳转到404组件)
  { path: '/:pathMatch(.*)*', redirect: '/404' }
]

三、路由跳转参数接收(配套必备)

跳转时传递的query/params参数,需在目标页面接收后使用,Vue2和Vue3接收方式不同,以下是完整示例:

1. Vue2 参数接收

// 1. 接收query参数
export default {
  mounted() {
    const id = this.$route.query.id // 接收query参数id
    const name = this.$route.query.name // 接收query参数name
    console.log(id, name) // 输出:1 张三
  }
}

// 2. 接收params参数
export default {
  mounted() {
    const id = this.$route.params.id // 接收params参数id
    const name = this.$route.params.name // 接收params参数name
    console.log(id, name) // 输出:1 张三
  }
}

2. Vue3 参数接收

Vue3 setup语法中,需通过useRoute引入路由对象,接收参数:

// 引入路由对象
import { useRoute } from 'vue-router'
const route = useRoute()

// 接收参数(可在setup中直接使用,或在生命周期中使用)
const id = route.query.id // query参数
const name = route.query.name

const paramsId = route.params.id // params参数
const paramsName = route.params.name

console.log(id, paramsId) // 输出:1 1

四、路由跳转进阶:导航守卫(权限控制)

实际开发中,常需要对路由跳转进行权限控制(如未登录不能访问个人中心),此时需使用导航守卫,拦截跳转并判断权限,Vue2、Vue3用法基本一致,以下是实战示例:

1. 全局导航守卫(控制所有路由跳转)

// Vue2 全局导航守卫(router/index.js)
router.beforeEach((to, from, next) => {
  // to:目标路由对象
  // from:当前跳转前的路由对象
  // next:放行/拦截方法
  
  // 示例:未登录不能访问/user路径
  const token = localStorage.getItem('token') // 模拟登录状态
  if (to.path === '/user' && !token) {
    next('/login') // 未登录,拦截并跳转到登录页
  } else {
    next() // 已登录,放行
  }
})

// Vue3 全局导航守卫(用法完全一致)
router.beforeEach((to, from, next) => {
  const token = localStorage.getItem('token')
  if (to.meta.requireAuth && !token) { // 结合路由元信息,更灵活
    next('/login')
  } else {
    next()
  }
})

// 路由元信息配置(标记需要权限的路由)
const routes = [
  {
    path: '/user',
    name: 'User',
    component: () => import('../views/User.vue'),
    meta: { requireAuth: true } // 标记:需要登录才能访问
  }
]

2. 组件内导航守卫(控制单个组件跳转)

仅对当前组件的跳转进行拦截,适合单个组件的特殊权限控制:

// Vue2 组件内守卫
export default {
  // 进入组件前拦截
  beforeRouteEnter(to, from, next) {
    const token = localStorage.getItem('token')
    if (!token) {
      next('/login')
    } else {
      next()
    }
  },
  // 离开组件前拦截(如提示用户未保存内容)
  beforeRouteLeave(to, from, next) {
    if (confirm('确定要离开吗?内容未保存')) {
      next()
    } else {
      next(false) // 取消跳转
    }
  }
}

// Vue3 组件内守卫(setup语法)
import { onBeforeRouteEnter, onBeforeRouteLeave } from 'vue-router'

// 进入组件前拦截
onBeforeRouteEnter((to, from, next) => {
  const token = localStorage.getItem('token')
  if (!token) {
    next('/login')
  } else {
    next()
  }
})

// 离开组件前拦截
onBeforeRouteLeave((to, from, next) => {
  if (confirm('确定要离开吗?内容未保存')) {
    next()
  } else {
    next(false)
  }
})

五、路由跳转常见问题及解决方案

1. 跳转后页面不刷新

原因:路由参数变化(如从/user/1跳转到/user/2),组件会复用,不会重新触发mounted生命周期。

解决方案:监听路由变化,触发数据重新请求:

// Vue2 监听路由
watch: {
  '$route'(to, from) {
    // 路由变化时,重新请求数据
    this.getUserData(to.params.id)
  }
}

// Vue3 监听路由
import { watch } from 'vue'
import { useRoute } from 'vue-router'
const route = useRoute()

watch(
  () => route.params,
  (newParams) => {
    // 监听params变化,重新请求数据
    getUserData(newParams.id)
  },
  { deep: true }
)

2. params参数刷新后丢失

原因:params参数不暴露在URL上,页面刷新后,路由信息重置,参数丢失。

解决方案:1. 改用query参数(适合非敏感数据);2. 将params参数存储到localStorage/sessionStorage,刷新后重新读取。

3. 路由跳转后,URL正确但页面空白

常见原因:1. 路由配置错误(path拼写错误、component路径错误);2. 未在页面中添加<router-view>标签(路由出口,用于渲染跳转后的组件)。

解决方案:核对路由path和component路径,确保App.vue中包含<router-view>

<!-- App.vue 必须添加路由出口 -->
<template>
  <div id="app">
    <router-link to="/"&gt;首页&lt;/router-link&gt;
    &lt;router-view /&gt; <!-- 路由跳转后的组件会渲染在这里 -->
  </div>
</template>

4. Vue3中报错“Cannot read property 'push' of undefined”

原因:Vue3 setup语法中,未通过useRouter引入路由实例,直接使用this.$router(setup中无this)。

解决方案:正确引入useRouter,创建路由实例后再使用:

// 正确用法
import { useRouter } from 'vue-router'
const router = useRouter()
router.push('/about') // 无报错

六、总结

Vue路由跳转核心分为3种方式,结合场景选择即可:

  • 简单页面切换:用声明式跳转() ,简洁高效;
  • 需结合业务逻辑(登录、判断):用编程式跳转(router.push) ,灵活可控;
  • 自动跳转(默认页、404):用路由重定向(redirect) ,无需用户操作。

关键注意点:Vue2和Vue3的跳转语法差异主要在“是否使用this”,Vue3需通过useRouter/useRoute引入路由实例和路由对象;参数传递需区分query(刷新保留)和params(刷新丢失);权限控制用导航守卫,避免未授权访问。

本文所有示例均可直接复制到项目中使用,只需根据自身项目的路由配置,修改路径和组件名称即可快速适配。

你的 Vue v-for,VuReact 会编译成什么样的 React 代码?

作者 Ruihong
2026年4月18日 11:06

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 v-for 指令经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的 v-for 指令用法。

编译对照

基础数组遍历

最简单的 v-for 指令,用于遍历数组并渲染列表项。

  • Vue 代码:
<li v-for="(item, i) in list" :key="item.id">{{ i }} - {{ item.name }}</li>
  • VuReact 编译后 React 代码:
{
  list.map((item, i) => (
    <li key={item.id}>
      {i} - {item.name}
    </li>
  ));
}

从示例可以看到:Vue 的 v-for 指令被编译为 React 的 map 函数。VuReact 采用 数组映射编译策略,将模板指令转换为 JSX 数组表达式,完全保持 Vue 的列表渲染语义——遍历数组中的每个元素,生成对应的 JSX 元素,并自动处理 key 属性以保证 React 的渲染性能。


对象遍历

v-for 也可以用于遍历对象的属性和值。

  • Vue 代码:
<li v-for="(val, key, i) in obj" :key="key">{{ i }} - {{ key }}: {{ val }}</li>
  • VuReact 编译后 React 代码:
{
  Object.entries(obj).map(([key, val], i) => (
    <li key={key}>
      {i} - {key}: {val}
    </li>
  ));
}

对于对象遍历,VuReact 采用 Object.entries 转换策略,将 Vue 的对象遍历语法转换为 Object.entries(obj).map() 形式。这种编译方式完全模拟 Vue 的对象遍历语义——按顺序遍历对象的键值对,保持 (值, 键, 索引) 的参数顺序,确保数据渲染的一致性。


嵌套 v-for 循环

复杂的嵌套列表渲染,使用多层 v-for 循环。

  • Vue 代码:
<div v-for="category in categories" :key="category.id">
  <h3>{{ category.name }}</h3>
  <ul>
    <li v-for="product in category.products" :key="product.id">
      {{ product.name }} - ${{ product.price }}
    </li>
  </ul>
</div>
  • VuReact 编译后 React 代码:
{
  categories.map((category) => (
    <div key={category.id}>
      <h3>{category.name}</h3>
      <ul>
        {category.products.map((product) => (
          <li key={product.id}>
            {product.name} - ${product.price}
          </li>
        ))}
      </ul>
    </div>
  ));
}

对于嵌套循环,VuReact 采用 嵌套 map 函数编译策略,将 Vue 的嵌套 v-for 转换为嵌套的 map 函数调用。这种编译方式完全保持 Vue 的嵌套循环语义——外层循环的每个迭代都会创建内层循环的完整列表,保持组件结构的层次关系。


v-if + v-for

实际业务中经常需要结合条件进行列表渲染。

  • Vue 代码:
<template v-if="cond" v-for="user in users" :key="user.id">
  <img :src="user.avatar" :alt="user.name" />
  <div class="user-info">
    <h4>{{ user.name }}</h4>
    <p>{{ user.email }}</p>
    <span class="role-badge">{{ user.role }}</span>
  </div>
  <div class="user-actions">
    <button @click="editUser(user.id)">编辑</button>
    <button @click="deleteUser(user.id)" class="danger">删除</button>
  </div>
</template>
  • VuReact 编译后 React 代码:
{
  cond
    ? users.map((user) => (
        <div key={user.id} className="user-card">
          <img src={user.avatar} alt={user.name} />
          <div className="user-info">
            <h4>{user.name}</h4>
            <p>{user.email}</p>
            <span className="role-badge">{user.role}</span>
          </div>
          <div className="user-actions">
            <button onClick={() => editUser(user.id)}>编辑</button>
            <button onClick={() => deleteUser(user.id)} className="danger">
              删除
            </button>
          </div>
        </div>
      ))
    : null;
}

对于带条件的列表渲染,VuReact 展示了智能的条件编译能力

  1. 优先条件编译:将 v-if 转换为三元表达式,包裹整个 v-for 渲染结果
  2. 自动提取 key:当 <template> 标签上存在 :key 属性时,会自动将其传递给内部的第一个子元素
  3. 事件绑定处理@click 转换为 onClick,并自动包装为箭头函数以传递参数
  4. 属性绑定转换:src:alt 等转换为 React 属性语法
  5. 样式类名处理class 转换为 className,符合 React 规范

VuReact 的编译策略完全保持 Vue 的列表渲染语义,同时生成符合 React 最佳实践的代码。


使用 v-for 范围值

Vue 的 v-for 也支持使用数字范围进行迭代。

  • Vue 代码:
<span v-for="n in 5" :key="n">{{ n }}</span>
  • VuReact 编译后 React 代码:
{
  Array.from({ length: 5 }, (_, n) => (
    <span key={n + 1}>{n + 1}</span>
  ));
}

对于范围值迭代,VuReact 采用 Array.from 转换策略,将 Vue 的数字范围语法转换为数组生成和映射。这种编译方式完全模拟 Vue 的范围迭代语义——从 1 开始到指定数字结束(包含),保持迭代顺序和数值的一致性。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

Vue v-if 转 React:VuReact 怎么处理?

作者 Ruihong
2026年4月18日 10:35

VuReact 是一个能将 Vue 3 代码编译为标准、可维护 React 代码的工具。今天就带大家直击核心:Vue 中常见的 v-if/v-else/v-else-if 指令经过 VuReact 编译后会变成什么样的 React 代码?

前置约定

为避免示例代码冗余导致理解偏差,先明确两个小约定:

  1. 文中 Vue / React 代码均为核心逻辑简写,省略完整组件包裹、无关配置等内容;
  2. 默认读者已熟悉 Vue 3 中的条件指令用法。

编译对照

基础 v-if 条件渲染

最简单的 v-if 指令,用于根据条件显示或隐藏元素。

  • Vue 代码:
<div v-if="cond">内容</div>
  • VuReact 编译后 React 代码:
{
  cond ? <div>内容</div> : null;
}

从示例可以看到:Vue 的 v-if 指令被编译为 React 的三元表达式。VuReact 采用 条件表达式编译策略,将模板指令转换为 JSX 内联表达式,完全保持 Vue 的条件渲染语义——当 cond 为真时渲染 <div>,为假时渲染 null(React 中 null 不会被渲染到 DOM)。


v-if 与 v-else 组合

v-ifv-else 组合使用,实现二选一的条件渲染。

  • Vue 代码:
<div v-if="cond">内容</div>
<div v-else>其他内容</div>
  • VuReact 编译后 React 代码:
{
  cond ? <div>内容</div> : <div>其他内容</div>;
}

VuReact 将 v-if/v-else 组合编译为完整的三元表达式完全模拟 Vue 的条件分支语义——两个分支互斥,确保同一时间只有一个元素被渲染。这种编译方式保持了代码的简洁性和可读性,同时与 React 的表达式渲染模式完美契合。


多条件 v-else-if 链

复杂的多条件判断链,使用 v-ifv-else-ifv-else 组合。

  • Vue 代码:
<div v-if="type === 'A'">内容A</div>
<div v-else-if="type === 'B'">内容B</div>
<div v-else>其他内容</div>
  • VuReact 编译后 React 代码:
{
  type === 'A' ? <div>内容A</div> : type === 'B' ? <div>内容B</div> : <div>其他内容</div>;
}

对于多条件链,VuReact 采用嵌套三元表达式编译策略,将 Vue 的 v-else-if 链转换为嵌套的条件表达式。这种编译方式完全保持 Vue 的条件链语义——按顺序检查条件,第一个满足条件的分支被渲染,后续分支被跳过。


复杂业务场景条件渲染

实际业务中的复杂条件渲染,包含嵌套条件、事件绑定、插值表达式等。

  • Vue 代码:
<div v-if="user.role === 'admin' && (user.permissions.includes('write') || isSuperAdmin)">
  <h1>管理员控制面板</h1>
  <button @click="deleteAll">删除所有数据</button>
</div>
<div v-else-if="user.role === 'editor' && articles.length > 0 && !isSuspended">
  <h2>编辑文章 (共{{ articles.length }}篇)</h2>
  <ul>
    <li v-for="article in articles" :key="article.id">{{ article.title }}</li>
  </ul>
</div>
<div v-else-if="user.role === 'viewer' && hasSubscription">
  <h3>订阅用户视图</h3>
  <p>您的订阅将于{{ subscriptionEndDate }}到期</p>
</div>
<div v-else-if="user.role === 'guest' && showTrial">
  <div class="trial-banner">
    <p>试用用户,剩余{{ trialDays }}天</p>
    <button @click="upgrade">升级账户</button>
  </div>
</div>
<div v-else>
  <div class="error-state">
    <p v-if="isLoading">加载中...</p>
    <p v-else-if="errorMessage">{{ errorMessage }}</p>
    <p v-else>无访问权限或账户状态异常</p>
    <button @click="retry">重试 ({{ retryCount }}/3)</button>
  </div>
</div>
  • VuReact 编译后 React 代码:
{
  user.role === 'admin' && (user.permissions.includes('write') || isSuperAdmin) ? (
    <div>
      <h1>管理员控制面板</h1>
      <button onClick={deleteAll}>删除所有数据</button>
    </div>
  ) : user.role === 'editor' && articles.length > 0 && !isSuspended ? (
    <div>
      <h2>编辑文章 (共{articles.length}篇)</h2>
      <ul>
        {articles.map((article) => (
          <li key={article.id}>{article.title}</li>
        ))}
      </ul>
    </div>
  ) : user.role === 'viewer' && hasSubscription ? (
    <div>
      <h3>订阅用户视图</h3>
      <p>您的订阅将于{subscriptionEndDate}到期</p>
    </div>
  ) : user.role === 'guest' && showTrial ? (
    <div>
      <div className="trial-banner">
        <p>试用用户,剩余{trialDays}天</p>
        <button onClick={upgrade}>升级账户</button>
      </div>
    </div>
  ) : (
    <div>
      <div className="error-state">
        {isLoading ? (
          <p>加载中...</p>
        ) : errorMessage ? (
          <p>{errorMessage}</p>
        ) : (
          <p>无访问权限或账户状态异常</p>
        )}
        <button onClick={retry}>重试 ({retryCount}/3)</button>
      </div>
    </div>
  );
}

对于复杂的业务场景,VuReact 展示了完整的条件编译能力

  1. 复杂条件表达式:将 Vue 的复杂条件逻辑(&&||、函数调用等)原样转换为 JSX 表达式
  2. 事件绑定转换@click 转换为 onClick,保持事件语义
  3. 插值表达式{{ }} 转换为 { },保持数据绑定
  4. 样式类名转换class 转换为 className,符合 React 规范

VuReact 的编译策略完全保持 Vue 的条件渲染语义,同时生成符合 React 最佳实践的代码,提高可维护性。

🔗 相关资源


✨ 如果你觉得本文对你理解 VuReact 有帮助,欢迎点赞、收藏、关注!

❌
❌