深入理解vue侦听器

d邓会杰
345 阅读7分钟

工作中侦听器的使用频率非常高，但是一直对侦听器总是模糊不清，什么时候监听的数据源要使用一个getter函数，watchEffect是啥，和watch有啥区别，什么时候使用，今天仔细阅读了一下vue文档，总结了本篇文章，希望对你有帮助。

侦听器的作用

侦听器用在当状态变化是执行一些具有副作用的操作，例如更改DOM,根据异步操作的结果去修改另一个状态。

在组合是API中，可以使用watch(source, callback, options)，effectWatch(callback, options)函数，当监听的响应式状态发生变化时会触发回调函数。

侦听数据源类型

watch侦听器，需要指定数据源source。侦听数据源可以是一个ref、一个计算属性、一个响应式对象、一个getter函数、多个数据源组成的数组。

<script setup> 
import { reactive, watch, watchEffect, ref, computed } from 'vue';
const count = ref(0) 
const doubleCount = computed(()=>count.value*2) 
const add = ()=>{ count.value++ } 
//监听ref。 
watch( count, 
    (newVal, oldVal) => { console.log(`count 变化,新值为${newVal},旧值为${oldVal}`); },
    { immediate: true } // 设置立即执行 
); 
//监听计算属性 
watch( doubleCount, 
    (newVal, oldVal) => { 
        console.log(`doubleCount 变化,新值为${newVal},旧值为${oldVal}`);
    },
    { immediate: true } // 设置立即执行 
); 
//监听多数据源组成的数组 
watch([count, doubleCount], ([newcount, newdoubleCount])=>{ 
    console.log(`count 变化,新值为${newcount}`);
    console.log(`doubleCount 变化,新值为${newdoubleCount}`);
}) 
</script>
<template> 
<button @click="add">+</button> 
<br/>count: {{ count }} <br/>doubleCount: {{ doubleCount }} 
</template>

如果要侦听响应式对象的属性值，需要用一个返回该属性的 getter 函数。

const obj = reactive({ count: 0 }) 
watch( () => obj.count, (count) => { console.log(`count is: ${count}`) } )

深层侦听器

watch的监听的数据源是响应式对象时，会隐式地创建一个深层侦听器，当响应式对象中嵌套的属性发生变化时会触发回调函数。

下面的示例，无论是改变属性a的值，还是改变嵌套属性b的值，都会触发侦听器回调函数的执行。这说明侦听器是深层次监听的。

<script setup>
import { reactive, watch, watchEffect, ref, computed } from 'vue';  
const obj = reactive({ a: {b: 1} })
const changeAobj = () => {
//会触发watch回调
  obj.a = {b:2}
}
const changeAobjValue = () => {
//会触发watch回调
  obj.a.b++
}
watch(obj, (newValue, oldValue) => {

  console.log(JSON.stringify(newValue))
})
</script>

<template>
  <button @click="changeAobj">改变a对象</button>  
  <button @click="changeAobjValue">改变a对象的属性值</button>  
  <br/>count: {{ obj.a.b }}
</template>

相比下面的例子，如果侦听getter函数返回的对象，只有该对象的值变化时，才会执行回调函数。对象属性值变化，不会执行回调函数。

下面例子，只有a的值发生变化会触发回调，a的属性值变化不会触发回调。因此监听getter函数返回的对象时，是浅层监听。

<script setup>
import { reactive, watch, watchEffect, ref, computed } from 'vue';  
const obj = reactive({ a: {b: 1} })
const changeAobj = () => {
 //这里会触发watch回调
   obj.a = {b:2}
}
const changeAobjValue = () => {
//这里不会触发watch回调
  obj.a.b++
}
watch(()=>obj.a, (newValue, oldValue) => {
  console.log(JSON.stringify(newValue))
})
</script>

<template>
  <button @click="changeAobj">改变a对象</button>  
  <button @click="changeAobjValue">改变a对象的属性值</button>  
  <br/>count: {{ obj.a.b }}
</template>

如果想让浅层监听转化为深层监听，可以加上deep:true选项。

<script setup>
import { reactive, watch, watchEffect, ref, computed } from 'vue';  
const obj = reactive({ a: {b: 1} })
const changeAobj = () => {
  obj.a = {b:2}
}
const changeAobjValue = () => {
  obj.a.b++
}
watch(
    ()=>obj.a, 
    (newValue, oldValue) => {
      console.log(JSON.stringify(newValue))
    },
    //加上deep属性后，changeAobj和changeAobjValue的执行，都会触发改回调函数
    { deep: true }
)
</script>

<template>
  <button @click="changeAobj">改变a对象</button>  
  <button @click="changeAobjValue">改变a对象的属性值</button>  
  <br/>count: {{ obj.a.b }}
</template>

立即执行侦听器

默认情况下，watch是懒执行的，仅当数据源发生变化时，才会执行回调，但是某些场景下，需要在创建侦听器时，立即执行一次回调。例如想请求一些初始数据，然后在相关状态更改时重新请求数据。

可以通过immediate: true选项来强制侦听器的回调立即执行。

watch(source, (newValue, oldValue) => {
  // 立即执行，且当 `source` 改变时再次执行
}, { immediate: true })

watchEffect()

watchEffect() 不需要指定数据源，允许我们自动跟踪回调的响应式依赖。

下面的示例中，watch和watchEffect效果是一样的。可以看出watchEffect是立即执行的深度侦听器。

<script setup>
import { reactive, watch, watchEffect, ref, computed } from 'vue';  
const obj = reactive({ a: {b: 1} })
const changeAobj = () => {
  obj.a = {b:2}
}
const changeAobjValue = () => {
  obj.a.b++
}

watch(
    ()=>obj.a, 
    (val)=>{
      console.log('watch:' + JSON.stringify(val))
    }, 
    {
      immediate: true,
      deep: true
    }
)

watchEffect(() => {
  console.log('watchEffect:'+JSON.stringify(obj.a))
})
  
</script>

<template>
  <button @click="changeAobj">改变a对象</button>  
  <button @click="changeAobjValue">改变a对象的属性值</button>  
  <br/>count: {{ obj.a.b }}
</template>

对于有多个依赖项的侦听器来说，使用watchEffect() 可以消除手动维护依赖列表的负担。

<script setup>
import { reactive, watch, watchEffect, ref, computed } from 'vue';  
const obj = reactive({ a: {b: 1} })
const count = ref(0)
const changeA = () => {
  obj.a = {b:2}
}
const changeCount = () => {
  obj.a.b++
}
watch([()=>obj.a, count], (val)=>{
  console.log("watch")
  console.log('obj.a:'+JSON.stringify(obj.a))
  console.log('count:'+JSON.stringify(count.value))}, 
{
  immediate: true,
  deep: true
})
 
 //同时监听obj.a和count的变化，不需要手动维护依赖列表    
watchEffect(() => {
  console.log("watchEffect")
  console.log('obj.a:'+JSON.stringify(obj.a))
  console.log('count:'+JSON.stringify(count.value))
})
  
</script>

<template>
  <button @click="changeA">改变a对象</button>  
  <button @click="changeCount">改变count</button>  
  <br/>count: {{ obj.a.b }}
</template>

此外，如果你需要侦听一个嵌套数据结构中的几个属性，watchEffect() 可能会比深度侦听器更有效，因为它将只跟踪回调中被使用到的属性，而不是递归地跟踪所有的属性。

下面示例可以看出，watch监听响应式对象时，深度监听和watchEffect的深度监听还不一样，watch会跟踪数据源的所有属性值，包括嵌套对象的属性值。watchEffect只会监听使用到的属性值，因此watchEffect更有效。

<script setup>
import { reactive, watch, watchEffect} from 'vue';
  
const obj = reactive({ 
  a: 1,
  b: 1,
  c: 1,
  d:{d:1}
})
//会触发watch和watchEffect
const changeA = () => {
  obj.a++
}
//会触发watch和watchEffect
const changeB = () => {
  obj.b++
}
//仅触发watch
const changeC = () => {
  obj.c++
}
//仅触发watch
const changeD = () => {
  obj.d.d++
}
watch(obj, 
(val)=>{
  console.log("watch")
  console.log('obj.a+obj.b:'+obj.a+obj.b)
})

watchEffect(() => {
  console.log("watchEffect")
  console.log('obj.a+obj.b:'+obj.a+obj.b)
})
  
</script>

<template>
  <button @click="changeA">改变obj.a</button>  
  <button @click="changeB">改变obj.b</button>  
  <button @click="changeC">改变obj.c</button>  
  <button @click="changeD">改变obj.d.d</button>  
  <br/>{{ obj.c}}
</template>

watch和watchEffect的区别

watch 和 watchEffect 都能响应式地执行有副作用的回调。它们之间的主要区别是追踪响应式依赖的方式：

  • watch 只追踪明确侦听的数据源。它不会追踪任何在回调中访问到的东西。另外，仅在数据源确实改变时才会触发回调。watch 会避免在发生副作用时追踪依赖，因此，我们能更加精确地控制回调函数的触发时机。
  • watchEffect，则会在副作用发生期间追踪依赖。它会在同步执行过程中，自动追踪所有能访问到的响应式属性。这更方便，而且代码往往更简洁，但有时其响应性依赖关系会不那么明确。

回调触发机制

当你更改了响应式状态，它可能会同时触发 Vue 组件更新和侦听器回调。默认情况下，用户创建的侦听器回调，都会在 Vue 组件更新之前被调用。这意味着你在侦听器回调中访问的 DOM 将是被 Vue 更新之前的状态。

如果想在侦听器回调中能访问被 Vue 更新之后的 DOM，你需要指明 flush: 'post' 选项：

watch(source, callback, {
  flush: 'post'
})

watchEffect(callback, {
  flush: 'post'
})

后置刷新的 watchEffect() 有个更方便的别名 watchPostEffect()：

import { watchPostEffect } from 'vue'

watchPostEffect(() => {
  /* 在 Vue 更新后执行 */
})

停止侦听器

在 setup() 或<script setup>中用同步语句创建的侦听器，会自动绑定到宿主组件实例上，并且会在宿主组件卸载时自动停止。因此，在大多数情况下，你无需关心怎么停止一个侦听器。

<script setup>
import { watchEffect } from 'vue'


// 它会自动停止
watchEffect(() => {})


// ...这个则不会！
setTimeout(() => {
  watchEffect(() => {})
}, 100)
</script>

要手动停止一个侦听器，请调用 watch 或 watchEffect 返回的函数：

const unwatch = watchEffect(() => {}) // ...当该侦听器不再需要时 unwatch()

注意，需要异步创建侦听器的情况很少，请尽可能选择同步创建。如果需要等待一些异步数据，你可以使用条件式的侦听逻辑：

// 需要异步请求得到的数据
const data = ref(null)

watchEffect(() => {
  if (data.value) {
    // 数据加载后执行某些操作...
  }
})

总结

  1. watch(source, callback, options)函数的第一个参数可以是一个ref(包括计算属性)、一个响应式对象、一个getter函数、多个数据源组成的数组。当监听响应式对象的属性时，需要使用getter函数返回该属性。
  2. watch监听响应式对象时，默认是深度监听。其他情况需要使用{deep:true}选项指定。
  3. watch默认是懒执行的，仅当数据源发生变化时，才会执行回调。可以使用{immdiate:true}选项时，会立即执行。
  4. watchEffect(callback， options)，会自动侦听回调函数中用到的响应式属性，watchEffect是立即执行的、深度监听的、效率更高。
  5. 侦听器默认是在dom更新前执行，使用{flush: 'post'}选项可以是侦听器在dom更新完成后再执行
  6. 当使用异步语句创建侦听器时，需要手动停止侦听器。
avatar
文章
阅读
粉丝