8、watch数据监视

一、监视ref基本类型数据

1. 监视ref定义的【基本类型】数据

Student.vue

<template>
<div>
    <h1>watch ref类型数据</h1>
    <h1>{{ sum }}</h1>
    <button @click="addSum">sum点我加1</button>
   
</div>
</template>

<script setup lang="ts" name="Student">
    import { ref ,watch} from 'vue';
   let sum=ref(0)

   function addSum(){
    sum.value+=1
   }

//    监听sum数据变化
const stopWatch=watch(sum,(newValue,oldValue)=>{
    console.log('sum变化了',newValue,oldValue)
    if (newValue>3){
        stopWatch()
    }

})


    
</script>

<style scoped>

</style>

二、监视ref对象类型数据

1. 监视ref定义的【对象类型】数据，监视的是对象的【地址值】，若想监视对象内部的数据，要手动开启深度监视。

注意：

若修改的是ref定义的对象中的属性，newValue 和 oldValue 都是新值，因为它们是同一个对象。

若修改整个ref定义的对象，newValue 是新值， oldValue 是旧值，因为不是同一个对象了。

Student.vue

<template>
    <div>
        <h1>watch ref对象类型数据监听</h1>
        <h1>学生姓名：{{ sutdentInfo.name }}</h1>
        <h1>学生年龄：{{ sutdentInfo.age }}</h1>
        <button @click="upName">修改学生姓名</button> <br /><br /><br />
        <button @click="upAge">修改学生年龄</button><br /><br /><br />
        <button @click="upStudent">修改整个学生信息</button>


    </div>
</template>

<script setup lang="ts" name="Student">
import { ref, watch } from 'vue';
let sutdentInfo = ref({ name: "张三", age: 18 })


function upName() {
    sutdentInfo.value.name += '~'

}

function upAge() {
    sutdentInfo.value.age += 1
}

function upStudent() {
    sutdentInfo.value = { name: "李四", age: 19 }
}


/* 
    监视，情况一：监视【ref】定义的【对象类型】数据，监视的是对象的地址值，若想监视对象内部属性的变化，需要手动开启深度监视
    watch的第一个参数是：被监视的数据
    watch的第二个参数是：监视的回调
    watch的第三个参数是：配置对象（deep、immediate等等.....） 
  */
watch(sutdentInfo, (newValue, oldValue) => {
    console.log('student变化了', newValue, oldValue)


},{deep:true})



</script>

<style scoped></style>

三、监视reactive对象类型数据

监视reactive定义的【对象类型】数据，且默认开启了深度监视。

Student.vue

<template>
    <div>
        <h1>watch reactive对象类型数据监听</h1>
        <h1>学生姓名：{{ sutdentInfo.name }}</h1>
        <h1>学生年龄：{{ sutdentInfo.age }}</h1>
        <button @click="upName">修改学生姓名</button> <br /><br /><br />
        <button @click="upAge">修改学生年龄</button><br /><br /><br />
        <button @click="upStudent">修改整个学生信息</button>


    </div>
</template>

<script setup lang="ts" name="Student">
import { reactive, watch } from 'vue';
let sutdentInfo = reactive({ name: "张三", age: 18 })


function upName() {
    sutdentInfo.name += '~'

}

function upAge() {
    sutdentInfo.age += 1
}

function upStudent() {
    Object.assign(sutdentInfo,{ name: "李四", age: 19 })
}


/* 
    监视，情况一：监视【ref】定义的【对象类型】数据，监视的是对象的地址值，若想监视对象内部属性的变化，需要手动开启深度监视
    watch的第一个参数是：被监视的数据
    watch的第二个参数是：监视的回调
    watch的第三个参数是：配置对象（deep、immediate等等.....） 
  */
watch(sutdentInfo, (newValue, oldValue) => {
    console.log('student变化了', newValue, oldValue)


})



</script>

<style scoped></style>

四、监视ref和reactive对象里面的属性值

监视ref或reactive定义的【对象类型】数据中的某个属性，注意点如下：

1. 若该属性值不是【对象类型】，需要写成函数形式。
2. 若该属性值是依然是【对象类型】，可直接编，也可写成函数，建议写成函数。

结论：监视的要是对象里的属性，那么最好写函数式，注意点：若是对象监视的是地址值，需要关注对象内部，需要手动开启深度监视。

Student.vue

<template>
  <div class="person">
    <h1>情况四：监视【ref】或【reactive】定义的【对象类型】数据中的某个属性</h1>
    <h2>姓名：{{ person.name }}</h2>
    <h2>年龄：{{ person.age }}</h2>
    <h2>汽车：{{ person.car.c1 }}、{{ person.car.c2 }}</h2>
    <button @click="changeName">修改名字</button>
    <button @click="changeAge">修改年龄</button>
    <button @click="changeC1">修改第一台车</button>
    <button @click="changeC2">修改第二台车</button>
    <button @click="changeCar">修改整个车</button>
  </div>
</template>

<script lang="ts" setup name="Person">
  import {reactive,watch} from 'vue'

  // 数据
  let person = reactive({
    name:'张三',
    age:18,
    car:{
      c1:'奔驰',
      c2:'宝马'
    }
  })
  // 方法
  function changeName(){
    person.name += '~'
  }
  function changeAge(){
    person.age += 1
  }
  function changeC1(){
    person.car.c1 = '奥迪'
  }
  function changeC2(){
    person.car.c2 = '大众'
  }
  function changeCar(){
    person.car = {c1:'雅迪',c2:'爱玛'}
  }

  // 监视，情况四：监视响应式对象中的某个属性，且该属性是基本类型的，要写成函数式
  /* watch(()=> person.name,(newValue,oldValue)=>{
    console.log('person.name变化了',newValue,oldValue)
  }) */

  // 监视，情况四：监视响应式对象中的某个属性，且该属性是对象类型的，可以直接写，也能写函数，更推荐写函数
  watch(()=>person.car,(newValue,oldValue)=>{
    console.log('person.car变化了',newValue,oldValue)
  },{deep:true})
</script>

五、同时监视多个数据

Student.vue

<template>
  <div class="person">
    <h1>情况五：监视上述的多个数据</h1>
    <h2>姓名：{{ person.name }}</h2>
    <h2>年龄：{{ person.age }}</h2>
    <h2>汽车：{{ person.car.c1 }}、{{ person.car.c2 }}</h2>
    <button @click="changeName">修改名字</button>
    <button @click="changeAge">修改年龄</button>
    <button @click="changeC1">修改第一台车</button>
    <button @click="changeC2">修改第二台车</button>
    <button @click="changeCar">修改整个车</button>
  </div>
</template>

<script lang="ts" setup name="Person">
  import {reactive,watch} from 'vue'

  // 数据
  let person = reactive({
    name:'张三',
    age:18,
    car:{
      c1:'奔驰',
      c2:'宝马'
    }
  })
  // 方法
  function changeName(){
    person.name += '~'
  }
  function changeAge(){
    person.age += 1
  }
  function changeC1(){
    person.car.c1 = '奥迪'
  }
  function changeC2(){
    person.car.c2 = '大众'
  }
  function changeCar(){
    person.car = {c1:'雅迪',c2:'爱玛'}
  }

  // 监视，情况五：监视上述的多个数据
  watch([()=>person.name,person.car],(newValue,oldValue)=>{
    console.log('person.car变化了',newValue,oldValue)
  },{deep:true})

</script>