So interagieren Sie mit Angular-Komponenten-js-Tutorial-php.cn

Dieses Mal zeige ich Ihnen, wie Sie Angular-Komponenten für die Interaktion verwenden und welche Vorsichtsmaßnahmen für die Verwendung von Angular-Komponenten für die Interaktion gelten. Das Folgende ist ein praktischer Fall, schauen wir uns das an.

Die übergeordnete Komponente übergibt die

an die untergeordnete Komponente über den @Input-Dekorator, um das Eingabeattribut zu definieren, und dann verweist die übergeordnete Komponente darauf Unterkomponente Übergibt Daten über diese Eingabeeigenschaften an Unterkomponenten, und Unterkomponenten können Änderungen in Eingabeeigenschaftswerten über Setter oder ngOnChanges() abfangen.

Definieren Sie zunächst zwei Komponenten, nämlich die Unterkomponente DemoChildComponent und die übergeordnete Komponente DemoParentComponent.

Unterkomponente:

@Component({
 selector: 'demo-child',
 template: `
 <p>{{paramOne}}</p>
 <p>{{paramTwo}}</p>
 `
})
export class DemoChildComponent {
 @Input() paramOne: any; // 输入属性1
 @Input() paramTwo: any; // 输入属性2
}

Nach dem Login kopieren

Die Unterkomponente definiert die Eingabeattribute paramOne und paramTwo (der Attributwert kann ein beliebiger Datentyp sein)

Übergeordnete Komponente:

@Component({
 selector: 'demo-parent',
 template: `
 <demo-child [paramOne]=&#39;paramOneVal&#39; [paramTwo]=&#39;paramTwoVal&#39;></demo-child>
 `
})
export class DemoParentComponent {
 paramOneVal: any = '传递给paramOne的数据';
 paramTwoVal: any = '传递给paramTwo的数据';
}

Nach dem Login kopieren

Die übergeordnete Komponente verweist über den Selektor demo-child in ihrer Vorlage auf die untergeordnete Komponente DemoChildComponent und übergibt die beiden der untergeordneten Komponente Eingabeattribute paramOne und paramTwo zur Übergabe von Daten an die Unterkomponente. Schließlich werden die beiden Textzeilen, die an paramOne und die an paramTwo übergebenen Daten, in der Vorlage der Unterkomponente angezeigt.

Abfangen von Änderungen in Eingabeattributwerten durch Setter

In praktischen Anwendungen müssen wir häufig entsprechende Operationen ausführen, wenn sich ein Eingabeattributwert ändert Zeit müssen wir den Setter des Eingabeattributs verwenden, um Änderungen im Eingabeattributwert abzufangen.

Wir haben die Unterkomponente DemoChildComponent wie folgt transformiert:

@Component({
 selector: 'demo-child',
 template: `
 <p>{{paramOneVal}}</p>
 <p>{{paramTwo}}</p>
 `
})
export class DemoChildComponent {
 private paramOneVal: any;
 
 @Input() 
 set paramOne (val: any) { // 输入属性1
  this.paramOneVal = val;
  // dosomething
 };
 get paramOne () {
  return this.paramOneVal;
 };
 
 @Input() paramTwo: any; // 输入属性2
}

Nach dem Login kopieren

Im obigen Code können wir sehen, dass der abgefangene Wert val durch den Setter von paramOne der internen privaten Eigenschaft paramOneVal zugewiesen wird Eigenschaft. Erzielen Sie den Effekt, dass die übergeordnete Komponente Daten an die untergeordnete Komponente weitergibt. Das Wichtigste ist natürlich, dass Sie im Setter mehr andere Operationen ausführen können, was das Programm flexibler macht.

Verwenden Sie ngOnChanges(), um Änderungen in Eingabeattributwerten abzufangen

Die Methode zum Abfangen von Änderungen in Eingabeattributwerten über Setter kann nur Änderungen in einem einzelnen Attribut überwachen value ist diese Methode nicht ausreichend, wenn mehrere interaktive Eingabeattribute überwacht werden müssen. Mithilfe der ngOnChanges()-Methode der OnChanges-Lebenszyklus-Hook-Schnittstelle (wird aufgerufen, wenn sich der Wert der von der Komponente durch den @Input-Dekorator explizit angegebenen Variablen ändert) können Sie Änderungen der Werte mehrerer Eingabeeigenschaften gleichzeitig überwachen.

Fügen Sie ngOnChanges in der Unterkomponente DemoChildComponent hinzu:

@Component({
 selector: 'demo-child',
 template: `
 <p>{{paramOneVal}}</p>
 <p>{{paramTwo}}</p>
 `
})
export class DemoChildComponent implements OnChanges {
 private paramOneVal: any;
 
 @Input() 
 set paramOne (val: any) { // 输入属性1
  this.paramOneVal = val;
  // dosomething
 };
 get paramOne () {
  return this.paramOneVal;
 };
 
 @Input() paramTwo: any; // 输入属性2
 
 ngOnChanges(changes: {[propKey: string]: SimpleChange}) {
  for (let propName in changes) { // 遍历changes
   let changedProp = changes[propName]; // propName是输入属性的变量名称
   let to = JSON.stringify(changedProp.currentValue); // 获取输入属性当前值
   if (changedProp.isFirstChange()) { // 判断输入属性是否首次变化
    console.log(`Initial value of ${propName} set to ${to}`);
   } else {
    let from = JSON.stringify(changedProp.previousValue); // 获取输入属性先前值
    console.log(`${propName} changed from ${from} to ${to}`);
   }
  }
 }
}

Nach dem Login kopieren

Die von der neuen ngOnChanges-Methode empfangenen Parameteränderungen sind ein Objekt mit dem Eingabeattributnamen als Schlüssel und dem Wert als SimpleChange Das Objekt enthält das aktuelle Eingabeattribut, unabhängig davon, ob es sich um die erste Änderung, den vorherigen Wert, den aktuellen Wert und andere Attribute handelt. Daher können in der ngOnChanges-Methode mehrere Eingabeattributwerte überwacht und entsprechende Vorgänge durch Durchlaufen des Änderungsobjekts ausgeführt werden.

Rufen Sie die Instanz der übergeordneten Komponente ab

Die vorherige Einführung besteht darin, dass die untergeordnete Komponente das Eingabeattribut über den @Input-Dekorator definiert, sodass die übergeordnete Komponente Daten an diese übergeben kann das Kind durch die Eingabeattributkomponenten.

Natürlich können wir uns eine proaktivere Methode vorstellen, die darin besteht, die Instanz der übergeordneten Komponente abzurufen und dann eine Eigenschaft oder Methode der übergeordneten Komponente aufzurufen, um die erforderlichen Daten zu erhalten. Da jede Komponenteninstanz dem Container des Injektors hinzugefügt wird, kann die Instanz der übergeordneten Komponente durch Abhängigkeitsinjektion gefunden werden.

Für die untergeordnete Komponente ist es schwieriger, die Instanz der übergeordneten Komponente abzurufen, als für die übergeordnete Komponente, die Instanz der untergeordneten Komponente abzurufen (direkt über die Vorlagenvariablen @ViewChild oder @ViewChildren abgerufen).

Um die Instanz der übergeordneten Komponente in der untergeordneten Komponente abzurufen, gibt es zwei Situationen:

Der Typ der übergeordneten Komponente ist bekannt

In dieser Situation kann eine übergeordnete Komponentenreferenz eines bekannten Typs direkt durch Einfügen von DemoParentComponent in den Konstruktor abgerufen werden. Das Codebeispiel lautet wie folgt:

@Component({
 selector: 'demo-child',
 template: `
 <p>{{paramOne}}</p>
 <p>{{paramTwo}}</p>
 `
})
export class DemoChildComponent {
 paramOne: any;
 paramTwo: any;
 constructor(public demoParent: DemoParentComponent) {
  // 通过父组件实例demoParent获取数据
  this.paramOne = demoParent.paramOneVal;
  this.paramTwo = demoParent.paramTwoVal;
 }
}

Nach dem Login kopieren

Der Typ der unbekannten übergeordneten Komponente

Eine Komponente kann sein. Bei Unterkomponenten mehrerer Komponenten ist es manchmal unmöglich, den Typ der übergeordneten Komponente direkt zu kennen. In Angular kann sie über die Klassenschnittstellenmethode gesucht werden, dh die übergeordnete Komponente kann durchsucht werden Bereitstellung einer Klassenschnittstellen-ID mit demselben Namen, um die Suche zu erleichtern.

Erstellen Sie zunächst die abstrakte Klasse DemoParent, die nur die Attribute paramOneVal und paramTwoVal ohne Implementierung (Zuweisung) deklariert. Der Beispielcode lautet wie folgt:

export abstract class DemoParent {
 paramOneVal: any;
 paramTwoVal: any;
}

Nach dem Login kopieren

Definieren Sie dann eines in den Provider-Metadaten des Alias-Anbieter der übergeordneten Komponente DemoParentComponent, verwenden Sie useExisting, um eine Instanz der übergeordneten Komponente DemoParentComponent einzufügen. Das Codebeispiel lautet wie folgt:

@Component({
 selector: 'demo-parent',
 template: `
 <demo-child [paramOne]=&#39;paramOneVal&#39; [paramTwo]=&#39;paramTwoVal&#39;></demo-child>
 `,
 providers: [{provider: DemoParent, useExisting: DemoParentComponent}]
})
export class DemoParentComponent implements DemoParent {
 paramOneVal: any = '传递给paramOne的数据';
 paramTwoVal: any = '传递给paramTwo的数据';
}

Nach dem Login kopieren

Dann können Sie das Beispiel der übergeordneten Komponente über die DemoParent-Kennung finden Untergeordnete Komponente. Der Beispielcode lautet wie folgt:

@Component({
 selector: 'demo-child',
 template: `
 <p>{{paramOne}}</p>
 <p>{{paramTwo}}</p>
 `
})
export class DemoChildComponent {
 paramOne: any;
 paramTwo: any;
 constructor(public demoParent: DemoParent) {
  // 通过父组件实例demoParent获取数据
  this.paramOne = demoParent.paramOneVal;
  this.paramTwo = demoParent.paramTwoVal;
 }
}

Nach dem Login kopieren

子组件向父组件传递

依然先定义两个组件，分别为子组件DemoChildComponent和父组件DemoParentComponent.

子组件：

@Component({
 selector: 'demo-child',
 template: `
 <p>子组件DemoChildComponent</p>
 `
})
export class DemoChildComponent implements OnInit {
 readyInfo: string = '子组件DemoChildComponent初始化完成！';
 @Output() ready: EventEmitter = new EventEmitter<any>(); // 输出属性
 
 ngOnInit() {
  this.ready.emit(this.readyInfo);
 }
}

Nach dem Login kopieren

父组件：

@Component({
 selector: 'demo-parent',
 template: `
 <demo-child (ready)="onReady($event)" #demoChild></demo-child>
 <p>
  <!-- 通过本地变量获取readyInfo属性，显示：子组件DemoChildComponent初始化完成！ -->
  readyInfo: {{demoChild.readyInfo}}
 </p>
 <p>
  <!-- 通过组件类获取子组件示例，然后获取readyInfo属性，显示：子组件DemoChildComponent初始化完成！ -->
  readyInfo: {{demoChildComponent.readyInfo}}
 </p>
 `
})
export class DemoParentComponent implements AfterViewInit {
 // @ViewChild('demoChild') demoChildComponent: DemoChildComponent; // 通过模板别名获取
 @ViewChild(DemoChildComponent) demoChildComponent: DemoChildComponent; // 通过组件类型获取
 
 ngAfterViewInit() {
  console.log(this.demoChildComponent.readyInfo); // 打印结果：子组件DemoChildComponent初始化完成！
 }
 onReady(evt: any) {
  console.log(evt); // 打印结果：子组件DemoChildComponent初始化完成！
 }
}

Nach dem Login kopieren

父组件监听子组件的事件

子组件暴露一个 EventEmitter 属性，当事件发生时，子组件利用该属性 emits(向上弹射)事件。父组件绑定到这个事件属性，并在事件发生时作出回应。

在上面定义好的子组件和父组件，我们可以看到：

子组件通过@Output()定义输出属性ready，然后在ngOnInit中利用ready属性的 emits(向上弹射)事件。

父组件在其模板中通过选择器demo-child引用子组件DemoChildComponent，并绑定了一个事件处理器(onReady())，用来响应子组件的事件($event)并打印出数据（onReady($event)中的$event是固定写法，框架(Angular)把事件参数(用 $event 表示)传给事件处理方法）。

父组件与子组件通过本地变量（模板变量）互动

父组件不能使用数据绑定来读取子组件的属性或调用子组件的方法。但可以在父组件模板里，新建一个本地变量来代表子组件，然后利用这个变量来读取子组件的属性和调用子组件的方法。

在上面定义好的子组件和父组件，我们可以看到：

父组件在模板demo-child标签上定义了一个demoChild本地变量，然后在模板中获取子组件的属性：

<p>
 <!-- 获取子组件的属性readyInfo，显示：子组件DemoChildComponent初始化完成！ -->
 readyInfo: {{demoChild.readyInfo}}
</p>

Nach dem Login kopieren

父组件调用@ViewChild()

本地变量方法是个简单便利的方法。但是它也有局限性，因为父组件-子组件的连接必须全部在父组件的模板中进行。父组件本身的代码对子组件没有访问权。

如果父组件的类需要读取子组件的属性值或调用子组件的方法，就不能使用本地变量方法。

当父组件类需要这种访问时，可以把子组件作为 ViewChild，注入到父组件里面。

在上面定义好的子组件和父组件，我们可以看到：

父组件在组件类中通过@ViewChild()获取到子组件的实例，然后就可以在模板或者组件类中通过该实例获取子组件的属性：

<p>
 <!-- 通过组件类获取子组件示例，然后获取readyInfo属性，显示：子组件DemoChildComponent初始化完成！ -->
 readyInfo: {{demoChildComponent.readyInfo}}
</p>

Nach dem Login kopieren

ngAfterViewInit() {
 console.log(this.demoChildComponent.readyInfo); // 打印结果：子组件DemoChildComponent初始化完成！
}

Nach dem Login kopieren

通过服务传递

Angular的服务可以在模块注入或者组件注入（均通过providers注入）。

在模块中注入的服务在整个Angular应用都可以访问（除惰性加载的模块）。

在组件中注入的服务就只能该组件和其子组件进行访问，这个组件子树之外的组件将无法访问该服务或者与它们通讯。

下面的示例就以在组件中注入的服务来进行父子组件之间的数据传递：

通讯的服务：

@Injectable()
export class CallService {
 info: string = '我是CallService的info';
}

Nach dem Login kopieren

父组件：

@Component({
 selector: 'demo-parent',
 template: `
 <demo-child></demo-child>
 <button (click)="changeInfo()">父组件改变info</button>
 <p>
  <!-- 显示：我是CallService的info -->
  {{callService.info}}
 </p>
 `,
 providers: [CallService]
})
export class DemoParentComponent {
 constructor(public callService: CallService) {
  console.log(callService.info); // 打印结果：我是CallService的info
 }
 
 changeInfo() {
  this.callService.info = '我是被父组件改变的CallService的info';
 }
}

Nach dem Login kopieren

子组件：

@Component({
 selector: 'demo-child',
 template: `
 <button (click)="changeInfo()">子组件改变info</button>
 `
})
export class DemoChildComponent {
 constructor(public callService: CallService) {
  console.log(callService.info); // 打印结果：我是CallService的info
 }
 
 changeInfo() {
  this.callService.info = '我是被子组件改变的CallService的info';
 }
}

Nach dem Login kopieren

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