Comment interagir avec les composants angulaires

Cette fois, je vais vous montrer comment utiliser les composants angulaires pour interagir, et quelles sont les précautions à prendre pour utiliser les composants angulaires pour interagir. Ce qui suit est un cas pratique, jetons un coup d'œil.

Le composant parent transmet

le composant enfant définit l'attribut d'entrée via le décorateur @Input, puis le composant parent fait référence au composant enfant Transmettez les données aux sous-composants via ces propriétés d'entrée, et les sous-composants peuvent intercepter les modifications des valeurs des propriétés d'entrée via des setters ou ngOnChanges().

Définissez d'abord deux composants, à savoir le sous-composant DemoChildComponent et le composant parent DemoParentComponent.

Sous-composant :

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

Le sous-composant définit les attributs d'entrée via @Input() paramOne et paramTwo (la valeur de l'attribut peut être n'importe quel type de données)

Composant parent :

@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的数据';
}

Le composant parent fait référence au composant enfant DemoChildComponent via le sélecteur demo-child dans son modèle, et via l'enfant. Les deux attributs d'entrée du composant, paramOne et paramTwo, transmettent les données au sous-composant. Enfin, les deux lignes de texte, les données transmises à paramOne et les données transmises à paramTwo, sont affichées dans le. modèle du sous-composant.

Interception des modifications des valeurs d'attribut d'entrée via des setters

Dans les applications pratiques, nous devons souvent effectuer des opérations correspondantes lorsqu'une valeur d'attribut d'entrée change. La fois où nous devons utiliser le setter de l'attribut d'entrée pour intercepter les changements dans la valeur de l'attribut d'entrée.

Nous avons transformé le sous-composant DemoChildComponent comme suit :

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

Dans le code ci-dessus, nous pouvons voir que la valeur interceptée val est affectée à la propriété privée interne via le setter du Attribut paramOne. paramOneVal obtient l'effet du composant parent transmettant des données au composant enfant. Bien sûr, le plus important est que vous puissiez effectuer davantage d'autres opérations dans le setter, ce qui rend le programme plus flexible.

Utilisez ngOnChanges() pour intercepter les modifications des valeurs des attributs d'entrée

La méthode d'interception des modifications des valeurs des attributs d'entrée via setter ne peut surveiller les modifications que dans un seul attribut value , si vous devez surveiller plusieurs attributs d'entrée interactifs, cette méthode devient insuffisante. En utilisant la méthode ngOnChanges() de l'interface hook de cycle de vie OnChanges (appelée lorsque la valeur des variables explicitement spécifiées par le composant via le décorateur @Input change), vous pouvez surveiller simultanément les modifications des valeurs de plusieurs propriétés d'entrée.

Ajoutez ngOnChanges dans le sous-composant DemoChildComponent :

@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}`);
   }
  }
 }
}

Les modifications de paramètre reçues par la nouvelle méthode ngOnChanges sont un objet avec le nom de l'attribut d'entrée comme clé et la valeur comme SimpleChange. L'objet SimpleChange contient les attributs d'entrée actuels, par exemple si l'attribut change pour la première fois, la valeur précédente, la valeur actuelle, etc. Par conséquent, dans la méthode ngOnChanges, plusieurs valeurs d'attribut d'entrée peuvent être surveillées et les opérations correspondantes effectuées en parcourant l'objet changes.

Obtenir l'instance du composant parent

L'introduction précédente est que le composant enfant définit l'attribut d'entrée via le décorateur @Input, afin que le composant parent puisse transmettre des données à l'enfant via les composants d'attribut d'entrée.

Bien sûr, nous pouvons penser à une méthode plus proactive, qui consiste à obtenir l'instance du composant parent puis à appeler une propriété ou une méthode du composant parent pour obtenir les données requises. Étant donné que chaque instance de composant est ajoutée au conteneur de l'injecteur, l'instance du composant parent peut être trouvée via l'injection de dépendances.

Il est plus difficile pour un composant enfant d'obtenir l'instance du composant parent que pour le composant parent d'obtenir l'instance du composant enfant (obtenue directement via les variables de modèle, @ViewChild ou @ViewChildren).

Pour récupérer l'instance du composant parent dans le composant enfant, il existe deux situations :

Le type du composant parent est connu

Cette situation peut obtenir une référence de composant parent d'un type connu directement en injectant DemoParentComponent dans le constructeur. L'exemple de code est le suivant :

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

Type de composant parent inconnu

<.>Un composant Il peut s'agir d'un sous-composant de plusieurs composants. Parfois, le type du composant parent ne peut pas être connu directement dans Angular, il peut être trouvé via la méthode class-interface (Class-Interface), c'est-à-dire le composant parent. fournit un identifiant d'interface de classe. Un alias avec le même nom pour faciliter la recherche.

Créez d'abord la classe abstraite DemoParent, qui déclare uniquement les attributs paramOneVal et paramTwoVal sans implémentation (affectation). L'exemple de code est le suivant :

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

Puis dans les métadonnées des fournisseurs du. composant parent DemoParentComponent Définissez un alias Provider et utilisez useExisting pour injecter une instance du composant parent DemoParentComponent L'exemple de code est le suivant :

@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的数据';
}

Ensuite dans le composant enfant, vous pouvez retrouver l'exemple du parent. composant via l’identifiant DemoParent. L’exemple de code est le suivant :

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

子组件向父组件传递

依然先定义两个组件，分别为子组件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);
 }
}

父组件：

@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初始化完成！
 }
}

父组件监听子组件的事件

子组件暴露一个 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>

父组件调用@ViewChild()

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

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

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

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

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

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

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

通过服务传递

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

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

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

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

通讯的服务：

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

父组件：

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

子组件：

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

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

推荐阅读：

css的新属性display:box使用方法

JS代码做出txt文件上传预览

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!