Vue笔记
watch和watchEffect的区别
简述
- watchEffect不需要指定监听的属性，自动收集依赖，只要在回调中引用到了响应式的属性，只要这些属性发生改变，回调就会执行。
- watch可以获取到新值和旧值，watchEffect只能获取到新值。
- watchEffect在组件初始化的时候就会自动执行一次，用来收集依赖，watch不需要，一开始就指定了。
详解
watchEffect讲解
立即执行传入的一个函数，同时响应式追踪其依赖，并在其依赖变更时重新运行该函数。
const count = ref(0)
watchEffect(() => console.log(count.value))
// -> logs 0
setTimeout(() => {
count.value++
// -> logs 1
}, 100)
watch
watch 需要侦听特定的数据源，并在单独的回调函数中执行副作用。默认情况下，它也是惰性的——即回调仅在侦听源发生变化时被调用。
使用方法：
// 侦听一个 getter
const state = reactive({ count: 0 })
watch(
() => state.count,
(count, prevCount) => {
/* ... */
}
)
// 直接侦听一个 ref
const count = ref(0)
watch(count, (count, prevCount) => {
/* ... */
})
//监听多个源
watch([fooRef, barRef], ([foo, bar], [prevFoo, prevBar]) => {
/* ... */
})
区别
执行时机：watchEffect是立即执行的，在页面加载时会主动执行一次，来收集依赖；而watch是惰性地执行副作用，它不会立即执行，但可以配置 immediate，使其主动触发
watchEffect(() => {
console.log(test.value)
})
watch (test.value,(val,oldval) => {
console.log(val)
},{ immediate: true })
//效果差不多
- 参数不同：watchEffect只需要传递一个回调函数，不需要传递侦听的数据，它会在页面加载时主动执行一次，来收集依赖；而watch至少要有两个参数（第三个参数是配置项），第一个参数是侦听的数据，第二个参数是回调函数
- 结果不同：watchEffect获取不到更改前的值；而watch可以同时获取更改前和更改后的值
相同点
watch 与 watchEffect 在手动停止侦听、清除副作用 (将 onInvalidate 作为第三个参数传递给回调)、刷新时机和调试方面有相同的行为。
其他
- 要想监听对象里的某一个属性，可以选择监听一个getter。虽然直接监听对象也可以，但是获取不到旧值
最后
具体使用哪个主要看业务需求，如果需要立即执行的话，还是用watchEffect方便点
vue3组件通信方式总结
vue3组件之间的通信方式常用七种：props、\(emit、expose/ref、\)attrs、v-model、provide/inject、vuex.
1. props
// Parent.vue 传送
<child :msg2="msg2"></child>
<script setup>
import child from "./child.vue"
import { ref, reactive } from "vue"
const msg2 = ref("这是传给子组件的信息2")
// 或者复杂类型
const msg2 = reactive(["这是传级子组件的信息2"])
</script>
// Child.vue 接收
<script setup>
// 不需要引入 直接使用
// import { defineProps } from "vue"
const props = defineProps({
// 写法一
msg2: String
// 写法二
msg2:{
type:String,
default:""
}
})
console.log(props) // { msg2:"这是传级子组件的信息2" }
</script>
2. $emit
// Child.vue 派发
<template>
// 写法一
<button @click="emit('myClick')">按钮</buttom>
// 写法二
<button @click="handleClick">按钮</buttom>
</template>
<script setup>
// 方法一 适用于Vue3.2版本 不需要引入
// import { defineEmits } from "vue"
// 对应写法一
const emit = defineEmits(["myClick","myClick2"])
// 对应写法二
const handleClick = ()=>{
emit("myClick", "这是发送给父组件的信息")
}
// 方法二 不适用于 Vue3.2版本，该版本 useContext()已废弃
import { useContext } from "vue"
const { emit } = useContext()
const handleClick = ()=>{
emit("myClick", "这是发送给父组件的信息")
}
</script>
// Parent.vue 响应
<template>
<child @myClick="onMyClick"></child>
</template>
<script setup>
import child from "./child.vue"
const onMyClick = (msg) => {
console.log(msg) // 这是父组件收到的信息
}
</script>
3.expose / ref 父组件获取子组件的属性或者调用子组件方法
// Child.vue
<script setup>
// 方法一 不适用于Vue3.2版本，该版本 useContext()已废弃
import { useContext } from "vue"
const ctx = useContext()
// 对外暴露属性方法等都可以
ctx.expose({
childName: "这是子组件的属性",
someMethod(){
console.log("这是子组件的方法")
}
})
// 方法二 适用于Vue3.2版本, 不需要引入
// import { defineExpose } from "vue"
defineExpose({
childName: "这是子组件的属性",
someMethod(){
console.log("这是子组件的方法")
}
})
</script>
// Parent.vue 注意 ref="comp"
<template>
<child ref="comp"></child>
<button @click="handlerClick">按钮</button>
</template>
<script setup>
import child from "./child.vue"
import { ref } from "vue"
const comp = ref(null)
const handlerClick = () => {
console.log(comp.value.childName) // 获取子组件对外暴露的属性
comp.value.someMethod() // 调用子组件对外暴露的方法
}
</script>
4. attrs包含父作用域里除 class 和 style 除外的非 props 属性集合
// Parent.vue 传送
<child :msg1="msg1" :msg2="msg2" title="3333"></child>
<script setup>
import child from "./child.vue"
import { ref, reactive } from "vue"
const msg1 = ref("1111")
const msg2 = ref("2222")
</script>
// Child.vue 接收
<script setup>
import { defineProps, useContext, useAttrs } from "vue"
// 3.2版本不需要引入 defineProps，直接用
const props = defineProps({
msg1: String
})
// 方法一 不适用于 Vue3.2版本，该版本 useContext()已废弃
const ctx = useContext()
// 如果没有用 props 接收 msg1 的话就是 { msg1: "1111", msg2:"2222", title: "3333" }
console.log(ctx.attrs) // { msg2:"2222", title: "3333" }
// 方法二 适用于 Vue3.2版本
const attrs = useAttrs()
console.log(attrs) // { msg2:"2222", title: "3333" }
</script>
5. v-model：可以支持多个数据双向绑定
// Parent.vue
<child v-model:key="key" v-model:value="value"></child>
<script setup>
import child from "./child.vue"
import { ref, reactive } from "vue"
const key = ref("1111")
const value = ref("2222")
</script>
// Child.vue
<template>
<button @click="handlerClick">按钮</button>
</template>
<script setup>
// 方法一 不适用于 Vue3.2版本，该版本 useContext()已废弃
import { useContext } from "vue"
const { emit } = useContext()
// 方法二 适用于 Vue3.2版本，不需要引入
// import { defineEmits } from "vue"
const emit = defineEmits(["key","value"])
// 用法
const handlerClick = () => {
emit("update:key", "新的key")
emit("update:value", "新的value")
}
</script>
6. provide / inject: 为依赖注入
provide：可以让我们指定想要提供给后代组件的数据或
inject：在任何后代组件中接收想要添加在这个组件上的数据，不管组件嵌套多深都可以直接拿来用
// Parent.vue
<script setup>
import { provide } from "vue"
provide("name", "沐华")
</script>
// Child.vue
<script setup>
import { inject } from "vue"
const name = inject("name")
console.log(name) // 沐华
</script>
7. Vuex
// store/index.js
import { createStore } from "vuex"
export default createStore({
state:{ count: 1 },
getters:{
getCount: state => state.count
},
mutations:{
add(state){
state.count++
}
}
})
// main.js
import { createApp } from "vue"
import App from "./App.vue"
import store from "./store"
createApp(App).use(store).mount("#app")
// Page.vue
// 方法一 直接使用
<template>
<div>{{ $store.state.count }}</div>
<button @click="$store.commit('add')">按钮</button>
</template>
// 方法二 获取
<script setup>
import { useStore, computed } from "vuex"
const store = useStore()
console.log(store.state.count) // 1
const count = computed(()=>store.state.count) // 响应式，会随着vuex数据改变而改变
console.log(count) // 1
</script>
reactive和ref区别
reactive 和 ref 都是用来定义响应式数据的。reactive更推荐去定义复杂的数据类型 ，ref 更推荐定义基本类型。
ref 和 reactive 本质我们可以简单地理解为：ref是对reactive的二次包装， ref定义的数据访问的时候要多一个.value。那么，使用ref可以定义基本数据类型，ref当然也可以定义数组和对象。
setup注意点
- 从 setup 返回的 refs 在模板中访问时是被自动浅解包的，因此不应在模板中使用 .value
- 在setup中避免使用this
provide和inject
provide默认不能向下传递数据（非响应式的）。使用闭包可以解决这个问题：
provide() {
return {
// 第一种，不能向下传递
// message:this.message
// 第二种，使用函数传递闭包
message:()=>this.message
}
},
v-model是语法糖
v-model本质上是两个操作：
- v-bind绑定一个value属性
- v-on给当前元素添加一个input事件
v-for关于绑定key的理解
绑定key是为了给vue一个提示，以便他能跟踪每个结点的身份，从而重用和重新排序现有元素。一个列表项要有一个key值,这个key值如果唯一且未发生变化,则dom就会被复用,反之则需要重新生成。
即：这个key值相同，就认为是同一个元素嘛，就会复用，稍微修改一些变化的值就行；而key不同，就说明是不同元素，需要重新创建节点。
v-if和v-show的区别
- v-if控制元素的创建和销毁
- v-show控制元素的display
- 频繁切换状态用v-show
- 条件很少改变，一次性的，使用v-if
computed和watch的区别
先看代码，两者怎么实现的：
<div id="app">
<input type="text" v-model="firstName"><br>
<input type="text" v-model="lastName"><br>
<h2>{{fullName()}}</h2>
</div>
<script>
var app = new Vue({
el: '#app',
data: {
firstName: '张',
lastName: '三',
fullName: '张三'
},
// watch 监视、监听，在此处定义监听器
// 作用：监视data中的数据变化
watch: {
// 侦听器以函数的形式定义，函数名称就是监视的数据的名称，参数就是数据变化后的新值
firstName(val) {
console.log(val);
this.fullName = val + this.lastName;
},
lastName(val) {
console.log(val);
this.fullName = this.firstName + val;
}
}
})
//计算属性方式实现
var app = new Vue({
el: '#app',
data: {
firstName: '张',
lastName: '三',
},
computed: {
// 计算属性在某些场景下（此示例），要比侦听器代码精简。
fullName() {
return this.firstName + this.lastName;
}
}
})
</script>
computed和watch的区别
- computed是计算属性；watch是监听，监听data中的数据变化。
- computed支持缓存，当其依赖的属性的值发生变化时，计算属性会重新计算，反之，则使用缓存中的属性值；watch不支持缓存，当对应属性发生变化的时候，响应执行。
- computed不支持异步，有异步操作时无法监听数据变化；watch支持异步操作。
- computed第一次加载时就监听；watch默认第一次加载时不监听。
- immediate 组件创建时刻执行与否
immediate: true,第一次加载时监听（默认为false）
- deep 深度监听 不推荐使用(非常的消耗性能)
监听的属性是对象的话 不开启deep 对象子属性变化不会触发watch
开启了deep 对象内部所有子属性变化 都会触发watch
- computed中的函数必须调用return；watch不是。
- 使用场景：
computed：一个属性受到多个属性影响，如：购物车商品结算。
watch：一个数据影响多条数据，如：搜索数据。
数据变化响应，执行异步操作，或高性能消耗的操作，watch为最佳选择。
