Je viens de commencer à travailler avec Angular 2.
Je me demandais quelles sont les différences entre les composants et les directives dans Angular 2?
Je viens de commencer à travailler avec Angular 2.
Je me demandais quelles sont les différences entre les composants et les directives dans Angular 2?
Réponses:
Fondamentalement, il existe trois types de directives dans Angular2 selon la documentation.
C'est aussi un type de directive avec un modèle, des styles et une partie logique qui est le type de directive le plus célèbre parmi tous dans Angular2. Dans ce type de directive, vous pouvez utiliser d'autres directives, qu'elles soient personnalisées ou intégrées dans l' @Component
annotation, comme suit:
@Component({
selector: "my-app"
directives: [custom_directive_here]
})
Utilisez cette directive dans votre vue comme:
<my-app></my-app>
Pour la directive relative aux composants, j'ai trouvé le meilleur tutoriel ici.
Comme *ngFor
et *ngIf
, utilisé pour changer la disposition DOM en ajoutant et en supprimant des éléments DOM. expliqué ici
Ils sont utilisés pour donner un comportement ou un style personnalisé aux éléments existants en appliquant certaines fonctions / logique. Like ngStyle
est une directive d'attribut pour donner du style dynamiquement aux éléments. Nous pouvons créer notre propre directive et l'utiliser comme attribut de certains éléments prédéfinis ou personnalisés, voici l'exemple d'une directive simple:
Premièrement, nous devons importer la directive de @angular/core
import {Directive, ElementRef, Renderer, Input} from '@angular/core';
@Directive({
selector: '[Icheck]',
})
export class RadioCheckbox {
// custom logic here...
}
Nous pouvons l'utiliser dans la vue comme indiqué ci-dessous:
<span Icheck>HEllo Directive</span>
Pour plus d'informations, vous pouvez lire le tutoriel officiel ici et ici
Les composants ont leur propre vue (HTML et styles). Les directives ne sont que des "comportements" ajoutés aux éléments et composants existants.
Component
s'étend Directive
.
Pour cette raison, il ne peut y avoir qu'un seul composant sur un élément hôte, mais plusieurs directives.
Les directives structurelles sont des directives appliquées aux <template>
éléments et utilisées pour ajouter / supprimer du contenu (tamponner le modèle). Les *
applications de directive in comme *ngIf
provoquent la <template>
création implicite d' une balise.
Pour compléter ce que Günter a dit, nous pouvons distinguer deux types de directives:
NgFor
et NgIf
. Ceux-ci sont liés au concept de modèle et doivent être précédés d'un *
. Voir la section "Modèles et *" dans ce lien pour plus de détails: http://victorsavkin.com/post/119943127151/angular-2-template-syntaxJ'espère que ça vous aide, Thierry
Voici la définition réelle.
Toute autre définition est fausse.
Un composant est une directive avec une vue associée (c'est-à-dire du HTML à rendre). Tous les composants sont des directives, mais toutes les directives ne sont pas des composants. Il existe trois types de directives:
*ngIf
qui peut insérer ou supprimer un élément DOM (ou un composant angulaire qui est un élément DOM personnalisé, mais toujours un élément DOM).import { Component, HostListener, HostBinding, Directive, ElementRef } from '@angular/core';
@Directive({
selector: '[appHighlight]'
})
export class HighlightDirective {
constructor(el: ElementRef) {
el.nativeElement.style.backgroundColor = 'yellow';
}
}
@Component({
selector: 'app-root',
template: `
<div *ngIf='myBool' appHighlight>Hi there</div>
`,
styleUrls: ['./app.component.scss'],
})
export class AppComponent {
myBool:boolean = true;
}
Dans l'exemple ci-dessus, nous pouvons observer ce qui suit:
AppComponent
a un modèle avec un <div>
élément qui s'affiche, bonjour.<div>
élément. Cela signifie qu'il manipulera le comportement de l' <div>
élément. Dans ce cas, il mettra en évidence le texte et le deviendra jaune.*ngIf
est également située sur l' <div>
élément et déterminera si l'élément doit être inséré. Le <div>
sera affiché conditionnellement selon que l'expression myBool
peut être forcée ou non true
.Angular 2 suit le modèle d'architecture de composant / service.
Une application angulaire 2 est constituée de composants. Un composant est la combinaison d'un modèle HTML et d'une classe de composant (classe A typescript) qui contrôle une partie de l'écran.
Pour la bonne pratique, la classe de composant est utilisée pour la liaison de données à la vue respective. La liaison de données bidirectionnelle est une fonctionnalité intéressante fournie par le framework angular.
Les composants sont réutilisables dans toute votre application à l'aide du nom de sélecteur fourni.
Le composant est également une sorte de directive avec un modèle.
Les deux autres directives sont
Directives structurelles: modifiez la disposition DOM en ajoutant et en supprimant des éléments DOM. Ex: NgFor
et NgIf
.
Directives d'attribut: modifiez l'apparence ou le comportement d'un élément, d'un composant ou d'une autre directive. Ex: NgStyle
En fait, les composants sont également des directives, mais présentent des différences entre eux.
Directives d'attribut :
Les directives d'attribut sont des classes capables de modifier le comportement ou l'apparence d'un seul élément. Pour créer une directive d'attribut, appliquez le @Directive
à une classe.
import { Directive, ElementRef } from "@angular/core";
@Directive({
selector: "[custom-attr]", })
export class CustomAttrDirective {
constructor(element: ElementRef) {
element.nativeElement.classList.add("bg-success", "text-white");
}
}
Ajout d'un fichier template.html d'attribut de directive
<tr *ngFor="let item of getProducts(); let i = index" custom-attr>
<td>{{i + 1}}</td>
<td>{{item.name}}</td>
</tr>
Directives structurelles :
Les directives structurelles modifient la mise en page du document HTML en ajoutant et en supprimant des éléments, sous forme de micro-modèles. Les directives structurelles permettent d'ajouter du contenu de manière conditionnelle en fonction du résultat d'une expression telle que *ngIf
ou pour que le même contenu soit répété pour chaque objet dans une source de données telle que *ngFor
.
Vous pouvez utiliser les directives intégrées pour les tâches courantes, mais l'écriture de directives structurelles personnalisées permet d'adapter le comportement à votre application.
<p *ngIf="true">
Expression is true and ngIf is true.
This paragraph is in the DOM.
</p>
<p *ngIf="false">
Expression is false and ngIf is false.
This paragraph is not in the DOM.
</p>
Composants :
Les composants sont des directives qui leurs propres modèles, plutôt que de s'appuyer sur du contenu fourni d'ailleurs. Les composants ont accès à toutes les fonctionnalités de directive, ont toujours un élément hôte, peuvent toujours définir des propriétés d'entrée et de sortie, etc., mais ils définissent également leur propre contenu.
Il peut être facile de sous-estimer l'importance du modèle, mais les directives attributaires et structurelles ont des limites. Les directives peuvent faire un travail utile et puissant, mais elles n'ont pas beaucoup d'informations sur les éléments auxquels elles sont appliquées. Les directives sont plus utiles lorsqu'il s'agit d'outils à usage général, comme la ngModel
directive, qui peut être appliquée à n'importe quelle propriété de modèle de données et à n'importe quel élément de formulaire, sans égard à l'utilisation des données ou de l'élément.
Les composants, en revanche, sont étroitement liés au contenu de leurs modèles. Les composants fournissent les données et la logique qui seront utilisées par les liaisons de données qui sont appliquées aux éléments HTML du modèle, qui fournissent le contexte utilisé pour évaluer les expressions de liaison de données et agissent comme le lien entre les directives et le reste de l'application. Les composants sont également un outil utile pour permettre à de grands projets angulaires d'être divisés en morceaux gérables.
import { Component, Input } from '@angular/core';
import { Hero } from './hero';
@Component({
selector: 'app-hero-child',
template: `
<h3>{{hero.name}} says:</h3>
<p>I, {{hero.name}}, am at your service, {{masterName}}.</p>
`
})
export class HeroChildComponent {
@Input() hero: Hero;
@Input('master') masterName: string;
}