1. Vue3.0介绍

1.1 为什么要学习 vue 3

Vue 是目前国内开发最火的前端框架之一
vue3.0 正式版已发布七个月左右，社区生态已经逐步完善
部分技术选型激进的公司已经在生产环境使用了vue3

所以，是时候了~

目前已支持 vue3 的UI组件库

ant-design-vue

antdv.com/docs/vue/in…

ant-design-vue 是 Ant Design 的 Vue 实现，组件的风格与 Ant Design 保持同步

目前支持 Vue 3.0 的 2.0.0 测试版已发布
element-plus

element-plus.gitee.io/#/zh-CN

Element Plus，一套为开发者、设计师和产品经理准备的基于 Vue 3.0 的桌面端组件库
vant

vant-contrib.gitee.io/vant/v3/#/z…

轻量、可靠的移动端 Vue 组件库

Vant 是有赞前端团队开源的移动端组件库，于 2016 年开源，已持续维护 4 年时间

目前 Vant 已完成了对 Vue 3.0 的适配工作，并发布了 Vant 3.0 版本
VueUse

vueuse.org/

基于composition组合api的常用集合，小兔仙项目会部分使用

1.2 Vue3带来的新变化

性能提升
- 首次渲染更快
- diff算法更快
- 内存占用更少
- 打包体积变小
更好的Typescript支持
Composition API （重点）

在使用vue2.x版本开发较复杂的组件时，逻辑难以复用，组合式api的出现可以解决此类问题

1.3 破坏性语法更新

vue3.0对于2.0版本的大部分语法都是可以兼容的，但是也有一些破坏性的语法更新，这个大家要格外注意

实例方法$on移除（eventBus现有实现模式不再支持可以使用三方插件替代）
过滤器filter移除（插值表达式里不能再使用过滤器可以使用methods替代）
.sync语法移除（和v-model语法合并）

更多阅读：https://v3.cn.vuejs.org/guide/migration/introduction.html

2. Vue3开发环境搭建

接下来我们会学习vue3的一些新语法，首先我们先搭建一个基础环境，还是使用大家熟悉的vue-cli快速生成一个集成了vue3的环境

本节目标: 掌握如何使用vue-cli搭建一个基于vue3.0的开发环境

(1) 选择自定义配置
在这里插入图片描述
(2) 选中自定义安装版本

(3) 选择3.x版本

以上步骤回车之后，vue-cli会帮助我们跑起来一个内置了vue3版本的vue项目

首先我们可以看一下package.json文件，在dependencies配置项中显示，我们当前使用的版本为3.0.0
在这里插入图片描述
然后打开main.js 入口文件，发现Vue的实例化发生了一些变化，由先前的new关键词实例化，转变为createApp方法的调用形式（更多详情：www.bilibili.com/read/cv1013…

vue2.x

new Vue({
  el: '#app',
  render: h => h(App)
})
复制代码

vue3.x

import { createApp } from 'vue'
import App from './App.vue'
createApp(App).mount('#app')
复制代码

最后我们打开一个单文件组件发现，vue3.0的单文件组件中不再强制要求必须有唯一根元素

<template>
  <img alt="Vue logo" src="./assets/logo.png">
  <HelloWorld msg="Welcome to Your Vue.js App"/>
</template>
复制代码

以上就我们当前阶段需要关注的所有的东西，接下来我们就可以基于当前环境学习vue3的全新composition API

3. 组合式API

组合式api（Composition API）算是vue3对我们开发者来说非常有价值的一个api更新，我们先不关注具体语法，先对它有一个大的感知

3.1 composition vs options

本节目标: 对组合式api（composition api）有一个大概的理解

options API开发出来的vue应用如左图所示，它的特点是理解容易，因为各个选项都有固定的书写位置，比如响应式数据就写到data选择中，操作方法就写到methods配置项中等，应用大了之后，相信大家都遇到过来回上下找代码的困境

composition API开发的vue应用如右图所示，它的特点是特定功能相关的所有东西都放到一起维护，比如功能A相关的响应式数据，操作数据的方法等放到一起，这样不管应用多大，都可以快读定位到某个功能的所有相关代码，维护方便，设置如果功能复杂，代码量大，我们还可以进行逻辑拆分处理
在这里插入图片描述

特别注意：

选项式api和组合式api俩种风格是并存的关系并不是非此即彼
需要大量的逻辑组合的场景，可以使用compition API进行增强

3.2 案例对比

我们通过图示简单了解了一下vue3带来的全新的api形式，这一小节，我们通过一个具体的小案例更加深入的体会一下俩种api下的开发模式对比，大家暂时忽略语法细节，只关注代码编写形式

本节目标: 通过俩种Api形式实现同一个需求，理解compition api 带来的好处

3.2.1 理解需求

功能：通过点击按钮来控制文字的显示和隐藏
在这里插入图片描述
（1 ) vue2.x option Api版本

<template>
<div>
  <button @click="showText">显示</button>
  <button @click="hideText">隐藏</button>
  <p v-if="isShow">这里是一些文字用来显示隐藏的</p>
</div>

</template>

<script>


export default {
name: 'App',
data(){
  return {
    isShow: true
  }
},
methods:{
  showText(){
    this.isShow = true
  },
  hideText(){
    this.isShow = false
  }
}
}
</script>

<style>

</style>

复制代码

（2）vue3.0 composition api版本

<template>
  <div>
    <button @click="showText">显示</button>
    <button @click="hideText">隐藏</button>
    <p v-if="isShow">这里是一些文字用来显示隐藏的</p>
  </div>

</template>

<script>
// 引入需要的方法
import { ref } from 'vue'

export default {
  name: 'App',
  setup() {
    // 这里定义数据
    const isShow = ref(true)
    // 这里写方法
    const showText = () => {
      isShow.value = true
    }
    // 这里写方法
    const hideText = () => {
      isShow.value = false
    }
    // 所用到的东西都需要return出去
    return {
      isShow,showText,hideText
    }
  }
}
</script>

<style>

</style>
复制代码

以上，我们通过定义功能函数，把功能相关的代码各自抽离到一个独立的小函数中，然后通过在setUp函数中再把小功能函数组合起来，这样一来，我们既可以把setup函数变得清爽，又可以方便维护快速定位功能位置

nice~ 到此我们没有关注api细节，只是体会组合式api给到我们的好处，接下来我们就要深入到api细节，看看全新的api都该如何使用

3.3 setup入口函数

本节目标: 了解setup函数的作用和调用时机

setup 函数是一个新的组件选项，作为组件中组合式API 的起点（入口）
从生命周期角度来看，setup 会在 beforeCreate 钩子函数之前执行
setup 中不能使用 this， this 指向 undefined

export default {
  setup () {
    console.log('setup执行了')
    console.log(this)
  },
  beforeCreate() {
    console.log('beforeCreate执行了')
    console.log(this)
  }
}
复制代码

在这里插入图片描述

3.4 响应式系统API

3.4.1 reactive 函数

本节目标: 了解reactive函数的语法使用

作用：reactive是一个函数，接收一个普通的对象传入，把对象数据转化为响应式对象并返回

使用步骤

从vue框架中导入reactive函数
在setup函数中调用reactive函数并将对象数据传入
在setup函数中把reactive函数调用完毕之后的返回值以对象的形式返回出去

在这里插入图片描述
这个时候点击年龄+1 发现数据是响应式的

代码落地

<template>
  <div>
    <p>年龄是{{ user.age }}</p>
    <button @click="user.age++">年龄+1</button>
  </div>

</template>

<script>
// 1. 从vue框架中引入reactive函数
import {reactive} from 'vue'

export default {
  setup() {
    // 2. 在setup中调用函数并将数据对象引入
    const user = reactive({
      name: 'zs',
      age: 18
    })
    // 3.在setup函数中把reactive函数调用完毕之后的返回值以对象的形式返回出去
    return {
      user
    }
  }
}
</script>

<style>

</style>
复制代码

3.4.2 ref 函数

本节目标: 了解ref函数的语法使用

作用：ref是一个函数，接受一个简单类型或者复杂类型的传入并返回一个响应式且可变的 ref 对象

使用步骤

从vue框架中导出ref函数
在setup函数中调用ref函数并传入数据（简单类型或者复杂类型）
在setup函数中把ref函数调用完毕的返回值以对象的形式返回出去
注意：在setup函数中使用ref结果，需要通过.value 访问，模板中使用不需要加.value

落地代码

<template>
  <div>
    <p>年龄是{{ age }}</p>
    <button @click="addAge">年龄+1</button>
  </div>

</template>

<script>
// 1. 从vue框架中引入ref函数
import {ref} from 'vue'

export default {
  setup() {
    // 2. 在setup中调用函数并将数据对象引入
    const age = ref(18)

    const addAge = () => {
      // 这里的this指向是underfined 所以不能使用this.访问数据
      // 这里访问数据需要使用.value
      age.value++
    }
    // 3.在setup函数中把reactive函数调用完毕之后的返回值以对象的形式返回出去
    return {
      age,addAge
    }
  }
}
</script>
复制代码

总结说明：

ref 函数可以接收一个简单类型的值，返回一个可改变的 ref 响应式对象，从而弥补reactive函数不支持简单类型的问题
reactive和ref函数都可以提供响应式数据的转换，具体什么时候需要使用哪个API社区还没有最佳实践，大家暂时可以使用自己熟练的API进行转换
推荐一种写法：只有我们明确知道要转换的对象内部的字段名称（key）我们才使用reactive，否则就一律使用ref，从而降低在语法选择上的心智负担

3.4.3 toRefs 函数

问题复现

本节目标: 使用toRefs函数简化响应式对象的使用

场景: 经过reactive函数处理之后返回的对象，如果给这个对象解构或者展开，会让数据丢失响应式的能力，为了解决这个问题需要引入toRefs函数，使用 toRefs函数可以保证该对象展开的每个属性都是响应式的

点击+1按钮，发现视图已经不发生变化了，这就是我们所说的，如果解构reactive的返回值，将破坏调用响应式特性，就需要我们使用toRefs方法进行处理了

在这里插入图片描述

<template>
  <div>
    <p>年龄是{{ age }}</p>
    <button @click="age++">年龄+1</button>
  </div>

</template>

<script>
// 1. 从vue框架中引入reactive函数
import {reactive} from 'vue'

export default {
  setup() {
    // 2. 在setup中调用函数并将数据对象引入
    const user = reactive({
      name: 'zs',
      age: 18
    })
    // 3.在setup函数中把reactive函数调用完毕之后的返回值以对象的形式返回出去
    return {
      ...user
    }
  }
}
</script>
复制代码

处理方法
在这里插入图片描述

3.4.4 computed

本节目标: 掌握在setup函数中使用计算属性函数

作用：根据现有响应式数据经过一定的计算得到全新的数据

使用步骤

从vue框架中导入computed 函数
在setup函数中执行computed函数，并传入一个函数，在函数中定义计算公式
把computed函数调用完的执行结果放到setup的return值对象中

代码落地

<template>
  {{ list }}
  {{ filterList }}
  <button @click="changeList">change list</button>
</template>

<script>
// 1. 引入计算属性函数
import { computed, ref } from 'vue'
export default {
  setup() {
    // 这是过滤用的数组
    const list = ref([1, 2, 3, 4, 5])
    // 2.  使用computed
    const filterList = computed(() => {
      return list.value.filter(item => item > 3)
    })
    // 修改list的函数
    function changeList() {
      list.value.push(6, 7, 8)
    }
    // 3. 数据必须return出去
    return {
      list,
      filterList,
      changeList
    }
  }
}
</script>
复制代码

3.4.5 watch 侦听器

本节目标: 掌握在setup函数中侦听器的使用

作用：基于响应式数据的变化执行回调逻辑，和vue2中的watch的功能完全一致

普通监听

立即执行

深度监听

使用步骤

从vue框架中导入watch函数
在setup函数中执行watch函数开启对响应式数据的监听
watch函数接收三个常规参数
1. 第一个参数为函数，返回你要监听变化的响应式数据
2. 第二个参数为响应式数据变化之后要执行的回调函数
3. 第三个参数为一个对象，在里面配置是否开启立刻执行或者深度监听

代码落地
(1) 普通侦听

<template>
  {{ age }}
  <button @click="age++">change age</button>
</template>

<script>
// 1. 引入watch函数
import {ref, watch} from 'vue'

export default {
  setup() {
    //  2. 初始化一个监听的数据
    const age = ref(18)
    /**
     * watch（回调函数1， 回调函数2）
     * 回调函数1是  需要侦听的目标 在函数内返回即侦听
     * 回调函数2是  在侦听函数执行后调用
     */
    watch(() => {
          return age.value
        },
        () => {
          console.log('监听函数执行了')
        }
        )
    return {
      age
    }
  }
}
</script>
复制代码

(2) 开启立刻执行和深度监听
代码落地
相比普通监听只是在watch函数里面多了一个参数对象

<template>
  {{ user.age }}
  <button @click="user.age++">change age</button>
</template>

<script>
// 1. 引入watch函数
import {ref, watch} from 'vue'

export default {
  setup() {
    //  2. 初始化一个监听的数据
    const user = ref({
      name: 'zs',
      age: 20
    })
    /**
     * watch（回调函数1， 回调函数2, 对象）
     * 回调函数1是  需要侦听的目标 在函数内返回即侦听
     * 回调函数2是  在侦听函数执行后调用
     * 对象    deep：深度深度监听    默认false   开启true
     *        immediate: 立即监听  默认false   开启true
     */
    watch(() => {
          return user
        },
        () => {
          console.log('监听函数执行了')
        },
        {
          deep: true, // 开启深度监听
          immediate: true // 立即监听
        }
        )
    return {
      user
    }
  }
}
</script>
复制代码

(3) 更好的做法

使用watch的时候，尽量详细的表明你到底要监听哪个属性，避免使用deep引起的性能问题，比如我仅仅只是想在state对象的age属性变化的时候执行回调，可以这么写

相比之前的深度侦听，在watch函数的第一个回调函数return要侦听的属性即可

<template>
  {{ user.age }}
  <button @click="user.age++">change age</button>
</template>

<script>
// 1. 引入watch函数
import {ref, watch} from 'vue'

export default {
  setup() {
    //  2. 初始化一个监听的数据
    const user = ref({
      name: 'zs',
      age: 20
    })
    /**
     * watch（回调函数1， 回调函数2, 对象）
     * 回调函数1是  需要侦听的目标 在函数内返回即侦听
     * 回调函数2是  在侦听函数执行后调用
     * 对象    deep：深度深度监听    默认false   开启true
     *        immediate: 立即监听  默认false   开启true
     */
    watch(() => {
          return user.value.age // 侦听需要的属性
        },
        () => {
          console.log('监听函数执行了')
        },
        {
          deep: true, // 开启深度监听
          immediate: true // 立即监听
        }
        )
    return {
      user
    }
  }
}
</script>
复制代码

3.5 生命周期函数

本节目标: 掌握组合式API中的生命周期钩子函数的使用方式

使用步骤

先从vue中导入以on打头的生命周期钩子函数
在setup函数中调用生命周期函数并传入回调函数
注：生命周期钩子函数可以调用多次

代码落地

<template>
  <div></div>
</template>

<script>
// 引入声明周期函数
import {onMounted} from "vue";

export default {
  setup(){
    // 2. 使用生命周期
    // 可以使用多次  因为声明周期是函数调用的形式
    onMounted(()=> {
      console.log('mouted生命周期执行了')
    })
  }
}
</script>
复制代码

在这里插入图片描述

3.6 父子通信

本节目标: 掌握在组合式API下的父子通信

在vue3的组合式API中，父传子的基础套路完全一样，基础思想依旧为：父传子是通过prop进行传入，子传父通过调用自定义事件完成

实现步骤

setup函数提供俩个参数，第一个参数为props，第二个参数为一个对象context
props为一个对象，内部包含了父组件传递过来的所有prop数据，context对象包含了attrs，slots， emit属性，其中的emit可以触发自定义事件的执行从而完成子传父

代码落地
Father.vue

<template>
  <div>
    <Son :name="name" @getName="getName"/>
  </div>
</template>

<script>
import Son from "./components/Son"
import {ref} from "vue";

export default {
  setup() {
    // 1. 定义数据(父向子)
    const name = ref('黑手')

    // 1. 自定义事件（子向父）
    const getName = (newVal) => {
      console.log(newVal)
    }
    return {
      name, getName
    }
  },
  components: {
    Son
  }
}


/**
 * 父向子传值
 *   1. 定义数据(父向子)
 *   2. 定义接受数据  和：名=值对应 (父向子)
 *   3. 通过props.属性名拿到父亲的值
 */
</script>
复制代码

Son.vue

<template>
  <div>
    <div>Son组件</div>
    <button @click="setMsgToSon">点击</button>
  </div>
</template>

<script>
export default {
  name: "Son",
  // 2. 定义接受数据  和：名=值对应 (父向子)
  props: {
    name: {
      type: String
    }
  },
  emits: ['getName'],
  setup(props, context) {
    // 2. 点击触发自定义事件传值  通过context传值
    const setMsgToSon = () => {
      context.emit('getName', '神鹰黑手细说前端')
    }
    // 3. 通过props.属性名拿到父亲的值
    console.log('父组件的name是', props.name)

    return {
      setMsgToSon
    }
  }
}


/**
 * 子向父传值
 *    1. 在子组件身上自定义事件 @自定义事件名=函数名
 *    2. 在子元素身上绑定点击事件触发传值
 *         setup(props, context){
 *           context.emit('自定义时间名', 需要传入的值)
 *         }
 */
</script>
复制代码

3.7 provide 和 inject

通常我们使用props进行父子之间的数据传递，但是如果组件嵌套层级较深，一层一层往下传递将会变的非常繁琐，有没有一种手段可以把这个过程简化一下呢，有的，就是我们马上要学习的provide 和 inject，它们配合起来可以方便的完成跨层传递数据

在这里插入图片描述

基础使用

本节目标: 掌握在setup函数中使用provide和inject的基础用法

来个需求: 爷组件中有一份数据传递给孙组件直接使用

实现步骤：

顶层组件在setup方法中使用provide函数提供数据
任何底层组件在setup方法中使用inject函数获取数据

代码落地
爷爷组件 - app.vue

<template>
  <div>
    我是爷爷组件
    <Father />
    <Son/>
  </div>
</template>

<script>
import Son from "./components/Son"
import Father from "./components/Father"
import {provide, ref} from "vue";

// 1. 引入provide函数

export default {
  setup() {
    // 2. 定义传过去的数据
    const name = ref('黑手')
    provide('name', name)
  },
  components: {
    Son,
    Father
  }
}

</script>
复制代码

孙组件 - components/Son.vue

<template>
  <div>
    <div>我是Son组件</div>
  </div>
</template>

<script>
import {inject} from "vue";

export default {
  name: "Son",
  setup(){
    const name = inject('name')
    console.log(name.value)
  }
}
</script>
复制代码

3.8 模板中 ref 的使用

在模板中使用ref，我们都很清楚，它一般有三种使用场景

ref + 普通dom标签获取真实dom对象

ref + 组件标签获取组件实例对象

ref + v-for 获取由dom对象（实例对象）组成的数组（不经常使用）

本节目标: 掌握在setup函数中使用ref获取真实dom获取组件实例的方法

实现步骤

使用ref函数传入null创建 ref对象 => const hRef = ref(null)
模板中通过定义ref属性等于1中创建的ref对象名称建立关联 => <h1 ref="hRef"></h1>
使用 => hRef.value

代码落地
Father.vue

<template>
  <div ref="hRef">
    123
  </div>
  <Son ref="sonRef"/>
</template>

<script>
import Son from './components/Son'
import {onMounted, ref} from "vue";

export default {
  setup() {
    const hRef = ref(null)
    const sonRef = ref(null)
    // 在Dom挂载之后获取Dom
    onMounted(() => {
      console.log(hRef.value)
      console.log(sonRef.value)
    })

    return {
      hRef,sonRef
    }
  },
  components:{
    Son
  }
}
</script>
复制代码

./components/Son.vue

<template>
  <div>我是子组件 {{ name }}</div>
</template>

<script>
import {ref} from "vue";

export default {
  name: "Son",
  setup() {
    const name = ref('黑手')
    return {
      name
    }
  }
}
</script>

<style scoped>

</style>
复制代码