vue3学习笔记

已于 2023-03-08 21:30:43 修改
阅读量783 收藏 1
点赞数
分类专栏： # vue学习 文章标签： 学习 vue.js 前端
于 2023-03-08 21:28:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16992475/article/details/129411879
版权

文章目录

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

  1. 理解：Vue3.0中一个新的配置项，值为一个函数。
  2. setup是所有Composition API（组合API）“ 表演的舞台 ”。
  3. 组件中所用到的：数据、方法等等，均要配置在setup中。
  4. setup函数的两种返回值：
    1. 若返回一个对象，则对象中的属性、方法, 在模板中均可以直接使用。（重点关注！）
    2. 若返回一个渲染函数：则可以自定义渲染内容。（了解）
  5. 注意点：
    1. 尽量不要与Vue2.x配置混用
      • Vue2.x配置（data、methos、computed…）中可以访问到setup中的属性、方法。
      • 但在setup中不能访问到Vue2.x配置（data、methos、computed…）。
      • 如果有重名, setup优先。
    2. setup不能是一个async函数，因为返回值不再是return的对象, 而是promise, 模板看不到return对象中的属性。（后期也可以返回一个Promise实例，但需要Suspense和异步组件的配合）
<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定义的数据：操作数据需要.value，读取数据时模板中直接读取不需要.value。
    • reactive定义的数据：操作数据与读取数据：均不需要.value。

8. setup的两个注意点

  • setup执行的时机

    • 在beforeCreate之前执行一次，this是undefined。

  • setup的参数

    • props：值为对象，包含：组件外部传递过来，且组件内部声明接收了的属性。
    • context：上下文对象
      • attrs: 值为对象，包含：组件外部传递过来，但没有在props配置中声明的属性, 相当于 this.$attrs。
      • slots: 收到的插槽内容, 相当于 this.$slots。
      • emit: 分发自定义事件的函数, 相当于 this.$emit。

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：
    • 作用：标记一个对象，使其永远不会再成为响应式对象。
    • 应用场景:
      1. 有些值不应被设置为响应式的，例如复杂的第三方类库等。
      2. 当渲染具有不可变数据源的大列表时，跳过响应式转换可以提高性能。
<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 选项来开始使用这些数据

  • 具体写法：

    1. 祖组件中：

      setup(){
	......
    let car = reactive({name:'奔驰',price:'40万'})
    provide('car',car)
    ......
}

    2. 后代组件中：

      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.xxxxapp.config.xxxx
      Vue.config.productionTip移除
      Vue.componentapp.component
      Vue.directiveapp.directive
      Vue.mixinapp.mixin
      Vue.useapp.use
      Vue.prototypeapp.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” 的假设，这不仅有学习成本，而且有实现成本！建议用方法调用或计算属性去替换过滤器。

  • …

ps酷教程
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Vue3 学习笔记
weixin_52253964的博客
10-29 868
Vue3 学习笔记
Vue3学习笔记（一）
qq_39753433的博客
08-25 639
一、创建Vue3项目1、传统创建方式2、与vite搭配使用创建vue项目。二、vue2与vue3的区别。三、setup的使用：1、setup的定义 2、setup的作用 3、响应区别 4、使用渲染函数 5、toRefs 6、computed 7、watch。四、生命周期。五、路由（router）。六、关系传值：1、父传子 2、子传父 3、父子组件双向数据传输（利用v-model传值）4、兄弟组件之间的传值（利用mitt插件）...
Vue 3 学习笔记
最新发布
qq_46735055的博客
05-23 1196
禹神最新Vue3教程学习笔记
vue3 的学习笔记
zyf13671493506的博客
11-20 359
环境配置和创建vue3项目 1.node版本要10以上 2.npm install -g @vue/cli 3.vue --version 查看版本号4.5.0以上 4.vue create vue3bases 5.第三项 6.第一个（choose Vue version），第二个(Babel)，第三个(TypeScript),倒数第三个（Unit Testing） 7.n,,,,,n 全是默认+n 1.在vscode中安装eslint 如果eslint不生效，在项目的更目录新建一个.vscode的文.
【无标题】
qq_51685537的博客
12-24 818
修改名字
vue2+vue3学习笔记
02-20
Vue2+Vue3 学习笔记 mounted 和 updated 在 Vue 中，`mounted` 和 `updated` 是两个非常重要的生命周期钩子函数。`mounted` 在页面初次加载时调用，而 `updated` 在数据改变并且要在页面重新渲染完成之后调用。...
vue3学习笔记，亲测有效，持续更新
06-14
这篇学习笔记将逐步介绍如何从零开始搭建一个 Vue3 项目，以及在开发过程中遇到的关键概念和功能。 首先，Vue3 的安装是通过命令行工具 CMD 来完成的。在你希望创建项目的位置打开终端，然后使用 Vue CLI 或 Vite ...
vue 3 学习笔记 vue3 vue3学习笔记
10-18
Vue 3 学习笔记 本文是关于 Vue 3 的学习笔记，涵盖了 Vue 3 的基础知识点，包括 Setup、Reactive、Ref、计算属性、Watch、生命周期函数、父子组件通信、Hook 等。 一、Setup Setup 是 Vue 3 中的组合式 API 的...
Vue3快速上手(Vue3学习笔记)
07-11
Vue3快速上手(Vue3学习笔记) .Vue3简介 - 2020年9月18日，Vue.js发布3.0版本，代号：One Piece（海贼王） - 耗时2年多、[2600+次提交](https://github.com/vuejs/vue-next/graphs/commit-activity)、[30+个RFC]...
vue3学习笔记及面试题
02-14
vue3学习笔记及面试题
vue3 学习笔记
XiaoPengPengs的博客
03-07 375
模板指令 同一个组件上可以使用多个v-model绑定 移除了2.0的syn修饰符 <!-- vue2.0 的写法 --> <ChildComponent :title.sync="pageTitle" /> <!-- vue3.0 的写法 --> <ChildComponent v-model:title="pageTitle" v-model:content="pageContent" /> <template v-for>
Vue3学习笔记
总柴的博客
04-13 331
Vue3学习笔记 setup = data + methods + computeds teleport组件：将其内部内容转移到目标元素中 suspense组件：加载异步组件 createApp()：创建新实例 不要再选项property或回调上使用箭头函数，因其没有this，导致报错 v-once：数据改变时，插值处的内容不会更新 <span v-once>这个将不会改变: {{ msg }}</span> v-html：双大括号会将数据解释为
vue3学习笔记尚硅谷
08-12
- *1* *2* *3* [Vue学习笔记（尚硅谷天禹老师）](https://blog.csdn.net/qq_55593227/article/details/119717498)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值