文章目录
- 1. 创建Vue3.0工程
- 2. 分析工程结构
- 3. setup
- 4. ref函数
- 5. reactive函数
- 6. Vue3.0中的响应式原理
- 7. reactive对比ref
- 8. setup的两个注意点
- 9. computed函数
- 10. watch函数
- 11. watchEffect函数
- 12. Vue3生命周期
- 13. 自定义hook函数
- 14. toRef和toRefs
- 15. shallowReactive与shallowRef
- 16. readonly 与 shallowReadonly
- 17. toRaw与markRaw
- 18. customRef
- 19. provide 与 inject
- 20. 响应式数据的判断
- 21. Composition API 的优势
- 22. Fragment组件
- 23. Teleport
- 24. Suspense
- 25. 全局API的转移
- 26. 其他改变
1. 创建Vue3.0工程
1. 使用 vue-cli 创建
官方文档:https://cli.vuejs.org/zh/guide/creating-a-project.html#vue-create
操作步骤
## 官方文档:https://cli.vuejs.org/zh/guide/creating-a-project.html#vue-create
## 查看@vue/cli版本(或使用命令vue -V),确保@vue/cli版本在4.5.0以上
vue --version
## 安装或者升级你的@vue/cli
npm install -g @vue/cli
## 创建
vue create vue_test
## 启动
cd vue_test
npm run serve
操作图示
然后,使用vscode打开刚刚创建好的脚手架工程,如下所示:
2. 使用vite创建
官方文档:https://v3.cn.vuejs.org/guide/installation.html#vite
vite官网:https://vitejs.cn
-
什么是vite?—— 新一代前端构建工具。
-
优势如下:
- 开发环境中,无需打包操作,可快速的冷启动。
- 轻量快速的热重载(HMR)。
- 真正的按需编译,不再等待整个应用编译完成。
-
传统构建 与 vite构建对比图
操作步骤
## 创建工程
npm init vite-app <project-name>
## 进入工程目录
cd <project-name>
## 安装依赖
npm install
## 运行
npm run dev
操作图示
然后,使用vscode打开vite创建的脚手架工程,如图所示
2. 分析工程结构
main.js
//引入的不再是Vue构造函数了,引入的是一个名为createApp的工厂函数
import { createApp } from 'vue'
import App from './App.vue'
//创建应用实例对象——app(类似于之前Vue2中的vm,但app比vm更“轻”)
const app = createApp(App)
//挂载
app.mount('#app')
/* 比较vue3与之前vue2的写法(现在vue3中不能使用下面的写法了, 因为vue中没有暴露Vue构造函数, 因此new不出来了)
const vm = new Vue({
render: h=>h(app)
})
vm.$mount('#app')
*/
App.vue
<template>
<!-- 可以使用多个根标签 -->
<img alt="Vue logo" src="./assets/logo.png">
<HelloWorld msg="Welcome to Your Vue.js App"/>
</template>
<script>
import HelloWorld from './components/HelloWorld.vue'
export default {
name: 'App',
components: {
HelloWorld
}
}
</script>
<style>
#app {
font-family: Avenir, Helvetica, Arial, sans-serif;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
text-align: center;
color: #2c3e50;
margin-top: 60px;
}
</style>
HelloWorld.vue
<template>
<div class="hello">
<h1>{{ msg }}</h1>
</div>
</template>
<script>
export default {
name: 'HelloWorld',
props: {
msg: String
}
}
</script>
<!-- Add "scoped" attribute to limit CSS to this component only -->
<style scoped>
h3 {
margin: 40px 0 0;
}
ul {
list-style-type: none;
padding: 0;
}
li {
display: inline-block;
margin: 0 10px;
}
a {
color: #42b983;
}
</style>
babel.config.js
module.exports = {
presets: [
'@vue/cli-plugin-babel/preset'
]
}
jsconfig.json
{
"compilerOptions": {
"target": "es5",
"module": "esnext",
"baseUrl": "./",
"moduleResolution": "node",
"paths": {
"@/*": [
"src/*"
]
},
"lib": [
"esnext",
"dom",
"dom.iterable",
"scripthost"
]
}
}
package.json
{
"name": "vue_test",
"version": "0.1.0",
"private": true,
"scripts": {
"serve": "vue-cli-service serve",
"build": "vue-cli-service build",
"lint": "vue-cli-service lint"
},
"dependencies": {
"core-js": "^3.8.3",
"vue": "^3.2.13"
},
"devDependencies": {
"@babel/core": "^7.12.16",
"@babel/eslint-parser": "^7.12.16",
"@vue/cli-plugin-babel": "~5.0.0",
"@vue/cli-plugin-eslint": "~5.0.0",
"@vue/cli-service": "~5.0.0",
"eslint": "^7.32.0",
"eslint-plugin-vue": "^8.0.3"
},
"eslintConfig": {
"root": true,
"env": {
"node": true
},
"extends": [
"plugin:vue/vue3-essential",
"eslint:recommended"
],
"parserOptions": {
"parser": "@babel/eslint-parser"
},
"rules": {}
},
"browserslist": [
"> 1%",
"last 2 versions",
"not dead",
"not ie 11"
]
}
vue.config.js
const { defineConfig } = require('@vue/cli-service')
module.exports = defineConfig({
transpileDependencies: true,
lintOnSave:false, //关闭语法检查
})
/* 也可以直接使用下面vue2之前的这种写法也没问题, 只不过上面是脚手架自动生成的配置代码
module.exports = {
lintOnSave:false, //关闭语法检查
}
*/
index.html
<!DOCTYPE html>
<html lang="">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<link rel="icon" href="<%= BASE_URL %>favicon.ico">
<title><%= htmlWebpackPlugin.options.title %></title>
</head>
<body>
<noscript>
<strong>
We're sorry but <%= htmlWebpackPlugin.options.title %>
doesn't work properly without JavaScript enabled. Please enable it to continue.
</strong>
</noscript>
<div id="app"></div>
<!-- built files will be auto injected -->
</body>
</html>
3. setup
- 理解:Vue3.0中一个新的配置项,值为一个函数。
- setup是所有Composition API(组合API)“ 表演的舞台 ”。
- 组件中所用到的:数据、方法等等,均要配置在setup中。
- setup函数的两种返回值:
- 若返回一个对象,则对象中的属性、方法, 在模板中均可以直接使用。(重点关注!)
- 若返回一个渲染函数:则可以自定义渲染内容。(了解)
- 注意点:
- 尽量不要与Vue2.x配置混用
- Vue2.x配置(data、methos、computed…)中可以访问到setup中的属性、方法。
- 但在setup中不能访问到Vue2.x配置(data、methos、computed…)。
- 如果有重名, setup优先。
- setup不能是一个async函数,因为返回值不再是return的对象, 而是promise, 模板看不到return对象中的属性。(后期也可以返回一个Promise实例,但需要Suspense和异步组件的配合)
- 尽量不要与Vue2.x配置混用
<template>
<h1>一个人的信息</h1>
<h2>姓名:{{name}}</h2>
<h2>年龄:{{age}}</h2>
<h2>性别:{{sex}}</h2>
<h2>a的值是:{{a}}</h2>
<button @click="sayHello">说话(Vue3所配置的——sayHello)</button>
<br>
<br>
<button @click="sayWelcome">说话(Vue2所配置的——sayWelcome)</button>
<br>
<br>
<button @click="test1">测试一下在Vue2的配置中去读取Vue3中的数据、方法(能正常读取)</button>
<br>
<br>
<button @click="test2">测试一下在Vue3的setup配置中去读取Vue2中的数据、方法</button>
</template>
<script>
// import {h} from 'vue'
export default {
name: 'App',
data() {
return {
sex:'男',
a:100 // 若vue2中定义的与vue3中定义的存在命名冲突, 则以vue3的优先
}
},
methods: {
sayWelcome(){
alert('欢迎来到尚硅谷学习')
},
test1(){
// vue2本身的sex能读取到
console.log(this.sex)
// vue3的setUp函数返回的下面3个也能读取到
console.log(this.name)
console.log(this.age)
console.log(this.sayHello)
}
},
//此处只是测试一下setup,暂时不考虑响应式的问题!!!(现在还没有响应式,指:修改数据,页面并不会更新)
/* async */setup(){ // 此处不能使用async修饰setup函数, 否则模板中用不了setup函数返回的数据
//数据
let name = '张三'
let age = 18
let a = 200
//方法
function sayHello(){
alert(`我叫${name},我${age}岁了,你好啊!`)
}
function test2(){
// vue3下面定义的3个能访问到
console.log(name)
console.log(age)
console.log(sayHello)
// vue2中定义的访问不到
console.log(this.sex)
console.log(this.sayWelcome)
}
//返回一个对象(常用)
return { // setUp函数返回的对象,才可以直接在模板中使用
name,
age,
sayHello,
test2,
a
}
//返回一个函数(渲染函数)
// return ()=> h('h1','尚硅谷') // 若返回一个函数, 则会忽略模板, 直接将该函数的返回值作为渲染结果
}
}
</script>
4. ref函数
- 作用: 定义一个响应式的数据
- 语法:
const xxx = ref(initValue)
- 创建一个包含响应式数据的引用对象(reference对象,简称ref对象)。
- JS中操作数据:
xxx.value
- 模板中读取数据: 不需要.value,直接:
<div>{{xxx}}</div>
- 备注:
- 接收的数据可以是:基本类型、也可以是对象类型。
- 基本类型的数据:响应式依然是靠
Object.defineProperty()
的get
与set
完成的。 - 对象类型的数据:内部 “ 求助 ” 了Vue3.0中的一个新函数——
reactive
函数。
<template>
<h1>一个人的信息</h1>
<!-- 模板中使用响应式数据, 不需要.value -->
<h2>姓名:{{name}}</h2>
<h2>年龄:{{age}}</h2>
<h3>工作种类:{{job.type}}</h3>
<h3>工作薪水:{{job.salary}}</h3>
<h3>工作描述: {{ job.desc.intro }}</h3>
<button @click="changeInfo">修改人的信息</button>
</template>
<script>
// 需要引入ref函数
import {ref} from 'vue'
export default {
name: 'App',
setup(){
//数据(使用ref将数据包裹, 得到响应式数据, 模板使用这些响应式数据, 修改数据时, 页面才会更新)
// 基本数据类型(内部用的仍然是Object的defineProperty和get/set实现的响应式)
let name = ref('张三')
let age = ref(18)
// 对象数据类型(内部借助的reacitve函数,而reactive封装了Proxy实现的响应式)
let job = ref({
type:'前端工程师',
salary:'30K',
desc: {
intro: '负责页面和数据展示'
}
})
//方法
function changeInfo(){
console.log(name,age); // RefImpl {__v_isShallow: false, dep: Set(1), __v_isRef: true,
// _rawValue: '张三', _value: '张三'}
// RefImpl {__v_isShallow: false, dep: Set(1), __v_isRef: true,
// _rawValue: 18, _value: 18}
// 页面都得到更新(对于基本数据类型,直接修改.value,页面得到更新)
name.value = '李四'
age.value = 48
console.log(job); // RefImpl {__v_isShallow: false, dep: Set(1), __v_isRef: true,
// _rawValue: {…}, _value: Proxy}
// (注意:这里将对象数据类型的数据转成了Proxy对象,
// 因为ref借助了reactive函数, 将我们定义的对象转为了Proxy对象)
console.log(job.value) // Proxy {type: '前端工程师', salary: '30K', desc: {…}}
// 页面都得到更新(对于对象数据类型,直接修改Proxy对象的属性,页面得到更新)
job.value.type = 'UI设计师'
job.value.salary = '60K'
job.value.desc.intro = '图标、页面设计'
}
//返回一个对象(常用)
return {
name,
age,
job,
changeInfo
}
}
}
</script>
5. reactive函数
- 作用: 定义一个对象类型的响应式数据(基本类型不要用它(),要用
ref
函数) - 语法:
const 代理对象= reactive(源对象)
接收一个对象(或数组),返回一个代理对象(Proxy的实例对象,简称proxy对象) - reactive定义的响应式数据是“深层次的”。
- 内部基于 ES6 的 Proxy 实现,通过代理对象操作源对象内部数据进行操作。
<template>
<h1>一个人的信息</h1>
<h2>姓名:{{person.name}}</h2>
<h2>年龄:{{person.age}}</h2>
<h3>工作种类:{{person.job.type}}</h3>
<h3>工作薪水:{{person.job.salary}}</h3>
<h3>爱好:{{person.hobby}}</h3>
<h3>测试的数据c:{{person.job.a.b.c}}</h3>
<button @click="changeInfo">修改人的信息</button>
<!-- 仍然是响应式的 -->
{{ person.job.skill }}
<button @click="person.job.skill = {level:5}">level5</button>
<button @click="person.job.skill.level++">salary++</button>
</template>
<script>
import {reactive} from 'vue'
export default {
name: 'App',
setup(){
// 不能这样使用!!!会报警告:value cannot be made reactive: zzhua!
// 同时它也不是响应式的, 这里只能传入对象
// let name = reactive('zzhua')
//数据
// (基本数据类型,不能放在reactive函数里面,但是,我们可以把数据包装成对象,放入reactive函数里面)
let person = reactive({
name:'张三',
age:18,
job:{
type:'前端工程师',
salary:'30K',
a:{
b:{
c:666
}
},
skill: {
level: 1
}
},
hobby:['抽烟','喝酒','烫头']
})
console.log(person); // Proxy {name: '张三', age: 18, job: {…}, hobby: Array(3)}
// 直接使用reactive函数, 会直接返回一个Proxy对象,
// 这样就不用像ref那里使用.value了,比较方便
//方法
function changeInfo(){
person.name = '李四'
person.age = 48
person.job.type = 'UI设计师'
person.job.salary = '60K'
person.job.a.b.c = 999
person.hobby[0] = '学习' // 之前的vue2并不能监测到到这里的改变,但vue3使用Proxy后,就可以了
}
//返回一个对象(常用)
return {
person,
changeInfo
}
}
}
</script>
6. Vue3.0中的响应式原理
vue2.x的响应式
-
实现原理:
-
对象类型:通过
Object.defineProperty()
对属性的读取、修改进行拦截(数据劫持)。 -
数组类型:通过重写更新数组的一系列方法来实现拦截。(对数组的变更方法进行了包裹)。
Object.defineProperty(data, 'count', { get () {}, set () {} })
-
-
存在问题:
- 新增属性、删除属性, 界面不会更新。
- 直接通过下标修改数组, 界面不会自动更新。
<template>
<div id="app">
<h1 v-show="person.name">姓名: {{ person.name }}</h1>
<h1>年龄: {{ person.age }}</h1>
<h1 v-show="person.sex">性别: {{ person.sex }} </h1>
<h1>爱好: {{ person.hobby }}</h1>
<button @click="addSex">添加sex属性</button>
<button @click="removeName">移除name属性</button>
<button @click="updateHobby">修改hobby</button>
</div>
</template>
<script>
import Vue from 'vue'
export default {
name: 'App',
data() {
return {
person: {
name: 'zzhua',
age: 21,
hobby: ['java','blender','ps']
}
}
},
methods: {
addSex(){
// vue2: 新增属性, 页面不会得到更新
// console.log(this.person.sex);
// this.person.sex = 'male'
// console.log(this.person.sex);
// 解决办法
// this.$set(this.person, 'sex', 'male')
Vue.set(this.person, 'sex', 'male')
},
removeName() {
// vue2: 移除属性, 页面不会得到更新
// console.log(this.person.name);
// delete this.person.name
// console.log(this.person.name);
// 解决办法
// this.$delete(this.person, 'name')
Vue.delete(this.person, 'name')
},
updateHobby() {
// vue2: 使用数组索引直接修改数组数据, 页面不会更新
// this.person.hobby[0] = 'JAVA'
// console.log(this.person.hobby);
// 解决办法
// this.$set(this.person.hobby, 0, 'JAVA')
this.person.hobby.splice(0,1,'JAVA')
}
}
}
</script>
Vue3.0的响应式
-
实现原理:
-
通过Proxy(代理): 拦截对象中任意属性的变化, 包括:属性值的读写、属性的添加、属性的删除等。
-
通过Reflect(反射): 对源对象的属性进行操作。
-
MDN文档中描述的Proxy与Reflect:
-
Proxy:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Proxy
-
Reflect:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/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'
-
-
vue3中解决的问题
vue3中已经解决了vue2中存在的下面几个问题:
- 新增属性、删除属性, 界面不会更新。
- 直接通过下标修改数组, 界面不会自动更新。
<template>
<h1>一个人的信息</h1>
<h2>姓名:{{ person.name }}</h2>
<h2>年龄:{{ person.age }}</h2>
<h3>工作种类:{{ person.job.type }}</h3>
<h3>工作薪水:{{ person.job.salary }}</h3>
<h3>爱好:{{ person.hobby }}</h3>
<h3>测试的数据c:{{ person.job.a.b.c }}</h3>
<button @click="changeInfo">修改信息</button>
<h2>sex:{{ person.sex }}</h2>
<button @click="addSex">添加sex属性</button>
<button @click="removeName">移除name属性</button>
</template>
<script>
import { reactive } from 'vue'
export default {
name: 'App',
setup() {
//数据
let person = reactive({
name: '张三',
age: 18,
job: {
type: '前端工程师',
salary: '30K',
a: {
b: {
c: 666
}
}
},
hobby: ['抽烟', '喝酒', '烫头']
})
//方法
function addSex() { // 添加属性,页面能更新
person.sex = 'male'
}
function removeName() { // 删除属性,页面能更新
delete person.name
}
function changeInfo() {
person.name = '李四'
person.age = 48
person.job.type = 'UI设计师'
person.job.salary = '60K'
person.job.a.b.c = 999
person.hobby[0] = '学习' // 直接通过数组索引修改数组中的数据,页面能更新
}
//返回一个对象(常用)
return {
person,
addSex,
removeName,
changeInfo
}
}
}
</script>
vue3的响应式原理
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>Document</title>
</head>
<body>
<script type="text/javascript" >
//源数据
let person = {
name:'张三',
age:18
}
//模拟Vue2中实现响应式
//#region
/* let p = {}
Object.defineProperty(p,'name',{ // 给p追加一个name属性
configurable:true, // 决定p上的name属性能否使用 delete p.name删除
get(){ //有人读取name时调用
return person.name
},
set(value){ //有人修改name时调用
console.log('有人修改了name属性,我发现了,我要去更新界面!')
person.name = value
}
})
Object.defineProperty(p,'age',{
get(){ //有人读取age时调用
return person.age
},
set(value){ //有人修改age时调用
console.log('有人修改了age属性,我发现了,我要去更新界面!')
person.age = value
}
}) */
//#endregion
//模拟Vue3中实现响应式(借助了window身上的Proxy属性)
//#region
const p = new Proxy(person,{
//有人读取p的某个属性时调用(当调用console.log(p.xxx)时候, 该方法被执行)
get(target,propName){
console.log(`有人读取了p身上的${propName}属性`)
// return target[propName]
return Reflect.get(target,propName) // (借助了window身上的Reflect属性)
},
//有人修改p的某个属性、或给p追加某个属性时调用(当调用p.xxx = yyy时候, 该方法被执行)
set(target,propName,value){
console.log(`有人修改了p身上的${propName}属性,我要去更新界面了!`)
// target[propName] = value
Reflect.set(target,propName,value)
},
//有人删除p的某个属性时调用(当调用delete p.xxx时候, 该方法被执行)
deleteProperty(target,propName){
console.log(`有人删除了p身上的${propName}属性,我要去更新界面了!`)
// return delete target[propName]
return Reflect.deleteProperty(target,propName)
}
})
//#endregion
let obj = {a:1,b:2}
//通过Object.defineProperty去操作
//#region
/* try {
Object.defineProperty(obj,'c',{
get(){
return 3
}
})
Object.defineProperty(obj,'c',{ // 这里会报错, 前面已经为obj的c属性定义了
get(){
return 4
}
})
} catch (error) {
console.log(error)
} */
//#endregion
//通过Reflect.defineProperty去操作
//#region
/* const x1 = Reflect.defineProperty(obj,'c',{
get(){
return 3
}
})
console.log(x1) // true
const x2 = Reflect.defineProperty(obj,'c',{
get(){
return 4
}
})
console.log(x2) // false
if(x2){ // 可以通过返回值,知道操作是否成功了
console.log('某某某操作成功了!')
}else{
console.log('某某某操作失败了!')
} */
//#endregion
</script>
</body>
</html>
7. reactive对比ref
- 从定义数据角度对比:
- ref用来定义:基本类型数据。
- reactive用来定义:对象(或数组)类型数据。
- 备注:ref也可以用来定义对象(或数组)类型数据, 它内部会自动通过
reactive
转为代理对象。
- 从原理角度对比:
- ref通过
Object.defineProperty()
的get
与set
来实现响应式(数据劫持)。 - reactive通过使用Proxy来实现响应式(数据劫持), 并通过Reflect操作源对象内部的数据。
- ref通过
- 从使用角度对比:
- ref定义的数据:操作数据需要
.value
,读取数据时模板中直接读取不需要.value
。 - reactive定义的数据:操作数据与读取数据:均不需要
.value
。
- ref定义的数据:操作数据需要
8. setup的两个注意点
-
setup执行的时机
- 在beforeCreate之前执行一次,this是undefined。
-
setup的参数
- props:值为对象,包含:组件外部传递过来,且组件内部声明接收了的属性。
- context:上下文对象
- attrs: 值为对象,包含:组件外部传递过来,但没有在props配置中声明的属性, 相当于
this.$attrs
。 - slots: 收到的插槽内容, 相当于
this.$slots
。 - emit: 分发自定义事件的函数, 相当于
this.$emit
。
- attrs: 值为对象,包含:组件外部传递过来,但没有在props配置中声明的属性, 相当于
App.vue
<template>
<!-- 绑定msg、school属性,绑定hello自定义事件 -->
<Demo msg="你好啊" school="尚硅谷" @hello="showHelloMsg" >
<!-- 定义插槽内容 -->
<template v-slot:qwe>
<span>尚硅谷</span>
</template>
<template v-slot:asd>
<span>尚硅谷</span>
</template>
</Demo>
</template>
<script>
import Demo from './components/Demo'
export default {
name: 'App',
components:{Demo},
setup(){
function showHelloMsg(value){
alert(`你好啊,你触发了hello事件,我收到的参数是:${value}!`)
}
return {
showHelloMsg
}
}
}
</script>
Demo.vue
<template>
<h1>一个人的信息</h1>
<h2>姓名:{{person.name}}</h2>
<h2>年龄:{{person.age}}</h2>
<button @click="test">测试触发一下Demo组件的Hello事件</button>
</template>
<script>
import {reactive} from 'vue'
export default {
name: 'Demo',
props:['msg','school'], // 声明接受父组件传过来的数据
emits:['hello'], // 如果父组件为子组件绑定了自定义事件, 但是子组件没有使用emits声明, 就会警告, 但不影响大局
setup(props,context){
// console.log('---setup---',props)
// console.log('---setup---',context)
// console.log('---setup---',context.attrs) // 相当与Vue2中的$attrs,如果父组件把数据传了,
// 但是子组件没有声明props去接收,
// 没接收的数据就放在这个里面了, 并且会有警告,
// 但不影响大局
// console.log('---setup---',context.emit) //触发自定义事件用的。
console.log('---setup---',context.slots) //插槽
//数据
let person = reactive({
name:'张三',
age:18
})
//方法
function test(){
context.emit('hello',666)
}
//返回一个对象(常用)
return {
person,
test
}
}
}
</script>
9. computed函数
-
与Vue2.x中computed配置功能一致
-
写法
import {reactive,computed} from 'vue' setup(){ //数据 let person = reactive({ firstName:'张', lastName:'三' }) //计算属性——简写 let fullName = computed(()=>{ 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] } }) }
示例
<template>
<h1>一个人的信息</h1>
姓:<input type="text" v-model="person.firstName">
<br>
名:<input type="text" v-model="person.lastName">
<br>
<span>全名:{{person.fullName}}</span>
<br>
全名:<input type="text" v-model="person.fullName">
</template>
<script>
import {reactive,computed} from 'vue'
export default {
name: 'Demo',
/* // vue2中的computed仍然可以使用
computed: {
fullName(){
return this.person.firstName + this.person.lastName
}
},
*/
setup(){
//数据
let person = reactive({
firstName:'张',
lastName:'三'
})
//计算属性——简写(没有考虑计算属性被修改的情况)
/* person.fullName = computed(()=>{
return person.firstName + '-' + person.lastName
}) */
//计算属性——完整写法(考虑读和写)
// (这里直接给person添加fullName属性,
// 根据前面学Proxy时,我们知道person是Proxy对象,给它添加fullName属性,这是可以被vue所监测到的,
// 所以是没问题的)
person.fullName = computed({
get(){ // 当读取person.fullName属性时, 该get方法被调用
return person.firstName + '-' + person.lastName
},
set(value){ // 当修改person.fullName属性时, 该set方法被调用,并传入修改的值
const nameArr = value.split('-')
person.firstName = nameArr[0]
person.lastName = nameArr[1]
}
})
//返回一个对象(常用)
return {
person
}
}
}
</script>
10. watch函数
-
与Vue2.x中watch配置功能一致
-
两个小“坑”:
- 监视reactive定义的响应式数据时:oldValue无法正确获取、强制开启了深度监视(deep配置失效)。
- 监视reactive定义的响应式数据中某个属性时:deep配置有效。
//情况一:监视ref定义的响应式数据 watch(sum,(newValue,oldValue)=>{ console.log('sum变化了',newValue,oldValue) },{immediate:true}) //情况二:监视多个ref定义的响应式数据 watch([sum,msg],(newValue,oldValue)=>{ console.log('sum或msg变化了',newValue,oldValue) }) /* 情况三:监视reactive定义的响应式数据 若watch监视的是reactive定义的响应式数据,则无法正确获得oldValue!! 若watch监视的是reactive定义的响应式数据,则强制开启了深度监视 */ watch(person,(newValue,oldValue)=>{ console.log('person变化了',newValue,oldValue) },{immediate:true,deep:false}) //此处的deep配置不再奏效 //情况四:监视reactive定义的响应式数据中的某个属性 watch(()=>person.job,(newValue,oldValue)=>{ console.log('person的job变化了',newValue,oldValue) },{immediate:true,deep:true}) //情况五:监视reactive定义的响应式数据中的某些属性 watch([()=>person.job,()=>person.name],(newValue,oldValue)=>{ console.log('person的job变化了',newValue,oldValue) },{immediate:true,deep:true}) //特殊情况 watch(()=>person.job,(newValue,oldValue)=>{ console.log('person的job变化了',newValue,oldValue) },{deep:true}) //此处由于监视的是reactive素定义的对象中的某个属性,所以deep配置有效
watch监视ref&reactive数据
<template>
<h2>当前求和为:{{sum}}</h2>
<button @click="sum++">点我+1</button>
<hr>
<h2>当前的信息为:{{msg}}</h2>
<button @click="msg+='!'">修改信息</button>
<hr>
<h2>姓名:{{person.name}}</h2>
<h2>年龄:{{person.age}}</h2>
<h2>薪资:{{person.job.j1.salary}}K</h2>
<button @click="person.name+='~'">修改姓名</button>
<button @click="person.age++">增长年龄</button>
<button @click="person.job.j1.salary++">涨薪</button>
</template>
<script>
import {ref,reactive,watch} from 'vue'
export default {
name: 'Demo',
/*
watch: { // 可以使用vue2中的watch监视
sum: {
immediate: true,
deep: true,
handler(newVal, oldVal) {
console.log(newVal, oldVal);
}
}
}, */
setup(){
//数据
let sum = ref(0)
let msg = ref('你好啊')
let person = reactive({ // 如果此处使用ref, 那么在使用watch时, 检测的值要写person.value,
// 否则监测不到; 如果使用reactive, 则watch监测的值, 直接写person
name:'张三',
age:18,
job:{
j1:{
salary:20
}
}
})
//情况一:监视ref所定义的一个响应式数据
/* watch(sum,(newValue,oldValue)=>{ // 当运行到这里时,sum.value其实已经是0了,
// 当配置了immediate为true时, 该回调会立即调用, newValue是0,
// oldValue是undefined
console.log('sum变了',newValue,oldValue)
},{immediate:true}) */
//情况二:监视ref所定义的多个响应式数据
/* watch([sum,msg],(newValue,oldValue)=>{
// 同时监视多个的话, 传过来的newValue和oldValue都是数组,
// 就是所监视的数据修改后的值和修改前的值, 比如是: [1, '你好啊'], [1, '你好啊!']
console.log('sum或msg变了',newValue,oldValue)
},{immediate:true}) */
/*
情况三:监视reactive所定义的一个响应式数据的全部属性
1.注意:此处无法正确的获取oldValue(oldValue与newValue一样,这是有问题的)
2.注意:强制开启了深度监视(deep配置无效)
(即使不配置deep:true,当修改person.job.j1.salary++时候,该回调也会执行,
即使配置了deep:false,该回调仍会执行)
*/
/* watch(person,(newValue,oldValue)=>{
console.log('person变化了',newValue,oldValue)
},{deep:false}) //此处的deep配置无效 */
//情况四:监视reactive所定义的一个响应式数据中的某个属性
/* watch(()=>person.name,(newValue,oldValue)=>{
console.log('person的name变化了',newValue,oldValue)
}) */
//情况五:监视reactive所定义的一个响应式数据中的某些属性
/* watch([()=>person.name,()=>person.age],(newValue,oldValue)=>{
console.log('person的name或age变化了',newValue,oldValue)
}) */
//特殊情况
/* watch(()=>person.job,(newValue,oldValue)=>{
console.log('person的job变化了',newValue,oldValue)
},{deep:true}) //此处由于监视的是reactive素定义的对象中的某个属性,所以deep配置有效 */
//返回一个对象(常用)
return {
sum,
msg,
person
}
}
}
</script>
watch监视ref数据的说明
<template>
<h2>当前求和为:{{sum}}</h2>
<button @click="sum++">点我+1</button>
<hr>
<h2>当前的信息为:{{msg}}</h2>
<button @click="msg+='!'">修改信息</button>
<hr>
<h2>姓名:{{person.name}}</h2>
<h2>年龄:{{person.age}}</h2>
<h2>薪资:{{person.job.j1.salary}}K</h2>
<button @click="person.name+='~'">修改姓名</button>
<button @click="person.age++">增长年龄</button>
<button @click="person.job.j1.salary++">涨薪</button>
</template>
<script>
import {ref,reactive,watch} from 'vue'
export default {
name: 'Demo',
setup(){
//数据
let sum = ref(0)
let msg = ref('你好啊')
let person = ref({
name:'张三',
age:18,
job:{
j1:{
salary:20
}
}
})
console.log(person)
watch(sum,(newValue,oldValue)=>{
console.log('sum的值变化了',newValue,oldValue)
})
watch(person,(newValue,oldValue)=>{
console.log('person的值变化了',newValue,oldValue)
},{deep:true})
/*
// 也可以下面这样写, 就相当于监视reactive定义的数据, 因为person是用ref定义的,所以.value获取到的是Proxy
watch(person.value,(newValue,oldValue)=>{
console.log('person的值变化了',newValue,oldValue)
})
*/
//返回一个对象(常用)
return {
sum,
msg,
person
}
}
}
</script>
11. watchEffect函数
-
watch的套路是:既要指明监视的属性,也要指明监视的回调。
-
watchEffect的套路是:不用指明监视哪个属性,监视的回调中用到哪个属性,那就监视哪个属性。
-
watchEffect有点像computed:
- 但computed注重的计算出来的值(回调函数的返回值),所以必须要写返回值。
- 而watchEffect更注重的是过程(回调函数的函数体),所以不用写返回值。
//watchEffect所指定的回调中用到的数据只要发生变化,则直接重新执行回调。 watchEffect(()=>{ const x1 = sum.value const x2 = person.age console.log('watchEffect配置的回调执行了') })
》
<template>
<h2>当前求和为:{{sum}}</h2>
<button @click="sum++">点我+1</button>
<hr>
<h2>当前的信息为:{{msg}}</h2>
<button @click="msg+='!'">修改信息</button>
<hr>
<h2>姓名:{{person.name}}</h2>
<h2>年龄:{{person.age}}</h2>
<h2>薪资:{{person.job.j1.salary}}K</h2>
<button @click="person.name+='~'">修改姓名</button>
<button @click="person.age++">增长年龄</button>
<button @click="person.job.j1.salary++">涨薪</button>
<button @click="person.k = {}">修改person.k</button>
<button @click="person.k.g.s++">person.k.g.s++(没有用,点击没反应)</button>
</template>
<script>
import {ref,reactive,watch,watchEffect} from 'vue'
export default {
name: 'Demo',
setup(){
//数据
let sum = ref(0)
let msg = ref('你好啊')
let person = reactive({
name:'张三',
age:18,
job:{
j1:{
salary:20
}
},
k: {
g: {
s: 3
}
}
})
//监视
/* watch(sum,(newValue,oldValue)=>{
console.log('sum的值变化了',newValue,oldValue)
},{immediate:true}) */
watchEffect(()=>{
const x1 = sum.value // 当sum.value发生变化时, 当前所在回调函数执行
const x2 = person.job.j1.salary// 当person.job.j1.salary发生变化时, 当前所在回调函数执行
const x3 = person.age // 当person.age发生变化时, 当前所在回调函数执行
const x4 = person.k // 当person.k发生变化时, 当前所在回调函数执行
console.log('watchEffect所指定的回调执行了')
})
//返回一个对象(常用)
return {
sum,
msg,
person
}
}
}
</script>
12. Vue3生命周期
- Vue3.0中可以继续使用Vue2.x中的生命周期钩子,但有有两个被更名:
beforeDestroy
改名为beforeUnmount
destroyed
改名为unmounted
- Vue3.0也提供了 Composition API 形式的生命周期钩子,与Vue2.x中钩子对应关系如下:
beforeCreate
===>setup()
created
=======>setup()
beforeMount
===>onBeforeMount
mounted
=======>onMounted
beforeUpdate
===>onBeforeUpdate
updated
=======>onUpdated
beforeUnmount
==>onBeforeUnmount
unmounted
=====>onUnmounted
App.vue
<template>
<button @click="isShowDemo = !isShowDemo">切换隐藏/显示</button>
<Demo v-if="isShowDemo"/>
</template>
<script>
import {ref} from 'vue'
import Demo from './components/Demo'
export default {
name: 'App',
components:{Demo},
setup() {
let isShowDemo = ref(true)
return {isShowDemo}
}
}
</script>
Demo.vue
<template>
<h2>当前求和为:{{sum}}</h2>
<button @click="sum++">点我+1</button>
</template>
<script>
import {ref,onBeforeMount,onMounted,onBeforeUpdate,
onUpdated,onBeforeUnmount,onUnmounted} from 'vue'
export default {
name: 'Demo',
setup(){
console.log('---setup---')
//数据
let sum = ref(0)
//通过组合式API的形式去使用生命周期钩子
onBeforeMount(()=>{
console.log('---onBeforeMount---')
})
onMounted(()=>{
console.log('---onMounted---')
})
onBeforeUpdate(()=>{
console.log('---onBeforeUpdate---')
})
onUpdated(()=>{
console.log('---onUpdated---')
})
onBeforeUnmount(()=>{
console.log('---onBeforeUnmount---')
})
onUnmounted(()=>{
console.log('---onUnmounted---')
})
//返回一个对象(常用)
return {sum}
},
//通过配置项的形式使用生命周期钩子
//#region
beforeCreate() {
console.log('---beforeCreate---')
},
created() {
console.log('---created---')
},
beforeMount() {
console.log('---beforeMount---')
},
mounted() {
console.log('---mounted---')
},
beforeUpdate(){
console.log('---beforeUpdate---')
},
updated() {
console.log('---updated---')
},
beforeUnmount() {
console.log('---beforeUnmount---')
},
unmounted() {
console.log('---unmounted---')
},
//#endregion
}
</script>
13. 自定义hook函数
-
什么是hook?—— 本质是一个函数,把setup函数中使用的Composition API进行了封装。
-
类似于vue2.x中的mixin。
-
自定义hook的优势: 复用代码, 让setup中的逻辑更清楚易懂。
使用hook前
设计一个功能:将鼠标在窗口所点击的坐标,显示在页面中
App.vue
<template>
<button @click="isShowDemo = !isShowDemo">isShowDemo</button>
<Demo v-if="isShowDemo" />
</template>
<script>
import { ref } from 'vue'
import Demo from './components/Demo.vue';
export default {
name: 'App',
components: {
Demo
},
methods: {
},
setup() {
const isShowDemo = ref(true);
return {
isShowDemo
}
}
}
</script>
Demo.vue
<template>
<h2>当前求和为:{{ sum }}</h2>
<button @click="sum++">点我+1</button>
<hr/>
<div>
x: {{ point.x }}
y: {{ point.y }}
</div>
</template>
<script>
import { reactive, ref, onMounted, onBeforeUnmount } from 'vue'
export default {
name: 'Demo',
setup() {
console.log('---setup---')
//数据
let sum = ref(0)
// ---------------将被抽离的部分-开始--------------------
const point = reactive({
x:0,
y:0
})
function savePoint(event){
point.x = event.pageX
point.y = event.pageY
console.log(event.pageX, event.pageY);
}
onMounted(()=>{
window.addEventListener('click', savePoint)
})
onBeforeUnmount(()=>{
window.removeEventListener('click', savePoint)
})
// ------------------将被抽离的部分-结束--------------------
return {
sum,
point
}
}
}
</script>
使用hook
usePoint.js
将功能抽取到usePoint.js中,可将这段代码复用(当其它组件也需要这段代码时,直接引入,调用该函数即可)
import { reactive, onMounted, onBeforeUnmount } from 'vue'
export default function () {
const point = reactive({
x: 0,
y: 0
})
function savePoint(event) {
point.x = event.pageX
point.y = event.pageY
console.log(event.pageX, event.pageY);
}
onMounted(() => {
window.addEventListener('click', savePoint)
})
onBeforeUnmount(() => {
window.removeEventListener('click', savePoint)
})
return point
}
App.vue
<template>
<button @click="isShowDemo = !isShowDemo">isShowDemo</button>
<Demo v-if="isShowDemo" />
</template>
<script>
import { ref } from 'vue'
import Demo from './components/Demo.vue';
export default {
name: 'App',
components: {
Demo
},
methods: {
},
setup() {
const isShowDemo = ref(true);
return {
isShowDemo
}
}
}
</script>
Demo.vue
<template>
<h2>当前求和为:{{ sum }}</h2>
<button @click="sum++">点我+1</button>
<hr/>
<div>
x: {{ point.x }}
y: {{ point.y }}
</div>
</template>
<script>
import { ref} from 'vue'
// 引入hook
import usePoint from '@/hooks/usePoint'
export default {
name: 'Demo',
setup() {
console.log('---setup---')
// 数据
let sum = ref(0)
// 使用hook
const point = usePoint()
return {
sum,
point
}
}
}
</script>
14. toRef和toRefs
-
作用:创建一个 ref 对象,其value值指向另一个对象中的某个属性。
-
语法:
const name = toRef(person,'name')
-
应用: 要将响应式对象中的某个属性单独提供给外部使用时,并且不丢失响应式。
-
扩展:
toRefs
与toRef
功能一致,但可以批量创建多个 ref 对象,语法:toRefs(person)
问题引入
<template>
<!-- 当我想引用响应式数据时, 我必须每个上面都携带person作为前缀,因为我在setup中返回的是person -->
<h2>姓名:{{ person.name }}</h2>
<h2>年龄:{{ person.age }}</h2>
<h2>薪资:{{ person.job.j1.salary }}K</h2>
<button @click="person.name += '~'">修改姓名</button>
<button @click="person.age++">增长年龄</button>
<button @click="person.job.j1.salary++">涨薪</button>
</template>
<script>
import { reactive, toRef } from "vue"
export default {
name: "Demo",
setup() {
//数据
let person = reactive({
name: "张三",
age: 18,
job: {
j1: {
salary: 20,
},
},
});
return {
person
}
},
};
</script>
如果我们不想总是携带person前缀,那能不能像下面这样做?
<template>
<!-- 那我在setup中将person的属性都一个个暴露出来,这样就不用写前缀了 -->
<!-- 随之而来的问题:丢失响应式了!!! -->
<h2>姓名:{{ name }}</h2>
<h2>年龄:{{ age }}</h2>
<h2>薪资:{{ salary }}K</h2>
<button @click="name += '~'">修改姓名</button>
<button @click="age++">增长年龄</button>
<button @click="salary++">涨薪</button>
</template>
<script>
import { reactive, toRef } from "vue"
export default {
name: "Demo",
setup() {
//数据
let person = reactive({
name: "张三",
age: 18,
job: {
j1: {
salary: 20,
},
},
});
let name1 = person.name
console.log(name1) // 张三
// (就相当于是访问了代理对象的name属性-因为person就是Proxy实例,
// 转而调用Proxy的get方法,得到的是目标对象的name属性值)
return {
person,
name: person.name, // 直接暴露的是 张三 这个字符串,根本就没有响应式了
age: person.age,
salary: person.job.j1.salary
}
},
};
</script>
使用toRef解决问题
<template>
{{ person }}
<h2>姓名:{{ name }}</h2>
<h2>年龄:{{ age }}</h2>
<h2>薪资:{{ salary }}K</h2>
<button @click="name += '~'">修改姓名</button>
<button @click="age++">增长年龄</button>
<button @click="salary++">涨薪</button>
</template>
<script>
import { reactive, toRef } from "vue"
export default {
name: "Demo",
setup() {
//数据
let person = reactive({
name: "张三",
age: 18,
job: {
j1: {
salary: 20,
},
},
});
let name1 = person.name
console.log(name1) // 张三
// 直接将person.name交出去, 这样并不是响应式数据
// 所以,使用toRef函数,将person的name属性交出去,并且交出去后,
// 当修改这个name值时,能够同时修改到原响应式数据person的name属性值,并且页面能正常得到刷新
// 并且,从下面,我们可以看出来,toRef函数返回的是RefImpl实例对象
// 就相当于说:暴露在模板中使用的其实是toRef函数的返回值,但是这个返回值链接到的是person这个响应式数据的name属性
const name = toRef(person, 'name')
const age = toRef(person, 'age')
const salary = toRef(person.job.j1, 'salary')
// ObjectRefImpl {_object: Proxy, _key: 'name', _defaultValue: undefined, __v_isRef: true}
console.log(name)
// ObjectRefImpl {_object: Proxy, _key: 'age', _defaultValue: undefined, __v_isRef: true}
console.log(age)
// ObjectRefImpl {_object: Proxy, _key: 'salary', _defaultValue: undefined, __v_isRef: true}
console.log(salary)
return {
person,
name,
age,
salary
}
},
};
</script>
使用toRefs解决问题
<template>
{{ person }}
<h2>姓名:{{ name }}</h2>
<h2>年龄:{{ age }}</h2>
<h2>薪资:{{ job.j1.salary }}K</h2>
<button @click="name += '~'">修改姓名</button>
<button @click="age++">增长年龄</button>
<!-- 注意这里使用的是:job.j1.salary -->
<button @click="job.j1.salary++">涨薪</button>
</template>
<script>
import { reactive, toRef, toRefs } from "vue"
export default {
name: "Demo",
setup() {
//数据
let person = reactive({
name: "张三",
age: 18,
job: {
j1: {
salary: 20,
},
},
});
let name1 = person.name
console.log(name1) // 张三
const p1 = toRefs(person)
// {name: ObjectRefImpl, age: ObjectRefImpl, job: ObjectRefImpl}
console.log(p1)
// toRefs只会将person的第一层的全部属性,每一个属性都使用toRef转换,toRefs(person)的效果同如下
const name = toRef(person,'name')
const age = toRef(person,'age')
const job = toRef(person,'job')
return {
person,
// name,
// age,
// job
...toRefs(person)
}
},
};
</script>
15. shallowReactive与shallowRef
-
shallowReactive:只处理对象最外层属性(就第一层属性)的响应式(浅响应式)。
-
shallowRef:只处理基本数据类型的响应式, 不进行对象的响应式处理。
-
什么时候使用?
- 如果有一个对象数据,结构比较深, 但变化时只是外层属性变化 ===> shallowReactive。
- 如果有一个对象数据,后续功能不会修改该对象中的属性,而是生新的对象来替换 ===> shallowRef。
<template>
<h4>当前的x.y值是:{{x.y}}</h4>
<button @click="x={y:888}">点我替换x</button>
<button @click="x.y++">点我x.y++</button>
<hr>
<h4>{{person}}</h4>
<h2>姓名:{{name}}</h2>
<h2>年龄:{{age}}</h2>
<h2>薪资:{{job.j1.salary}}K</h2>
<button @click="name+='~'">修改姓名</button>
<button @click="age++">增长年龄</button>
<button @click="job.j1.salary++">涨薪</button>
</template>
<script>
import {ref,reactive,toRef,toRefs,shallowReactive,shallowRef} from 'vue'
export default {
name: 'Demo',
setup(){
// 数据
// let person = shallowReactive({ // 只考虑第一层数据的响应式,比如下面只会当name和age变化时,
// 会更新页面,而salary变化,并不会更新页面
let person = reactive({
name:'张三',
age:18,
job:{
j1:{
salary:20
}
}
})
// shallowRef会处理基本数据类型的响应式(即:如果传入的是基本类型,那跟ref没啥区别),
// 但不会处理对象类型的响应式(如果传入的是对象,当对象的里面的属性值变化,页面并不会得到刷新,
// 但是如果直接修改x,比如x={y:888},页面会刷新,
// 但是如果直接修改x.y,比如x.y++,页面不会得到刷新)
//
let x = shallowRef({
y:0
})
// 同样是RefImpl,但是里面包裹的value是Object,而不是使用ref函数获得的Proxy,所以不是响应式的
console.log('******',x)
//返回一个对象(常用)
return {
x,
person,
...toRefs(person)
}
}
}
</script>
16. readonly 与 shallowReadonly
- readonly: 让一个响应式数据变为只读的(深只读)。
- shallowReadonly:让一个响应式数据变为只读的(浅只读)。
- 应用场景: 不希望数据被修改时。
<template>
<h4>当前求和为:{{sum}}</h4>
<button @click="sum++">点我++</button>
<hr>
<h2>姓名:{{name}}</h2>
<h2>年龄:{{age}}</h2>
<h2>薪资:{{job.j1.salary}}K</h2>
<button @click="name+='~'">修改姓名</button>
<button @click="age++">增长年龄</button>
<button @click="job.j1.salary++">涨薪</button>
</template>
<script>
import {ref,reactive,toRefs,readonly,shallowReadonly} from 'vue'
export default {
name: 'Demo',
setup(){
//数据
let sum = ref(0)
let person = reactive({
name:'张三',
age:18,
job:{
j1:{
salary:20
}
}
})
// 传入一个响应式的数据,让它变成只读的
// person中的所有属性都不允许修改(即:点击上面的修改按钮,修改了name、age、salary都没效果,
// 控制台会有警告,并且person身上的属性数据都没改)
person = readonly(person)
// shallowReadonly只考虑对象数据中的第一层属性(即:修改了name、age没效果,控制台会有警告,
// person身上的name和age属性数据都没改,
// 但修改了salary,则salary值会改,并且页面会更新)
// person = shallowReadonly(person)
// sum是基本数据类型的响应式数据,没有层次可言,下面2个都可以,建议使用readonly
// sum = readonly(sum)
// sum = shallowReadonly(sum)
//返回一个对象(常用)
return {
sum,
...toRefs(person)
}
}
}
</script>
17. toRaw与markRaw
- toRaw:
- 作用:将一个由
reactive
生成的响应式对象转为普通对象。 - 使用场景:用于读取响应式对象对应的普通对象,对这个普通对象的所有操作,不会引起页面更新。
- 作用:将一个由
- markRaw:
- 作用:标记一个对象,使其永远不会再成为响应式对象。
- 应用场景:
- 有些值不应被设置为响应式的,例如复杂的第三方类库等。
- 当渲染具有不可变数据源的大列表时,跳过响应式转换可以提高性能。
<template>
<h4>当前求和为:{{ sum }}</h4>
<button @click="sum++">点我++</button>
<hr>
<h2>姓名:{{ name }}</h2>
<h2>年龄:{{ age }}</h2>
<h2>薪资:{{ job.j1.salary }}K</h2>
<h3 v-show="person.car">座驾信息:{{ person.car }}</h3>
<button @click="name += '~'">修改姓名</button>
<button @click="age++">增长年龄</button>
<button @click="job.j1.salary++">涨薪</button>
<button @click="showRawPerson">输出最原始的person</button>
<button @click="addCar">给人添加一台车</button>
<button @click="person.car.name += '!'">换车名</button>
<button @click="changePrice">换价格</button>
</template>
<script>
import { ref, reactive, toRefs, toRaw, markRaw } from 'vue'
export default {
name: 'Demo',
setup() {
//数据
let sum = ref(0)
// 原person对象
let rawPerson = {
name: '张三',
age: 18,
job: {
j1: {
salary: 20
}
}
}
let person = reactive(rawPerson)
function showRawPerson() {
const p = toRaw(person)
console.log(toRaw(person) === rawPerson); // true (证明toRaw获取到的是原person对象)
p.age++ // 直接修改原对象(它不是响应式数据),因此页面不会更新
console.log(p)
console.log(toRaw(sum)); // RefImpl {__v_isShallow: false, dep: Set(1), __v_isRef: true,
// _rawValue: 0, _value: 0}
// 返回的仍然是响应式的,同sum
}
// 给person添加一个car属性
function addCar() {
let car = { name: '奔驰', price: 40 }
// person.car = car // 当往person(person是Proxy实例对象)上添加car这个属性时,
// 这个car属性(包括car里面的每一级属性)也变成了响应式
person.car = markRaw(car) // 但是有的时候,我们不想添加的这个car属性变成响应式的,
// 就可以像这里一样使用markRaw函数,然后添加到person上
console.log(markRaw(car));// {name: '奔驰', price: 40, __v_skip: true},
// 其实就是给car添加了个__v_skip属性,值为true
}
// 修改person的car的price
function changePrice() {
person.car.price++
console.log(person.car.price)
}
return {
sum,
person,
...toRefs(person),
showRawPerson,
addCar,
changePrice
}
}
}
</script>
18. customRef
-
作用:创建一个自定义的 ref,并对其依赖项跟踪和更新触发进行显式控制。
-
实现防抖效果:
<template> <input type="text" v-model="keywords"> <h3>{{ keywords }}</h3> </template> <script> import { ref,customRef } from 'vue' export default { name: 'App', components: { }, methods: { }, setup() { // 自定义一个ref——名为:myRef function myRef(value,delay) { let timer; return customRef((track,trigger)=> { console.log('factory function executing...'); return { get(){ console.log(`有人从myRef这个容器中读取数据了,我把${value}给他了`) console.log('-value-'); // 下面不调用一下track()的话,当修改value值时, 这个-value-都不打印的 // (即:此时修改了value值,但get方法没有执行,感觉很奇怪) track() // 通知Vue追踪value的变化(提前和get商量一下,让他认为这个value是有用的) //(解释:提前通知value会改变,随时做好改变的准备) // 我觉得应该是第一次解析模板时,读取到keywords,这个时候get方法一定会至少调用一次, // 而在这次的过程中,就会根据逻辑,看是否在get方法里执行了track方法,如果执行了, // 那么后面,vue重新解析模板读取keywords时,就有理由重新调用这个get方法, // 如果第一次没有调用过track,那vue就有理由不调用get return value }, set(newValue){ console.log(`有人把myRef这个容器中数据改为了:${newValue}`) value = newValue // 因为get里面访问的是value,模板里面读取的结果就是get的返回值, // 所以在这里修改value值 clearTimeout(timer) // 如果之前存在定时器,就清除掉它 timer = setTimeout(function() { trigger() // 通知Vue去重新解析模板 },500) } } }) } // let keywords = ref('hello') //使用Vue提供的ref(自动挡) // 当模板中读取keywords时, myRef中定义的get方法会被调用; // 当模板中通过v-model,从而影响keywords发生变化时, myRef中定义的set方法会被调用; let keywords = myRef('hello',500) //使用程序员自定义的ref(手动挡) console.log('myRef done'); return { keywords } } } </script>
19. provide 与 inject
-
作用:实现祖与后代组件间通信
-
套路:父组件有一个
provide
选项来提供数据,后代组件有一个inject
选项来开始使用这些数据 -
具体写法:
-
祖组件中:
setup(){ ...... let car = reactive({name:'奔驰',price:'40万'}) provide('car',car) ...... }
-
后代组件中:
setup(props,context){ ...... const car = inject('car') return {car} ...... }
-
App.vue
<template>
<div class="app">
<h3>我是App组件(祖), {{ name }} - {{ price }}</h3>
<button @click="name+='~'">changeCarName</button>
<Child/>
</div>
</template>
<script>
import Child from '@/components/Child'
import { reactive, toRefs, provide } from 'vue'
export default {
name: 'App',
components: {Child},
setup() {
const car = reactive({name: '奔驰', price: '40w'})
provide('car', car) // 给自己的后代组件(包括子组件及孙组件)传递数据
return {
...toRefs(car)
}
}
}
</script>
<style scoped>
.app{
background-color: gray;
padding: 10px;
}
</style>
Child.vue
<template>
<div class="child">
<h3>我是Child组件(子){{ car }}</h3>
<Son/>
</div>
</template>
<script>
import Son from '@/components/Son'
import { inject } from 'vue'
export default {
name: 'Child',
components: {
Son
},
setup() {
const car = inject('car') // 子组件中也可以使用父组件中'提供'的数据
return {
car
}
}
}
</script>
<style scoped>
.child{
background-color: skyblue;
padding: 10px;
}
</style>
Son.vue
<template>
<div class="son">
<h3>我是Son组件(孙){{ car }}</h3>
</div>
</template>
<script>
import { inject } from 'vue'
export default {
name: 'Son',
setup() {
const car = inject('car')
console.log('son-car',car); // son-car Proxy {name: '奔驰', price: '40w'}(car是响应式数据)
return {
car
}
}
}
</script>
<style scoped>
.son{
background-color: orange;
padding: 10px;
}
</style>
20. 响应式数据的判断
- isRef: 检查一个值是否为一个 ref 对象
- isReactive: 检查一个对象是否是由
reactive
创建的响应式代理 - isReadonly: 检查一个对象是否是由
readonly
创建的只读代理 - isProxy: 检查一个对象是否是由
reactive
或者readonly
方法创建的代理
<template>
<h3>我是App组件</h3>
</template>
<script>
import {ref, reactive,toRefs,readonly,isRef,isReactive,isReadonly,isProxy } from 'vue'
export default {
name:'App',
setup(){
let car = reactive({name:'奔驰',price:'40W'})
let sum = ref(0)
let car2 = readonly(car)
console.log(isRef(sum)) // true
console.log(isReactive(car)) // true
console.log(isReadonly(car2)) // true
console.log(isProxy(car)) // true
console.log(isProxy(car2)) // true
console.log(isProxy(sum)) // false
return {...toRefs(car)}
}
}
</script>
<style>
.app{
background-color: gray;
padding: 10px;
}
</style>
21. Composition API 的优势
1. Options API 存在的问题
使用传统OptionsAPI中,新增或者修改一个需求,就需要分别在data,methods,computed里修改 。
2. Composition API 的优势
22. Fragment组件
- 在Vue2中: 组件必须有一个根标签
- 在Vue3中: 组件可以没有根标签, 内部会将多个标签包含在一个Fragment虚拟元素中
- 好处: 减少标签层级, 减小内存占用
23. Teleport
-
什么是Teleport?——
Teleport
是一种能够将我们的组件html结构移动到指定位置的技术。<teleport to="移动位置"> <div v-if="isShow" class="mask"> <div class="dialog"> <h3>我是一个弹窗</h3> <button @click="isShow = false">关闭弹窗</button> </div> </div> </teleport>
示例
将弹窗添加到body元素中,这样就不会影响到样式
<template>
<div>
<button @click="isShow = true">点我弹个窗</button>
<!-- 当前是找到body标签,这里还可以写id选择器 -->
<teleport to="body">
<div v-if="isShow" class="mask">
<div class="dialog">
<h3>我是一个弹窗</h3>
<h4>一些内容</h4>
<h4>一些内容</h4>
<h4>一些内容</h4>
<button @click="isShow = false">关闭弹窗</button>
</div>
</div>
</teleport>
</div>
</template>
<script>
import {ref} from 'vue'
export default {
name:'Dialog',
setup(){
let isShow = ref(false)
return {isShow}
}
}
</script>
<style>
.mask{
position: absolute;
top: 0;bottom: 0;left: 0;right: 0;
background-color: rgba(0, 0, 0, 0.5);
}
.dialog{
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%,-50%);
text-align: center;
width: 300px;
height: 300px;
background-color: green;
}
</style>
24. Suspense
-
等待异步组件时渲染一些额外内容,让应用有更好的用户体验
-
使用步骤:
-
异步引入组件
import {defineAsyncComponent} from 'vue' const Child = defineAsyncComponent(()=>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>
-
网速慢1
App.vue
<template>
<div class="app">
<h3>我是App组件</h3>
<Child/>
</div>
</template>
<script>
// import Child from './components/Child' // 静态引入
import {defineAsyncComponent} from 'vue'
const Child = defineAsyncComponent(()=> import('@/components/Child') ) // 异步引入
export default {
name:'App',
components:{Child},
}
</script>
<style>
.app{
background-color: gray;
padding: 10px;
}
</style>
Child.vue
<template>
<div class="child">
<h3>我是Child组件</h3>
</div>
</template>
<script>
export default {
name:'Child',
}
</script>
<style>
.child{
background-color: skyblue;
padding: 10px;
}
</style>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kxi6CKi7-1678281314386)(assets/网速慢1.gif)]
网速慢2(Suspense)
App.vue
<template>
<div class="app">
<h3>我是App组件</h3>
<Suspense>
<template v-slot:default>
<Child/>
</template>
<template v-slot:fallback>
<h3>请稍侯, 正在加载中...</h3>
</template>
</Suspense>
</div>
</template>
<script>
// import Child from './components/Child' // 静态引入
import {defineAsyncComponent} from 'vue'
const Child = defineAsyncComponent(()=> import('@/components/Child') ) // 异步引入
export default {
name:'App',
components:{Child},
}
</script>
<style>
.app{
background-color: gray;
padding: 10px;
}
</style>
Child.vue
<template>
<div class="child">
<h3>我是Child组件</h3>
</div>
</template>
<script>
export default {
name:'Child',
}
</script>
<style>
.child{
background-color: skyblue;
padding: 10px;
}
</style>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dDTxIyrV-1678281314387)(assets/网速慢2.gif)]
Suspense+Promise
App.vue
<template>
<div class="app">
<h3>我是App组件</h3>
<Suspense>
<template v-slot:default>
<Child/>
</template>
<template v-slot:fallback>
<h3>请稍侯, 正在加载中...</h3>
</template>
</Suspense>
</div>
</template>
<script>
// import Child from './components/Child' // 静态引入
import {defineAsyncComponent} from 'vue'
const Child = defineAsyncComponent(()=> import('@/components/Child') ) // 异步引入
export default {
name:'App',
components:{Child},
}
</script>
<style>
.app{
background-color: gray;
padding: 10px;
}
</style>
Child.vue
<template>
<div class="child">
<h3>我是Child组件</h3>
{{sum}}
</div>
</template>
<script>
import {ref} from 'vue'
export default {
name:'Child',
async setup(){ // async函数返回的一定是个Promise实例
//(setup函数的返回值是个Promise,必须结合Suspense使用)
let sum = ref(0)
let p = new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve({sum})
},3000)
})
let result = await p // 等待3秒后, result被赋值
return result // 将result,包装成Promise返回
}
}
</script>
<style>
.child{
background-color: skyblue;
padding: 10px;
}
</style>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RDqKbbL5-1678281314387)(assets/suspense+promise.gif)]
25. 全局API的转移
-
ue 2.x 有许多全局 API 和配置。
-
例如:注册全局组件、注册全局指令等。
//注册全局组件 Vue.component('MyButton', { data: () => ({ count: 0 }), template: '<button @click="count++">Clicked {{ count }} times.</button>' }) //注册全局指令 Vue.directive('focus', { inserted: el => el.focus() }
-
-
Vue3.0中对这些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
-
26. 其他改变
-
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'] // 这里没写'click', 会认为click是dom的原生点击事件,而不是自定义click事件 } </script>
-
-
移除过滤器(filter)
过滤器虽然这看起来很方便,但它需要一个自定义语法,打破大括号内表达式是 “只是 JavaScript” 的假设,这不仅有学习成本,而且有实现成本!建议用方法调用或计算属性去替换过滤器。
-
…