Les Pipes : Guide Complet

Nous allons démarrer rapidement un nouveau projet Angular avec Angular-CLI. Il s’agit d’un outil conçu pour faciliter les tâches de développement les plus courantes : démarrer un petit serveur de développement, créer un nouveau composant, exécuter des tests automatisés, etc. Cet outil va nous permettre de démarrer un nouveau projet Angular en quelques lignes de commandes seulement, afin de mettre en pratique certains exemples de code.

L’installation et l’utilisation d’Angular-CLI sont assez simples. Pour installer ou mettre à jour Angular-CLI, utilisez la commande suivante :  

npm install –g @angular/cli

Ensuite, générez un nouveau projet. La commande suivante va créer un nouveau dossier ng-pipes, avec le contenu de votre projet à l’intérieur : 

ng new ng-pipes

Déplacez-vous dans l’arborescence des dossiers, pour pointer vers notre application. 

cd ng-pipes/

Démarrez ensuite notre application : 

ng serve --open

Cette commande va démarrer un petit serveur de développement, afin d’héberger notre application. L’option open va directement afficher l’application dans un navigateur.

Vous êtes maintenant prêt pour commencer !

Avant de commencer à suivre ce tutoriel, il est recommandé de connaître un minimum Angular, à savoir connaître au moins le fonctionnement de base d’un composant et d’un template. Si vous savez déjà ce qu'est un pipe, c’est un plus, mais ce n’est pas nécessaire pour suivre ce tutoriel. 

De plus, les exemples de code ci-dessous sont en TypeScript, donc cet article nécessite un minimum de connaissance sur ce sujet également.

Oh là, cela fait déjà deux questions !

Essayons d’aborder la chose en douceur. Pensez à toutes les applications que vous avez développées (ou allez développer). Toutes ces applications sont en fait assez semblables : vous obtenez des données, vous effectuez des transformations dessus, et ensuite vous les affichez aux utilisateurs.

Obtenir ces données peut être aussi simple que de déclarer une nouvelle variable dans votre composant, ou aussi complexe que la diffusion en temps réel à travers des WebSocket. Dans tous les cas, une fois que les données arrivent, vous avez deux choix.

• Vous pouvez les afficher directement dans la vue. Vous recevez le prénom « Jean », et vous affichez « Jean » dans votre template. Rien de compliqué, vous n’avez pas besoin d’effectuer de transformations dans ce cas.
• Imaginez maintenant que vous recevez la date « Fri Apr 15 1988 00:00:00 GMT-0700 » depuis le serveur que vous avez appelé. Est-ce que vous avez envie d’afficher cette date à vos utilisateurs ? Personnellement, en tant qu’utilisateur, je préférerais visualiser une date dans un format plus lisible, comme « 15 avril 1988 ».

En fait, certaines valeurs gagnent à être légèrement retouchées avant d’être affichées dans le template. Et on voudra souvent effectuer les mêmes transformations à plusieurs reprises au sein d’un projet.

Vous pouvez essayer de voir ces transformations comme des règles de style CSS. Vous pouvez les appliquer dans vos différents templates HTML, et centraliser leur définition dans un fichier commun.

Eh bien, c’est cela les pipes avec Angular : un moyen d’écrire des transformations pour nos données, que l’on peut ensuite appliquer dans nos templates.

Le fonctionnement d’un pipe est plutôt simple : un pipe reçoit des données en entrée, et les transforme dans le format de sortie souhaité. Il s’agit d’une règle d’or, ce fonctionnement est valable, quel que soit le pipe que vous appliquez : pipe avec ou sans paramètres, personnalisé ou natif. Nous verrons tous ces cas un peu plus loin dans ce tutoriel.

Pour commencer, je vous propose de voir comment utiliser un pipe pour transformer une date d’anniversaire en une date sympathique à afficher à l’utilisateur. Vous pouvez bien sûr mettre votre propre date d’anniversaire à la place de celle que je propose ci-dessous : 

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  template: `<p>Mon anniversaire est le : {{ birthday | date }}</p>`
  // L’affichage avec le pipe donne : « Dec 19, 1992 »
})
export class AppComponent {
  birthday = new Date(1992, 11, 19); 
  // Le nombre 11 correspond au mois de décembre, car ça commence à zéro !
}

Concentrez-vous sur le template du composant, à la ligne 5 ci-dessous : 

<p>Mon anniversaire est le : {{ birthday | date }}</p>

À l’intérieur de cette expression d’interpolation, vous pouvez apercevoir votre premier pipe ! Voici comment cela fonctionne :

1. D’abord, tout à gauche de cette expression, on a une propriété birthday.
2. Ensuite, on applique une transformation sur notre propriété grâce à l’opérateur de pipe qui est la barre verticale (|).
3. Enfin, on ajoute le pipe date à appliquer (à droite).

Sans l’application du pipe date, voici ce que j’ai dans mon template :

Et en appliquant simplement le pipe Date :

C’est quand même plus sympathique comme affichage pour l’utilisateur  !

Avez-vous remarqué que pour pouvoir utiliser le pipe Date, nous n’avons rien eu besoin d’importer, précédemment ? Nous avons simplement appliqué directement le pipe Date dans notre template.

En fait, Angular est proposé avec un ensemble de pipes de base. On les appelle les pipes « natifs ». Ils permettent de couvrir plusieurs usages de base, et sont des pipes disponibles de base avec Angular :

• DatePipe : permet de formater l’affichage d’une date ;
• UpperCasePipe : transforme le texte passé en entrée en majuscule ;
• LowerCasePipe : transforme le texte passé en entrée en minuscule ;
• TitleCasePipe : pour une phrase passée en paramètre, permet de mettre la première lettre de chaque mot en majuscule, et le reste en minuscule ;
• CurrencyPipe : prend en paramètre une devise pour mettre en forme un nombre comme monnaie ;
• PercentPipe : formate un nombre en tant que pourcentage. Par exemple, le chiffre 0.26 devient 26 % lorsque vous appliquez ce pipe ;
• JsonPipe : convertit la valeur passée en paramètre en chaîne JSON, grâce à la méthode JSON.stringify. Ce pipe peut être utile pour débugger votre code et retrouver plus facilement vos erreurs.

Je vous ai listé les pipes principaux, ceux que vous utiliserez le plus souvent lors de vos développements. Cependant, je dois quand même vous donner la liste complète des pipes natifs. La liste complète est disponible sur cette page de la documentation officielle.

Vous trouverez pour chaque pipe toutes les informations nécessaires, ainsi qu’un exemple d’utilisation pour chaque cas.

Il est possible de passer des paramètres à certains pipes, afin de personnaliser leur rendu. Concernant les paramètres des pipes, il y a deux règles d’or à retenir :

• D’abord, un pipe peut accepter n’importe quel nombre de paramètres d’entrée.
• Ensuite, tous les paramètres attendus sont forcément optionnels. C’est-à-dire qu’un pipe doit toujours pouvoir s’utiliser sans ses paramètres éventuels. Il faut donc prévoir un cas d’utilisation par défaut, quel que soit le nombre de paramètres prévus.

Pour passer des paramètres à un pipe, cela se fait dans votre template. Vous devez ajouter un deux-points « : » après le nom du pipe, puis la valeur du paramètre. Par exemple, dans le cas d’une devise en dollars canadiens, il faut passer le paramètre 'currency' avec la valeur 'CAD' : 

Le prix en dollars canadiens est : {{ 100 | currency:'CAD' }}. // Ce pipe affichera 'CA$100'

Dans le cas de notre date d’anniversaire, nous allons modifier notre template pour passer au pipe date un paramètre, afin d’adapter le format de la date en sortie. Après le formatage, la date d’anniversaire du 19 décembre deviendra « 19/12/1992 » : 

<p> Mon anniversaire est le : {{ birthday | date:"dd/MM/yyyy" }}</p>

Voilà, maintenant ce template affichera un beau message à l’utilisateur : « Mon anniversaire est le 19/12/1992 ». C’est quand même plus agréable pour l’utilisateur, que d’afficher la date brute !

La valeur du paramètre de votre pipe n’est pas forcément statique. Cette valeur peut tout à fait être dynamique, et l’affichage de votre pipe peut être modifié en fonction d’un événement quelconque : un Timer, une action de l’utilisateur, etc.

La valeur du paramètre peut être n’importe quelle expression de template valide, comme une chaîne de caractères ou une propriété du composant associé. Dans notre exemple de date d’anniversaire, cela signifie que vous pouvez contrôler le format de sortie de la date en passant par une propriété du composant.

Je vous propose d’ajouter un bouton dans notre template qui nous permet d’afficher la date d’anniversaire soit au format britannique (‘19 December 1992’), soit au format américain (‘December 19, 1992’). Par défaut, la date d’anniversaire sera affichée au format britannique.

Voyons cela en pratique. Récrivez notre composant pour qu’il lie le paramètre format du pipe à une nouvelle propriété format du composant, que nous allons ajouter. Voici déjà le template mis à jour :

template: `
  <p>Mon anniversaire est le : {{ birthday | date:format }}</p>
  <button (click)="toggleFormat()">Changer le format</button>
`

On a ajouté deux nouveaux éléments dans cet extrait de code :

• À la ligne 2, le paramètre du pipe date a été remplacé par la variable format plutôt qu’une valeur écrite en dure.
• À la ligne 3, j’ai ajouté un nouveau bouton dans le template, qui appelle la méthode toggleFormat lorsqu’on clique dessus. Cette méthode permet de basculer le format de la date entre le format américain et le format britannique.

Et voici le code du composant à jour :

export class AppComponent {
  birthday = new Date(1992, 11, 19);
  britishFormat = 'd MMMM y';
  americanFormat = 'MMMM d, y';
  toggle = true; // Le format britannique est le format par défaut

  get format()   {
    return this.toggle ? this.britishFormat : this.americanFormat;
  }

  toggleFormat() { this.toggle = !this.toggle; }

}

Lorsque vous cliquez sur le bouton, la date affichée alterne entre « 19 December 1992 » et « December 19, 1992 ».

Vous pouvez combiner plusieurs pipes afin d’obtenir le résultat que vous souhaitez. Dans l’exemple suivant, on souhaite afficher la date d’anniversaire en majuscule. Pour cela, on combine deux pipes natifs différents sur la date d’anniversaire : le pipe DatePipe et UpperCasePipe :

<p>Mon anniversaire est le : {{ birthday | date:format | uppercase }}</p>

Cet exemple affichera notre date d’anniversaire « 19 DECEMBER 1992 » en majuscule. Voilà, rien de très compliqué ! 

Dans l’exemple que nous allons voir, le composant utilise la stratégie de détection des changements par défaut. Il s’agit de la stratégie de détection de changement la plus agressive, c’est-à-dire la façon de faire la plus gourmande en ressource (la plus « bourrin », si vous voulez).

Je vous montre comment l’utiliser à titre d’exemple uniquement, ne reproduisez pas ça chez vous bien entendu.

Prenons comme exemple une liste d’animaux quelconque, en sachant que certains animaux volent, et d’autres non. À chaque fois que l’utilisateur ajoute un nouvel animal, nous allons surveiller cet ajout, et mettre à jour l’affichage du template en conséquence. Voici le template du composant :

<h1>Les animaux</h1>
Ajouter un animal:
<input type="text" #box
        (keyup.enter)="addAnimal(box.value); box.value=''"
        placeholder="Nom de l’animal"/>
<button (click)="reset()">Reset</button>

<h2>Tous les animaux</h2>
<div *ngFor="let animal of animals">
  {{animal.name}}
</div>

La classe du composant associé fournit un certain nombre d’éléments au tableau animals. Elle permet aussi d’ajouter de nouveaux animaux dans le tableau, et peut les réinitialiser également.

export class AppComponent implements OnInit {
  animals: any[] = [];
  canFly = true;

  ngOnInit() {
    this.animals = [
      {name: 'Lion', canFly: false},
      {name: 'Eagle', canFly: true},
      {name: 'Tortoise', canFly: false},
      {name: 'Dog', canFly: false},
      {name: 'Seagull', canFly: true},
      {name: 'Snake', canFly: false},
    ]
  }

  // On ajoute un nouvel animal dans le tableau des animaux
  addAnimal(name: string) {
    name = name.trim();
    if (!name) { return; }
    let animal = {name, canFly: this.canFly};
    this.animals.push(animal);
    this.animals = this.animals.slice();
  }
  
  // On réinitialise le tableau des animaux
  reset() { this.animals = []; }

}

Vous pouvez essayer d’ajouter des animaux depuis l’interface. Par défaut, tous les animaux que vous ajoutez sont volants (ligne 3 ci-dessus). Comme vous pourrez le voir, Angular met à jour l’interface pour la liste de tous les animaux. Si vous cliquez sur le bouton de réinitialisation, Angular remplace les animaux par un nouveau tableau vide, et met à jour l’affichage en conséquence.

Maintenant, passons à ce qui nous intéresse, les pipes. 

Ajoutez le code HTML ci-dessous dans votre template. Ce code permet de filtrer la liste des animaux pour afficher uniquement les animaux volants :

<h2>Animaux volants</h2>
<div *ngFor="let animal of animals | flyingAnimal">
  {{animal.name}}
</div>

Ensuite, créons ce nouveau pipe FlyingAnimalsPipe que nous appelons dans notre template. Pour créer notre pipe, on utilise une commande de Angular-CLI: 

Ng generate pipe flying-animal

Notre pipe a été généré par Angular-CLI, qui s’occupe automatiquement pour nous de déclarer notre nouveau pipe auprès du module racine de notre application.

Maintenant, modifiez le code du pipe comme ceci :

import { Pipe, PipeTransform } from '@angular/core';
import { Flyer } from './animals';

@Pipe({ name: 'flyingAnimals' })
export class FlyingAnimalsPipe implements PipeTransform {
  transform(allAnimals: Flyer[]) {
    return allAnimals.filter(animal => animal.canFly);
  }
}

Avant de continuer, laissez-moi vous expliquer les quelques lignes ci-dessus. Il y a plusieurs éléments importants à remarquer dans ce code :

• Quel que soit l’objectif du pipe que vous envisagez de créer, vous devez importer deux éléments : Pipe et PipeTransform, à la ligne 1. Vous importez ces éléments depuis le paquet @angular/core.
• On remarque également qu’un pipe est une simple classe, décoré avec l’annotation @Pipe, à la ligne 3. C’est comme ça qu’Angular peut savoir qu’il s’agit d’une classe de Pipe et non d’un autre élément.
• L’annotation @Pipe vous permet de définir le nom du pipe que vous utiliserez dans les expressions de templates. Le nom de notre pipe est ici « flyingAnimals ».
• Notre classe implémente la méthode transform de l’interface PipeTransform qui accepte une valeur d’entrée, suivie par autant de paramètres que nécessaire. Dans notre cas nous n’avons qu’un seul paramètre, il s’agit de la liste des animaux à trier, à la ligne 6. La méthode transform doit ensuite renvoyer la valeur transformée, c’est-à-dire la liste des animaux volants exclusivement.
• La méthode transform est essentielle pour qu’un pipe puisse fonctionner. Ne l’oubliez pas sous peine de lever une erreur !

Pour revenir à notre application, remarquez le comportement suivant : quand vous ajoutez des animaux volants, aucun d’entre eux n’est affiché sous le libellé « Animaux volants » !

Bien que vous n’obteniez pas le comportement souhaité, Angular fonctionne normalement ! 

Il s’agit simplement d’un algorithme de détection des changements différent, qui ignore les modifications apportées à la liste ou à l’un de ses éléments. Remarquez comment on ajoute un animal dans notre composant :

this.animals.push(animal);

Vous ajoutez l’animal dans le tableau des animaux, mais la référence au tableau n’a pas changé. C’est le même tableau, avec une nouvelle valeur. C’est tout ce dont Angular se soucie. De son point de vue, c’est le même tableau, et il n’y donc pas de changements, donc pas de mise à jour à afficher ! Angular ne s’intéresse pas aux modifications à l’intérieur du tableau !

Pour corriger cela, il faut créer un nouveau tableau avec le nouvel animal ajouté et l’attribuer au tableau animals. Cette fois, Angular détectera que la référence du tableau a changé. Il exécutera donc le pipe et mettra à jour l'affichage avec le nouveau tableau, qui comprend le nouvel animal volant.

Pour faire simple, si vous modifiez uniquement les valeurs du tableau, sans modifier sa référence, aucun pipe n’est appelé, et l’affichage n’est pas mis à jour. Si vous remplacez le tableau, le pipe s’exécute et l’affichage est mis à jour.

Remplacer le tableau est donc un moyen efficace de signaler à Angular de mettre à jour l’affichage.

Eh bien, lorsque les données sont modifiées. C'est une règle facile à suivre dans cet exemple, où la seule façon de modifier les données est d'ajouter un nouvel animal :

// …

// On ajoute un nouvel animal dans le tableau des animaux
  addAnimal(name: string) {
    name = name.trim();
    if (!name) { return; }
    let animal = {name, canFly: this.canFly};
    this.animals.push(animal); // pas de détection, car la référence au tableau est identique
    this.animals = this.animals.slice(); // On attribue une nouvelle copie du tableau, la référence est différente
  }
// …

Ici, c’est la méthode slice() qui permet d’attribuer une nouvelle copie du tableau à la liste d’animaux. Les valeurs des tableaux sont identiques, mais comme la référence du tableau a changé, cela permet de forcer la détection de changement. Notre exemple étant assez simple, on peut faire cela nous-mêmes.

Mais le plus souvent, vous ne savez pas quand les données ont changé. En particulier dans les applications qui modifient les données de plusieurs façons (interactions des utilisateurs, modifications des données du serveur, etc.). Un composant d'une telle application ne peut habituellement pas connaître tous ces changements. C’est pour cela que Angular nous propose d’utiliser les pipes impurs, que nous allons utiliser pour filtrer plus efficacement nos animaux volants.

Angular exécute un pipe pur uniquement lorsqu’il détecte une modification d’une valeur d’entrée primitive (chaîne de caractères, nombre, booléen, etc.) ou une référence d’objet modifiée, comme nous venons de le voir. (une date, un tableau, un objet, une fonction, etc.).

Cela peut sembler restrictif, mais c’est aussi plus rapide. Une vérification de la référence de l’objet est beaucoup plus rapide qu’une vérification approfondie des différences des valeurs à l’intérieur de cet objet. De sorte qu’Angular peut rapidement déterminer s’il peut éviter l’exécution du pipe et la mise à jour de la vue.

Pour cette raison, un pipe pur est préférable lorsque vous pouvez vous adapter avec la stratégie de détection des changements (comme nous l’avons fait avec la méthode slice dans notre exemple précédent). Lorsque vous ne le pouvez pas, vous pouvez utiliser un pipe impur.

III-C-1. Pipes impurs▲

III-C-2. Un pipe impur pour le FlyingAnimalsPipe▲

@Pipe({
  name: 'flyingAnimalsImpure',
  pure: false
})
export class FlyingAnimalsImpurePipe extends FlyingAnimalsPipe {}

import { Pipe, PipeTransform } from '@angular/core';
import { Flyer } from './animals';

@Pipe({ name: 'flyingAnimals' })
export class FlyingAnimalsPipe implements PipeTransform {
  transform(allAnimals: Flyer[]) {
    return allAnimals.filter(animal => animal.canFly);
  }
}

return allHeroes.filter(hero => hero.canFly);

<div *ngFor="let animal of (animals | flyingAnimalsImpure)">
  {{hero.name}}
</div>

Le pipe natif AsyncPipe est un excellent exemple de pipe impur. Ce pipe accepte une promesse ou un Observable en entrée. Il s’abonne automatiquement à l’élément passé en entrée, et reçoit les nouvelles valeurs émises au fur et à mesure qu’elles arrivent. Il met également l’interface utilisateur à jour à chaque nouvelle valeur. Bref, il fait une bonne partie du boulot pour nous ! 😊

L’exemple suivant lie un Observable avec un template, grâce au pipe async. L’Observable émet le dernier message reçu (message$), et nous souhaitons l’afficher dans le template :

…

@Component({
  selector: 'async-message',
  template: `
    <h2>Dernier message asynchrone reçu : </h2>
    <p>Message: {{ message$ | async }}</p>`,
})
export class AsyncMessageComponent {…}

Comme vous pouvez le voir, le pipe Async nous économise beaucoup de travail. Tout ce que nous aurions dû développer dans le composant est fait par le pipe : s’inscrire à la source de données asynchrones, extraire les valeurs résolues, les exposer pour la liaison de données, se désabonner de l’Observable lorsque le composant est détruit, etc. (Nous verrons le cas du désabonnement à un Observable un peu plus loin).

Le pipe JsonPipe est un pipe très simple, mais extrêmement utile pour le débogage. Par exemple, pour connaître le format de la réponse JSON du serveur que vous venez de recevoir, il suffit d’appliquer le pipe JsonPipe dessus : 

<p>{{someDataFromServer|json}}</p>

Et là, c’est magique ! Vous pouvez visualiser la réponse de votre serveur directement dans votre template, sans passer par la console de débogage de votre navigateur ! Bon, dans la réalité, si la réponse du serveur est trop longue, il faudra mieux passer par la console de débogage pour la visualiser. Cependant, ce pipe fournit un moyen simple de diagnostiquer une liaison de données mystérieusement défaillante, ou d’inspecter un objet pour une future liaison de données. Et rappelez-vous que ce pipe est impur, donc il se met à jour automatiquement avec d’éventuelles données asynchrones ! 😊

Angular ne fournit pas de pipes natifs pour filtrer ou trier des listes. Les développeurs familiers avec AngularJS connaissent bien les filtres filter et orderBy. Sachez qu’il n’y a pas d’équivalent en Angular, et que ce n’est pas un oubli, mais un choix délibéré de la part des équipes chargées du développement d’Angular.

Le filtrage, et surtout le tri, sont des opérations coûteuses. L’expérience utilisateur peut se dégrader sévèrement même pour des listes de taille modérée, lorsque Angular appelle ces pipes plusieurs fois par seconde. Les filtres filter et orderBy ont souvent été utilisés avec abus dans les applications AngularJS, entraînant des plaintes selon lesquelles AngularJS est lent…

Cette accusation est juste dans le sens où AngularJS a préparé le terrain pour cette faille de performance, en mettant en avant les filtres filter et orderBy, sans prévenir que leur mauvaise utilisation pouvait entraîner une dégradation des performances.

Il existe également un risque concernant la minification de votre code. Imaginez un pipe appliqué à une liste d’animaux. La liste peut être triée en fonction du nom et de la date d’ajout des animaux :

<div *ngFor="let animal of animals | orderBy:'name,date’"></div>

Les champs de tris sont identifiés par des chaînes de caractères, en attendant que le pipe fasse référence à une propriété de l’objet (animal[‘name’]). Cependant, lorsque vous minifiez votre code, cela entraîne une modification des noms de propriété de la classe Animal, de telles sortes que Animal.name et Animal.date deviennent quelque chose comme Animal.a et Animal.b. Du coup, animal[‘name’] ne fonctionnera plus !

Bien que certains ne se soucient pas de minifier leur code, Angular ne doit pas empêcher les développeurs de minimiser leur code. L'équipe Angular a donc décidé que tout ce qui est fourni par Angular pourra être minifié en toute sécurité, y compris les pipes. C’est aussi pour cela que les pipes filter et orderBy n’existent plus.

L’équipe Angular, et de nombreux développeurs Angular expérimentés recommandent donc fortement de filtrer et de trier les listes dans la logique du composant lui-même. Le composant peut exposer une propriété filteredAnimals ou sortedAnimals, et prendre le contrôle sur la fréquence d’exécution des mises à jour de la propriété. Toutes les fonctionnalités que vous auriez mises dans un pipe peuvent être écrites dans un service dédié au filtrage et au tri, puis injectées dans le composant.

Si ces considérations de performance et de minification ne s’appliquent pas pour vous, vous pouvez toujours créer vos propres pipes comme vous le souhaitez, ou utiliser ceux développés par la communauté. Mais gardez ces problématiques de performances et de minification en tête, où vous pourriez avoir de mauvaises surprises lors de vos prochains développements ! 😊

• Un pipe est un moyen d’écrire des transformations pour nos données, que l’on peut ensuite appliquer dans nos templates.
• Il existe des pipes natifs fournis par Angular, que l’on peut appliquer dans nos templates sans importations.
• On peut passer des paramètres à nos pipes, mais ils sont tous facultatifs. Un paramètre ne peut pas être obligatoire pour un pipe.
• On peut contrôler dynamiquement les paramètres d’un pipe depuis le composant.
• Il existe deux types de pipes : pur et impur. Les pipes impurs permettent de développer des fonctionnalités plus avancées, mais peuvent entraîner une dégradation des performances de l’application s’ils sont mal implémentés.
• Pour afficher des données asynchrones, on peut utiliser le pipe async.
• Il est possible de créer ses propres pipes personnalisés pour répondre aux besoins spécifiques de son application.

Cet article est un extrait de ma formation « Maîtriser Angular 6 : Développer pour l’entreprise». Si vous souhaitez recevoir d’autres guides complets sur Angular 6, directement dans votre boîte email, vous pouvez vous abonner à ma liste email via le lien ci-dessus. À très vite pour les plus courageux ! 😉

Je tiens à remercier f-leb pour la relecture orthographique.