从高层设计的角度去探讨框架需要关注的问题。
参考:速读《Vue.js 设计与实现》 - 掘金 (juejin.cn)
系列目录:
标题 | 博客 |
---|---|
第一篇:框架设计概览 | 【Vue.js设计与实现】第一篇:框架设计概览-阅读笔记 |
第二篇:响应系统 | 【Vue.js设计与实现】第二篇:响应系统-阅读笔记 |
第三篇:渲染器 | 【Vue.js设计与实现】第三篇:渲染器-阅读笔记 |
第四篇:组件化 | 【Vue.js设计与实现】第四篇:组件化-阅读笔记 |
第五篇:编译器 | 【Vue.js设计与实现】第五篇:编译器-阅读笔记 |
第六篇:服务端渲染 | 【Vue.js设计与实现】第六篇:服务端渲染-阅读笔记 |
第一篇:框架设计概览
框架的设计,本身就是一种权衡的艺术。
命令式关注过程,声明式关注结果
命令式:
const div=document.querySelector('#app') //获取div
div.innerText='hello world' //设置文本内容
div.addElementListener('click',()=>{alert('OK')}) //绑定事件
声明式:
<div @click="()=>alert('OK')">Hello worlddiv>
vue的内部是命令式的,而我们使用vue的时候是声明式的。
即,vue封装了命令式的过程,对外暴露出了声明式的结果。
从性能的角度上看,命令式的性能>声明式的性能。
原因:
命令式的代码通过原生的JS实现,声明式的代码要实现同样功能时,还要再调用相同的命令式代码。
声明式代码的更新性能消耗 = 找出差异的性能消耗+直接修改的性能消耗.
所谓的虚拟 DOM,就是为了最小化找出差异这一步的性能消耗而出现的。
显然命令式的性能更高。此时vue还要对外暴露出声明式的接口,原因是声明式的可维护性,远大于命令式的可维护性
而且,vue在性能优化之下,它并不会比纯命令式的性能差太多。
在前端领域,用JS修改HTML的方式主要有3种:原生JS,innerHTML,虚拟DOM。
心智负担:虚拟DOM < innerHTML< 原生JS
性能:innerHTML < 虚拟DOM < 原生JS
可维护性:原生JS < innerHTML < 虚拟DOM
虚拟DOM的性能并不是最高的,但是vue依然选择虚拟DOM来进行渲染层的构架。
这也是性能与可维护性的权衡。
都是框架设计的一种方式,可单独出现,也可组合使用。
runtime
利用render函数,把虚拟DOM转化为真实DOM的方式。
compiler
把template模板中的内容,转化为真实DOM。
注意,存在编译过程,可以分析用户提供的内容。同时,没有运行时理论上性能会更好。
过程分两步:
- 先把template模板转化成render函数,即编译时
- 再利用render函数,把虚拟DOM转化为真实DOM,即运行时
两者的结合,可以:
- 在编译时:分析用户提供的内容
- 在运行时,提供足够的灵活性
这也是vue的主要实现方式。
__DEV__
:在开发环境中为用户提供友好的警告信息的同时,不会增加生产环境代码的体积有一个常量__DEV__
,存在于所有的console.warn中:
if (__DEV__ && !res) {
warn(
`Failed to mount app: mount target selector "${container}"
returned null.`
);
}
在开发环境中__DEV__
永远为true
,在生产环境中__DEV__
永远为false
。永远不会执行的代码成为dead code
,不会出现在最终产物中。
/*#__PURE__*/
与Tree ShakingTree Shaking:消除那些永远不会被执行的代码。
想要实现Tree Shaking,模块必须是ESM。
Tree Shaking的关键点:副作用。如果一个函数调用会产生副作用,那么就不能将其移除。副作用就是,当调用函数的时候会对外部产生影响,例如修改了全局变量。
举个例子:
如果 obj 对象是一个通过
Proxy
创建的代理对象,那么当我们读取对象属性时,就会触发代理对象的 get 夹子(trap),在 get 夹子中是可能产生副作用的,例如我们在 get 夹子中修改了某个全局变量。而到底会不会产生副作用,只有代码真正运行的时候才能知道,JavaScript 本身是动态语言,因此想要静态地分析哪些代码是 dead code 很有难度
静态地分析 JavaScript 代码很困难,所以像 rollup.js 这类工具都会提供一个机制,让我们能明确地告诉 rollup.js:这段代码没有副作用,可以移除。
import {foo} from './utils'
/*#__PURE__*/ foo()
注释代码/*#__PURE__*/
,就是告诉rollup.js,对于foo的调用不会产生副作用,可以Tree-Shaking。
实际上,通常产生副作用的代码都是模块内函数的顶级调用。
foo() // 顶级调用
function bar(){
foo() // 函数内调用
}
可以看到,对于顶级调用来说,是可能产生副作用的;对于函数内调用来说,只要函数 bar 没有调用,那么 foo 函数的调用自然不会产生副作用。
因此,在 Vue.js 3 的源码中,基本都是在一些顶级调用的函数上使用 /*#__PURE__*/
注释。此注释也可以应用在语句上。
用户能够使用 标签直接引入 ESM 格式的资源,如:
<script type="module" src="/path/to/vue.esm-browser.js">
script>
ESM格式的资源中,文件会有一个-browser
字样。其实对于ESM格式的资源来说,Vue.js还会输出一个vue.esm-bundler.js
文件。这样做的原因是:在寻找资源时,如果package.json中存在module字段,那么会优先使用module字段指向的资源来代替main字段指向的资源。
如Vue.js源码中的packages/vue/package.json
:
{
"main":"index.js",
"module":"dist/vue.runtime.esm-bundler.js"
}
带有
-bundler
字样的 ESM 资源是给 rollup.js 或 webpack 等打包工具使用的,而带有-browser
字样的 ESM 资源是直接给使用的
当我们构建提供给打包工具的ESM格式的资源时,不能直接把__DEV__
设置为true或false,而是:process.env.NODE_ENV!=='production'
。即,当前环境不是生产环境.
如源码:
if (__DEV__)
在带有 -bundler
字样的资源中会变为:
if ((process.env.NODE_ENV !== 'production'))
举个例子,一个模块导出一个方法,参数是一个回调函数:
import utils from 'utils.js'
utils.foo(()=>{
//...
})
如果用户在执行回调函数时出错了,怎么办?有两个方法:让用户自己处理、vue代替用户统一处理错误。
用户自己处理:
utils.foo(()=>{
try{
//...
}catch(e){
//...
}
})
会增加用户的负担。不建议。
vue代替用户统一处理错误
将错误处理程序封装为一个函数,如:callWithErrorHanding
export default {
foo(fn) {
callWithErrorHanding(fn);
},
bar(fn) {
callWithErrorHanding(fn);
},
};
function callWithErrorHanding(fn) {
try {
fn && fn();
} catch (e) {
console.log(e);
}
}
这样做的好处:为用户提供统一的错误处理接口。
提供 registerErrorHandler
函数,用户可以使用它注册错误处理程序,在callWithErrorHanding
捕获错误后,把错误传给用户注册的错误处理程序:
export default {
foo(fn) {
callWithErrorHanding(fn);
},
// 用户可以调用该函数注册统一的错误处理函数
registerErrorHandler(fn) {
handleError = fn;
},
};
function callWithErrorHanding(fn) {
try {
fn && fn();
} catch (e) {
// 将捕获到的错误传递给用户的错误处理程序
handleError(e);
}
}
这时错误处理的能力完全由用户控制,用户既可以选择忽略错误,也可以调用上报程序将错误上报给监控系统。
在Vue.js中,我们也可以注册统一的错误处理函数:
import App from "App.vue";
const app = createApp(app);
app.config.errorHandler = () => {
// 错误处理程序
};
使用TS 编写代码与对TS 类型支持友好是两件事。
举个例子:
function foo(val: any) {
return val;
}
const res = foo('str')
当我们把鼠标指针悬浮到 res 常量上时,可以看到其类型是 any
,而不是string
——返回值类型丢失。
function foo<T extends any>(val: T):T {
return val;
}
由此可见,框架想要做到完善的类型支持,需要付出相当大的努力。
开发体验是衡量一个框架的重要指标之一。大多数情况下“框架”要比开发者更清楚问题出在哪里,因此在框架层面抛出有意义的警告信息是非常必要的。
我们通过预定义 __DEV__
常量,从而实现仅在开发环境中打印警告信息—— Tree-Shaking 机制。这使得线上代码不会因为警告信息而体积过大。
Tree-Shaking是一种排除 dead code 的机制。一些工具能够识别/*#__PURE__*/
注释,可以利用此注释来辅助构建工具进行 Tree-Shaking。
对于框架的输出产物,不同类型的产物是为了满足不同的需求。为了让用户能够通过 标签直接引用并使用,我们需要输出 IIFE 格式的资源,即立即调用的函数表达式。为了让用户能够通过
引用并使用,我们需要输出ESM 格式的资源。
需要注意的是,ESM 格式的资源有两种:用于浏览器的 esm-browser.js
和用于打包工具的 esm-bundler.js
。它们的区别在于对预定义常量 __DEV__
的处理,前者直接将 __DEV__
常量替换为字面量 true 或 false,后者则将 __DEV__
常量替换为process.env.NODE_ENV !== 'production'
语句。
有时出于灵活性和兼容性的考虑,对于同样的任务,框架提供了两种解决方案,如组合式API/选项式API。不被使用的方案会被 Tree-Shaking 机制排除。
框架的错误处理做得好坏直接决定了用户应用程序的健壮性,同时还决定了用户开发应用时处理错误的心智负担。框架需要为用户提供统一的错误处理接口,这样用户可以通过注册自定义的错误处理函数来处理全部的框架异常。
Vue.js 3是一个声明式的UI框架。前端页面涉及的东西:
Vue是如何声明式地描述上述内容的:
使用模板来声明式地描述UI
:
或 v-bind
来描述动态绑定的属性@
或 v-on
来描述事件使用JavaScript 对象来声明式地描述UI
const title = {
// 标签名称
tag: "h1",
// 标签属性
props: {
onClick: handler,
},
// 子节点
children: [{ tag: "span" }],
};
对应到Vue模板:
<h1 onClick="handler">
<span>span>
h1>
使用 JavaScript 对象描述UI比模板描述更加灵活。如:表示一个标题,根据标题级别的不同,会分别采用 h1~h6 这几个标签,JS对象描述:
let level = 3;
const title = {
tag: `h${level}`,
};
用模板描述,只能穷举:
<h1 v-if="level === 1">h1>
<h2 v-else-if="level === 2">h2>
<h3 v-else-if="level === 3">h3>
<h4 v-else-if="level === 4">h4>
<h5 v-else-if="level === 5">h5>
<h6 v-else-if="level === 6">h6>
使用 JavaScript 对象来描述 UI的方式,就是虚拟DOM。
Vue.js组件中手写的渲染函数就是使用虚拟 DOM 来描述 UI 的,如:
import { h } from "vue";
export default {
render() {
return h("h1", { onClick: handlder }); // 虚拟DOM
},
};
这里的h函数返回值是一个对象,其作用是让我们编写虚拟DOM更加轻松。也可以这样写:
export default {
render() {
return {
tag: "h1",
props: { onClick: handler },
};
},
};
h 函数,一个辅助创建虚拟 DOM 的工具函数
渲染器的工作原理其实很简单,是使用一些我们熟悉的 DOM 操作 API 来完成渲染工作。
虚拟 DOM:用 JavaScript对象来描述真实的 DOM 结构。
渲染器:把虚拟 DOM 渲染为真实 DOM。
const vnode = {
tag: "div",
props: {
onClick: () => alert("hello"),
},
children: "click me",
};
实际上,你完全可以自己设计虚拟 DOM 的结构,例如可以使用tagName 代替 tag,因为它本身就是一个 JavaScript 对象,并没有特殊含义
分析渲染器 renderer 的实现思路
vnode.tag
作为标签名vnode.props
对象,如果 key
以on
字符开头,说明它是一个事件children
:若children
是一个数组,就递归地调用renderer
继续渲染具体代码如下:
渲染器:
vnode
:虚拟DOM节点container
:真实 DOM 元素,作为挂载点,渲染器会把虚拟 DOM 渲染到该挂载点下function renderer(vnode, container) {
// 使用 vnode.tag 作为标签名称创建 DOM 元素
const el = document.createElement(vnode.tag);
// 遍历 vnode.props,将属性、事件添加到 DOM 元素
for (const key in vnode.props) {
// on开头的事件名
if (/^on/.test(key)) {
el.addEventListener(
key.substring(2).toLowerCase(),
vnode.props[key]
);
}
}
// 处理children
if (typeof vnode.children === "string") {
// 文本子节点
el.appendChild(document.createTextNode(vnode.children));
} else if (Array.isArray(vnode.children)) {
// 递归地调用 renderer 函数渲染子节点,使用当前元素 el 作为挂载点
vnode.children.forEach((child) => renderer(child, el));
}
// 将元素添加到挂载点下
container.appendChild(el);
}
如:
<div id="div">div>
const div = document.getElementById("div");
renderer(vnode, div);
打开浏览器,会发现渲染出了click me,点击它:
上述仅仅只是创建节点,渲染器的精髓在更新节点:渲染器只更新修改的部分,而不是重新渲染全部节点。
虚拟 DOM 除了能够描述真实 DOM 之外,还能够描述组件。组件就是一 组 DOM 元素的封装。
定义一个函数来代表组件,而函数的返回值就代表组件要渲染的内容。
这里tag
用来描述组件函数。
const MyComponent = function () {
return {
tag: "div",
props: {
onClick: () => alert("hello"),
},
children: "click me",
};
};
const vnode = {
tag: MyComponent,
};
总体代码:
function renderer(vnode, container) {
// 渲染标签/组件
if (typeof vnode.tag === "string") {
mountElement(vnode, container);
} else if (typeof vnode.tag === "function") {
mountComponent(vnode, container);
}
}
function mountElement(vnode, container) {
// 使用 vnode.tag 作为标签名称创建 DOM 元素
const el = document.createElement(vnode.tag);
// 遍历 vnode.props,将属性、事件添加到 DOM 元素
for (const key in vnode.props) {
// on开头的事件名
if (/^on/.test(key)) {
el.addEventListener(
key.substring(2).toLowerCase(),
vnode.props[key]
);
}
}
// 处理children
if (typeof vnode.children === "string") {
// 文本子节点
el.appendChild(document.createTextNode(vnode.children));
} else if (Array.isArray(vnode.children)) {
// 递归地调用 renderer 函数渲染子节点,使用当前元素 el 作为挂载点
vnode.children.forEach((child) => renderer(child, el));
}
// 将元素添加到挂载点下
container.appendChild(el);
}
function mountComponent(vnode, container) {
// 获取虚拟DOM
const subtree = vnode.tag();
renderer(subtree, container);
}
实际上,组件不一定得是函数,也可以是对象。对象里有一个render
函数,返回一个虚拟DOM。
const MyComponent = {
render() {
return {
tag: "div",
props: {
onClick: () => alert("hello"),
},
children: "click me",
};
},
};
const vnode = {
tag: MyComponent,
};
function mountComponentObj(vnode, container) {
const subtree=vnode.tag.render()
renderer(subtree, container);
}
function renderer(vnode, container) {
// 渲染标签/组件
if (typeof vnode.tag === "string") {
mountElement(vnode, container);
} else if (typeof vnode.tag === "function") {
mountComponent(vnode, container);
} else if (typeof vnode.tag === "object") {
mountComponentObj(vnode, container);
}
}
在Vue中,UI形式主要分为两种:
编译器
编译,得到渲染函数render
<div :id="Id" :class="{Class:true}" @click="onClick">
import {h} from 'vue'
export default {
render(){
return h('h1',{onClick:handler}) //虚拟DOM
}
}
注意,渲染器和渲染函数,不一样
渲染器是:
createRenderer
的返回值,是一个对象,被叫做renderer
renderer
对象中有一个方法叫render
,即渲染函数即,渲染函数是渲染器的返回对象的一个方法
render
渲染函数接受两个参数:VNode
和container
VNode
即虚拟DOM,本质上是一个JS对象。
container
是一个容器,即被挂载的位置。
render
的作用:把VNode
挂载到container
上。
同时,Vue以组件代表最小颗粒度,vue内部的渲染,本质上是大量的组件渲染。
而组件本质上是一组DOM的集合,因此,vue渲染一个组件就是在渲染一组DOM。
即,以组件为介质,来完成针对一组组DOM的渲染