飞道的博客

Vue--》vue3中的计算属性与监视的使用讲解

290人阅读  评论(0)

computed函数

Vue2.x中的computed配置功能一致,只不过在Vue3.x中我们需要按需导入该函数。因为Vue3.x是向下兼容Vue2语法的,所以我们可以写成既有 setup 又有 Vue2中的computed函数,如下代码示例:


   
  1. <template>
  2. <h1>个人信息</h1>
  3. 姓:<input type= "text" v-model= "person.firstName"><br><br>
  4. 名:<input type= "text" v-model= "person.lastName"><br><br>
  5. 全名:<span>{{fullName}}</span>
  6. </template>
  7. <script>
  8. import { reactive } from 'vue';
  9. export default {
  10. computed:{
  11. fullName( ){
  12. return this. person. firstName+ '-' + this. person. lastName
  13. }
  14. },
  15. setup( ){
  16. // 数据
  17. let person = reactive({
  18. firstName: '张',
  19. lastName: '三'
  20. })
  21. // 返回对象出去
  22. return {
  23. person
  24. }
  25. }
  26. }
  27. </script>

这种既有Vue2又有Vue3的语法显然是不合适的,从开发者工具我们也看出来,setup和computed并列。如下图所示:

在Vue3的做法是将计算属性按需导入,在setup内部进行使用,如下:


   
  1. <template>
  2. <h1>个人信息</h1>
  3. 姓:<input type= "text" v-model= "person.firstName"><br><br>
  4. 名:<input type= "text" v-model= "person.lastName"><br><br>
  5. 全名:<span>{{person. fullName}}</span><br><br>
  6. 全面:<input type= "text" v-model= "person.fullName">
  7. </template>
  8. <script>
  9. import { reactive,computed } from 'vue';
  10. export default {
  11. setup( ){
  12. // 数据
  13. let person = reactive({
  14. firstName: '张',
  15. lastName: '三'
  16. })
  17. // 计算属性的简写方式(只能读)
  18. // person.fullName = computed(()=>{
  19. // return person.firstName+ '-' + person.lastName
  20. // })
  21. // 计算属性的完整方式(读写)
  22. person. fullName = computed({
  23. get( ){
  24. return person. firstName+ '-' + person. lastName
  25. },
  26. set( value){
  27. const nameStr = value. split( '-')
  28. person. firstName = nameStr[ 0]
  29. person. lastName = nameStr[ 1]
  30. }
  31. })
  32. // 返回对象出去
  33. return {
  34. person
  35. }
  36. }
  37. }
  38. </script>

watch函数

在Vue3中watch监听ref定义的数据,在按需导入watch后,watch函数能接收三个参数:第一个参数是监视对象;第二个参数是监视的回调函数;第三个是监视的配置属性。如下:


   
  1. <template>
  2. <h2>当前的值为:{{num}}</h2>
  3. <button @click="num++">点击+1</button>
  4. <br>
  5. <br>
  6. <h2>当前的信息为:{{say}}</h2>
  7. <button @click="say+='!'">加感叹号!</button>
  8. </template>
  9. <script>
  10. import { ref,watch } from 'vue';
  11. export default {
  12. setup () {
  13. // 数据
  14. let num = ref( 0)
  15. let say = ref( 'Hello World')
  16. watch([num,say], (newValue,oldValue)=>{
  17. console. log( 'num或say值变了',newValue,oldValue);
  18. },{ immediate: true})
  19. // 返回对象
  20. return {
  21. num,say,watch
  22. }
  23. }
  24. }
  25. </script>

当监视reactive所定义的一个响应式数据的全部属性时,是无法正确的获取到oldValue的,默认是强制开启了深度监听,所以即使你把深度监听关掉也是不奏效的,如下:


   
  1. <template>
  2. <h2>姓名:{{person.name}}</h2>
  3. <h2>年龄:{{person.age}}</h2>
  4. <h2>秘密:{{person.privacy.secret.msg}}</h2>
  5. <button @click="person.age+=1">年龄+1</button>
  6. <button @click="person.privacy.secret.msg+='--被我看到了'">查看秘密</button>
  7. </template>
  8. <script>
  9. import { reactive,watch } from 'vue';
  10. export default {
  11. setup () {
  12. // 数据
  13. let person = reactive({
  14. name: '张三',
  15. age: 18,
  16. privacy:{
  17. secret:{
  18. msg: '这是我的秘密'
  19. }
  20. }
  21. })
  22. watch(person, (newValue,oldValue)=>{
  23. console. log( 'person变化了',newValue,oldValue);
  24. },{ deep: false})
  25. // 返回对象
  26. return {
  27. person
  28. }
  29. }
  30. }
  31. </script>

如果想监视reactive所定义的一个响应式数据中的某个或某些属性,可以通过如下方式进行:


   
  1. <template>
  2. <h2>姓名:{{person.name}}</h2>
  3. <h2>年龄:{{person.age}}</h2>
  4. <h2>秘密:{{person.privacy.secret.msg}}</h2>
  5. <button @click="person.name+='-'">修改名字</button>
  6. <button @click="person.age+=1">年龄+1</button>
  7. </template>
  8. <script>
  9. import { reactive,watch } from 'vue';
  10. export default {
  11. setup () {
  12. // 数据
  13. let person = reactive({
  14. name: '张三',
  15. age: 18,
  16. privacy:{
  17. secret:{
  18. msg: '这是我的秘密'
  19. }
  20. }
  21. })
  22. // 监听person中name和age的变化
  23. watch([ ()=>person. name, ()=>person. age], (newValue,oldValue)=>{
  24. console. log( 'person中的name和age变化了',newValue,oldValue);
  25. })
  26. // 返回对象
  27. return {
  28. person
  29. }
  30. }
  31. }
  32. </script>

如果想拿到reactive函数中深层次的属性,即reactive函数中某个对象的属性,这时候就需要借助深度监视 deep 了,而且deep有效,如下:


   
  1. <template>
  2. <h2>姓名:{{person.name}}</h2>
  3. <h2>年龄:{{person.age}}</h2>
  4. <h2>秘密:{{person.privacy.secret.msg}}</h2>
  5. <button @click="person.name+='-'">修改名字</button>
  6. <button @click="person.age+=1">年龄+1</button>
  7. <button @click="person.privacy.secret.msg+='--'">查看秘密</button>
  8. </template>
  9. <script>
  10. import { reactive,watch } from 'vue';
  11. export default {
  12. setup () {
  13. // 数据
  14. let person = reactive({
  15. name: '张三',
  16. age: 18,
  17. privacy:{
  18. secret:{
  19. msg: '这是我的秘密'
  20. }
  21. }
  22. })
  23. // 监听person中name和age的变化
  24. watch( ()=>person. privacy, (newValue,oldValue)=>{
  25. console. log( 'person中的privacy变化了',newValue,oldValue);
  26. },{ deep: true}) // 由于监视的是reactive函数定义的某个对象中的属性,deep配置有效
  27. // 返回对象
  28. return {
  29. person
  30. }
  31. }
  32. }
  33. </script>

虽然我们监听到了值的变化,但是还是拿不到旧值,所以说白了,对于Vue3中的watch函数来说,在对象中是拿不到旧值的。如下:

watcrEffect函数

watch的套路是:既要指明监视的属性,也要指明监视的回调;watchEffect的套路是:不用指明监视哪个属性,监视的回调中用到哪个属性,那就监视哪个属性。

watchEffect有点像computed :
但computed注重的计算出来的值(回调函数的返回值),所以必须要写返回值。
watchEffect更注重的是过程(回调函数的函数体),所以不用写返回值。

   
  1. <script>
  2. import { reactive,watchEffect } from 'vue';
  3. export default {
  4. setup () {
  5. // 数据
  6. let person = reactive({
  7. name: '张三',
  8. age: 18,
  9. privacy:{
  10. secret:{
  11. msg: '这是我的秘密'
  12. }
  13. }
  14. })
  15. // 监视
  16. watchEffect( ()=>{
  17. const p1 = person. name
  18. const p2 = person. privacy. secret. msg
  19. console. log( 'watchEffect所指定的回调执行了');
  20. })
  21. // 返回对象
  22. return {
  23. person
  24. }
  25. }
  26. }
  27. </script>


转载:https://blog.csdn.net/qq_53123067/article/details/128558552
查看评论
* 以上用户言论只代表其个人观点,不代表本网站的观点或立场