• Vue3 中文文档 https://vue3js.cn/docs/zh/
• Vue3 设计理念 https://vue3js.cn/vue-composition/

• vue3优点

1. 性能提升(首次渲染更快, diff算法更快,内存占用更少,打包体积更小)
2. 更好的Typescript支持
3. Composition API 组合式api（重点）

• vue3和vue2对比

1. 实例方法$on移除 （eventBus现有实现模式不再支持 可以使用三方插件替代）
2. 过滤器filter移除 （插值表达式里不能再使用过滤器 可以使用methods替代）
3. .sync语法移除 （和v-model语法合并）
4. vue3.0的单文件组件中不再强制要求必须有唯一根元素

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

vue3组件库

• ant-design-vue
  ant-design-vue 是 Ant Design 的 Vue 实现，组件的风格与 Ant Design 保持同步
  网址:https://antdv.com/docs/vue/introduce-cn/

• element-plus(elementUi3.0适配)
  Element Plus，一套为开发者、设计师和产品经理准备的基于 Vue 3.0 的桌面端组件库
  网址:| https://element-plus.gitee.io/#/zh-CN |

• vant
  有赞前端团队开源的移动端组件库，于 2016 年开源，已持续维护 4 年时间
  网址:https://vant-contrib.gitee.io/vant/v3/#/zh-CN

• Naive UI
  一个 Vue 3 组件库比较完整，主题可调，使用 TypeScript，不算太慢，有点意思
  网址:https://www.naiveui.com/zh-CN/

• VueUse
  基于composition组合api的常用集合，小兔仙项目会部分使用
  网址:https://vueuse.org/

组合式API

• 特定功能相关的所有东西都放到一起维护，比如功能A相关的响应式数据，操作数据的方法等放到一起，这样不管应用多大，都可以快读定位到某个功能的所有相关代码

• 维护方便，设置如果功能复杂，代码量大，我们还可以进行逻辑拆分处理

  
  
  image.png

特别注意：

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

setup入口函数

1. setup 函数是一个新的组件选项，作为组件中组合式API 的入口函数
2. setup 中不能使用 this， this 指向 undefined
3. setup函数只会在组件初始化的时候执行一次
4. setup函数在beforeCreate生命周期钩子执行之前执行

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

响应式API - reactive

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

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

<template>
  <div>{{ state.name }}</div>
  <div>{{ state.age }}</div>
  <button @click="state.name = 'pink'">改值</button>
</template>

<script>
import { reactive } from 'vue' //引入reactive函数
export default {
  setup () {
    const state = reactive({   //在reactive函数中传入对象
      name: 'cp',
      age: 18
    })
    return {
      state
    }
  }
}
</script>

响应式API - ref

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

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

<template>
  <div>{{ money }}</div>
  <button @click="changeMondy">改值</button>
</template>

<script>
import { ref } from 'vue'
export default {
  setup() {
    let money = ref(100)
    console.log(money.value)
    return {
      money
    }
  }
}
</script>

ref和reactive函数对比结论：

1. ref 函数可以接收一个简单类型的值，返回一个可改变的 ref 响应式对象，从而弥补reactive函数不支持简单类型的问题
2. 只有我们明确知道要转换的对象内部的字段名称我们才使用reactive，否则就一律使用ref，从而降低在语法选择上的心智负担

响应式API - computed

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

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

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

<script>
import { computed, ref } from 'vue'
export default {
  setup() {
    const list = ref([1, 2, 3, 4, 5])
    // 输入大于3的数字
    const filterList = computed(() => {
      return list.value.filter(item => item > 3)
    })
    // 修改list的函数
    function changeList() {
      list.value.push(6, 7, 8)
    }
    return {
      list,
      filterList,
      changeList
    }
  }
}
</script>

响应式API - watch

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

1. 普通监听
2. 立即执行
3. 深度监听

• 使用步骤

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

1）普通监听

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

<script>
import { ref, watch } from 'vue'
export default {
  setup() {
    const age = ref(18)
    watch(() => {
      // 返回你想要监听的响应式属性(ref产生的对象必须加.value)
      return age.value
    }, () => {
      // 数据变化之后的回调函数
      console.log('age发生了变化')
    })
    return {
      age
    }
  }
}
</script> 

2）开启立刻执行

• watch的效果默认状态下，只有监听的数据发生变化才会执行回调，如果你需要在一上来的时候就立刻执行一次，需要配置一下immediate属性

<template>
  {{ age }}
  <button @click="age++">change age</button>
</template>
<script>
import { ref, watch } from 'vue'
export default {
  setup() {
    const age = ref(18)
    watch(() => {
      // 返回你想要监听的响应式属性(ref产生的对象必须加.value)
      return age.value
    }, () => {
      // 数据变化之后的回调函数
      console.log('age发生了变化')
    },{ immediate: true})
    return {
      age
    }
  }
}
</script> 

3）开启深度监听

• 当我们监听的数据是一个对象的时候，默认状态下，对象内部的属性发生变化是不会引起回调函数执行的，如果想让对象下面所有属性都能得到监听，需要开启deep配置
• 注意: 使用watch的时候，尽量详细的表明你到底要监听哪个属性，避免使用deep引起的性能问题，

<template>
  {{ name }}
  {{ info.age }}
  <button @click="name = 'pink'">change name</button>
  <button @click="info.age++">change age</button>
</template>

<script>
import { reactive, toRefs, watch } from 'vue'
export default {
  setup() {
    const state = reactive({
      name: 'cp',
      info: {
        age: 18
      }
    })
    watch(() => {
      return state
    }, () => {
      // 数据变化之后的回调函数
      console.log('age发生了变化')
    }, {
      deep: true
    })
    return {
      ...toRefs(state)
    }
  }
}
</script> 

生命周期函数

• 使用步骤

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

<template>
  <div>生命周期函数</div>
</template>

<script>
import { onMounted } from 'vue'
export default {
  setup() {
    // 时机成熟 回调函数自动执行
    onMounted(() => {
      console.log('mouted生命周期执行了')
    })
     onMounted(() => {
      console.log('mouted生命周期函数又执行了')
    })
  }
}
</script> 

image.png

父子通信

• 实现步骤

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

app.vue

<template>
  <son :name="name" @get-msg="getMsg"></son>
</template>

<script>
import { ref } from 'vue'
import Son from './components/son'
export default {
  components: {
    Son
  },
  setup() {
    const name = ref('cp')
    function getMsg(msg) {
      console.log(msg)
    }
    return {
      name,
      getMsg
    }
  }
}
</script>

components/son.vue

<template>
  <div>
    {{name}}
    <button @click="setMsgToSon">set</button>
  </div>
</template>

<script>
export default {
  props: {
    name: {
      type: String
    }
  },
  emits: ['get-msg'], // 声明当前组件触发的自定义事件
  setup(props,{emit}) {
    console.log(props.name)
    function setMsgToSon(){
      emit('get-msg','这是一条来自子组件的msg信息')
    }
    return {
      setMsgToSon
    }
  }
}
</script>

provide 和 inject (组件传值)

• provide 和 inject，它们配合起来可以完成从顶层组件向任意底层组件传递数据的效果,也可以传递响应式数据
• 实现步骤

1. 顶层组件在setup方法中使用provide函数提供数据
   provide('key'，数据)
2. 任何底层组件在setup方法中使用inject函数获取数据
   const data = inject('key')

爷爷组件 - app.vue

<template>
  <father></father>
</template>

<script>
import Father from '@/components/Father'
import { provide } from 'vue'
export default {
  components: {
    Father
  },
  setup() {
    let name = '柴柴老师'
    // 使用provide配置项注入数据 key - value
    provide('name', name)
  }
}
</script> 

孙组件 - components/Son.vue

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

<script>
import { inject } from 'vue'
export default {
  setup() {
    const name = inject('name')
    return {
      name
    }
  }
}
</script>

TemplateRef(获取组件实例)

• 实现步骤

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

components/RefComponent.vue

<template>
  我是一个普通的组件
</template>

app.vue

<template>
  <h1 ref="h1Ref">我是普通dom标签</h1>
  <ref-comoonent ref="comRef"></ref-comoonent>
</template>

<script>
import { onMounted, ref } from 'vue'
import RefComoonent from '@/components/RefComponent'
export default {
  components: {
    RefComoonent
  },
  setup() {
    const h1Ref = ref(null)
    const comRef = ref(null)
    onMounted(() => {
      console.log(h1Ref.value)
      console.log(comRef.value)
    })
    // 必须return
    return {
      h1Ref,
      comRef
    }
  }
}
</script>