watch和watchEffect都是vue3中的监听器，但是在写法和使用上是有区别的，主要是介绍一下watch和watchEffect的使用方法以及他们之间的区别。
watch 的工作原理：侦听特定的数据源，并在回调函数中执行副作用。它默认是惰性的——只有当被侦听的源发生变化时才执行回调，不过，可以通过配置 immediate 为 true 来指定初始时立即执行第一次。可以通过配置 deep 为 true，来指定深度监视
immdiate: 默认情况下，侦听器需要 data 后面值改变了才会生效，若需要侦听器一进入页面就生效，那就需要使用 immediate
deep: 默认情况下，侦听器只会监听数据本身的改变，若要进行深度监听，那就需要使用 deep。 immediate 和 deep 配置在第三个参数对象里
第一个参数：监听谁，第二个参数：回调函数，第三个参数：配置对象
watch监听单个数据
<template>
<input type="text" v-model="text1" />
</template>
<script setup>
import { ref, watch } from 'vue'
const text1 = ref('')
watch(text1, (newVal, oldVal) => {console.log('监听单个数据', newVal, oldVal)
})
</script>
监听多个数据(初始值为空，并没有进行打印)
<template>
<input type="text" v-model="text1" placeholder="text1值" />
<hr />
<input type="text" v-model="text2" placeholder="text2值" />
</template>
<script setup>
import { ref, watch, reactive } from 'vue'
const text1 = ref('')
const text2 = ref('')
watch([text1,text2], (newValue, oldValue) => {
console.log('监听一组数据变化', newValue, oldValue)
})
// { immediate: true }
</script>
监听一个对象--问题
<template>
name: <input type="text" v-model="student.name" />
<hr/>
age: <input type="number" v-model="student.age" />
</template>
<script setup> import { reactive, watch } from 'vue'
const student = reactive({name: '',age: ''
})
watch(student, (newVal, oldVal) => {
console.log('newVal', newVal)
console.log('oldVal', newVal)
}) </script>
监听对象的某一个值
<template>
name: <input type="text" v-model="student.name" />
<hr />
age: <input type="number" v-model="student.age" />
</template>
<script lang="ts" setup>
import { reactive, watch } from 'vue'
const student = reactive({
name: '', age: ''
})
watch(() => student.name, (newVal, oldVal) => {
console.log('newVal', newVal)
console.log('oldVal', newVal)
}, {
deep: true, immediate: true
})
</script>
遇到的坑：
1.监视reactive定义的响应式数据时：oldValue无法正确获取、强制开启了深度监视（deep配置失效）
<template>
<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>
<hr />
<input type="text" v-model="text1" />
</template>
<script>
import { reactive, watch, ref } from 'vue'
export default {
setup() {
//数据
let person = reactive({
name: '张三',
age: 18,
job: {
j1: {
salary: 20
}
}
})
const text1 = ref('')
/* 情况三：监视reactive所定义的一个响应式数据的全部属性
1.注意：此处无法正确的获取oldValue
2.注意：强制开启了深度监视（deep配置无效）-不管嵌套有多深
*/
watch(person, (newValue, oldValue) => {
console.log('person变化了', newValue, oldValue)
}, { deep: false }) //此处的deep配置无效 */
watch(text1, (newVal, oldVal) => {
console.log('监听单个数据', newVal, oldVal)
})
//返回一个对象（常用）
return {
person, text1
}
}
}
</script>
2.监视reactive定义的响应式数据中某个属性时：deep配置有效
<template>
<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>
<hr />
<input type="text" v-model="text1" />
</template>
<script>
import { reactive, watch, ref } from 'vue'
export default {
setup() {
//数据
let person = reactive({
name: '张三',
age: 18,
job: {
j1: {
salary: 20
}
}
})
const text1 = ref('')
/* 情况三：监视reactive所定义的一个响应式数据的全部属性
1.注意：此处无法正确的获取oldValue
2.注意：强制开启了深度监视（deep配置无效）-不管嵌套有多深
*/
watch(person, (newValue, oldValue) => {
console.log('person变化了', newValue, oldValue)
}, { deep: false }) //此处的deep配置无效 */
watch(text1, (newVal, oldVal) => {
console.log('监听单个数据', newVal, oldVal)
})
watch(() => person.age, (newValue, oldValue) => {
console.log('person的age变化了', newValue, oldValue)
}, { deep: true }) //此处由于监视的是reactive素定义的对象中的某个属性，所以deep配置有效
//返回一个对象（常用）
return {
person, text1
}
}
}
</script>
3.使用ref定义数组时：(触发changeArr的时候，监听不到)
<template>
<button @click="changeArr">按钮</button>
</template>
<script>
import { reactive, watch, ref } from 'vue'
export default {
setup() {
const array = ref([1, 2, 3]);
const changeArr = () => {
console.log('触发');
array.value = [];
}
watch(array.value, (now, old) => {
console.log(now, old); // 触发changeArr的时候，监听不到
})
return {
array, changeArr
}
}
}
</script>
解决方案：
<template>
<button @click="changeArr">按钮</button>
</template>
<script>
import { reactive, watch, ref } from 'vue'
export default {
setup() {
const array = ref([1, 2, 3]);
const changeArr = () => {
console.log('触发');
array.value = [];
}
// watch(array.value, (now, old) => {
// console.log(now, old); // 触发changeArr的时候，监听不到
// })
watch(() => [array.value], (now, old) => {
console.log(now, old)
})
return {
array, changeArr
}
}
}
</script>
watchEffect
watchEffect 函数的特点：
watch() 是懒执行的：当数据源发生变化时，才会执行回调。但在某些场景中，我们希望在创建侦听器时，立即执行一遍回调。
watchEffect相当于将watch 的依赖源和回调函数合并，当任何你有用到的响应式依赖更新时，该回调函数便会重新执行。不同于 watch，watchEffect 的回调函数会被立即执行（即 { immediate: true }）
简单来说，watchEffect 是 Vue3 中的一个响应式 API，它允许你监听响应式状态的变化，并在其发生变化时触发副作用函数。这个特性非常有用，在我们需要对响应式数据进行操作的时候，我们可以在监听到变化后马上做出反应。
<template>
name: <input type="text" v-model="student.name" />
age: <input type="number" v-model="student.age" />
</template>
<script setup>
import { reactive, watchEffect } from 'vue'
const student = reactive({name: '',age: ''
})
watchEffect(() => {console.log('name: ',student.name, 'age: ', student.age)
})
</script>
watcheffect停止监听
<template>
<div>
<input type="text" v-model="obj.name">
<button @click="stopWatchEffect">停止监听</button>
</div>
</template>
<script>
import { reactive, watchEffect } from 'vue';
export default {
setup() {
let obj = reactive({
name: 'zs'
});
const stop = watchEffect(() => {
console.log('name:', obj.name)
})
const stopWatchEffect = () => {
console.log('停止监听')
stop();
}
return {
obj,
stopWatchEffect,
}
}
}
</script>
watchEffect的副作用
什么是副作用（side effect），简单的说副作用就是执行某种操作，如对外部可变数据或变量的修改，外部接口的调用等。watchEffect的回调函数就是一个副作用函数，因为我们使用watchEffect就是侦听到依赖的变化后执行某些操作。
Vue3的watchEffect侦听副作用传入的函数可以接收一个 onInvalidate 函数作为入参，用来注册清理失效时的回调
当以下情况发生时，这个失效回调会被触发：
import { watchEffect, ref } from 'vue'
const count = ref(0)
watchEffect((onInvalidate) => {
console.log(count.value)
onInvalidate(() => {
console.log('执行了onInvalidate')
})
})
setTimeout(()=> {
count.value++
}, 1000)
上述代码打印的顺序为： 0 -> 执行了onInvalidate，最后执行 -> 1
分析：初始化时先打印count的值0， 然后由于定时器把count的值更新为1, 此时副作用即将重新执行，因此onInvalidate的回调函数会被触发，打印执行了onInvalidate，然后执行了副作用函数，打印count的值1。
import { watchEffect, ref } from 'vue'
const count = ref(0)
const stop = watchEffect((onInvalidate) => {
console.log(count.value)
onInvalidate(() => {
console.log('执行了onInvalidate')
})
})
setTimeout(()=> {
stop()
}, 1000)
上述代码：当我们显示执行stop函数停止侦听，此时也会触发onInvalidate的回调函数。同样，watchEffect所在的组件被卸载时会隐式调用stop函数停止侦听，故也能触发onInvalidate的回调函数。
【注意】：
watchEffect 会在 Vue3 开发中大量使用，这里说几个注意点：
-
如果有多个负效应，不要粘合在一起，建议写多个 watchEffect。
watchEffect(() => {
setTimeout(() => console.log(a.val + 1), 1000);
setTimeout(() => console.log(b.val + 1), 1000);
});
//错误的
这两个 setTimeout 是两个不相关的效应，不需要同时监听 a 和 b，可以分开写
watchEffect(() => {
setTimeout(() => console.log(a.val + 1), 1000);
});
watchEffect(() => {
setTimeout(() => console.log(b.val + 1), 1000);
});
2.watchEffect 也可以放在其他生命周期函数内
onMounted(() => {
watchEffect(() => {
// access the DOM or template refs
});
}
总结
watch
懒执行副作用——需要手动指明侦听的内容，也要指明侦听的回调。
默认 immdiate 是 false，所以初始化时不会执行，仅在侦听的源数据变更时才执行回调。
不需要有返回值。
可以获得变化前的值（oldVal）
watchEffect
自动收集依赖，不需要手动传递侦听内容——自动侦听回调函数中使用到的响应式数据
默认 immdiate 是 true，所以初始化时会立即执行，同时源数据变更时也会执行回调。
不需要有返回值。
无法获得变化前的值（oldVal）
