Zusammenfassung der gegenseitigen Eltern-Kind-Kommunikationsmethoden in VueJs-Komponenten

Dieses Mal werde ich Ihnen eine Zusammenfassung der gegenseitigen Kommunikationsmethoden zwischen Vater und Sohn in der VueJs-Komponente geben. Was sind die Vorsichtsmaßnahmen für die gegenseitige Kommunikation zwischen Vater und Sohn in der VueJs-Komponente? Das Folgende ist ein praktischer Fall, werfen wir einen Blick darauf.

Komponente (Eltern-Kind-Kommunikation)

1. Zusammenfassung

Definieren Sie eine weitere Komponente innerhalb einer Komponente, die aufgerufen wird Eltern-Kind-Komponenten.

Aber bitte beachten Sie: 1. Untergeordnete Komponenten können nur innerhalb der übergeordneten Komponente verwendet werden (geschrieben in der übergeordneten Komponentenvorlage); der Umfang jeder Komponenteninstanz ist unabhängig; So vervollständigen Sie die Kommunikation zwischen Vater und Sohn in einem einfachen Satz: Requisiten runter, Ereignisse hoch: Die übergeordnete Komponente leitet Daten über props an die untergeordnete Komponente weiter, die untergeordnete Komponente sendet

über Ereignisse an die übergeordnete Komponente : Requisiten

vom Sohn zum Elternteil: Kind: $emit(eventName) Elternteil $on(eventName)

Elternteil greift auf Kind zu: ref

Die folgenden drei Fälle werden erklärt:

2. Weitergabe vom Vater an den Sohn: Requisiten

Der Umfang der Komponenteninstanz ist isoliert. Das bedeutet, dass Sie die Daten der übergeordneten Komponente nicht direkt in der Vorlage der untergeordneten Komponente referenzieren können (und sollten). Damit die untergeordnete Komponente die Daten der übergeordneten Komponente verwenden kann, müssen Sie die Props-Option der untergeordneten Komponente verwenden Die Verwendung von Prop zum Übertragen von Daten umfasst zunächst statische Requisiten

1. Statische Requisiten

<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>

Wirkung:

Namenskonvention:

Für durch Requisiten deklarierte Attribute im übergeordneten HTML Vorlage, Attributname Es ist notwendig, die Unterstrich-Schreibmethode zu verwenden

Wenn Sie das untergeordnete Requisitenattribut deklarieren, können Sie die Kleinschreibung oder die Unterstrich-Schreibmethode verwenden, wenn die untergeordnete Vorlage vom übergeordneten Element übergebene Variablen verwendet , Sie müssen das entsprechende kleine Kameletui verwenden Geschrieben

Was bedeutet der obige Satz?

<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>

Wenn myMessage in unserem childNode in {{my-message}} geändert wird, sehen Sie sich die laufenden Ergebnisse an:

2. Dynamische Requisiten

In der Vorlage müssen Sie die Daten der übergeordneten Komponente mithilfe von v-bind dynamisch an die Requisiten der untergeordneten Vorlage binden, was der Bindung an jede gewöhnliche HTML-Funktion ähnelt. Immer wenn sich die Daten der übergeordneten Komponente ändern, wird die Änderung auch an die untergeordnete Komponente übertragen

 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'
   }
  }
 };

3. Übergeben von Zahlen

Ein häufiger Fehler, den Anfänger machen, ist die Verwendung einer wörtlichen Syntax zur Übergabe von Werten

<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>

Ergebnis:

Da es sich um eine Literal-Requisite handelt, ist ihr Wert

Zeichenfolge „1“ anstelle einer Zahl. Wenn Sie eine tatsächliche Zahl übergeben möchten, müssen Sie v-bind verwenden, damit sein Wert als JS

-Ausdruck

-Berechnung behandelt wird. Wie konvertiert man einen String tatsächlich in eine Zahl? Sie müssen nur einen Ort wechseln.

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

Was sollten Sie natürlich tun, wenn Sie einen String-Typ über v-bind übergeben möchten?

Wir können dynamische Requisiten verwenden und die entsprechende Zahl 1 im Datenattribut festlegen >

Über die Verwendung von $emit

1. Übergeordnete Komponenten können Requisiten verwenden, um Daten an untergeordnete Komponenten zu übergeben .

2. Unterkomponenten können $emit verwenden, um benutzerdefinierte Ereignisse von übergeordneten Komponenten auszulösen.

Untergeordneter Primärschlüssel

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
 }
 }
};

Übergeordnete Komponente

<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>

Das Ergebnis ist: toCity: Dalian

Der zweite Fall

<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>

ausführliche Erklärung :

   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中文网其它相关文章！

推荐阅读：

Vue数组变异实现详解

Vue数据响应式原理分析

vue个人信息查看与密码修改如何实现

Das obige ist der detaillierte Inhalt vonZusammenfassung der gegenseitigen Eltern-Kind-Kommunikationsmethoden in VueJs-Komponenten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!