Méthode de transfert de valeur du composant Vue : 1. Utilisez des accessoires pour transférer la valeur du parent à l'enfant ; 2. Utilisez "$emit" pour transférer la valeur de l'enfant au parent 3. Utilisez EventBus ou Vuex pour transférer la valeur aux frères ; ; 4. Utiliser Les méthodes "provide/inject" ou "$attrs/$listeners" effectuent un transfert de valeur entre niveaux.
L'environnement d'exploitation de ce tutoriel : système Windows7, version vue3, ordinateur Dell G3.
Nous savons tous que Vue est un framework front-end léger, et son cœur est le développement de composants. Vue est composée de composants un par un. La composantisation est son essence et l'une de ses fonctions les plus puissantes. Les portées des instances de composants sont indépendantes les unes des autres, ce qui signifie que les données entre différents composants ne peuvent pas se référencer mutuellement.
Mais dans le processus de développement du projet lui-même, nous devons accéder aux données d'autres composants, il y a donc un problème de communication entre les composants. Les relations entre les composants de Vue sont : père-fils, frère et générationnel. Comment mettre en œuvre le transfert de données pour différentes relations est ce dont nous parlerons ensuite.
C'est-à-dire que le composant parent transmet la valeur au composant enfant via des attributs, et le Le composant enfant transmet les accessoires à recevoir.
Lier les propriétés personnalisées dans la balise du composant enfant du composant parent
// 父组件
<user-detail :myName="name" />
export default {
components: {
UserDetail
}
......
}Utilisez simplement des accessoires (peut être un tableau ou un objet) dans le composant enfant pour le recevoir. Plusieurs attributs peuvent être transmis.
// 子组件
export default {
props: ['myName']
}
/*
props: { myName: String } //这样指定传入的类型，如果类型不对会警告
props: { myName: [String, Number] } // 多个可能的类型
prosp: { myName: { type: String, requires: true } } //必填的的字符串
props: {
childMsg: {
type: Array,
default: () => []
}
} // default指定默认值
如果 props 验证失败，会在控制台发出一个警告。
*/La valeur du composant parent reçue par le composant enfant est divisée en deux types : type référence et type ordinaire :
Types courants : Chaîne, Nombre, Booléen, Null
Types de référence : Tableau, Objet (Objet)
Si la valeur transmise est un type de données simple, elle peut être modifiée dans le composant enfant et n'affectera pas les autres composants frères qui appellent également le même données du parent. La valeur du composant.
L'opération spécifique consiste d'abord à réaffecter la valeur transmise à une variable dans les données, puis à modifier cette variable .
// 子组件
export default {
props: ['myName'],
data() {
return {
name : this.myName // 把传过来的值赋值给新的变量
}
},
watch: {
myName(newVal) {
this.name = newVal //对父组件传过来的值进行监听，如果改变也对子组件内部的值进行改变
}
},
methods: {
changeName() {
this.name = 'Lily' // 这里修改的只是自己内部的值，就不会报错了
},
}
}Remarque : Si watch n'est pas utilisé pour surveiller la valeur myName transmise par le composant parent, la valeur name dans le composant enfant est Il ne changera pas avec la valeur myName du composant parent, car name: this.myName dans les données ne définit qu'une valeur initiale.
Si la valeur du type référence est modifiée dans le composant enfant, le composant parent sera également modifié car les données sont publiques et sont également référencées par d'autres . Les sous-composants de la valeur seront également modifiés en conséquence. On comprend que la valeur transmise par le composant parent au composant enfant équivaut à faire une copie. Le pointeur de cette copie pointe toujours vers celui du composant parent, c'est-à-dire qu'il partage la même référence. Donc, sauf besoins particuliers, ne le modifiez pas facilement.
1. event , déclenchez
via this.$emit(). Liez un événement dans le composant enfant et définissez une fonction pour cet événement
// 子组件
<button @click="changeParentName">改变父组件的name</button>
export default {
methods: {
//子组件的事件
changeParentName: function() {
this.$emit('handleChange', 'Jack') // 触发父组件中handleChange事件并传参Jack
// 注：此处事件名称与父组件中绑定的事件名称要一致
}
}
}Défini dans le composant parent. Et liez l'événement handleChange
// 父组件
<child @handleChange="changeName"></child>
methods: {
changeName(name) { // name形参是子组件中传入的值Jack
this.name = name
}
} 2. Grâce à la fonction de rappel
définissez d'abord une fonction de rappel dans le composant parent et transmettez-y la fonction de rappel
// 父组件
<child :callback="callback"></child>
methods: {
callback: function(name) { this.name = name
}
}est reçu dans le composant enfant et exécute la fonction de rappel
// 子组件
<button @click="callback('Jack')">改变父组件的name</button>
props: {
callback: Function,
}3 Accédez à l'instance du composant via $parent / $children ou $refs
Les deux obtiennent directement l'instance du composant. Après utilisation, vous pouvez directement appeler la méthode du composant ou accéder aux données.
// 子组件
export default {
data () {
return {
title: '子组件'
}
},
methods: {
sayHello () {
console.log('Hello');
}
}
}Remarque : la communication entre les composants de cette manière ne peut pas être multi-niveaux.
4. $attrs / $listeners Cliquez ici pour plus de détails
1、还是通过 $emit 和 props 结合的方式
在父组件中给要传值的两个兄弟组件都绑定要传的变量，并定义事件
// 父组件
<child-a :myName="name" />
<child-b :myName="name" @changeName="editName" />
export default {
data() {
return {
name: 'John'
}
},
components: {
'child-a': ChildA,
'child-b': ChildB,
},
methods: {
editName(name) {
this.name = name
},
}
}在子组件B中接收变量和绑定触发事件
// child-b 组件
<p>姓名：{{ myName }}</p>
<button @click="changeName">修改姓名</button>
<script>
export default {
props: ["myName"],
methods: {
changeName() {
this.$emit('changeName', 'Lily') // 触发事件并传值
}
}
}
</script>// child-a 组件
<p>姓名：{{ newName }}</p>
<script>
export default {
props: ["myName"],
computed: {
newName() {
if(this.myName) { // 判断是否有值传过来
return this.myName
}
return 'John' //没有传值的默认值
}
}
}
</script>即：当子组件B 通过 $emit() 触发了父组件的事件函数 editName，改变了父组件的变量name 值，父组件又可以把改变了的值通过 props 传递给子组件A，从而实现兄弟组件间数据传递。
2. 通过一个空 vue 实例
创建一个 EventBus.js 文件，并暴露一个 vue 实例
import Vue from 'Vue'export default new Vue()
在要传值的文件里导入这个空 vue 实例，绑定事件并通过 $emit 触发事件函数
(也可以在 main.js 中全局引入该 js 文件，我一般在需要使用到的组件中引入)
<template>
<div>
<p>姓名: {{ name }}</p>
<button @click="changeName">修改姓名</button>
</div>
</template>
<script>
import { EventBus } from "../EventBus.js"
export default {
data() {
return {
name: 'John',
}
},
methods: {
changeName() {
this.name = 'Lily'
EventBus.$emit("editName", this.name) // 触发全局事件,并且把改变后的值传入事件函数
}
}
}
</script>在接收传值的组件中也导入 vue 实例，通过 $on 监听回调，回调函数接收所有触发事件时传入的参数
import { EventBus } from "../EventBus.js"
export default {
data() {
return {
name: ''
}
},
created() {
EventBus.$on('editName', (name) => {
this.name = name
})
}
}这种通过创建一个空的 vue 实例的方式，相当于创建了一个事件中心或者说是中转站，用来传递和接收事件。这种方式同样适用于任何组件间的通信，包括父子、兄弟、跨级，对于通信需求简单的项目比较方便，但对于更复杂的情况，或者项目比较大时，可以使用 vue 提供的更复杂的状态管理模式 Vuex 来进行处理。
3. 使用 vuex →点这里
有时需要实现通信的两个组件不是直接的父子组件，而是祖父和孙子，或者是跨越了更多层级的父子组件，这种时候就不可能由子组件一级一级的向上传递参数，特别是在组件层级比较深，嵌套比较多的情况下，需要传递的事件和属性较多，会导致代码很混乱。
这时就需要用到 vue 提供的更高阶的方法：provide/inject。
这对选项需要一起使用，以允许一个祖先组件向其所有子孙后代注入一个依赖，不论组件层次有多深，并在起上下游关系成立的时间里始终生效。查 看 官 网
provide/inject：简单来说就是在父组件中通过provider来提供变量，然后在子组件中通过inject来注入变量，不管组件层级有多深，在父组件生效的生命周期内，这个变量就一直有效。
父组件：
export default {
provide: { // 它的作用就是将 **name** 这个变量提供给它的所有子组件。
name: 'Jack'
}
}子组件：
export default {
inject: ['name'], // 注入了从父组件中提供的name变量
mounted () {
console.log(this.name); // Jack
}
}注：provide 和 inject 绑定并不是可响应的。即父组件的name变化后，子组件不会跟着变。
如果想要实现 provide 和 inject 数据响应，有两种方法：
// 父组件
<div>
<button @click="changeName">修改姓名</button>
<child-b />
</div>
<script>
......
data() {
return {
name: "Jack"
};
},
provide() {
return {
parentObj: this //提供祖先组件的实例
};
},
methods: {
changeName() {
this.name = 'Lily'
}
}
</script>后代组件中取值：
<template>
<div class="border2">
<P>姓名：{{parentObj.name}}</P>
</div>
</template>
<script>
export default {
inject: {
parentObj: {
default: () => ({})
}
} // 或者inject: ['parentObj']
};
</script>注：这种方式在函数式组件中用的比较多。函数式组件，即无状态(没有响应式数据)，无实例化(没有 this 上下文)，内部也没有任何生命周期处理方法，所以渲染性能高，比较适合依赖外部数据传递而变化的组件。
使用 Vue.observable 优化响应式 provide，这个我用的不熟就不说了，可以 → 官方文档
父子通信：父向子传递数据是通过 props，子向父是通过 $emit；通过 $parent / $children 通信；$ref 也可以访问组件实例；provide / inject ；
兄弟通信： EventBus；Vuex；
跨级通信： EventBus；Vuex；provide / inject ；$attrs / $listeners；
相关推荐：《vue.js教程》
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Le composant parent Vue appelle la méthode du composant enfant
vue v-si
La différence entre vue2.0 et 3.0
Comment transmettre une valeur au composant vue
La différence entre vue3.0 et 2.0
vue instructions communes
Quelles sont les instructions couramment utilisées dans vue ?
La différence entre mpvue et vue
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
