• vue3.0与vue2.0的区别


    前言

    Vue 3.0是一个用于构建用户界面的JavaScript框架。相比于Vue 2.x,Vue 3.0在性能、体积和开发体验上都有了很大的提升。


    以下将从不同的角度上去分析Vue 3.0与Vue 2.0的区别:

    一、项目架构


    从项目搭建和打包工具的选择来看:


    Vue 2.0 中通常会选择使用 webpack 或者 vue-cli 来进行项目搭建和打包。这些工具较为成熟和稳定,支持插件化和自定义配置,但是配置过于复杂,需要耗费较多的时间和精力来理解和维护。
    而 Vue 3.0 中则更加推崇使用 Vite 这款新型的前端构建工具,其基于 ES Modules 标准的优点,使得整个开发过程速度大大提升。使用 Vite 工具,不仅能够提高编译速度,还能够简化开发过程和调试过程。


    从架构的设计思路和实现方式来看:


    Vue 2.0 中通常会采用大型 monolithic 系统架构模式,即将整个项目打包成一个庞大的文件,加载速度慢,模块化能力较弱。这种模式容易导致开发难度大,难以维护。
    而 Vue 3.0 则更倾向于使用组合式 API + TypeScript 的方式来进行架构设计和实现。组合式 API 是 Vue 3.0 中引入的新特性,它能够使开发人员更加灵活的进行组件开发和复用。同时,使用 TypeScript 在架构上也增加了更加严格的类型校验,能够在编译阶段发现许多潜在的问题,提高代码质量和可维护性。这种模式使得代码更加简洁,结构更加清晰,便于组件化和模块化管理。


    二、数据响应式系统

    Vue 2.0中的数据响应式系统,主要是通过Object.defineProperty()方法来实现的。每个数据属性被定义成可观察的,具有getter和setter方法,当这些属性被修改后,Vue会自动追踪并重新计算相关的渲染函数,并更新视图。然而,这种方法存在一些限制,比如无法扩展属性和删除属性,也不能对新添加的属性进行响应化,同时在大规模数据变化时,这种方法也会带来性能问题。
     

    • Vue 3.0在数据响应式系统方面,在Vue 2.0的基础上进行了重构和改进,实现了更快速、更稳定的数据响应式。具体改进如下:

    • Proxy替换Object.defineProperty
      Vue 3.0使用了ES6中的Proxy代理对象来替代Object.defineProperty()方法。Proxy对象可以拦截对象上的一些操作,比如读取、修改、删除等,从而实现更加灵活的响应式更新。

    • 更好的响应式追踪
      在Vue 3.0中,响应式变量的追踪由Track和Trigger两个阶段完成。Track阶段用于追踪响应式变量的读取,Trigger阶段用于重新计算相关的渲染函数并更新视图。这种方式可以避免了无效渲染,提高了应用的性能。

    • 更灵活的响应式更新
      Vue 3.0还增加了watchEffect API和ref API等新API,可以更加灵活地对响应式变量进行操作。watchEffect可以监听响应式变量,并在变量变化时自动执行副作用函数。ref可以把普通变量转换成响应式变量,并返回一个带有value属性的对象。这些新API可以方便地扩展和操作响应式系统。

      三、虚拟DOM

    • 静态节点提升:将静态节点与动态节点分离,有效提高了渲染性能
    • 快速标记和补丁:Vue 3.0中采用了更加高效的标记和补丁方式,使得页面渲染更加快速和稳定
    • 更小的bundle大小:Vue 3.0使用了tree-shaking和基于ES2015的模块系统,使得框架的bundle大小更加的小。

         四、生命周期

           1. Vue 2.0 的生命周期:
    • beforeCreate:在实例初始化之后,数据观测 (data observer) 和 event/watcher 事件配置 (event/watcher option) 之前被调用。
    • created:在实例创建完成后被立即调用。在这一步,实例已完成以下的配置:数据观测(data observer)、属性和方法的运算、watch/event 事件回调。然而,挂载阶段还没开始,$el 属性目前尚不可用。
    • beforeMount:在挂载开始之前被调用:相关的 render 函数首次被调用。
    • mounted:实例挂载完成后调用,这时 el 被新创建的 vm.$el 替换了。
    • beforeUpdate:数据更新时调用,发生在虚拟 DOM 重新渲染和打补丁之前。这里适合在更新之前访问现有DOM,如移除手动设置的class。
    • updated:由于数据更改导致的虚拟 DOM 重新渲染和打补丁后调用。
    • activated:在组件章节中深入讨论过,这里不做详细讲解。
    • deactivated:在组件章节中深入讨论过,这里不做详细讲解。
    • beforeDestroy:实例销毁之前调用。在这一步,实例仍然完全可用。
    • destroyed:实例销毁后调用。这时候,绑定在实例上的全部指令、事件监听器都会被移除,所有子实例也会被销毁。
    • Vue 3.0 的生命周期:
    • onBeforeMount:在挂载之前被调用,与 Vue 2.0 中的 beforeMount 类似。
    • onMounted:在挂载之后被调用,与 Vue 2.0 中的 mounted 类似。
    • onBeforeUpdate:在更新之前被调用,与 Vue 2.0 中的 beforeUpdate 类似。
    • onUpdated:在更新之后被调用,与 Vue 2.0 中的 updated 类似。
    • onBeforeUnmount:在卸载之前被调用,与 Vue 2.0 中的 beforeDestroy 类似。
    • onUnmounted:在卸载之后被调用,与 Vue 2.0 中的 destroyed 类似。

      可以看到,Vue 3.0 对生命周期进行了一些小的调整,并不影响使用,而且增加了一些新的钩子函数,极大的方便使用者进行开发和维护。

        五、组件实例的创建方式

    Vue 2.0中组件实例的创建是通过Vue.extend()方法或者组件的对象字面量方式进行创建的,而在Vue 3.0中,组件实例的创建是通过标准的ES2015的类方式进行创建的。

    Vue 2.0 的组件实例创建方式:

    1. Vue.component('my-component', {
    2. // 组件配置
    3. // ...
    4. });
    5. // 创建根实例,渲染组件
    6. new Vue({
    7. el: '#app',
    8. template: ''
    9. })

    Vue 3.0 的组件实例创建方式:

    1. import { defineComponent } from 'vue';
    2. // 定义组件
    3. const MyComponent = defineComponent({
    4. // 组件配置
    5. // ...
    6. });
    7. // 导出组件
    8. export default MyComponent;

    在 Vue 3.0 中,我们可以使用 defineComponent() 方法快速定义组件,然后直接导出即可。这个方法返回一个组件选项对象,不同于 Vue 2.0 中的组件配置对象,它具有类型检查、组合式 API、构建工具集成以及更好的 IDE 支持等优点。而且,Vue 3.0 中的组件实例创建过程更加简单,我们只需要把组件导出即可在其他文件中使用。

    代码示例:
     

    1. // MyComponent.vue
    2. import { defineComponent } from 'vue';
    3. export default defineComponent({
    4. name: 'MyComponent',
    5. data() {
    6. return {
    7. count: 0
    8. };
    9. },
    10. methods: {
    11. increment() {
    12. this.count++;
    13. }
    14. },
    15. template: `
    16. Count: {{ count }}

  • `
  • });
  • 在这个示例中,我们使用 defineComponent() 方法来定义一个组件并导出。该组件包含一个名为 count 的计数器,并提供方法 increment() 来增加计数器的值。组件的模板包含了一个展示当前计数器值和一个点击按钮,每次点击按钮都会执行 increment() 方法来增加计数器的值。我们可以像下面这样在其他地方使用它:
     

    1. // main.js
    2. import { createApp } from 'vue';
    3. import MyComponent from './MyComponent.vue';
    4. const app = createApp({});
    5. app.component('my-component', MyComponent);
    6. app.mount('#app')

    在这个示例中,我们使用 createApp() 方法创建一个应用实例,并强制声明组件 MyComponent 作为 my-component 组件的名称,然后将其挂载在 DOM 上。在这个过程中,我们不需要使用 Vue.extend() 或者 Vue.component() 来创建组件实例,而可以直接使用 defineComponent() 方法定义组件并导出,然后在其他地方使用它。这是 Vue 3.0 中组件实例创建比 Vue 2.0 更加简单的一个例子。

    六、路由


    从路由的角度来看,Vue 2.0 和 Vue 3.0 的最大区别在于 Vue Router 的使用方式和 API 的变化。
    在 Vue 2.0 中,我们需要使用 Vue.use(VueRouter) 来引入 Vue Router,然后创建一个 Router 实例,并在根组件中使用它:

    1. import Vue from 'vue'
    2. import Router from 'vue-router'
    3. import HelloWorld from '@/components/HelloWorld'
    4. Vue.use(Router)
    5. export default new Router({
    6. routes: [
    7. {
    8. path: '/',
    9. name: 'HelloWorld',
    10. component: HelloWorld
    11. }
    12. ]
    13. })


    然后在 main.js 中导入 Router 并使用它:

    1. import Vue from 'vue'
    2. import App from './App.vue'
    3. import router from './router'
    4. new Vue({
    5. router,
    6. render: h => h(App),
    7. }).$mount('#app')

    在 Vue 3.0 中,Vue Router 的使用方式发生了变化。现在,我们需要使用 createRouter 工厂函数来创建路由实例,然后将其传递给根组件使用:

    1. import { createRouter, createWebHistory } from 'vue-router'
    2. import HelloWorld from './components/HelloWorld.vue'
    3. const routes = [
    4. { path: '/', component: HelloWorld }
    5. ]
    6. const router = createRouter({
    7. history: createWebHistory(),
    8. routes
    9. })
    10. export default router

    然后,在 main.js 中,我们需要通过 app.use(router) 将路由实例挂载到根组件上:

    1. import { createApp } from 'vue'
    2. import App from './App.vue'
    3. import router from './router'
    4. const app = createApp(App)
    5. app.use(router)
    6. app.mount('#app')

    总的来说,Vue Router 在 Vue 3.0 中提供了更加灵活的 API 和更好的类型推断支持,但是它的使用方式与 Vue 2.0 有所不同。因此,如果你想升级到 Vue 3.0,并且在你的项目中使用了 Vue Router,就必须阅读相关文档,并进行一些相应的修改才能够使用。
     

    七、请求


    使用的 HTTP 请求库:
    在 Vue 2.0 中,通常会使用第三方库 axios 或者 vue-resource 来进行 HTTP 请求的封装。这些库通常需要在全局导入后才能使用,然后通过在组件内部使用相关方法来发起请求。虽然这种方式比较灵活,但是需要编写较多的重复代码,并且类型推断和类型校验的支持也较差。


    而在 Vue 3.0 中,官方推荐的 HTTP 请求库是 axios 的替代品 - vite-plugin-mock,该库内置了一套基于 axios 的请求拦截和响应拦截机制,并且已经在 Vite 中默认启用了。这种方式可以大大减少编写重复代码的工作量,同时也支持更好的类型推断和类型校验。


    1.封装请求时的代码风格和规范:
    Vue 2.0 中通常会采用类似 Promise 封装的方式,例如将请求代码封装为一个函数,然后返回一个 Promise。而 Vue 3.0 中则更倾向于使用 async/await 来封装请求代码。这种方式可以让代码更加简洁易懂,同时也支持更好的错误处理和异常捕获。
     

    八、模板指令

    1. v-bind 指令:在 Vue 2.0 中,可以使用 v-bind 指令将属性绑定到一个变量或表达式上,例如:
      bind:class="{'active': isActive}">

      在 Vue 3.0 中,v-bind 指令可以用更简洁的语法代替:

         
      class="{'active': isActive}">

      v-if 和 v-for 指令:在 Vue 2.0 中,v-if 和 v-for 指令不能同时使用,因为 v-for 比 v-if 先执行,导致渲染出不必要的组件。

      在 Vue 3.0 中,v-if 和 v-for 可以同时使用,但是需要将 v-if 指令放在 v-for 指令的父元素上:
       

      1. if="show">
      2. <div v-for="item in items" :key="item.id">{{ item }}div>

v-model 指令:在 Vue 2.0 中,v-model 指令是一个语法糖,可以将表单元素的 value 属性和 input 事件绑定到一个变量或表达式上。

在 Vue 3.0 中,v-model 指令实现了双向绑定的核心逻辑,语法也进行了改进,可以更加灵活地绑定表单元素和数据
 

  1. "count" type="number">
  2. <input :value="count" @input="count = $event.target.value" type="number">

总结
综上可以看出,Vue 3.0在性能方面:

有更快的渲染速度:Vue 3.0在虚拟DOM和响应式系统方面进行了优化,可以实现更快的渲染速度。
有更小的代码体积:Vue 3.0采用了Tree-shaking技术,可以消除未使用的代码,从而减小应用程序的体积。
有更高的容错性:在Vue 3.0中,模板编译错误会抛出编译期错误而不是运行时错误,从而更早地发现问题。
其次,Vue 3.0引入了组合式API,使得开发者可以更轻松地组合逻辑,这提高了开发体验。组合式API的优势在于:

可以更好地组织代码结构和逻辑。
可以更方便地复用逻辑和代码片段。
可以更灵活地跨越组件进行逻辑抽象。
最后,Vue 3.0还提供了一些新特性,例如:

teleport:提供了更多灵活的组件位置控制方式。
新的响应式API:提供了更多的API,如watchEffect、ref、computed等,使得开发者可以更方便地处理响应式数据。
Fragment:可以在组件中使用多个元素而不需要用一个外层元素包裹它们。
总的来说,Vue 3.0相对于Vue 2.0更加稳定、快速、灵活,但也需要一定的学习成本
 

  • 相关阅读:
    手机桌面待办事项APP推荐
    畅捷通+数环通iPaaS,实现无代码集成上千款应用
    作业-11.11
    【动态规划】leetcode 62. 不同路径
    【LeetCode高频SQL50题-基础版】打卡第7天:第36~40题
    【STM32】基本定时器
    金仓数据库KingbaseES客户端编程接口指南-DCI(2. 概述)
    rk版本编译系统
    面试:单例模式VS静态方法
    02-Scala变量与数据类型
  • 原文地址:https://blog.csdn.net/qq_63608386/article/details/133838180