<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title><![CDATA[yujiafree.com]]></title> 
<description><![CDATA[]]></description>
<link>https://www.yujiafree.com/</link>
<language>zh-cn</language>
<generator>www.emlog.net</generator>
<item>
    <title>基于 vue3+threejs 实现可视化大屏</title>
    <link>https://www.yujiafree.com/?post=5</link>
    <description><![CDATA[<p>Three.js是一款基于原生WebGL封装通用Web 3D引擎，在小游戏、产品展示、物联网、数字孪生、智慧城市园区、机械、建筑、全景看房、GIS等各个领域基本上都有three.js的身影。</p>
<p>本文需要对 threejs 的一些基本概念和 api 有一定了解。</p>
<p>如果对 threejs 这部分还不了解的可以看下官方文档和一些中文文档进行学习。</p>
<p>本文主要主要讲述对 threejs 的一些 api 进行基本的封装，在 vue3 项目中来实现一个可视化的3d项目。包含了一些常用的功能，场景、灯光、摄像机初始化，模型、天空盒的加载，以及鼠标点击和悬浮的事件交互。</p>
<p>项目截图：<br />
<a href="https://www.yujiafree.com/content/uploadfile/202404/826a1714380136.png"><img src="https://www.yujiafree.com/content/uploadfile/202404/826a1714380136.png" alt="" /></a></p>
<p>基础功能<br />
1.场景 Viewer 类<br />
首先我们第一步需要初始化场景、摄像机、渲染器、灯光等。这些功能只需要加载一次，我们都放到 Viewer 类中可以分离关注点，在业务代码中就不需要关注这一部分逻辑。业务代码中我们只需要关注数据与交互即可。</p>
<p>1.1 初始化场景和摄像机<br />
private initScene() {<br />
this.scene = new Scene();<br />
}</p>
<p>private initCamera() {<br />
// 渲染相机<br />
this.camera = new PerspectiveCamera(25, window.innerWidth / window.innerHeight, 1, 2000);<br />
//设置相机位置<br />
this.camera.position.set(4, 2, -3);<br />
//设置相机方向<br />
this.camera.lookAt(0, 0, 0);<br />
}<br />
1.2 初始化摄像机控制器<br />
private initControl() {<br />
this.controls = new OrbitControls(<br />
this.camera as Camera,<br />
this.renderer?.domElement<br />
);<br />
this.controls.enableDamping = false;<br />
this.controls.screenSpacePanning = false; // 定义平移时如何平移相机的位置 控制不上下移动<br />
this.controls.minDistance = 2;<br />
this.controls.maxDistance = 1000;<br />
this.controls.addEventListener('change', ()=&gt;{<br />
this.renderer.render(this.scene, this.camera);<br />
});<br />
}<br />
1.3 初始化灯光<br />
这里放了一个环境灯光和平行灯光，这里是写在 Viewer 类里面的，如果想灵活一点，也可以抽出去。</p>
<p>private initLight() {<br />
const ambient = new AmbientLight(0xffffff, 0.6);<br />
this.scene.add(ambient);</p>
<p>const light = new THREE.DirectionalLight( 0xffffff );<br />
light.position.set( 0, 200, 100 );<br />
light.castShadow = true;</p>
<p>light.shadow.camera.top = 180;<br />
light.shadow.camera.bottom = -100;<br />
light.shadow.camera.left = -120;<br />
light.shadow.camera.right = 400;<br />
light.shadow.camera.near = 0.1;<br />
light.shadow.camera.far = 400;<br />
// 设置mapSize属性可以使阴影更清晰，不那么模糊<br />
light.shadow.mapSize.set(1024, 1024);</p>
<p>this.scene.add(light);<br />
}<br />
1.4 初始化渲染器<br />
private initRenderer() {<br />
// 获取画布dom<br />
this.viewerDom = document.getElementById(this.id) as HTMLElement;<br />
// 初始化渲染器<br />
this.renderer = new WebGLRenderer({<br />
logarithmicDepthBuffer: true,<br />
antialias: true, // true/false表示是否开启反锯齿<br />
alpha: true, // true/false 表示是否可以设置背景色透明<br />
precision: 'mediump', // highp/mediump/lowp 表示着色精度选择<br />
premultipliedAlpha: true, // true/false 表示是否可以设置像素深度（用来度量图像的分辨率）<br />
// preserveDrawingBuffer: false, // true/false 表示是否保存绘图缓冲<br />
// physicallyCorrectLights: true, // true/false 表示是否开启物理光照<br />
});<br />
this.renderer.clearDepth();</p>
<p>this.renderer.shadowMap.enabled = true;<br />
this.renderer.outputColorSpace = SRGBColorSpace; // 可以看到更亮的材质，同时这也影响到环境贴图。<br />
this.viewerDom.appendChild(this.renderer.domElement);<br />
}<br />
Viewer 里面还加了一些 addAxis 添加坐标轴、addStats 性能监控等辅助的公用方法。具体可以看仓库完整代码。</p>
<p>1.5 鼠标事件<br />
里面主要使用了 mitt 这个库，来发布订阅事件。</p>
<p>threejs里面的鼠标事件主要通过把屏幕坐标转换成 3D 坐标。通过raycaster.intersectObjects方法转换。</p>
<p>/*<em>注册鼠标事件监听 </em>/<br />
public initRaycaster() {<br />
this.raycaster = new Raycaster();</p>
<p>const initRaycasterEvent: Function = (eventName: keyof HTMLElementEventMap): void =&gt; {<br />
const funWrap = throttle(<br />
(event: any) =&gt; {<br />
this.mouseEvent = event;<br />
this.mouse.x = (event.clientX / window.innerWidth) <em> 2 - 1;<br />
this.mouse.y = - (event.clientY / window.innerHeight) </em> 2 + 1;<br />
// @ts-expect-error<br />
this.emitter.emit(Events[eventName].raycaster, this.getRaycasterIntersectObjects());<br />
},<br />
50<br />
);<br />
this.viewerDom.addEventListener(eventName, funWrap, false);<br />
};</p>
<p>// 初始化常用的几种鼠标事件<br />
initRaycasterEvent('click');<br />
initRaycasterEvent('dblclick');<br />
initRaycasterEvent('mousemove');<br />
}</p>
<p>/*<em>自定义鼠标事件触发的范围，给定一个模型组，对给定的模型组鼠标事件才生效 </em>/<br />
public setRaycasterObjects (objList: THREE.Object3D[]): void {<br />
this.raycasterObjects = objList;<br />
}</p>
<p>private getRaycasterIntersectObjects(): THREE.Intersection[] {<br />
if (!this.raycasterObjects.length) return [];<br />
this.raycaster.setFromCamera(this.mouse, this.camera);<br />
return this.raycaster.intersectObjects(this.raycasterObjects, true);<br />
}<br />
通过 setRaycasterObjects 方法，传递一个触发鼠标事件的模型范围，可以避免在整个场景中都去触发鼠标事件。这里也可以用一个 Map 去存不同模型的事件，在取消订阅时再移除。</p>
<p>使用方式：</p>
<p>let viewer: Viewer;<br />
viewer = new Viewer('three');</p>
<p>viewer.initRaycaster();</p>
<p>viewer.emitter.on(Event.dblclick.raycaster, (list: THREE.Intersection[]) =&gt; {<br />
onMouseClick(list);<br />
});</p>
<p>viewer.emitter.on(Event.mousemove.raycaster, (list: THREE.Intersection[]) =&gt; {<br />
onMouseMove(list);<br />
});<br />
2.模型加载器 ModelLoder 类<br />
模型的加载我们需要用的threejs里面的，GLTFLoader、DRACOLoader 这两个类。</p>
<p>模型加载器 ModelLoder 初始化的时候需要把 Viewer 的实例传进去。</p>
<p>需要注意的是，需要把 draco 从 node_modules 拷贝到项目的 public 目录中去。</p>
<p>图片</p>
<p>实现代码：</p>
<p>import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';<br />
import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader';<br />
import BaseModel from '../BaseModel';<br />
import type Viewer from '../Viewer';</p>
<p>type LoadModelCallbackFn&lt;T = any&gt; = (arg: T) =&gt; any;</p>
<p>/*<em>模型加载器 </em>/<br />
export default class ModelLoder {<br />
protected viewer: Viewer;<br />
private gltfLoader: GLTFLoader;<br />
private dracoLoader: DRACOLoader;</p>
<p>constructor(viewer: Viewer, dracolPath: string = '/draco/') {<br />
this.viewer = viewer;<br />
this.gltfLoader = new GLTFLoader();<br />
this.dracoLoader = new DRACOLoader();</p>
<pre><code>// 提供一个DracLoader实例来解码压缩网格数据
// 没有这个会报错 dracolPath 默认放在public文件夹当中
this.dracoLoader.setDecoderPath(dracolPath);
this.gltfLoader.setDRACOLoader(this.dracoLoader);</code></pre>
<p>}</p>
<p>/*<em>模型加载到场景 </em>/<br />
public loadModelToScene(url: string, callback: LoadModelCallbackFn<BaseModel>) {<br />
this.loadModel(url, model =&gt; {<br />
this.viewer.scene.add(model.object);<br />
callback &amp;&amp; callback(model);<br />
});<br />
}</p>
<p>private loadModel(url: string, callback: LoadModelCallbackFn<BaseModel>) {<br />
this.gltfLoader.load(url, gltf =&gt; {<br />
const baseModel = new BaseModel(gltf, this.viewer);<br />
callback &amp;&amp; callback(baseModel);<br />
});<br />
}<br />
}<br />
3.模型 BaseModel 类<br />
这里对模型外面包了一层，做了一些额外的功能，如模型克隆、播放动画、设置模型特性、颜色、材质等方法。</p>
<p>/**</p>
<ul>
<li>设置模型动画</li>
<li>@param i 选择模型动画进行播放<br />
*/<br />
public startAnima(i = 0) {<br />
this.animaIndex = i;<br />
if (!this.mixer) this.mixer = new THREE.AnimationMixer(this.object);<br />
if (this.gltf.animations.length &lt; 1) return;<br />
this.mixer.clipAction(this.gltf.animations[i]).play();<br />
// 传入参数需要将函数与函数参数分开，在运行时填入<br />
this.animaObject = {<br />
fun: this.updateAnima,<br />
content: this,<br />
};<br />
this.viewer.addAnimate(this.animaObject);<br />
}</li>
</ul>
<p>private updateAnima(e: any) {<br />
e.mixer.update(e.clock.getDelta());<br />
}<br />
还有一些其他方法的实现，可以看仓库代码。</p>
<p>4.天空盒 SkyBoxs 类<br />
import * as THREE from 'three';<br />
import type Viewer from '../Viewer';<br />
import { Sky } from '../type';</p>
<p>/*<em> 场景天空盒</em>/<br />
export default class SkyBoxs {<br />
protected viewer: Viewer;</p>
<p>constructor (viewer: Viewer) {<br />
this.viewer = viewer;<br />
}</p>
<p>/**</p>
<ul>
<li>添加雾效果</li>
<li>
<p>@param color 颜色<br />
*/<br />
public addFog (color = 0xa0a0a0, near = 500, far = 2000) {<br />
this.viewer.scene.fog = new THREE.Fog(new THREE.Color(color), near, far);<br />
}</p>
<p>/**</p>
</li>
<li>
<p>移除雾效果<br />
*/<br />
public removeFog () {<br />
this.viewer.scene.fog = null;<br />
}</p>
<p>/**</p>
</li>
<li>添加默认天空盒</li>
<li>
<p>@param skyType<br />
*/<br />
public addSkybox (skyType: keyof typeof Sky = Sky.daytime) {<br />
const path = <code>/skybox/${Sky[skyType]}/</code>; // 设置路径<br />
const format = '.jpg'; // 设定格式<br />
this.setSkybox(path, format);<br />
}</p>
<p>/**</p>
</li>
<li>自定义添加天空盒</li>
<li>@param path 天空盒地址</li>
<li>@param format 图片后缀名<br />
*/<br />
private setSkybox (path: string, format = '.jpg') {<br />
const loaderbox = new THREE.CubeTextureLoader();<br />
const cubeTexture = loaderbox.load([<br />
path + 'posx' + format,<br />
path + 'negx' + format,<br />
path + 'posy' + format,<br />
path + 'negy' + format,<br />
path + 'posz' + format,<br />
path + 'negz' + format,<br />
]);<br />
// 需要把色彩空间编码改一下<br />
cubeTexture.encoding = THREE.sRGBEncoding;<br />
this.viewer.scene.background = cubeTexture;<br />
}<br />
}<br />
5.模型轮廓辅助线<br />
通过 BoxHelper 可以实现简单的鼠标选中的特效。</li>
</ul>
<p>也可以通过 OutlinePass 实现发光的特效。</p>
<p>这里有一篇关于 threejs 中轮廓线、边框线、选中效果实现的N种方法以及性能评估的文章：zhuanlan.zhihu.com/p/462329055</p>
<p>import {<br />
BoxHelper,<br />
Color,<br />
Object3D<br />
} from 'three';<br />
import type Viewer from '../Viewer';</p>
<p>export default class BoxHelperWrap {<br />
protected viewer: Viewer;<br />
public boxHelper: BoxHelper;</p>
<p>constructor (viewer: Viewer, color?: number) {<br />
this.viewer = viewer;<br />
const boxColor = color === undefined ? 0x00ffff : color;<br />
this.boxHelper = new BoxHelper(new Object3D(), new Color(boxColor));<br />
// // @ts-expect-error<br />
// this.boxHelper.material.depthTest = false;</p>
<pre><code>this.initBoxHelperWrap();</code></pre>
<p>}</p>
<p>private initBoxHelperWrap () {<br />
this.viewer.scene.add(this.boxHelper);<br />
}</p>
<p>public setVisible (visible: boolean): void {<br />
this.boxHelper.visible = visible;<br />
}</p>
<p>public attach (obj: Object3D): void {<br />
this.boxHelper.setFromObject(obj);<br />
this.setVisible(true);<br />
}</p>
<p>public dispose (): void {<br />
const parent = this.boxHelper.parent;<br />
if (parent !== null) {<br />
parent.remove(this.boxHelper);<br />
}</p>
<pre><code>Object.keys(this).forEach(key =&gt; {
  // @ts-expect-error
  this[key] = null;
});</code></pre>
<p>}<br />
}<br />
使用方式：</p>
<p>let modelLoader = new ModelLoader(viewer);</p>
<p>boxHelperWrap = new BoxHelperWrap(viewer);</p>
<p>boxHelperWrap.setVisible(false);</p>]]></description>
    <pubDate>Mon, 29 Apr 2024 16:40:53 +0800</pubDate>
    <author>yujiafree</author>
    <guid>https://www.yujiafree.com/?post=5</guid>
</item>
<item>
    <title>探探各个微前端框架</title>
    <link>https://www.yujiafree.com/?post=4</link>
    <description><![CDATA[<p>微前端架构是为了在解决单体应用在一个相对长的时间跨度下，由于参与的人员、团队的增多、变迁，从一个普通应用演变成一个巨石应用(Frontend Monolith)后，随之而来的应用不可维护的问题。这类问题在企业级 Web 应用中尤其常见。</p>
<p>微前端框架内的各个应用都支持独立开发部署、不限技术框架、支持独立运行、应用状态隔离但也可共享等特征。<br />
本文会从框架的应用隔离实现方案、实战、优缺点三个方面探一探各个框架。帮助大家了解各个框架是如何使用，如何运行，从而能选出适合自己项目的微前端方案。</p>
<p>iframe<br />
在没有各大微前端解决方案之前，iframe是解决这类问题的不二之选，因为iframe提供了浏览器原生的硬隔离方案，不论是样式隔离、js 隔离这类问题统统都能被完美解决。<br />
但他的最大问题也在于他的隔离性无法被突破，导致应用间上下文无法被共享，随之带来的开发体验、产品体验的问题：</p>
<p>url 不同步，浏览器刷新 iframe url 状态丢失、后退前进按钮无法使用。<br />
UI 不同步，DOM 结构不共享，弹窗只能在iframe内部展示，无法覆盖全局<br />
全局上下文完全隔离，内存变量不共享，iframe 内外系统的通信、数据同步等需求，主应用的 cookie 要透传到根域名都不同的子应用中实现免登效果。<br />
慢，每次子应用进入都是一次浏览器上下文重建、资源重新加载的过程。<br />
single-spa<br />
目前(2024年4月)github star 13k<br />
Single-spa(<a href="https://github.com/single-spa/single-spa">https://github.com/single-spa/single-spa</a>) 是最早的微前端框架，兼容多种前端技术栈；是一个将多个单页面应用聚合为一个整体应用的 JavaScript 微前端框架；<br />
简单来说就是一个聚合，使用这个库可以让你的应用可以 使用多个不同的技术栈（vue、react、angular等等)进行同步开发，最后使用一个公用的路由去实现完美的切换；</p>
<p>实现方案<br />
Single-spa 实现了一套生命周期，开发者需要在相应的时机自己去加载对应的子应用。<br />
它做的事情就是注册子应用、监听 URL 变化，然后加载对应的子应用js，执行对应子应用的生命周期流程。</p>
<p>提供registerApplication方法，用来注册子应用列表。<br />
提供了activeWhen，由开发者指定路由满足条件时，激活（挂载）子应用的js、css。<br />
js隔离由single-spa-leaked-globals实现，本质上就是在 mount A 子应用时，正常添加全局变量，比如 jQuery 的 $, lodash 的 _。在 unmount A 子应用时，用一个对象记录之前给 window 添加的全局变量，并把 A 应用里添加 window 的变量都删掉。下一次再 mount A 应用时，把记录的全局变量重新加回来就好了。<br />
css隔离：子应用和子应用之间通过single-spa-css插件提供的css生命周期函数，做到子应用mount时加载css，子应用unmount时将css也unmount掉；而主应用与子应用之间可以通过PostCSSPrefix Selector 给样式自动加前缀的方式，或者Shadow DOM 的形式去解决。<br />
single-spa实战</p>
<ol>
<li>主应用入口文件：<br />
主要通过single-spa提供的registerApplication方法注册子应用，子应用需要指定加载子应用的方法、和路由条件。</li>
</ol>
<p>import Vue from 'vue'<br />
import App from './App.vue'<br />
import router from './router'<br />
import { registerApplication, start } from 'single-spa'</p>
<p>Vue.config.productionTip = false</p>
<p>// 远程加载子应用<br />
function createScript(url) {<br />
return new Promise((resolve, reject) =&gt; {<br />
const script = document.createElement('script')<br />
script.src = url<br />
script.onload = resolve<br />
script.onerror = reject<br />
const firstScript = document.getElementsByTagName('script')[0]<br />
firstScript.parentNode.insertBefore(script, firstScript)<br />
})<br />
}</p>
<p>// 记载函数，返回一个 promise<br />
function loadApp(url, globalVar) {<br />
// 支持远程加载子应用<br />
return async () =&gt; {<br />
await createScript(url + '/js/chunk-vendors.js')<br />
await createScript(url + '/js/app.js')<br />
// 这里的return很重要，需要从这个全局对象中拿到子应用暴露出来的生命周期函数<br />
return window[globalVar]<br />
}<br />
}</p>
<p>// 子应用列表<br />
const apps = [<br />
{<br />
// 子应用名称<br />
name: 'app1',<br />
// 子应用加载函数，是一个promise<br />
app: loadApp('<a href="http://localhost:8081">http://localhost:8081</a>', 'app1'),<br />
// 当路由满足条件时（返回true），激活（挂载）子应用<br />
activeWhen: location =&gt; location.pathname.startsWith('/app1'),<br />
// 传递给子应用的对象<br />
customProps: {}<br />
},<br />
{<br />
name: 'app2',<br />
app: loadApp('<a href="http://localhost:8082">http://localhost:8082</a>', 'app2'),<br />
activeWhen: location =&gt; location.pathname.startsWith('/app2'),<br />
customProps: {}<br />
},<br />
{<br />
// 子应用名称<br />
name: 'app3',<br />
// 子应用加载函数，是一个promise<br />
app: loadApp('<a href="http://localhost:3000">http://localhost:3000</a>', 'app3'),<br />
// 当路由满足条件时（返回true），激活（挂载）子应用<br />
activeWhen: location =&gt; location.pathname.startsWith('/app3'),<br />
// 传递给子应用的对象，这个很重要，该配置告诉react子应用自己的容器元素是什么，这块儿和vue子应用的集成不一样，官网并没有说这部分，或者我没找到，是通过看single-spa-react源码知道的<br />
customProps: {<br />
domElement: document.getElementById('microApp'),<br />
// 添加 name 属性是为了兼容自己写的lyn-single-spa，原生的不需要，当然加了也不影响<br />
name: 'app3'<br />
}<br />
}<br />
]</p>
<p>// 注册子应用<br />
for (let i = apps.length - 1; i &gt;= 0; i--) {<br />
registerApplication(apps[i])<br />
}</p>
<p>new Vue({<br />
router,<br />
mounted() {<br />
// 启动<br />
start()<br />
},<br />
render: h =&gt; h(App)<br />
}).$mount('#app')</p>
<ol start="2">
<li>子应用导出文件<br />
子应用需要安装single-spa-react或者single-spa-vue，<br />
将子应用传递给single-spa-react，得到子应用运行的生命周期，<br />
子应用将生命周期导出到全局，<br />
在主应用可以获取子应用的生命周期函数<br />
import React from 'react';<br />
import ReactDOM from 'react-dom';<br />
import './index.css'<br />
import { BrowserRouter, Link, Route } from 'react-router-dom'<br />
import singleSpaReact from 'single-spa-react'</li>
</ol>
<p>// 子应用独立运行<br />
if (!window.singleSpaNavigate) {<br />
ReactDOM.render(rootComponent(), document.getElementById('root'))<br />
}</p>
<p>// 生命周期a<br />
const reactLifecycles = singleSpaReact({<br />
React,<br />
ReactDOM,<br />
rootComponent,<br />
errorBoundary(err, info, props) {<br />
return <div><br />
This renders when a catastrophic error occurs<br />
</div><br />
}<br />
})</p>
<p>// 这里和vue不一样，props必须向下传递<br />
export const bootstrap = async props =&gt; {<br />
console.log('app3 bootstrap');<br />
return reactLifecycles.bootstrap(props)<br />
}<br />
export const mount = async props =&gt; {<br />
console.log('app3 mount');<br />
return reactLifecycles.mount(props);<br />
}<br />
export const unmount = async props =&gt; {<br />
console.log('app3 unmount');<br />
return reactLifecycles.unmount(props)<br />
}</p>
<p>// 根组件<br />
function rootComponent() {<br />
return <React.StrictMode></p>
<BrowserRouter>
      <div>
        <Link to="/app3">Home</Link> |
          <Link to="/app3/about"> About</Link>
        <Route exact path="/app3" component={Home} />
        <Route exact path="/app3/about" component={About} />
      </div>
    </BrowserRouter>
<p>&lt;/React.StrictMode&gt;<br />
}</p>
<p>// home 组件<br />
function Home() {<br />
return <div></p>
<h1>app3 home page</h1>
<p></div><br />
}</p>
<p>// about 组件<br />
function About() {<br />
return <div></p>
<h1>app3 about page</h1>
<p></div><br />
}</p>
<ol start="3">
<li>打包配置<br />
将子应用导出模式设置为umd</li>
</ol>
<p>const package = require('./package.json')<br />
module.exports = {<br />
// 告诉子应用在这个地址加载静态资源，否则会去基座应用的域名下加载<br />
publicPath: '//localhost:8082',<br />
// 开发服务器<br />
devServer: {<br />
port: 8082<br />
},<br />
configureWebpack: {<br />
// 导出umd格式的包，在全局对象上挂载属性package.name，基座应用需要通过这个全局对象获取一些信息，比如子应用导出的生命周期函数<br />
output: {<br />
// library的值在所有子应用中需要唯一<br />
library: package.name,<br />
libraryTarget: 'umd'<br />
}<br />
}<br />
}</p>
<ol start="4">
<li>预览<br />
图片<br />
可以看到它是动态加载的子应用的js，并执行js，将内容渲染到了主应用的盒子内。</li>
</ol>
<p>框架优缺点<br />
优点：<br />
敏捷性 - 独立开发、独立部署，微应用仓库独立，前后端可独立开发，部署完成后主框架自动完成同步更新；<br />
技术栈无关，主框架不限制接入应用的技术栈，微应用具备完全自主权；<br />
增量升级，在面对各种复杂场景时，我们通常很难对一个已经存在的系统做全量的技术栈升级或重构，而微前端是一种非常好的实施渐进式重构的手段和策略<br />
缺点<br />
需要自己去加载子应用<br />
不支持 Javascript 沙箱隔离，需要自己去使用single-spa-leaked-globals之类的库去隔离<br />
不支持css隔离，需要自己使用single-spa-css库或者postcss等去解决样式冲突问题<br />
无法预加载<br />
qiankun<br />
目前(2024年4月) github star 15.4k<br />
阿里的qiankun 是一个基于 single-spa 的微前端实现库，孵化自蚂蚁金融，帮助大家能更简单、无痛的构建一个生产可用微前端架构系统。</p>
<p>实现方案<br />
single-spa是基于js-entry方案，而qiankun 是基于html-entry 及沙箱设计，使得微应用的接入 像使用 iframe 一样简单。<br />
主应用监听路由，加载对应子应用的html，挂载到主应用的元素内，然后解析子应用的html，从中分析出css、js再去沙盒化后加载执行，最终将子应用的内容渲染出来。<br />
qiankun实现样式隔离有两种模式可供开发者选择：<br />
strictStyleIsolation： 这种模式下 qiankun 会为每个微应用的容器包裹上一个 shadow dom 节点，从而确保微应用的样式不会对全局造成影响。<br />
experimentalStyleIsolation： 当 experimentalStyleIsolation 被设置为 true 时，qiankun 会改写子应用所添加的样式，会为所有样式规则增加一个特殊的选择器规则，来限定其影响范围<br />
qiankun实现js隔离，采用了两种沙箱，分别为基于Proxy实现的沙箱和快照沙箱，当浏览器不支持Proxy会降级为快照沙箱<br />
Proxy沙箱机制：<br />
// 伪代码<br />
class ProxySandbox {<br />
constructor() {<br />
const rawWindow = window;<br />
const fakeWindow = {}<br />
const proxy = new Proxy(fakeWindow, {<br />
set(target, p, value) {<br />
target[p] = value;<br />
return true<br />
},<br />
get(target, p) {<br />
return target[p] || rawWindow[p];<br />
}<br />
});<br />
this.proxy = proxy<br />
}<br />
}<br />
let sandbox1 = new ProxySandbox();<br />
let sandbox2 = new ProxySandbox();<br />
window.a = 1;<br />
// 伪代码<br />
((window) =&gt; {<br />
window.a = 'hello';<br />
console.log(window.a) // hello<br />
})(sandbox1.proxy);<br />
((window) =&gt; {<br />
window.a = 'world';<br />
console.log(window.a) // world<br />
})(sandbox2.proxy);<br />
快照沙箱<br />
// 伪代码<br />
class SnapshotSandbox {<br />
constructor() {<br />
this.proxy = window;<br />
this.modifyPropsMap = {}; // 修改了那些属性<br />
this.active(); // 调用active保存主应用window快照<br />
}</p>
<pre><code>/**1. 初始化时，在子应用即将mount前，先调用active，保存当前主应用的window快照*/
active() {
    this.windowSnapshot = {}; // window对象的快照
    for (const prop in window) {
        if (window.hasOwnProperty(prop)) {
            // 将window上的属性进行拍照
            this.windowSnapshot[prop] = window[prop];
        }
    }
    Object.keys(this.modifyPropsMap).forEach(p =&gt; {
        window[p] = this.modifyPropsMap[p];
    });
}

/**
* 子应用卸载时，遍历当前子应用的window属性，和主应用的window快照做对比
* 如果不一致，做两步操作 
*     1. 保存 不一致的window属性，
*     2. 还原window
*/
inactive() {
    for (const prop in window) { // diff 差异
        if (window.hasOwnProperty(prop)) {
            // 将上次拍照的结果和本次window属性做对比
            if (window[prop] !== this.windowSnapshot[prop]) {
                // 保存修改后的结果
                this.modifyPropsMap[prop] = window[prop]; 
                // 还原window
                window[prop] = this.windowSnapshot[prop]; 
            }
        }
    }
}</code></pre>
<p>}<br />
qiankun实战</p>
<ol>
<li>主应用入口文件<br />
初始化主应用，并注册子应用<br />
主应用入口文件初始化应用，注册子应用，注册子应用时支持传入子应用列表， 注册子应用时需要指明以下几个主要参数：</li>
</ol>
<p>name： 微应用的名称，微应用之间必须确保唯一<br />
entry： 子应用的访问链接。主应用会加载整个页面，例如https://qiankun.umijs.org/guide/<br />
container：需要挂载子应用的DOM元素<br />
loader: 子应用未加载时的界面，一般为loading<br />
activeRule： 路由匹配规则<br />
开启子应用start(options)<br />
options.prefetch此时可以选择是否预加载子应用。<br />
options.sandbox默认情况下的沙箱可以确保单实例场景子应用之间的样式隔离，但是无法确保主应用跟子应用、或者多实例场景的子应用样式隔离。qiankun提供了另外两种方式的隔离，供开发者选择：</p>
<p>strictStyleIsolation： 当配置为 { strictStyleIsolation: true } 时表示开启严格的样式隔离模式。这种模式下 qiankun 会为每个微应用的容器包裹上一个 shadow dom 节点，从而确保微应用的样式不会对全局造成影响。<br />
experimentalStyleIsolation：当 {experimentalStyleIsolation: true} 被设置，qiankun 会改写子应用所添加的样式为所有样式规则增加一个特殊的选择器规则来限定其影响范围。<br />
import { registerMicroApps, start, initGlobalState } from 'qiankun';</p>
<p>registerMicroApps([<br />
{<br />
name: 'react app', // app name registered<br />
entry: '//localhost:7100',<br />
container: '#yourContainer',<br />
activeRule: '/yourActiveRule',<br />
},<br />
{<br />
name: 'vue app',<br />
entry: { scripts: ['//localhost:7100/main.js'] },<br />
container: '#yourContainer2',<br />
activeRule: '/yourActiveRule2',<br />
},<br />
]);</p>
<p>// 通讯<br />
const { onGlobalStateChange, setGlobalState } = initGlobalState({<br />
user: 'qiankun',<br />
});</p>
<p>onGlobalStateChange((value, prev) =&gt; console.log('[onGlobalStateChange - master]:', value, prev));</p>
<p>setGlobalState({<br />
ignore: 'master',<br />
user: {<br />
name: 'master',<br />
},<br />
});</p>
<p>/**</p>
<ul>
<li>设置默认进入的子应用<br />
*/<br />
setDefaultMountApp('/react16');</li>
</ul>
<p>/**</p>
<ul>
<li>启动应用<br />
*/<br />
start({<br />
prefetch: true, // 预加载子应用<br />
sandbox:{<br />
strictStyleIsolation: true, //  shadow dom的方式实现样式隔离<br />
// experimentalStyleIsolation: true, //添加特殊的选择器的方式实现样式隔离<br />
}<br />
});</li>
</ul>
<p>runAfterFirstMounted(() =&gt; {<br />
console.log('[MainApp] first app mounted');<br />
});</p>
<ol start="2">
<li>子应用导出生命周期钩子<br />
子应用需要在自己的入口 js导出 bootstrap、mount、unmount 三个生命周期钩子，以供主应用在适当的时机调用。</li>
</ol>
<p>import React from 'react';<br />
import ReactDOM from 'react-dom';<br />
import App from './App';<br />
import * as serviceWorker from './serviceWorker';</p>
<p>function render(props) {<br />
const { container } = props;<br />
ReactDOM.render(<App />, container ? container.querySelector('#root') : document.querySelector('#root'));<br />
}</p>
<p>/**</p>
<ul>
<li>和主应用通讯<br />
*/<br />
function storeTest(props) {<br />
props.onGlobalStateChange((value, prev) =&gt; console.log(<code>[onGlobalStateChange - ${props.name}]:</code>, value, prev), true);<br />
props.setGlobalState({<br />
ignore: props.name,<br />
user: {<br />
name: props.name,<br />
},<br />
});<br />
}</li>
</ul>
<p>if (!window.<strong>POWERED_BY_QIANKUN</strong>) {<br />
render({});<br />
}</p>
<p>/**</p>
<ul>
<li>bootstrap 只会在微应用初始化的时候调用一次，下次微应用重新进入时会直接调用 mount 钩子，不会再重复触发 bootstrap。</li>
<li>通常我们可以在这里做一些全局变量的初始化，比如不会在 unmount 阶段被销毁的应用级别的缓存等。<br />
*/<br />
export async function bootstrap() {<br />
console.log('[react16] react app bootstraped');<br />
}</li>
</ul>
<p>/**</p>
<ul>
<li>应用每次进入都会调用 mount 方法，通常我们在这里触发应用的渲染方法<br />
*/<br />
export async function mount(props) {<br />
console.log('[react16] props from main framework', props);<br />
storeTest(props);<br />
render(props);<br />
}</li>
</ul>
<p>/**</p>
<ul>
<li>应用每次 切出/卸载 会调用的方法，通常在这里我们会卸载微应用的应用实例<br />
*/<br />
export async function unmount(props) {<br />
const { container } = props;<br />
ReactDOM.unmountComponentAtNode(container ? container.querySelector('#root') : document.querySelector('#root'));<br />
}
<ol start="3">
<li>配置打包工具：<br />
为了让主应用能正确识别微应用暴露出来的一些全局信息和开发环境下的跨域兼容，在子应用（以create-react-app出来的react项目为例）安装@rescripts/cli，并在子应用目录下新建.rescriptsrc.js，内容如下：</li>
</ol></li>
</ul>
<p>const { name } = require('./package');</p>
<p>module.exports = {<br />
webpack: (config) =&gt; {<br />
config.output.library = <code>${name}-[name]</code>;<br />
config.output.libraryTarget = 'umd'; // 为了能通过window['app-name1']拿到子应用声明的生命周期<br />
// webpack 5 需要把 jsonpFunction 替换成 chunkLoadingGlobal<br />
config.output.jsonpFunction = <code>webpackJsonp_${name}</code>;<br />
config.output.globalObject = 'window';</p>
<pre><code>return config;</code></pre>
<p>},</p>
<p>devServer: (<em>) =&gt; {<br />
const config = </em>;</p>
<pre><code>config.headers = {
  'Access-Control-Allow-Origin': '*',
};
config.historyApiFallback = true;
config.hot = false;
config.watchContentBase = false;
config.liveReload = false;

return config;</code></pre>
<p>},<br />
};</p>
<ol start="4">
<li>预览<br />
使用strictStyleIsolation：true方式进行样式隔离，会生成一个shadow dom，进行样式的完全隔离：图片</li>
</ol>
<p>使用experimentalStyleIsolation：true的方式进行样式隔离，会在css选择器前添加特殊标识：<br />
图片</p>
<p>可以看到，qiankun会将子应用的html渲染到自定义的container中。 主应用加载的是子应用的html，在解析子应用的html的过程中遇到js和css会载框架内进行沙盒处理，完成css和js的隔离，之后下载并执行，完成整个子应用的渲染过程。</p>
<p>框架优缺点<br />
优点<br />
html entry的接入方式，不需要自己写load方法，而是直接写子应用的访问链接就可以。<br />
提供js沙箱<br />
提供样式隔离，两种方式可选<br />
资源预加载，在浏览器空闲时间预加载未打开的微应用资源，加速微应用打开速度。<br />
社区活跃<br />
umi 插件，提供了 @umijs/plugin-qiankun 供 umi 应用一键切换成微前端架构系统 除了最后一点拓展以外，微前端想要达到的效果都已经达到。<br />
应用间通信简单，全局注入<br />
路由保持，浏览器刷新、前进、后退，都可以作用到子应用<br />
缺点<br />
改造成本较大，从 webpack、代码、路由等等都要做一系列的适配<br />
对 eval 的争议，eval函数的安全和性能是有一些争议的：MDN的eval介绍；<br />
无法同时激活多个子应用，也不支持子应用保活<br />
无法支持 vite 等 ESM 脚本运行<br />
wujie<br />
目前（2024年4月）github star 3.7k<br />
wujie是腾讯出品。基于 webcomponent 容器 + iframe 沙箱，能够完善的解决适配成本、样式隔离、运行性能、页面白屏、子应用通信、子应用保活、多应用激活、vite 框架支持、应用共享等</p>
<p>实现方案<br />
无界利用iframe和webcomponent来搭建天然的js隔离沙箱和css隔离沙箱,<br />
利用iframe的history和主应用的history在同一个top-level browsing context来搭建天然的路由同步机制<br />
支持以fiber的形式执行js，由于子应用的执行会阻塞主应用的渲染线程，当fiber设置为true，那么js执行时采取类似react fiber的模式方式间断执行，每个 js 文件的执行都包裹在requestidlecallback中，每执行一个js可以返回响应外部的输入，但是这个颗粒度是js文件，如果子应用单个js文件过大，可以通过拆包的方式降低达到fiber模式效益最大化<br />
wujie是如何渲染子应用的？<br />
wujie跟qiankun一样，都是基于html entry加载的，但他们解析html的过程是不一样的。 qiankun是直接解析并执行js、css、html的，而wujie则是先解析html，提取出script脚本放入空的iframe中，提取出css、html放入到web components中，具体来说：</p>
<p>解析入口 HTML ，分别得到script、css、模版html<br />
创建一个纯净的 iframe，为了实现应用间（iframe 间）通讯，无界子应用 iframe 的 url 会设置为主应用的域名（同域），因此 iframe 的 location.href 并不是子应用的 url。创建好后停止加载iframe。<br />
iframe内插入js，将抽离出来的script脚本，插到iframe中去，在iframe中执行子应用的js<br />
创建web component，id为子应用id，将抽离出来的html插入。<br />
由于iframe内的js有可能操作dom，但是iframe内没有dom，随意wujie框架内对iframe拦截document对象，统一将dom指向shadowRoot，此时比如新建元素、弹窗或者冒泡组件就可以正常约束在shadowRoot内部。<br />
wujie实战<br />
wujie接入很简单，主应用可以让开发者以组件的方式加载子应用。子应用只需要做支持跨域请求改造，这个是所有微前端框架运行的前提，除此之外子应用可以不做任何改造就可以在无界框架中运行，不过此时运行的方式是重建模式。 子应用也可以配置保活、生命周期适配进入保活模式或单例模式。</p>
<ol>
<li>主应用入口文件<br />
与其他框架一样，先配置子应用，</li>
</ol>
<p>// main-react/index.js<br />
import &quot;react-app-polyfill/stable&quot;;<br />
import &quot;react-app-polyfill/ie11&quot;;</p>
<p>import React from &quot;react&quot;;<br />
import ReactDOM from &quot;react-dom&quot;;<br />
import WujieReact from &quot;wujie-react&quot;;<br />
import &quot;./index.css&quot;;<br />
import App from &quot;./App&quot;;<br />
import hostMap from &quot;./hostMap&quot;;<br />
import credentialsFetch from &quot;./fetch&quot;;<br />
import lifecycles from &quot;./lifecycle&quot;;<br />
import plugins from &quot;./plugin&quot;;</p>
<p>const { setupApp, preloadApp, bus } = WujieReact;<br />
const isProduction = process.env.NODE_ENV === &quot;production&quot;;<br />
bus.$on(&quot;click&quot;, (msg) =&gt; window.alert(msg));</p>
<p>const degrade = window.localStorage.getItem(&quot;degrade&quot;) === &quot;true&quot; || !window.Proxy || !window.CustomElementRegistry;<br />
/**</p>
<ul>
<li>大部分业务无需设置 attrs</li>
<li>此处修正 iframe 的 src，是防止github pages csp报错</li>
<li>因为默认是只有 host+port，没有携带路径<br />
*/<br />
const attrs = isProduction ? { src: hostMap(&quot;//localhost:7700/&quot;) } : {};<br />
/**</li>
<li>配置应用，主要是设置默认配置</li>
<li>preloadApp、startApp的配置会基于这个配置做覆盖<br />
*/<br />
setupApp({<br />
name: &quot;react16&quot;,<br />
url: hostMap(&quot;//localhost:7600/&quot;),<br />
attrs, // 子应用iframe的src<br />
exec: true, // 预执行<br />
fetch: credentialsFetch, // 自定义的fetch方法<br />
plugins,<br />
/*<em> 子应用短路径替换，路由同步时生效 </em>/<br />
prefix: { &quot;prefix-dialog&quot;: &quot;/dialog&quot;, &quot;prefix-location&quot;: &quot;/location&quot; },<br />
/*<em> 子应用采用降级iframe方案 </em>/<br />
degrade,<br />
...lifecycles,<br />
});</li>
</ul>
<p>setupApp({<br />
name: &quot;vue3&quot;,<br />
url: hostMap(&quot;//localhost:7300/&quot;),<br />
attrs,<br />
exec: true,<br />
alive: true, // 子应用保活，state不会丢失<br />
plugins: [{ cssExcludes: [&quot;<a href="https://stackpath.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">https://stackpath.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css</a>&quot;] }],<br />
// 引入了的第三方样式不需要添加credentials<br />
fetch: (url, options) =&gt;<br />
url.includes(hostMap(&quot;//localhost:7300/&quot;)) ? credentialsFetch(url, options) : window.fetch(url, options),<br />
degrade,<br />
...lifecycles,<br />
});</p>
<p>if (window.localStorage.getItem(&quot;preload&quot;) !== &quot;false&quot;) {<br />
preloadApp({<br />
name: &quot;react16&quot;,<br />
});</p>
<p>if (window.Proxy) {<br />
preloadApp({<br />
name: &quot;vue3&quot;,<br />
});<br />
}<br />
}</p>
<p>ReactDOM.render(<App />, document.getElementById(&quot;root&quot;));</p>
<p>引入子应用的地方直接以组件式的方式引入：</p>
<p>import React from &quot;react&quot;;<br />
import hostMap from &quot;../hostMap&quot;;<br />
import WujieReact from &quot;wujie-react&quot;;<br />
import { useNavigate, useLocation } from &quot;react-router-dom&quot;;</p>
<p>export default function React16() {<br />
const navigation = useNavigate();<br />
const location = useLocation();<br />
const path = location.pathname.replace(&quot;/react16-sub&quot;, &quot;&quot;).replace(&quot;/react16&quot;, &quot;&quot;).replace(&quot;/&quot;,&quot;&quot;); ////<br />
const react16Url = hostMap(&quot;//localhost:7600/&quot;) + path;<br />
const props = {<br />
jump: (name) =&gt; {<br />
navigation(<code>/${name}</code>);<br />
},<br />
};<br />
return (<br />
// 单例模式，name相同则复用一个无界实例，改变url则子应用重新渲染实例到对应路由<br />
&lt;WujieReact<br />
width=&quot;100%&quot;<br />
height=&quot;100%&quot;<br />
name=&quot;react16&quot;<br />
url={react16Url}<br />
sync={!path}<br />
props={props}</p>
<blockquote>
<p></WujieReact><br />
);<br />
}</p>
</blockquote>
<ol start="2">
<li>预览<br />
图片</li>
</ol>
<p>框架优缺点<br />
优点<br />
接入简单，可以以组件的方式引入子应用<br />
纯净无污染<br />
无界利用iframe和webcomponent来搭建天然的js隔离沙箱和css隔离沙箱<br />
利用iframe的history和主应用的history在同一个top-level browsing context来搭建天然的路由同步机制<br />
副作用局限在沙箱内部，子应用切换无需任何清理工作，没有额外的切换成本<br />
支持vite esmoudle加载，由于js是独立在iframe中加载的，所以支持esmodule加载<br />
支持预加载<br />
支持应用保活，子应用状态保留，由于是独立在iframe中的，而切换应用时不会移除iframe，所以子应用的状态会被保留在原来的iframe中，当主应用再次渲染子应用dom时，会显示之前的状态。<br />
多应用同时激活在线<br />
缺点<br />
iframe沙箱的src设置了主应用的host，初始化iframe的时候需要等待iframe的location.orign从'about:blank'初始化为主应用的host，这个采用的计时器去等待的不是很优雅。<br />
Micro App<br />
截至目前（2024年4月）github star 5.2k<br />
mirco-app 是京东2021年开源的一款微前端框架。它借助了浏览器对 webComponent 的支持，实现了一套微前端方案体系。并且由于 Shadow Dom 对 react 这类库的兼容性较差，便自己实现了类 Shadow Dom 的效果。与 qiankun 相比，接入更加简单。最新的版本也支持iframe实现js隔离，类似wujie。</p>
<p>实现方案<br />
首先micro-app实现了一个基于WebComponent的组件，并实现了类Shadow Dom 的效果，开发者只需要用<micro-app name="xx" url="xx" baseroute="/xxx/xxx">来加载子应用，整个对子应用的加载、js隔离、css隔离的逻辑都封装在了web component组件<micro-app>中，具体来说：</p>
<p>当调用microApp.start()后，会注册一个名为micro-app 的自定义 webComponent 标签。我们可以从 <micro-app name='app1' url='xx' baseroute='/my-page'></micro-app> 中拿到子应用的线上入口地址。</p>
<micro-app>组件内部，当匹配到路由后，跟qiankun一样加载html，得到html字符串模版
分析html字符串，提取<head>头和<body>，并替换为框架自定义标签<micro-app-head>和<micro-app-body>
在<micro-app-head>内，会对script标签和link标签的内容进行加载并执行
将<micro-app-head>和<micro-app-body>插入到<micro-app>标签内
<micro-app>内提供了js沙箱方法（v1.0以前跟qiankun沙箱一样），<micro-app-head>挂载到<micro-app>后，内部会逐一对<micro-app-head>内的script标签的js绑定作用域，实现js隔离。
css隔离方案
默认使用正则将CSS字符串切割成最小单元，每个单元包含一段CSS信息，将所有的信息整理生成CSSTree，遍历CSSTree的每个规则，添加前缀实现样式隔离。
图片

js隔离方案
micro-app有两种方式实现js隔离，默认是跟qiankun一样采用proxy沙箱的方式隔离， 在v1.0发布后支持了基于原生iframe的隔离方式。

Micro App实战
1. 主应用入口文件
import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import Router from './router';
import microApp from '@micro-zoe/micro-app'

microApp.start()

ReactDOM.render(
  <React.StrictMode>
    <Router />
  </React.StrictMode>,
  document.getElementById('root')
);

调用子应用
export function MyPage () {
  return (
    <div>
      <h1>子应用👇</h1>
      // name：应用名称, url：应用地址
      <micro-app name='my-app' url='http://localhost:3000/'></micro-app>
    </div>
  )
}

2.预览
图片

框架优缺点
优点
接入简单，组件式引入子应用
团队持续更新维护
js隔离、css隔离、路由同步
支持子应用保活, 需要开启keep-alive模式
支持fiber模式，提升主应用的渲染性能。
缺点
1.0之前不支持vite，1.0之后支持了
默认css隔离方式，主应用的样式还是会污染到子应用。
子应用和主应用必须相同的路由模式，要么同时hash模式，要么同时history模式
依赖于CustomElements和Proxy两个较新的API。Proxy暂时没有做兼容，所以对于不支持Proxy的浏览器无法运行micro-app。]]></description>
    <pubDate>Mon, 29 Apr 2024 16:37:19 +0800</pubDate>
    <author>yujiafree</author>
    <guid>https://www.yujiafree.com/?post=4</guid>
</item>
<item>
    <title>Vue2.0和Vue3.0的区别</title>
    <link>https://www.yujiafree.com/?post=3</link>
    <description><![CDATA[<p>vue经历从2.0到3.0更新之后，简⽽⾔之就是变得更轻，更快，使⽤起来更加⽅便，每⼀次的版本迭代都是对上⼀个版本的升级优化，不管 是对于我们开发者还是对于⽤户体验都是不断地在越来越⽅便，接下来我会着重于开发者来说⼀下两个不同版本的区别，</p>
<p><strong>详解</strong><br />
1.vue2.0和3.0的初始化就存在着⼀定区别，⽐如vue3.0可以在安装脚⼿架同时提前安装好⼀些项⽬开发必备的插件，并且3.0提供了可视 化创建脚⼿架，可以更加⽅便的对插件和依赖进⾏管理和配置，同时两个版本的⽬录结构也是有些许差别的。</p>
<p>2.在开发过程中两个版本的使⽤⽅法虽然在表⾯上没有太⼤的⼀个区别，但是在他的底层⽅⾯去看的话区别还是很⼤的，其中就包括渲染⽅ 式，数据监听，双向绑定，⽣命周期，vue3更精准变更通知，</p>
<p>这⾥着重说⼀下关于双向绑定的更新，</p>
<p>vue2 的双向数据绑定是利⽤ES5 的⼀个 API ，Object.definePropert()对数据进⾏劫持 结合 发布订阅模式的⽅式来实现的。</p>
<p>vue3 中使⽤了 es6 的 ProxyAPI 对数据代理，通过 reactive() 函数给每⼀个对象都包⼀层 Proxy，通过 Proxy 监听属性的变化，从⽽ 实现对数据的监控。</p>
<p>这⾥是引相⽐于vue2版本，使⽤proxy的优势如下<br />
1.defineProperty只能监听某个属性，不能对全对象监听<br />
可以省去for in、闭包等内容来提升效率（直接绑定整个对象即可）<br />
2.可以监听数组，不⽤再去单独的对数组做特异性操作,通过Proxy可以直接拦截所有对象类型数据的操作，完美⽀持对数组的监听。</p>
<p>复制代码<br />
3.另外vue3还新增了⼀些内置组件和⽅法，⽐如vue3可以默认进⾏懒观察，使⽤Function-based API，setup函数，对与插件或对象的⼀ 个按需引⼊，Computed Value ，新加⼊了 TypeScript 以及 PWA 的⽀持等等… 这⾥着重说⼀下vue3的⼀个按需引⼊</p>
<p>Vue2.x中new出的实例对象，所有的东西都在这个vue对象上，这样其实⽆论你⽤到还是没⽤到，都会跑⼀遍，这样不仅提⾼了性能消耗，<br />
也⽆疑增加了⽤户加载时间。</p>
<p>⽽vue3.0中可以⽤ES module imports按需引⼊，如：keep-alive内置组件、v-model指令，等等，不仅我们开发起来更加的便捷，减少 了内存消耗，也同时减少了⽤户加载时间，优化⽤户体验。</p>
<p>创建vue2和vue3项目的文件发生的变化<br />
1.main.js中</p>
<p>核心代码：<br />
createApp(App).mount('#app') = createApp(根组件).mount('public/index.html中的div容器')</p>
<p>1.vue2.0中是直接创建了一个vue实例<br />
2.vue3.0中按需导出了一个createApp （ceateApp做了什么）<br />
3.vue3中的app单文件不再强制要求必须有根元素 也就是说 在vue2.0中必须要有一个根元素，在vue3中没这个要求</p>
<template>
  <img alt="Vue logo" src="./assets/logo.png">
  <HelloWorld msg="Welcome to Your Vue.js App"/>
</template>
<p>复制代码<br />
数据双向绑定原理<br />
Vue2使⽤的是Object.defineProperty()进⾏数据劫持，结合发布订阅的⽅式实现。</p>
<p>Vue3使⽤的是Proxy代理，使⽤ref或者reactive将数据转化为响应式数据</p>
<p>数据和方法的定义<br />
Vue2使⽤的是选项类型API（Options API），Vue3使⽤的是合成型API（Composition API）</p>
<p>Vue2：</p>
<p>data() { return {}; }, methods:{ }<br />
复制代码<br />
Vue3：</p>
<p>数据和⽅法都定义在setup中，并统⼀进⾏return{}</p>
<p>生命周期</p>
<p>获取props<br />
vue2：console.log(‘props’,this.xxx)<br />
vue3：setup(props,context){ console.log(‘props’,props) }</p>
<p>给父组件传值emit<br />
vue2：this.$emit()<br />
vue3：setup(props,context){context.emit()}</p>]]></description>
    <pubDate>Mon, 06 Feb 2023 14:32:08 +0800</pubDate>
    <author>yujiafree</author>
    <guid>https://www.yujiafree.com/?post=3</guid>
</item>
<item>
    <title>2023前端二面高频vue面试题集锦</title>
    <link>https://www.yujiafree.com/?post=2</link>
    <description><![CDATA[<p>1、 Vue2.0 和 Vue3.0 有什么区别？<br />
响应式系统的重新配置，使用代理替换对象.define属性，使用代理优势：<br />
可直接监控阵列类型的数据变化 监听的目标是对象本身，不需要像Object.defineProperty那样遍历每个属性，有一定的性能提升 可拦截应用、拥有密钥、有等13种方法，以及Object.define属性没有办法 直接添加对象属性/删除<br />
新增组合API，更好的逻辑重用和代码组织<br />
重构虚拟 DOM<br />
模板编译时间优化，将一些静态节点编译成常量 slot优化，采取槽编译成懒人功能，拿槽渲染的决定留给子组件 在模板中提取和重用内联事件（最初，每次渲染时都会重新生成内联函数）<br />
代码结构调整，更方便树摇动，使其更小<br />
使用打字脚本替换流<br />
2、Vue3带来了什么改变？<br />
1.性能的提升<br />
打包大小减少41% 初次渲染快55%, 更新渲染快133% 内存减少54% ......<br />
2.源码的升级<br />
使用Proxy代替defineProperty实现响应式 重写虚拟DOM的实现和Tree-Shaking ......<br />
3.拥抱TypeScript<br />
Vue3可以更好的支持TypeScript<br />
4.新的特性<br />
Composition API（组合API） setup配置 ref与reactive watch与watchEffect provide与inject ......<br />
新的内置组件 Fragment Teleport Suspense<br />
其他改变 新的生命周期钩子 data 选项应始终被声明为一个函数 移除keyCode支持作为 v-on 的修饰符 ......<br />
4.vue3还有哪些其他改变？</p>
<p>data选项应始终被声明为一个函数。 过度类名的更改： Vue2.x写法 .v-enter, .v-leave-to {  opacity: 0; } .v-leave, .v-enter-to {  opacity: 1; } Vue3.x写法 .v-enter-from, .v-leave-to {  opacity: 0; } ​ .v-leave-from, .v-enter-to {  opacity: 1; } 移除keyCode作为 v-on 的修饰符，同时也不再支持config.keyCodes 移除v-on.native修饰符 父组件中绑定事件 <my-component  v-on:close="handleComponentEvent"  v-on:click="handleNativeClickEvent" /> 子组件中声明自定义事件 <script>  export default {    emits: [close] } </script> 移除过滤器（filter） 过滤器虽然这看起来很方便，但它需要一个自定义语法，打破大括号内表达式是 “只是 JavaScript” 的假设，这不仅有学习成本，而且有实现成本！建议用方法调用或计算属性去替换过滤器。 ......<br />
3、生命周期（vue2和vue3的生命周期对比）有哪些？<br />
vue2.x的生命周期</p>
<p>vue3.0的生命周期</p>
<p>1</p>
<p>Vue3.0中可以继续使用Vue2.x中的生命周期钩子，但有有两个被更名： beforeDestroy改名为 beforeUnmount destroyed改名为 unmounted Vue3.0也提供了 Composition API 形式的生命周期钩子，与Vue2.x中钩子对应关系如下： beforeCreate===&gt;setup() created=======&gt;setup() beforeMount ===&gt;onBeforeMount mounted=======&gt;onMounted beforeUpdate===&gt;onBeforeUpdate updated =======&gt;onUpdated beforeUnmount ==&gt;onBeforeUnmount unmounted =====&gt;onUnmounted<br />
4、Vue3.0中的响应式原理是什么？vue2的响应式原理是什么？<br />
vue2.x的响应式<br />
实现原理： 对象类型：通过Object.defineProperty()对属性的读取、修改进行拦截（数据劫持）。 数组类型：通过重写更新数组的一系列方法来实现拦截。（对数组的变更方法进行了包裹）。 Object.defineProperty(data, count, {    get () {},    set () {} }) 存在问题： 新增属性、删除属性, 界面不会更新。 直接通过下标修改数组, 界面不会自动更新。<br />
Vue3.0的响应式<br />
实现原理: 通过Proxy（代理）: 拦截对象中任意属性的变化, 包括：属性值的读写、属性的添加、属性的删除等。 通过Reflect（反射）: 对源对象的属性进行操作。 MDN文档中描述的Proxy与Reflect： Proxy： Reflect： new Proxy(data, { // 拦截读取属性值    get (target, prop) {   return Reflect.get(target, prop)   },    // 拦截设置属性值或添加新属性    set (target, prop, value) {   return Reflect.set(target, prop, value)   },    // 拦截删除属性    deleteProperty (target, prop) {   return Reflect.deleteProperty(target, prop)   } }) ​ proxy.name = tom<br />
5、vue3响应式数据的判断？<br />
isRef: 检查一个值是否为一个 ref 对象 isReactive: 检查一个对象是否是由 reactive 创建的响应式代理 isReadonly: 检查一个对象是否是由 readonly 创建的只读代理 isProxy: 检查一个对象是否是由 reactive 或者 readonly 方法创建的代理<br />
6、vue3的常用 Composition API有哪些？<br />
官方文档:</p>
<p>1.拉开序幕的setup<br />
理解：Vue3.0中一个新的配置项，值为一个函数。<br />
setup是所有Composition API（组合API）“ 表演的舞台 ”。<br />
组件中所用到的：数据、方法等等，均要配置在setup中。<br />
setup函数的两种返回值： 若返回一个渲染函数：则可以自定义渲染内容。（了解）<br />
5.setup的几个注意点</p>
<p>setup执行的时机 在beforeCreate之前执行一次，this是undefined。 setup的参数 props：值为对象，包含：组件外部传递过来，且组件内部声明接收了的属性。 context：上下文对象 attrs: 值为对象，包含：组件外部传递过来，但没有在props配置中声明的属性, 相当于 this.$attrs。 slots: 收到的插槽内容, 相当于 this.$slots。 emit: 分发自定义事件的函数, 相当于 this.$emit。 尽量不要与Vue2.x配置混用 Vue2.x配置（data、methos、computed...）中可以访问到setup中的属性、方法。 但在setup中不能访问到Vue2.x配置（data、methos、computed...）。 如果有重名, setup优先。 setup不能是一个async函数，因为返回值不再是return的对象, 而是promise, 模板看不到return对象中的属性。（后期也可以返回一个Promise实例，但需要Suspense和异步组件的配合）<br />
2.ref函数<br />
作用: 定义一个响应式的数据 语法: const xxx = ref(initValue) 创建一个包含响应式数据的引用对象（reference对象，简称ref对象）。 JS中操作数据： xxx.value 模板中读取数据: 不需要.value，直接：<div>{ {xxx}}</div> 备注： 接收的数据可以是：基本类型、也可以是对象类型。 基本类型的数据：响应式依然是靠Object.defineProperty()的get与set完成的。 对象类型的数据：内部 “ 求助 ” 了Vue3.0中的一个新函数—— reactive函数。<br />
3.reactive函数<br />
作用: 定义一个对象类型的响应式数据（基本类型不要用它，要用ref函数） 语法：const 代理对象= reactive(源对象)接收一个对象（或数组），返回一个代理对象（Proxy的实例对象，简称proxy对象） reactive定义的响应式数据是“深层次的”。 内部基于 ES6 的 Proxy 实现，通过代理对象操作源对象内部数据进行操作。<br />
4.reactive对比ref<br />
从定义数据角度对比： ref用来定义：基本类型数据。 reactive用来定义：对象（或数组）类型数据。 备注：ref也可以用来定义对象（或数组）类型数据, 它内部会自动通过reactive转为代理对象。 从原理角度对比： ref通过Object.defineProperty()的get与set来实现响应式（数据劫持）。 reactive通过使用Proxy来实现响应式（数据劫持）, 并通过Reflect操作源对象内部的数据。 从使用角度对比： ref定义的数据：操作数据需要.value，读取数据时模板中直接读取不需要.value。 reactive定义的数据：操作数据与读取数据：均不需要.value。<br />
5.计算属性与监视<br />
1.computed函数<br />
与Vue2.x中computed配置功能一致 写法 import {computed} from vue ​ setup(){    ... //计算属性——简写    let fullName = computed(()=&gt;{        return person.firstName + - + person.lastName   })    //计算属性——完整    let fullName = computed({        get(){            return person.firstName + - + person.lastName       },        set(value){            const nameArr = value.split(-)            person.firstName = nameArr[0]            person.lastName = nameArr[1]       }   }) }<br />
2.watch函数<br />
与Vue2.x中watch配置功能一致 两个小“坑”： 监视reactive定义的响应式数据时：oldValue无法正确获取、强制开启了深度监视（deep配置失效）。 监视reactive定义的响应式数据中某个属性时：deep配置有效。 //情况一：监视ref定义的响应式数据 watch(sum,(newValue,oldValue)=&gt;{ console.log(sum变化了,newValue,oldValue) },{immediate:true}) ​ //情况二：监视多个ref定义的响应式数据 watch([sum,msg],(newValue,oldValue)=&gt;{ console.log(sum或msg变化了,newValue,oldValue) }) ​ /<em> 情况三：监视reactive定义的响应式数据 若watch监视的是reactive定义的响应式数据，则无法正确获得oldValue！！ 若watch监视的是reactive定义的响应式数据，则强制开启了深度监视 </em>/ watch(person,(newValue,oldValue)=&gt;{ console.log(person变化了,newValue,oldValue) },{immediate:true,deep:false}) //此处的deep配置不再奏效 ​ //情况四：监视reactive定义的响应式数据中的某个属性 watch(()=&gt;person.job,(newValue,oldValue)=&gt;{ console.log(person的job变化了,newValue,oldValue) },{immediate:true,deep:true}) ​ //情况五：监视reactive定义的响应式数据中的某些属性 watch([()=&gt;person.job,()=&gt;person.name],(newValue,oldValue)=&gt;{ console.log(person的job变化了,newValue,oldValue) },{immediate:true,deep:true}) ​ //特殊情况 watch(()=&gt;person.job,(newValue,oldValue)=&gt;{    console.log(person的job变化了,newValue,oldValue) },{deep:true}) //此处由于监视的是reactive素定义的对象中的某个属性，所以deep配置有效<br />
3.watchEffect函数<br />
watch的套路是：既要指明监视的属性，也要指明监视的回调。 watchEffect的套路是：不用指明监视哪个属性，监视的回调中用到哪个属性，那就监视哪个属性。 watchEffect有点像computed： 但computed注重的计算出来的值（回调函数的返回值），所以必须要写返回值。 而watchEffect更注重的是过程（回调函数的函数体），所以不用写返回值。 //watchEffect所指定的回调中用到的数据只要发生变化，则直接重新执行回调。 watchEffect(()=&gt;{    const x1 = sum.value    const x2 = person.age    console.log(watchEffect配置的回调执行了) })<br />
10.toRef<br />
作用：创建一个 ref 对象，其value值指向另一个对象中的某个属性。 语法：const name = toRef(person,name) 应用: 要将响应式对象中的某个属性单独提供给外部使用时。<br />
扩展：toRefs 与toRef功能一致，但可以批量创建多个 ref 对象，语法：toRefs(person)<br />
1.shallowReactive 与 shallowRef<br />
shallowReactive：只处理对象最外层属性的响应式（浅响应式）。 shallowRef：只处理基本数据类型的响应式, 不进行对象的响应式处理。 什么时候使用? 如果有一个对象数据，结构比较深, 但变化时只是外层属性变化 ===&gt; shallowReactive。 如果有一个对象数据，后续功能不会修改该对象中的属性，而是生新的对象来替换 ===&gt; shallowRef。<br />
2.readonly 与 shallowReadonly<br />
readonly: 让一个响应式数据变为只读的（深只读）。 shallowReadonly：让一个响应式数据变为只读的（浅只读）。 应用场景: 不希望数据被修改时。<br />
3.toRaw 与 markRaw<br />
toRaw： 作用：将一个由reactive生成的响应式对象转为普通对象。 使用场景：用于读取响应式对象对应的普通对象，对这个普通对象的所有操作，不会引起页面更新。 markRaw： 作用：标记一个对象，使其永远不会再成为响应式对象。 应用场景: 有些值不应被设置为响应式的，例如复杂的第三方类库等。 当渲染具有不可变数据源的大列表时，跳过响应式转换可以提高性能。<br />
4.customRef<br />
作用：创建一个自定义的 ref，并对其依赖项跟踪和更新触发进行显式控制。 实现防抖效果： <template> <input type="text" v-model="keyword"> <h3>{ {keyword}}</h3> </template> ​ <script> import {ref,customRef} from vue export default { name:Demo, setup(){ // let keyword = ref(hello) //使用Vue准备好的内置ref //自定义一个myRef function myRef(value,delay){ let timer //通过customRef去实现自定义 return customRef((track,trigger)=&gt;{ return{ get(){ track() //告诉Vue这个value值是需要被“追踪”的 return value }, set(newValue){ clearTimeout(timer) timer = setTimeout(()=&gt;{ value = newValue trigger() //告诉Vue去更新界面 },delay) } } }) } let keyword = myRef(hello,500) //使用程序员自定义的ref return { keyword } } } </script><br />
5.provide 与 inject<br />
作用：实现祖与后代组件间通信 套路：父组件有一个 provide 选项来提供数据，后代组件有一个 inject 选项来开始使用这些数据 具体写法： 祖组件中： setup(){ ......    let car = reactive({name:奔驰,price:40万})    provide(car,car)    ...... } 后代组件中： setup(props,context){ ......    const car = inject(car)    return {car} ...... }<br />
7、vue3为什么要添加新的组合API，它可以解决哪些问题<br />
在 Vue2.0 中，随着功能的增加，组件越来越复杂，维护起来也越来越难，而难以维护的根本原因是 Vue 的 API 设计迫使开发者使用监视、计算、方法 Option 组织代码，而不是实际的业务逻辑。</p>
<p>另外 Vue2.0 缺乏一个简单而低成本的机制来完成逻辑重用，虽然你可以 minxis 完全重用逻辑，但是当 mixin 更多的时候，就使得很难找到相应的数据，计算出来也许是从中 mixin 的方法，使得类型推断变得困难。</p>
<p>因此组合API外观，主要是解决选项API带来的问题，首先是代码组织，组合API开发者可以根据业务逻辑组织自己的代码，让代码更具可读性和可扩展性，也就是说，当下一个开发者接触到这段不是自己写的代码， 他可以更好地利用代码的组织来反转实际的业务逻辑，或者根据业务逻辑更好地理解代码。</p>
<p>8、什么是hook？什么是自定义hook函数？<br />
什么是hook？—— 本质是一个函数，把setup函数中使用的Composition API进行了封装。 类似于vue2.x中的mixin。 自定义hook的优势: 复用代码, 让setup中的逻辑更清楚易懂。<br />
9、都说 Composition API 和 React Hook 很像，请问他们的区别是什么？<br />
从 React Hook 从实现的角度来看，React Hook 是基于 useState 的调用顺序来确定下一个 re 渲染时间状态从哪个 useState 开始，所以有以下几个限制</p>
<p>不在循环中、条件、调用嵌套函数 Hook 你必须确保它总是在你这边 React Top level 调用函数 Hook 使用效果、使用备忘录 依赖关系必须手动确定<br />
和 Composition API 是基于 Vue 的响应系统，和 React Hook 相比</p>
<p>在设置函数中，一个组件实例只调用一次设置，而 React Hook 每次重新渲染时，都需要调用 Hook，给 React 带来的 GC 比 Vue 更大的压力，性能也相对 Vue 对我来说也比较慢 Compositon API 你不必担心调用的顺序，它也可以在循环中、条件、在嵌套函数中使用 响应式系统自动实现依赖关系收集，而且组件的性能优化是由 Vue 内部完成的，而 React Hook 的依赖关系需要手动传递，并且依赖关系的顺序必须得到保证，让路 useEffect、useMemo 等等，否则组件性能会因为依赖关系不正确而下降。<br />
虽然Compoliton API看起来像React Hook来使用，但它的设计思路也是React Hook的参考。</p>
<p>10、Options API 存在的问题是什么？Composition API 的优势有哪些？<br />
1.Options API 存在的问题<br />
使用传统OptionsAPI中，新增或者修改一个需求，就需要分别在data，methods，computed里修改 。</p>
<p>2.Composition API 的优势<br />
我们可以更加优雅的组织我们的代码，函数。让相关功能的代码更加有序的组织在一起。</p>
<p>11、vue3有哪些新的组件？<br />
1.Fragment<br />
在Vue2中: 组件必须有一个根标签 在Vue3中: 组件可以没有根标签, 内部会将多个标签包含在一个Fragment虚拟元素中 好处: 减少标签层级, 减小内存占用<br />
2.Teleport<br />
什么是Teleport？—— Teleport 是一种能够将我们的组件html结构移动到指定位置的技术。 <teleport to="移动位置"> <div v-if="isShow" class="mask"> <div class="dialog"> <h3>我是一个弹窗</h3> &lt;button @click=&quot;isShow = false&quot;&gt;关闭弹窗</button> </div> </div> </teleport><br />
3.Suspense<br />
等待异步组件时渲染一些额外内容，让应用有更好的用户体验 使用步骤： 异步引入组件 import {defineAsyncComponent} from vue const Child = defineAsyncComponent(()=&gt;import(./components/Child.vue)) 使用Suspense包裹组件，并配置好default 与 fallback <template> <div class="app"> <h3>我是App组件</h3> <Suspense> <template v-slot:default> <Child/> </template> <template v-slot:fallback> <h3>加载中.....</h3> </template> </Suspense> </div> </template><br />
12.vue2和vue3的全局 API 和配置区别？<br />
Vue 2.x 有许多全局 API 和配置。 例如：注册全局组件、注册全局指令等。 //注册全局组件 Vue.component(MyButton, {  data: () =&gt; ({    count: 0 }),  template: &lt;button @click=&quot;count++&quot;&gt;Clicked { { count }} times.</button> }) ​ //注册全局指令 Vue.directive(focus, {  inserted: el =&gt; el.focus() } Vue3.0中对这些API做出了调整：全局API的转移 将全局的API，即：Vue.xxx调整到应用实例（app）上 2.x 全局 API（Vue） 3.x 实例 API (app) Vue.config.xxxx app.config.xxxx Vue.config.productionTip 移除 Vue.component app.component Vue.directive app.directive Vue.mixin app.mixin Vue.use app.use Vue.prototype app.config.globalProperties<br />
13、什么是前端服务端渲染？你明白SSR 吗？原理是什么？在vue2和vue3里使用ssr有什么区别？Vue SSR服务端渲染的使用场景有哪些？<br />
客户端渲染vs服务端渲染<br />
客户端渲染我们叫做CSR渲染方式，服务端渲染我们叫做SSR渲染<br />
什么是服务器端渲染？<br />
server side render 前端页面的产生是由服务器端生成的，我们就称之为服务端渲染。<br />
什么是客户端渲染？<br />
client side render 服务端只提供json格式的数据，渲染成什么样子由客户端通过js控制。<br />
运行对比：<br />
CSR执行流程：浏览器加载html文件 -&gt; 浏览器下载js文件 -&gt; 浏览器运行vue代码 -&gt; 渲染页面 SSR执行流程：浏览器加载html文件 -&gt; 服务端装填好内容 -&gt; 返回浏览器渲染</p>
<p>开发模式对比 CSR：前后端通过接口JSON数据进行通信，各自开发互不影响<br />
SSR：前后端分工搭配复杂，前端需要写好html模板交给后端，后端装填模板内容返给浏览器</p>
<p>vue框架中的服务端渲染<br />
为了解决第3章节提出的问题，目前我们的vue组件都是在浏览器侧通过js渲染出来的，所以首次加载时间很慢，那么我们把vue组件交给服务端负责渲染，渲染为完整内容之后直接返给客户端，是不是就可以可以解决既想渲染快，还想继续使用vue进行开发的问题了？</p>
<p>vue ssr基础使用：</p>
<p>更多详细信息 彻底了解服务器渲染 -SSR 原则，可以参考这篇文章：</p>
<p>当客户端请求服务器时，服务器从数据库中获取相关数据，而服务器内部的Vue组件呈现为HTML，并将数据、HTML并返回给客户端，这样就将数据和组件转换为HTML的过程，就叫做服务器呈现SSR。</p>
<p>而当客户端拿到服务器渲染的HTML和数据，因为数据已经有了，客户端就不需要再请求数据了，只需将数据同步到组件或者Vuex里面就可以了。除了数据意外，HTML和结构已经存在，当客户端渲染组件时，你只需要将HTML的DOM节点映射到虚拟DOM即可，不需要重新创建DOM节点，这将结合数据和HTML同步过程，也称为客户端激活。</p>
<p>使用 SSR 的好处是：<br />
对SEO有利：其实爬虫爬你的页面是件好事，因为有些页面爬虫不支持执行JavaScript的，这不支持实现JavaScript并不是说SSR我的页面会是空的HTML页面，而有了SSR以后，这些抓取工具就可以得到完整的HTML结构化数据，然后被纳入搜索引擎。 更短的白屏时间：相对于客户端渲染，服务器渲染是在浏览器URL中请求的，之后我们得到了一个HTML文本，浏览器只需要解析HTML，构建...直接DOM只是一棵树。而客户端渲染，需要得到一个空的一个第一个HTML页面，此时页面已经进入白屏，之后需要加载并执行JavaScript、请求后端服务器获取数据、JavaScript渲染页面几次才能看到最后一页。特别是在复杂的应用程序中，由于需要加载JavaScript脚本，应用程序越复杂，需要加载JavaScript的脚本越多，它就越大，这导致应用程序的首屏加载时间很长，并且降低了体验感。<br />
在vue2和vue3里使用ssr有什么区别？<br />
vue2时代做ssr一般使用vue2+vue-server-renderer可以实现SSR功能，但是vue3中会报错；</p>
<p>vue3可以不使用插件就实现SSR，就是原生支持。</p>
<p>Vue SSR服务端渲染的使用场景有哪些？<br />
1.SEO需求 SEO（Search Engine Optimization，搜索引擎优化），是一种利用搜索引擎规则，提高网站在搜索引擎内自然排名的技术。通常这需要页面内容在页面加载完成时便已经存在。</p>
<p>前后端分离的纯前端项目，由于这类项目需要页面加载完成后再异步获取数据渲染，因此大部分搜索引擎无法获取到这类项目的内容。Vue SSR正是基于此类需求而给出的一种技术方案。利用nodejs搭建页面渲染服务，在服务端完成之前需要在客户端完成的页面渲染工作，输出给SEO更友好的页面。</p>
<p>2.首屏渲染速度 目前对于首屏渲染速度的提升有许多方案，在ssr之外还有龙骨，墓碑，数据直出。相比于这些方案ssr方案实现是最复杂的，但效果也是最好的。</p>]]></description>
    <pubDate>Mon, 06 Feb 2023 14:11:33 +0800</pubDate>
    <author>yujiafree</author>
    <guid>https://www.yujiafree.com/?post=2</guid>
</item>
<item>
    <title>程序员应聘技巧 保姆级流程攻略</title>
    <link>https://www.yujiafree.com/?post=1</link>
    <description><![CDATA[<p>当我们走出校园，走向社会。我们都绕不开一个话题，就是应聘。程序员这个岗位是一个技术岗位，所以应聘是有一些技巧在里边的，这些技巧的使用可以大大提升应聘成功率。这个视频我们就讲一下这些技巧。<br />
嗨，小伙伴们大家好。我是技术胖。有很多人编程技术很好，可是一到应聘、面试就怂了。这个视频就让你彻底告别程序员应聘撞大运、看运气，而是让你水到渠成的轻松入职。请放心，这并不难，只要做好下面五件事，应聘成功率就可以大大提高。废话不多说，从脑图中可以看出，本期的内容是比较多，阅读时间比较长，但也保证全程无尿点。好了，废话不多说，直接上干货。</p>]]></description>
    <pubDate>Mon, 06 Feb 2023 13:23:02 +0800</pubDate>
    <author>yujiafree</author>
    <guid>https://www.yujiafree.com/?post=1</guid>
</item></channel>
</rss>