✅创作者：陈书予
🎉个人主页：陈书予的个人主页
🍁陈书予的个人社区，欢迎你的加入: 陈书予的社区
🌟专栏地址: 三十天精通 Vue 3

引言

当今 Web 开发中，Vue 框架已经成为了一个非常流行的前端框架。Vue 3 是 Vue 框架的最新版本，它引入了许多新的功能和改进。在本文中，我们将探讨 Vue 3 中的一些新功能，包括计算属性、监听器、响应式计算属性等。今天将按照目录结构进行讲解，同时也会配合代码示例进行说明。

一、Vue 3 计算属性概述

1.1 计算属性的简介

计算属性是一种响应式数据，它可以根据其他响应式数据进行计算。它通常用于在组件中使用，以便在渲染期间计算某些值。例如，我们可以在组件中使用计算属性来计算文本的长度，以便在渲染期间动态更新文本的长度。

1.2 计算属性的分类

在 Vue 3 中，计算属性可以分为基本计算属性和动态计算属性两种类型。

• 基本计算属性：基本计算属性是计算属性的一种基本类型，它只能使用基本数据类型 (例如数字、字符串、布尔值等) 进行计算。它们通常用于计算组件的值，例如计算按钮的点击事件。
• 动态计算属性：动态计算属性是 Vue 3 中的一种高级计算属性类型，它可以动态计算响应式数据。动态计算属性的语法与普通计算属性相似，但它们可以动态地计算响应式数据。它们通常用于在渲染期间动态计算响应式数据，例如计算文本的长度。

1.3 计算属性的语法

在 Vue 3 中，计算属性的语法与普通组件的语法相似，但它们可以使用响应式数据进行计算。计算属性的语法如下:

<template>
  <div>
    {{ fullName }}
  </div>
</template>

<script>
  import { computed } from 'vue';

  export default {
    data() {
      return {
        firstName: 'John',
        lastName: 'Doe',
      };
    },
    computed: {
      fullName: {
        get() {
          return `${this.firstName} ${this.lastName}`;
        },
        set(value) {
          const [firstName, lastName] = value.split(' ');
          this.firstName = firstName;
          this.lastName = lastName;
        },
      },
    },
  };
</script>

在这个 Vue3 的代码片段中，我们使用 computed 函数导入 computed 对象，然后在组件中定义 computed 对象，fullName 是一个计算属性，get 方法返回计算属性的值，set 方法接收一个参数，并在这个计算属性被赋值时触发，以更新组件的 data 数据。与 Vue2 不同的是，Vue3 中计算属性的 setter 方法也可以通过这种方式定义，而不是像 Vue2 中那样在方法中直接修改组件的 data 数据。

二、Vue 3 基本计算属性

2.1 计算属性的实例参数

在 Vue 3 中，计算属性不再通过 this 访问当前组件实例，而是作为一个函数接受一个参数，该参数指向当前组件的响应式数据。这个参数在默认情况下称为 getter，你可以在计算属性内部使用它来获取数据。

例如，下面是一个使用实例参数 getter 的计算属性示例：

<template>
  <div>
    {{ fullName }}
  </div>
</template>

<script>
  import { computed } from 'vue';

  export default {
    data() {
      return {
        firstName: 'John',
        lastName: 'Doe',
      };
    },
    computed: {
      fullName: {
        get(getter) {
          return `${getter.firstName} ${getter.lastName}`;
        },
        set(value) {
          const [firstName, lastName] = value.split(' ');
          this.firstName = firstName;
          this.lastName = lastName;
        },
      },
    },
  };
</script>

在这个例子中，我们在计算属性的 get 方法中使用了一个参数 getter，这个参数指向当前组件实例的响应式数据。通过这个参数，我们可以直接访问到组件内部的 firstName 和 lastName 数据，从而计算出完整的 fullName。而在 set 方法中，我们仍然使用 this 访问到组件实例，来更新 firstName 和 lastName 数据。

2.2 计算属性的默认值

计算属性可以设置默认值，这样在数据没有发生变化时，计算属性不会重新计算，而只会在数据发生变化时更新。默认值可以通过计算属性的 default 属性设置，例如:

<template>  
  <div>  
    <p>计算属性：{{ calculated }}</p>  
    <button @click="increment">增加</button>  
  </div>  
</template>

<script>  
export default {  
  data() {  
    return {  
      calculated: 0,  
    };  
  },  
  methods: {  
    increment() {  
      this.calculated++;  
    },  
  },  
};  
</script>  

在上面的例子中，计算属性 calculated 的默认值为 0。当数据没有发生变化时，计算属性不会重新计算，而只会在数据发生变化时更新。

2.3 计算属性的嵌套

计算属性可以嵌套，这样可以实现更复杂的计算逻辑。嵌套计算属性的优先级低于非嵌套计算属性，也就是说，如果某个计算属性需要根据嵌套计算属性来计算，那么该计算属性的优先级要高于嵌套计算属性。

例如:

<template>  
  <div>  
    <p>嵌套计算属性：{{ calculated }}</p>  
    <button @click="increment">增加</button>  
  </div>  
</template>

<script>  
export default {  
  data() {  
    return {  
      calculated: 0,  
    };  
  },  
  methods: {  
    increment() {  
      this.calculated++;  
    },  
  },  
};  
</script>

<template>  
  <div>  
    <p>非嵌套计算属性：{{ nonNested }}</p>  
    <button @click="incrementNonNested">增加</button>  
  </div>  
</template>

<script>  
export default {  
  data() {  
    return {  
      nonNested: 0,  
    };  
  },  
  methods: {  
    incrementNonNested() {  
      this.nonNested++;  
    },  
  },  
};  
</script>  

在上面的例子中，嵌套计算属性 calculated 的优先级低于非嵌套计算属性 nonNested。当数据没有发生变化时，计算属性 nonNested 不会重新计算，而只会在数据发生变化时更新。

三、Vue 3 动态计算属性

3.1 动态计算属性的简介

在 Vue 3 中，动态计算属性是一种通过传递一个函数作为计算属性的参数来实现动态渲染的方式。这个函数接受两个参数：一个数据对象和一个上下文对象。数据对象是你在模板中传递给计算属性的数据，上下文对象是一个可选的参数，用于提供计算属性的上下文信息。

动态计算属性的语法比较简单，可以用箭头函数或者普通函数作为计算属性的参数。例如:

<template>  
  <div>{{ message }}</div>  
</template>

<script>  
export default {  
  data() {  
    return {  
      message: "Hello Vue!"  
    }  
  },  
  computed: {  
    messageWithFunction() {  
      return this.message + " with function"  
    }  
  }  
}
</script>  

在这个例子中，我们使用了箭头函数作为计算属性的参数，计算属性返回的结果是字符串 “Hello Vue! with function”。

我们还可以使用普通函数作为计算属性的参数，计算属性返回的结果是依赖数据对象的消息。例如:

<template>  
  <div>{{ message }}</div>  
</template>

<script>  
export default {  
  data() {  
    return {  
      message: "Hello Vue!"  
    }  
  },  
  computed: {  
    messageWithFunction() {  
      return this.message + " with function"  
    }  
  }  
}
</script>  

在这个例子中，我们使用了普通函数作为计算属性的参数，计算属性返回的结果是字符串 “Hello Vue! with function”。

3.2 动态计算属性的语法

动态计算属性的语法可以概括为以下几点:

• 使用 computed 标签定义计算属性，其中 computed 属性是一个对象，包含一个或多个计算属性。
• 计算属性的参数是一个函数，这个函数接受两个参数：一个数据对象和一个上下文对象。
• 函数返回的结果是一个字符串、数字、对象等任意类型的数据。
• 可以使用 this 关键字来引用计算属性的上下文对象。

例如:

<template>  
  <div>{{ message }}</div>  
</template>

<script>  
export default {  
  data() {  
    return {  
      message: "Hello Vue!"  
    }  
  },  
  computed: {  
    messageWithFunction() {  
      return this.message + " with function"  
    }  
  }  
}
</script>  

在这个例子中，我们定义了一个计算属性 messageWithFunction,它的参数是一个函数，返回的结果是字符串 “Hello Vue! with function”。在模板中，我们可以使用 message 变量来访问数据对象的消息，并且可以使用 this 关键字来访问计算属性的上下文对象。

3.3 动态计算属性的应用场景

Vue 3 的动态计算属性提供了一种更加灵活和强大的特性，可以用于多种应用场景，包括:

3.3.1 动态生成组件属性

在组件中，可以使用动态计算属性来生成组件属性。例如，可以使用动态计算属性生成组件的 name 和 age 属性。以下是一个示例代码:

<template>  
  <div>  
    <h2>Hello, {{ name }}</h2>  
    <p>Age: {{ age }}</p>  
  </div>  
</template>

<script>  
export default {  
  data() {  
    return {  
      name: 'World',  
      age: 30  
    }  
  },  
  computed: {  
    hello() {  
      return this.name + '!'  
    }  
  }  
}
</script>  

在这个示例中，hello 计算属性是根据模板中的 name 变量动态生成的。当 name 变量发生变化时，hello 计算属性的值也会自动更新。

3.3.2 动态生成路由导航栏菜单

在 Vue 3 中，可以使用动态计算属性来生成路由导航栏菜单。例如，可以使用动态计算属性生成 path 和 name 属性，用于生成路由导航栏菜单。以下是一个示例代码:

<template>
  <div>
    <ul>
      <li v-for="route in routes" :key="route.path">
        <router-link :to="route.path">{{ route.name }}</router-link>
      </li>
    </ul>
  </div>
</template>

<script>
import { computed } from 'vue'
import { useRoute } from 'vue-router'

export default {
  setup() {
    const route = useRoute()

    const routes = computed(() => {
      return [
        { path: '/', name: 'Home' },
        { path: '/about', name: 'About' },
        { path: '/contact', name: 'Contact' }
      ]
    })

    return {
      route,
      routes
    }
  }
}
</script>

在这个示例中，使用 computed 创建一个名为 routes 的动态计算属性，该属性返回一个包含所有路由路径和名称的数组。在模板中，使用 v-for 渲染路由列表，并使用 router-link 组件将每个路由链接到对应的路径。

四、Vue 3 响应式计算属性

4.1 响应式计算属性的简介

响应式计算属性是 Vue 3 中实现响应式数据的一种机制。它是基于响应式数据的自动求值，当响应式数据发生变化时，响应式计算属性会自动更新。

响应式计算属性的语法如下:

export default {  
  computed: {  
    myValue() {  
      // 这里是计算属性的实现代码  
      return someReactableObject.value;  
    }  
  }  
}

其中，computed 是一个关键字，表示这是一个响应式计算属性。myValue 是计算属性的名称，() 中是计算属性的实现代码。在实现代码中，我们可以使用 Vue 3 中的响应式数据，如 this.$data 或 this.$options.data。

响应式计算属性的应用场景非常广泛。在 Vue 3 中，许多组件都使用响应式计算属性来实现响应式数据。例如，在表格中，我们可以使用响应式计算属性来计算单元格的值，以便在数据变化时自动更新视图。

4.2 响应式计算属性的语法

响应式计算属性的语法非常简单。它只需要包含一个 computed 关键字和一个计算属性的实现代码。

计算属性的实现代码可以使用 Vue 3 中的响应式数据，如 this.$data 或 this.$options.data。在实现代码中，我们可以使用这些数据来计算属性的值。

例如，以下代码中，我们使用 this.$data.items 来计算 myValue 的值，以便在数据变化时自动更新视图:

export default {  
  computed: {  
    myValue() {  
      return this.$data.items.length;  
    }  
  }  
}

4.3 响应式计算属性的应用场景

4.3.1 处理数据的变化

在 Vue 3 中，响应式计算属性可以用于处理数据的变化。例如，可以使用响应式计算属性来处理用户输入的值，并将其更新到组件中。以下是一个示例代码:

<template>
  <div>
    <input v-model="userInput" />
    <p>{{ capitalizedUserInput }}</p>
  </div>
</template>

<script>
import { computed, reactive } from 'vue'

export default {
  setup() {
    const state = reactive({
      userInput: '',
    })

    const capitalizedUserInput = computed(() => {
      return state.userInput.toUpperCase()
    })

    return {
      ...state,
      capitalizedUserInput,
    }
  },
}
</script>

在这个示例代码中，我们使用 reactive 函数创建了一个响应式对象 state，用来存储用户输入的值。然后我们使用 computed 函数创建了一个响应式计算属性 capitalizedUserInput，用来将用户输入的值转化为大写字母。最后在组件中，我们使用 v-model 将用户输入的值绑定到 userInput 上，并将处理后的值渲染到组件中。

4.3.2 处理异步数据的变化

在 Vue 3 中，响应式计算属性也可以用于处理异步数据的变化。例如，可以使用响应式计算属性来处理从后端返回的数据，并将其更新到组件中。以下是一个示例代码:

<template>
  <div>
    <button @click="fetchData">Get Data</button>
    <div v-if="data.length">
      <p>Data: {{ data }}</p>
    </div>
  </div>
</template>

<script>
import { reactive, computed } from 'vue'
import axios from 'axios'

export default {
  setup() {
    const state = reactive({
      rawData: null
    })

    const data = computed(() => {
      if (state.rawData) {
        return state.rawData.map(item => item.name)
      } else {
        return []
      }
    })

    const fetchData = async () => {
      const response = await axios.get('/api/data')
      state.rawData = response.data
    }

    return {
      data,
      fetchData
    }
  }
}
</script>

在这个示例中，state.rawData 作为响应式对象来保存异步获取的数据。通过 computed 计算属性，可以在 state.rawData 更新时自动更新组件中的数据。当数据尚未加载时，data 计算属性返回一个空数组。在 fetchData 函数中，我们使用 async/await 语法来异步获取数据，并在获取到数据后更新 state.rawData。

五、Vue 3 监听器概述

5.1 监听器的简介

在 Vue 3 中，监听器是一种用于监听数据或事件变化的函数。当数据或事件发生变化时，监听器会执行相应的操作。监听器可以使用 watch 选项来定义，也可以在组件的生命周期钩子中定义。

例如，我们可以使用 watch 选项来定义一个监听器，以便在数据变化时执行相应的操作。例如:

<template>
  <div>
    <p>Value: {{ value }}</p>
    <button @click="increment">Increment</button>
  </div>
</template>

<script>
import { reactive, watch } from 'vue'

export default {
  setup() {
    const state = reactive({
      value: 0
    })

    const increment = () => {
      state.value++
    }

    watch(() => state.value, (newValue, oldValue) => {
      console.log(`Value changed from ${oldValue} to ${newValue}`)
    })

    return {
      value: state.value,
      increment
    }
  }
}
</script>

在这个示例中，我们定义了一个名为 value 的响应式数据，并使用 watch 选项来监听它的变化。watch 函数的第一个参数是一个函数，它返回要监听的响应式数据。第二个参数是一个回调函数，它会在 value 变化时被执行，参数为新值和旧值。在这个示例中，我们在回调函数中输出变化的值。

5.2 监听器的分类

Vue 3 中的监听器可以分为以下几类:

• 响应式监听器：用于监听响应式数据的变化。
• 事件监听器：用于监听事件的发生。
• 定时器监听器：用于监听一段时间内的数据或事件变化。
• 全局监听器：用于监听全局事件，可以在父组件中注册。

5.3 监听器的语法

在 Vue 3 中，监听器可以使用以下语法定义:

this.$watch(  
  condition,  
  callback,  
  options  
);  

其中，condition 是一个可选的参数，用于指定监听器的条件。如果条件为 true,则监听器将执行相应的操作。callback 是必选的参数，用于在条件满足时执行相应的操作。options 是可选的参数，用于指定监听器的一些选项，例如 deep、澎涨 等。

例如，我们可以使用以下语法定义一个响应式监听器:

this.$watch('value', (newValue) => {  
  console.log('value has changed to', newValue);  
});  

在上面的例子中，我们使用 $watch 选项定义了一个响应式监听器，用于监听 value 数据的变化。当 value 数据发生变化时，监听器会执行相应的操作，即在控制台中输出一条日志。

六、Vue 3 基本监听器

6.1 监听器的实例参数

在 Vue 3 中，监听器可以接受一个实例参数 data,该参数指向当前组件的响应式数据。这个实例参数可以在监听器内部使用，用于获取或修改响应式数据。例如:

import { reactive, watch } from 'vue'

const state = reactive({
  count: 0
})

watch(() => state.count, (newVal, oldVal, data) => {
  console.log(`count changed from ${oldVal} to ${newVal}`)
  data.count = newVal * 2
})

state.count++ // count changed from 0 to 1
console.log(state.count) // 2

在上面的代码中，当 state.count 的值发生变化时，watch 函数的回调函数会被调用，并且在回调函数中，我们通过修改 data.count 来实现了对响应式数据的修改。最后，我们打印出了 state.count 的值，发现它的值已经变成了 2。

6.2 监听器的默认参数

在 Vue 3 中，监听器可以接受一个实例参数 data,该参数指向当前组件的响应式数据。这个实例参数可以在监听器内部使用，用于获取或修改响应式数据。例如:

<template>  
  <div>  
    <p>监听器:{{ calculated }}</p>  
    <button @click="increment">增加</button>  
  </div>  
</template>

<script>  
export default {  
 data() {  
  return {  
    calculated: 0  
  }  
 },  
 methods: {  
  increment() {  
    this.calculated++;  
  }  
 }  
}
</script>  

在上面的例子中，我们定义了一个计算属性 calculated,并使用监听器来监听计算属性的变化。在监听器内部，我们可以使用 this.calculated 来访问响应式数据。

6.3 监听器的嵌套

在 Vue 3 中，监听器可以嵌套，这样可以实现更复杂的监听逻辑。嵌套监听器的使用方式与嵌套计算属性类似，可以使用 deep 选项指定嵌套监听器的执行方式。例如:

<template>  
  <div>  
    <p>嵌套监听器:{{ calculated }}</p>  
    <button @click="incrementDeep">增加</button>  
    <ul>  
      <li v-for="item in deepData">{{ item }}</li>  
    </ul>  
  </div>  
</template>

<script>  
export default {  
 data() {  
  return {  
    deepData: [  
      { id: 1, name: 'John' },  
      { id: 2, name: 'Mary' },  
      { id: 3, name: 'Peter' }  
    ]  
  }  
 },  
 methods: {  
  incrementDeep() {  
    this.deepData.forEach(item => {  
      item.id++  
    })  
  }  
 }  
}
</script>  

在上面的例子中，我们定义了一个嵌套计算属性 deepData,并使用嵌套监听器来监听计算属性的变化。在嵌套监听器内部，我们使用 v-for 指令来遍历嵌套计算属性的响应式数据，并更新相应的元素。

七、Vue 3 事件监听器

7.1 事件监听器的简介

在 Vue 3 中，事件监听器是一种用于监听组件或元素事件变化的函数。可以使用 watch 选项在组件中定义事件监听器，也可以在父组件中使用 eventName 和 eventHandler 的方式定义事件监听器。

事件监听器可以接受一个事件名称和一个回调函数作为参数。当事件名称所描述事件发生时，回调函数将会被执行。例如:

<template>    
  <div>    
    <p>普通事件监听器:{{ message }}</p>    
    <button @click="increment">增加</button>    
  </div>    
</template>

<script>    
export default {    
  data() {    
    return {    
      message: '初始值为 0'    
    }    
  },    
  methods: {    
    increment() {    
      this.message = this.message + 1    
    }    
  }    
}
</script>    

在上面的例子中，我们定义了一个普通事件监听器，用于监听点击事件。当用户点击按钮时，回调函数将会被执行，更新组件中的消息值。

7.2 事件监听器的语法

在 Vue 3 中，事件监听器可以使用 watch 选项在组件中定义，也可以使用 eventName 和 eventHandler 的方式在父组件中定义。

使用 watch 选项定义事件监听器的语法如下:

this.$watch(    
  condition,    
  callback,    
  options    
);    

其中，condition 是一个可选参数，用于指定事件监听器的条件。如果条件为 true,则事件监听器将执行相应的操作。callback 是一个必选参数，用于在事件触发时执行的函数。options 是一个可选参数，用于指定事件监听器的一些选项，例如 deep、澎涨 等。

使用 eventName 和 eventHandler 的方式定义事件监听器的语法如下:

this.$emit(    
  eventName,    
  data,    
  bubbles,    
  capture    
);    

其中，eventName 是一个必选参数，用于指定事件名称。data 是一个可选参数，用于传递事件数据。bubbles 是一个可选参数，用于指定事件是否在父组件中传播。capture 是一个可选参数，用于指定事件是否在捕获阶段执行。

7.3 事件监听器的应用场景

7.3.1 监听用户输入

在 Vue 3 中，可以使用事件监听器来监听用户的输入。例如，可以使用 @input 修饰符在组件中使用事件监听器来监听用户输入的值。以下是一个示例代码:

<template>      
  <div>      
    <input @input="handleInput" />      
    <p>{{ value }}</p>      
  </div>      
</template>

<script>      
export default {      
  data() {      
    return {      
      value: ''      
    }      
  },      
  methods: {      
    handleInput(event) {      
      this.value = event.target.value      
    }      
  }      
}
</script>      

在这个示例中，handleInput 方法用于更新组件中 value 计算属性的值，以响应用户输入。@input 修饰符用于监听用户输入事件，并将其传递给事件监听器。

7.3.2 监听组件事件

在 Vue 3 中，可以使用事件监听器来监听组件事件。例如，可以使用 @click 修饰符在组件中使用事件监听器来监听用户的点击事件。以下是一个示例代码:

<template>      
  <div>      
    <button @click="handleClick" >Click me</button>      
    <p>{{ value }}</p>      
  </div>      
</template>

<script>      
export default {      
  data() {      
    return {      
      value: ''      
    }      
  },      
  methods: {      
    handleClick() {      
      this.value = 'Hello Vue!'      
    }      
  }      
}
</script>      

在这个示例中，handleClick 方法用于更新组件中 value 计算属性的值，以响应用户的点击事件。@click 修饰符用于监听用户点击事件，并将其传递给事件监听器。

7.3.3 监听 DOM 事件

在 Vue 3 中，可以使用事件监听器来监听 DOM 事件。例如，可以使用 @click 修饰符在父组件中使用事件监听器来监听用户的点击事件。以下是一个示例代码:

<template>      
  <div>      
    <child-component @click="handleClick" />      
    <p>{{ value }}</p>      
  </div>      
</template>

<script>      
import ChildComponent from './child-component.vue'

export default {      
  name: 'App',      
  components: {      
    ChildComponent      
  },      
  data() {      
    return {      
      value: ''      
    }      
  },      
  methods: {      
    handleClick() {      
      this.value = 'Hello Vue!'      
    }      
  }      
}
</script>      

在这个示例中，handleClick 方法用于更新组件中 value 计算属性的值，以响应用户的点击事件。@click 修饰符用于监听用户点击事件，并将其传递给事件监听器。在父组件中，可以使用 @click 修饰符在子组件中使用事件监听器，以监听子组件的点击事件。

八、Vue 3 响应式监听器

8.1 响应式监听器的简介

在 Vue 2 中，我们使用事件监听器来监听数据的变化。例如，当我们更新一个组件的值时，可以使用 v-on 指令将事件监听器绑定到组件上，并在数据变化时执行相应的操作。在 Vue 3 中，我们可以使用响应式监听器来代替事件监听器。

响应式监听器是一种监听数据变化的机制，它监听的数据通常是在一个响应式数据源中，例如一个数组或一个对象。当响应式数据源中的数据发生变化时，响应式监听器会自动触发，并在触发时执行相应的操作。

与事件监听器类似，响应式监听器也使用 v-on 指令将监听器绑定到组件上。但是，与事件监听器不同的是，响应式监听器使用的是 v-on-change 事件，而不是事件名。例如，我们可以使用以下代码将一个响应式监听器绑定到一个文本框上:

<template>  
  <input type="text" v-model="value" @change="handleChange">  
</template>

<script>  
export default {  
  data() {  
    return {  
      value: ''  
    }  
  },  
  methods: {  
    handleChange() {  
      this.value = this.$el.value  
    }  
  }  
}
</script>  

在这个例子中，我们使用 v-model 指令将文本框和响应式监听器绑定到同一个组件上。当用户在文本框中输入时，响应式监听器会自动触发，并更新组件的值。

8.2 响应式监听器的语法

在 Vue 3 中，响应式监听器可以使用以下语法:

this.$watch(  
  expression,  
  callback,  
  {  
    immediate: boolean,  
    clearOnDestroy: boolean,  
    capture: boolean  
  }  
)

其中，expression 是需要监听的表达式，例如 this.value。callback 是响应式监听器在数据变化时执行的函数，它通常包含两个参数：当前值和新值。

在 Vue 3 中，我们还可以使用 $emit 方法触发一个事件来通知组件数据变化。例如，我们可以使用以下代码将一个响应式监听器绑定到一个按钮上，并在按钮点击时触发一个事件:

<template>  
  <button @click="handleClick">点击我</button>  
</template>

<script>  
export default {  
  data() {  
    return {  
      value: ''  
    }  
  },  
  methods: {  
    handleClick() {  
      this.$emit('change', this.value)  
    }  
  }  
}
</script>  

在这个例子中，当用户点击按钮时，响应式监听器会自动触发，并传递当前组件的值作为参数。

8.3 响应式监听器的应用场景

8.3.1 管理组件状态

在 Vue 3 中，组件可以拥有自己的状态，例如数据、选项等等。当我们需要在一个组件中管理这些状态时，可以使用响应式监听器来实现。例如，我们可以在组件中创建一个名为 data 的响应式监听器，用于监听数据的变化。当数据发生变化时，可以通过触发 data 监听器来更新组件中的状态。

下面是一个使用响应式监听器管理组件状态的示例代码:

import { defineComponent, ref } from 'vue'

const MyComponent = defineComponent({  
  name: 'MyComponent',  
  props: {  
    value: {  
      type: String,  
      default: '',  
    },  
  },  
  setup() {  
    const valueRef = ref(this.value)

    return {  
      value: valueRef.value,  
      set value(value) {  
        valueRef.value = value  
      },  
    }  
  },  
})

export default MyComponent  

在这个示例中，我们创建了一个名为 MyComponent 的组件，该组件拥有一个名为 value 的响应式监听器。该监听器监听到了 value 数据的变化，并在数据变化时更新组件中的状态。在组件的 setup 函数中，我们定义了一个名为 value 的响应式监听器，用于监听 value 数据的变化。

8.3.2 管理组件选项

在 Vue 3 中，组件可以拥有自己的选项，例如 name、value 等等。当我们需要在一个组件中管理这些选项时，可以使用响应式监听器来实现。例如，我们可以在组件中创建一个名为 options 的响应式监听器，用于监听选项的变化。当选项发生变化时，可以通过触发 options 监听器来更新组件中的状态。

下面是一个使用响应式监听器管理组件选项的示例代码:

import { defineComponent, ref } from 'vue'

const MyComponent = defineComponent({  
  name: 'MyComponent',  
  props: {  
    value: {  
      type: String,  
      default: '',  
    },  
  },  
  setup() {  
    const valueRef = ref(this.value)

    return {  
      value: valueRef.value,  
      set value(value) {  
        valueRef.value = value  
      },  
      options: ref([]),  
    }  
  },  
})

export default MyComponent  

在这个示例中，我们创建了一个名为 MyComponent 的组件，该组件拥有一个名为 value 的响应式监听器。该监听器监听到了 value 数据的变化，并在数据变化时更新组件中的状态。在组件的 setup 函数中，我们定义了一个名为 value 的响应式监听器，用于监听 value 数据的变化。此外，我们还定义了一个名为 options 的响应式监听器，用于监听选项的变化。

九、Vue 3 插件监听器

9.1 插件监听器的简介

在 Vue 3 中，插件监听器是一种用于监听插件内部状态变化的机制。当我们需要在插件内部监听某些状态的变化时，可以使用插件监听器来实现。

在 Vue 3 中，插件监听器可以通过 watch 选项来定义。在定义插件时，可以在 setup 函数中定义 watch 选项，该选项可以监听插件内部状态的变化。当插件内部状态发生变化时，会触发相应的事件，并在事件触发时执行相应的操作。

例如，我们可以在 Vue 3 插件中定义一个名为 data 的监听器，用于监听插件内部状态的变化。下面是一个使用插件监听器的示例代码:

import { defineComponent, ref } from 'vue'

const MyComponent = defineComponent({  
  name: 'MyComponent',  
  components: {  
    myComponent: () => import('my-component')  
  },  
  setup() {  
    const myData = ref('my data')

    return {  
      myData,  
      set myData(data) {  
        myData.value = data  
      },  
    }  
  },  
})

export default MyComponent  

在这个示例中，我们定义了一个名为 MyComponent 的组件，该组件使用了 watch 选项来定义一个名为 myData 的监听器。该监听器监听到了 my data 数据的变化，并在数据变化时更新组件中的状态。

9.2 插件监听器的语法

在 Vue 3 中，使用插件监听器需要遵循以下语法:

import { defineComponent, ref, watch } from 'vue'

const MyComponent = defineComponent({  
  name: 'MyComponent',  
  components: {  
    myComponent: () => import('my-component')  
  },  
  setup() {  
    const myData = ref('my data')

    watch: {  
      myData (newValue, oldValue) {  
        // 在 my data 数据变化时执行的操作  
      }  
    },  
  },  
})

export default MyComponent  

在上面的示例代码中，我们定义了一个名为 MyComponent 的组件，该组件使用了 watch 选项来定义一个名为 myData 的监听器。在监听器中，我们定义了一个名为 my data 的 ref 对象，用于监听插件内部状态的变化。在监听器中，我们使用了 watch 选项来监听 my data 数据的变化，并在数据变化时执行相应的操作。

在 Vue 3 中，插件监听器可以使用 ref 函数来创建，该函数可以创建一个响应式对象，用于监听插件内部状态的变化。在创建插件监听器时，需要使用 ref 函数来创建响应式对象，该对象会监听到插件内部状态的变化，并在状态变化时执行相应的操作。

9.3 插件监听器的应用场景

9.3.1 监听插件启用

在 Vue 3 中，可以使用插件监听器来监听插件的启用和禁用事件。例如，可以使用 @use 修饰符在组件中使用插件监听器，以监听插件的启用和禁用事件。以下是一个示例代码:

<template>      
  <div>      
    <button @click="handleUse">Use plugin</button>      
    <div v-if="pluginUsed">      
      <p>Plugin used</p>      
    </div>      
  </div>      
</template>

<script>      
import { use } from 'vue'

export default {      
  setup() {      
    const plugin = use('plugin-name')      
    // ...      
  },      
  methods: {      
    handleUse() {      
      plugin.启用插件      
    }      
  }      
}
</script>      

在这个示例中，handleUse 方法用于启用或禁用插件。@use 修饰符用于在组件中使用插件监听器，以监听插件的启用和禁用事件。

9.3.2 监听插件更新

在 Vue 3 中，可以使用插件监听器来监听插件的更新事件。例如，可以使用 @update 修饰符在组件中使用插件监听器，以监听插件的更新事件。以下是一个示例代码:

<template>      
  <div>      
    <button @click="handleUpdate">Update plugin</button>      
    <div v-if="pluginUpdated">      
      <p>Plugin updated</p>      
    </div>      
  </div>      
</template>

<script>      
import { use } from 'vue'

export default {      
  setup() {      
    const plugin = use('plugin-name')      
    // ...      
  },      
  methods: {      
    handleUpdate() {      
      plugin.更新插件      
    }      
  }      
}
</script>      

在这个示例中，handleUpdate 方法用于更新插件。@update 修饰符用于在组件中使用插件监听器，以监听插件的更新事件。