一起学习vue3Ts-computed、watch、watchEffect

computed计算属性

1、当依赖的属性的值发生变化的时候，才会触发他的更改

2、会缓存，使用时用缓存中的属性值

（1）函数形式

let computedValue = ref(25)
let indexComputed = 0
let resultValue = computed<string>(() => {
   console.log( `调用次数：${indexComputed++ }` )
   return `永远 ${computedValue.value} 岁`
})
setTimeout(function () {
   computedValue.value = 18
}, 2000)

（2）对象形式

let computedValue2 = ref<string | number>(25)
let resultValue2 = computed({
   get: ()=>{
      return computedValue2.value
   },
   set: (value)=>{
      computedValue2.value = value + '岁'
   }
})

watch侦听器

watch 需要侦听特定的数据源，并在单独的回调函数中执行副作用，注意监听对象时，旧值和新值相同的处理方法（处理方法在案例中）

1、watch第一个参数监听源

2、watch第二个参数回调函数callback(newValue, oldValue)

3、watch第三个参数一个options配置项是一个对象

（1）immediate:true //是否立即调用一次

（2）deep:true //是否开启深度监听

4、使用reactive监听深层对象开启和不开启deep 效果一样

//定义一个深拷贝
function clone<T>(obj:T):T{
   let newObj:any = Array.isArray(obj) ? [] : {}
   type objType = object | Array<T>
   if(typeof obj === 'object'){
      for(const key in obj){
         newObj[key] = typeof obj[key] == 'object' ? clone(obj[key]) : obj[key]
      }
   }else{
      newObj = obj
   }
   return newObj
}
//定义一个监听对象
let watchValue = reactive({
   person:{
      handel:{
         todo: "yes"
      }
   }
})

//在变异 (不是替换) 对象或数组时，旧值将与新值相同，可能deep属性没起作用，假设watch监听的是数组或者对象的变动，非深度监听
//利用 computed 深层监听依赖深拷贝返回新对象
let newWatchValue = computed(()=>clone(watchValue))
watch(newWatchValue, (newValue, oldValue)=>{
   console.dir("新值：")
   console.dir(newValue)
   console.dir("旧值：")
   console.dir(oldValue)
}, {
   immediate: true,
   deep: true
})
//注意：vue在watch监听时：在变异 (不是替换) 对象或数组时，旧值将与新值相同，因为它们的引用指向同一个对象/数组。Vue 不会保留变异之前值的副本。
setTimeout(()=>{
   watchValue.person.handel.todo = 'no'
}, 1000)

watchEffect高级侦听器

立即执行传入的一个函数，并响应式追踪其依赖，并在其依赖变更时重新运行该函数。

const count = ref(0)
watchEffect(
	() => console.log(count.value)
)
// -> 打印出 0
setTimeout(() => {
  count.value++
  // -> 打印出 1
}, 100)

1、停止侦听

当 watchEffect 在组件的 setup() 函数或生命周期钩子被调用时， 侦听器会被连接到该组件的生命周期，并在组件卸载时自动停止。

在一些情况下，也可以显式调用返回值以停止侦听：

const stop = watchEffect(() => {
  /* ... */
})
// 之后，停止监听
stop()

2、清除副作用

有时副作用函数会执行一些异步的副作用, 这些响应需要在其失效时清除（即完成之前状态已改变了）。所以侦听副作用传入的函数可以接收一个 onInvalidate 函数作入参, 用来注册清理失效时的回调。当以下情况发生时，这个失效回调会被触发:

• 副作用即将重新执行时
• 侦听器被停止 (如果在 setup() 或 生命周期钩子函数中使用了 watchEffect, 则在卸载组件时)

let id = ref(0)

class performAsyncOperation{
   constructor(id:string|number){
      console.log("id："+id)
   }
   cancel = ()=>{
      console.log("值改变，调用cancel")
   }
}
watchEffect((onInvalidate) => {
  //performAsyncOperation 返回一个对象 token
  const token = new performAsyncOperation(id.value)
  //当监听到 id 的变化时，会触发清理失效回调函数
  onInvalidate(() => {
    // id 改变时 或 停止侦听时
    // 取消之前的异步操作
    token.cancel()
  })
})
id.value++;

/*我们之所以是通过传入一个函数去注册失效回调，而不是从回调返回它（如 React useEffect 中的方式），是因为返回值对于异步错误处理很重要。
在执行数据请求时，副作用函数往往是一个异步函数：*/
const data = ref(null)
watchEffect(async () => {
  data.value = await fetchData(props.id)
})
//我们知道异步函数都会隐式地返回一个 Promise，但是清理函数必须要在 Promise 被 resolve 之前被注册。另外，Vue 依赖这个返回的 Promise 来自动处理 Promise 链上的潜在错误。
 

3、副作用刷新时机

Vue 的响应式系统会缓存副作用函数，并异步地刷新它们，这样可以避免同一个 Tick 中多个状态改变导致的不必要的重复调用。在核心的具体实现中, 组件的更新函数也是一个被侦听的副作用。当一个用户定义的副作用函数进入队列时, 会在所有的组件更新后执行：

<template>
  <div>{{ count }}</div>
</template>
<script>
  export default {
    setup() {
      const count = ref(0)
        watchEffect(() => {
                console.log(count.value)
              })
        return {
            count,
        }
    },
  }
</script>

在这个例子中：

? count 会在初始运行时同步打印出来

? 更改 count 时，将在组件更新后执行副作用。

请注意，初始化运行是在组件 mounted 之前执行的。因此，如果你希望在编写副作用函数时访问 DOM（或模板 ref），请在 onMounted 钩子中进行：

onMounted(() => {

  watchEffect(() => {

 			 // 在这里可以访问到 DOM 或者 template refs

  })

})

如果副作用需要同步或在组件更新之前重新运行，我们可以传递一个拥有 flush 属性的对象作为选项（默认为 'post'）：

// 同步运行
watchEffect(
  () => {
    /* ... */
  },
  {
    flush: 'sync',
  }
)

// 组件更新前执行
watchEffect(
    () => {
   	 /* ... */
    },
    {
   	 flush: 'pre',
    }
)

4、侦听器调试

onTrack 和 onTrigger 选项可用于调试一个侦听器的行为，onTrack 和 onTrigger 仅在开发模式下生效。

• 当一个 reactive 对象属性或一个 ref 作为依赖被追踪时，将调用 onTrack
• 依赖项变更导致副作用被触发时，将调用 onTrigger

这两个回调都将接收到一个包含有关所依赖项信息的调试器事件。建议在以下回调中编写 debugger 语句来检查依赖关系：

watchEffect(
  () => {
    /* 副作用的内容 */
  },
  {
    onTrigger(e) {
      debugger
    },
  }
)