Maison > Article > interface Web > Comment utiliser la communication parent-enfant du composant VueJs (avec code)

Comment utiliser la communication parent-enfant du composant VueJs (avec code)

php中世界最好的语言original: 2018-05-31 10:39:451263parcourir

Cette fois, je vais vous montrer comment utiliser les composants VueJs pour la communication parent-enfant (avec code), et quelles sont les précautions pour l'utilisation des composants VueJs pour la communication parent-enfant. Ce qui suit est un exemple pratique. cas, jetons un coup d'oeil.

Composant (communication parent-enfant)

1.Résumé

Définir un autre composant au sein d'un composant, qui est appelé. Composants parent-enfant.

Mais veuillez noter : 1. Les composants enfants ne peuvent être utilisés qu'à l'intérieur du composant parent (écrit dans le modèle du composant parent) ; Les données sur la portée de chaque instance de composant sont indépendantes ; Comment compléter la communication entre père et fils, en une phrase simple : accessoires vers le bas, événements vers le haut : le composant parent transmet les données vers le bas au composant enfant via props , le composant enfant envoie

au composant parent via des événements : Props

du fils au parent : Enfant : $emit(eventName) Parent $on(eventName)

Le parent accède à l'enfant : ref

Les trois cas suivants seront expliqués :

2. Passer de père en fils : Accessoires

La portée de l'instance de composant est isolée. Cela signifie que vous ne pouvez pas (et ne devez pas) référencer les données du composant parent directement dans le modèle du composant enfant. Pour permettre au composant enfant d'utiliser les données du composant parent, vous devez utiliser l'option props du composant enfant L'utilisation de Prop pour transférer des données inclut des formulaires statiques et dynamiques

1. Accessoires statiques

Effet :

<script src="https://unpkg.com/vue"></script>
<p id="example">
 <parent></parent>
</p>
<script>
 //要想子组件能够获取父组件的，那么在子组件必须申明:props
 var childNode = {
  template: '<p>{{message}}</p>',
  props: ['message']
 }
 //这里的message要和上面props中值一致
 var parentNode = {
  template: `
   <p class="parent">
   <child message="我是"></child>
   <child message="徐小小"></child>
   </p>`,
  components: {
   'child': childNode
  }
 };
 // 创建根实例
 new Vue({
  el: '#example',
  components: {
   'parent': parentNode
  }
 })
</script>

Convention de dénomination :

Pour les attributs déclarés par les accessoires, dans le modèle HTML parent, les noms d'attribut doivent être écrits en tirets

Lors de la déclaration des attributs d'accessoires enfants, vous pouvez utiliser une petite casse ou des tirets lorsque le modèle enfant utilise des variables transmises par le parent, vous devez utiliser le correspondant ; Petite bosse d'écriture

Que signifie la phrase ci-dessus ?

Si myMessage dans notre childNode est remplacé par {{my-message}}, regardez les résultats en cours :

<script>
 //这里需要注意的是props可以写成['my-message']或者['myMessage']都是可以的
 //但是template里的属性名，只能是驼峰式{{myMessage}}，如果也写成{{my-message}}那么是无效的
 var childNode = {
  template: '<p>{{myMessage}}</p>',
  props: ['myMessage']
 }
 //这里的属性名为my-message
 var parentNode = {
  template: `
   <p class="parent">
   <child my-message="我是"></child>
   <child my-message="徐小小"></child>
   </p>`,
  components: {
   'child': childNode
  }
 };
</script>

Dans le modèle, vous devez lier dynamiquement les données du composant parent aux accessoires du modèle enfant, ce qui est similaire à la liaison à n'importe quelle fonctionnalité HTML ordinaire, à l'aide de v-bind. Chaque fois que les données du composant parent changent, la modification sera également transmise au composant enfant

3. Passer les numéros

Une erreur courante que commettent les débutants est d'utiliser une syntaxe littérale pour transmettre des valeurs

 var childNode = {
  template: '<p>{{myMessage}}</p>',
  props: ['my-message']
    }
 var parentNode = {
  template: `
 <p class="parent">
 <child :my-message="data1"></child>
 <child :my-message="data2"></child>
 </p>`,
  components: {
   'child': childNode
  },
  data() {
   return {
    'data1': '111',
    'data2': '222'
   }
  }
 };

Résultat :

<script src="https://unpkg.com/vue"></script>
<p id="example">
 <parent></parent>
</p>
<script>
 var childNode = {
  template: '<p>{{myMessage}}的类型是{{type}}</p>',
  props: ['myMessage'],
  computed: {
   type() {
    return typeof this.myMessage
   }
  }
 }
 var parentNode = {
  template: `
 <p class="parent">
 <my-child my-message="1"></my-child>
 </p>`,
  components: {
   'myChild': childNode
  }
 };
 // 创建根实例
 new Vue({
  el: '#example',
  components: {
   'parent': parentNode
  }
 })
</script>

Parce qu'il s'agit d'un accessoire littéral, sa valeur est

string "1" à la place. de numéro. Si vous souhaitez transmettre un nombre réel, vous devez utiliser v-bind, afin que sa valeur soit traitée comme une expression JS

calcul Comment convertir une chaîne en nombre ? il vous suffit de changer d'endroit.

Bien sûr, si vous souhaitez transmettre un type de chaîne via v-bind, que devez-vous faire ?

Nous pouvons utiliser des accessoires dynamiques et définir le numéro correspondant 1 dans l'attribut data

 var parentNode = {
  template: `
 <p class="parent">
 //只要把父组件my-message="1"改成:my-message="1"结果就变成number类型
 <my-child :my-message="1"></my-child>
 </p>`,
 };

3. Enfant à parent : $emit

var parentNode = {
 template: `
 <p class="parent">
 <my-child :my-message="data"></my-child>
 </p>`,
 components: {
 'myChild': childNode
 },
 //这里'data': 1代表就是number类型，'data': "1"那就代表String类型
 data(){
 return {
  'data': 1
 }
 }
};

À propos de l'utilisation de $emit 1. Les composants parents peuvent utiliser des accessoires pour transmettre des données aux composants enfants.

2. Les sous-composants peuvent utiliser $emit pour déclencher des événements personnalisés des composants parents.

Clé primaire enfant

Composant parent

<template> 
 <p class="train-city"> 
 <span @click=&#39;select(`大连`)&#39;>大连</span> 
 </p> 
</template> 
<script> 
export default { 
 name:'trainCity', 
 methods:{ 
 select(val) { 
  let data = { 
  cityname: val 
  }; 
  this.$emit('showCityName',data);//select事件触发后，自动触发showCityName事件 
 } 
 } 
} 
</script>

Le résultat est : toCity : Dalian

Le deuxième cas

<template> 
 <trainCity @showCityName="updateCity" :index="goOrtoCity"></trainCity> //监听子组件的showCityName事件。 
<template> 
<script> 
export default { 
 name:'index', 
 data () { 
 return { 
  toCity:"北京" 
 } 
 } 
 methods:{ 
 updateCity(data){//触发子组件城市选择-选择城市的事件 
  this.toCity = data.cityname;//改变了父组件的值 
  console.log('toCity:'+this.toCity)  
 } 
 } 
} 
</script>

Explication détaillée :

1：button-counter作为父主键，父主键里有个button按钮。

2:两个button都绑定了click事件，方法里： this.$emit('increment1', [12, 'kkk']);，那么就会去调用父类v-on所监听的increment1事件。

3：当increment1事件被监听到，那么执行incrementTotal，这个时候才会把值传到父组件中，并且调用父类的方法。

4：这里要注意第二个button-counter所对应的v-on:'increment2,而它里面的button所对应是this.$emit('increment1', [12, 'kkk']);所以第二个button按钮是无法把值传给他的父主键的。

示例：一个按钮点击一次那么它自身和上面都会自增1，而第二个按钮只会自己自增，并不影响上面这个。

还有就是第一个按钮每点击一次，后台就会打印一次如下：

四、ref ($refs)用法

ref 有三种用法

1.ref 加在普通的元素上，用this.ref.name 获取到的是dom元素

2.ref 加在子组件上，用this.ref.name 获取到的是组件实例，可以使用组件的所有方法。

3.如何利用v-for 和ref 获取一组数组或者dom 节点

1.ref 加在普通的元素上，用this.ref.name 获取到的是dom元素

<script src="https://unpkg.com/vue"></script>
<p id="ref-outside-component" v-on:click="consoleRef">
 <component-father ref="outsideComponentRef">
 </component-father>
 <p>ref在外面的组件上</p>
</p>
<script>
 var refoutsidecomponentTem = {
  template: "<p class=&#39;childComp&#39;><h5>我是子组件</h5></p>"
 };
 var refoutsidecomponent = new Vue({
  el: "#ref-outside-component",
  components: {
   "component-father": refoutsidecomponentTem
  },
  methods: {
   consoleRef: function() {
    console.log(this.); // #ref-outside-component  vue实例
    console.log(this.$refs.outsideComponentRef); // p.childComp vue实例
   }
  }
 });
</script>

效果：当在p访问内点击一次：

2.ref使用在外面的元素上

<script src="https://unpkg.com/vue"></script>
<!--ref在外面的元素上-->
<p id="ref-outside-dom" v-on:click="consoleRef">
 <component-father>
 </component-father>
 <p ref="outsideDomRef">ref在外面的元素上</p>
</p>
<script>
 var refoutsidedomTem = {
  template: "<p class=&#39;childComp&#39;><h5>我是子组件</h5></p>"
 };
 var refoutsidedom = new Vue({
  el: "#ref-outside-dom",
  components: {
   "component-father": refoutsidedomTem
  },
  methods: {
   consoleRef: function() {
    console.log(this); // #ref-outside-dom vue实例
    console.log(this.$refs.outsideDomRef); // <p> ref在外面的元素上</p>
   }
  }
 });
</script>

效果：当在p访问内点击一次：

3.ref使用在里面的元素上---局部注册组件

<script src="https://unpkg.com/vue"></script>
<!--ref在里面的元素上-->
<p id="ref-inside-dom">
 <component-father>
 </component-father>
 <p>ref在里面的元素上</p>
</p>
<script>
 var refinsidedomTem = {
  template: "<p class=&#39;childComp&#39; v-on:click=&#39;consoleRef&#39;>" +
   "<h5 ref=&#39;insideDomRef&#39;>我是子组件</h5>" +
   "</p>",
  methods: {
   consoleRef: function() {
    console.log(this); // p.childComp vue实例 
    console.log(this.$refs.insideDomRef); // <h5 >我是子组件</h5>
   }
  }
 };
 var refinsidedom = new Vue({
  el: "#ref-inside-dom",
  components: {
   "component-father": refinsidedomTem
  }
 });
</script>

效果：当在click范围内点击一次：

4.ref使用在里面的元素上---全局注册组件

<script src="https://unpkg.com/vue"></script>
<!--ref在里面的元素上--全局注册-->
<p id="ref-inside-dom-all">
 <ref-inside-dom-quanjv></ref-inside-dom-quanjv>
</p>
<script>
 //v-on:input指当input里值发生改变触发showinsideDomRef事件
 Vue.component("ref-inside-dom-quanjv", {
  template: "<p class=&#39;insideFather&#39;> " +
   "<input type=&#39;text&#39; ref=&#39;insideDomRefAll&#39; v-on:input=&#39;showinsideDomRef&#39;>" +
   " <p>ref在里面的元素上--全局注册 </p> " +
   "</p>",
  methods: {
   showinsideDomRef: function() {
    console.log(this); //这里的this其实还是p.insideFather
    console.log(this.$refs.insideDomRefAll); // <input type="text">
   }
  }
 });
 var refinsidedomall = new Vue({
  el: "#ref-inside-dom-all"
 });
</script>

效果：当我第一次输入1时，值已改变出发事件，当我第二次在输入时在触发一次事件，所以后台应该打印两次

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

Articles Liés

Voir plus