<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kevin Tale on Medium]]></title>
        <description><![CDATA[Stories by Kevin Tale on Medium]]></description>
        <link>https://medium.com/@kevin-tale?source=rss-285f1fc06b48------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Qvob7pFpLMYH6bA2O4H9fQ.png</url>
            <title>Stories by Kevin Tale on Medium</title>
            <link>https://medium.com/@kevin-tale?source=rss-285f1fc06b48------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 23:18:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kevin-tale/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Tout sur les Inputs dans Angular]]></title>
            <link>https://kevin-tale.medium.com/tout-sur-les-inputs-dans-angular-7a16d91eeb5d?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a16d91eeb5d</guid>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Thu, 30 Nov 2023 10:39:30 GMT</pubDate>
            <atom:updated>2023-11-30T12:31:54.656Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YEqhDChrIUOgYV1HmY0ptQ.png" /></figure><p>On le sait, un Input dans Angular sert à récupérer une donnée venant d’un composant parent. C’est une des fonctionnalités qu’on utilise le plus couramment dans une application.</p><p>Mais ça, <strong>c’est la partie émergée de l’iceberg</strong>.</p><p>En fait, @Input() a bien d’autres capacités et surtout depuis les versions récentes d’Angular.</p><p>Dans cette article, je vous dresse une liste exhaustive de <strong>toutes les fonctionnalités</strong> des @Input() d’Angular.</p><h3>Alias</h3><pre>@Component({...})<br>export class ListComponent {<br>  // ici 👇<br>  @Input({alias: &#39;list&#39;}) items: Item[] = [];<br>}<br><br>@Component({<br>  template: `&lt;app-list [list]=&quot;products&quot; /&gt;`<br>})<br>export class AppComponent {<br>  products = [...];<br>}</pre><p>alias sert à donner un autre nom à la propriété bindée au niveau du composant parent. Par exemple ici, dans le scope de ListComponent, la propriété s’appelle items tandis que pour le consommateur ça sera son alias list.</p><p>Ce n’est pas quelque chose que vous allez utiliser tous les jours, mais cela peut être utile dans certains cas, par exemple conjointement à l’utilisation des setters.</p><h3>Setter</h3><pre>@Component({...})<br>export class UserDetailsComponent {<br><br>  #service = inject(UserService);<br>  user = signal&lt;User&gt;({} as User); <br>  <br>  @Input()<br>  set id(id: number) {<br>    // s&#39;exécute à chaque fois que l&#39;input change<br>    this.user.set(this.#service.getUserDetails(id));<br>  }<br>}</pre><p>Les setter vous permettent de rendre l’utilisation de OnChanges complètement superflue. En fait, dès qu’une nouvelle donnée sera reçue dans l’input, le setter va s’exécuter. Dans mon exemple, j’appelle un service qui va me renvoyer les données de l’utilisateur selon son id.</p><p>Un autre exemple où nous l’utilisation en combinaison avec alias pour mettre à jour un signal.</p><pre>@Component({...})<br>export class ProductsComponent {<br><br>  products = signal&lt;Product[]&gt;([]);<br>  <br>  @Input({alias: &#39;products&#39;})<br>  set _products(products: Product[]) {<br>    this.products.set(products);<br>  }<br>}</pre><h3>Required</h3><p>Depuis la version 16, vous pouvez rendre vos Inputs obligatoire, auquel cas si le composant parent ne l’utilise pas, le compilateur vous lèvera une erreur.</p><pre>@Component({...})<br>export class UserDetailsComponent {<br>  @Input({required: true}) name = &#39;&#39;;<br>}<br><br>@Component({<br>  template: `&lt;app-user-details /&gt;` // Required input &#39;name&#39; from component UserDetailsComponent must be specified.<br>})<br>export class AppComponent {}</pre><h3>Transform</h3><p>La propriété transform vous permet de modifier la valeur de l’input très facilement.</p><pre>@Component({...})<br>export class UserDetailsComponent {<br>  @Input({transform: (value: string) =&gt; Number(value)}) id!: number;<br>}</pre><p>Ici, je modifie la valeur en number car on imagine que dans ce scénario le composant parent renvoie l’id en tant que string.</p><p>Cette propriété peut être utile dans pas mal de scénarios, par exemple il vous est déjà peut-être arrivé de devoir faire ça :</p><pre>@Component({<br>  template: `&lt;app-table [withFooter]=&quot;true&quot; /&gt;`<br>})<br>export class AppComponent {}</pre><p>Grâce à transform , nous pouvons juste faire ça :</p><pre>@Component({<br>  template: `&lt;app-table withFooter /&gt;`<br>})<br>export class AppComponent {}<br><br>@Component({...})<br>export class TableComponent {<br>  @Input({transform: booleanAttribute}) withFooter = false;<br>}</pre><p>booleanAttribute est une fonction qu’Angular nous a mis à disposition justement pour modifier automatiquement les attributs en booléen. Et d’ailleurs, une fonction qui caste en number est également disponible.</p><pre>import { booleanAttribute, numberAttribute } from &#39;@angular/core&#39;;</pre><blockquote>Je vous aide à devenir autonome sur Angular via la plateforme que j’ai fondé : <strong>Bonjour Angular</strong>.</blockquote><blockquote>📕<a href="http://apprendre.bonjour-angular.com/">La bible d’Angular en FR</a> <br>🚀<a href="https://www.eventbrite.fr/e/billets-devenir-autonome-sur-angular-moderne-2023-699654374067">Ma formation Angular</a><br>🗨️<a href="https://discord.com/invite/c8XThfW9a7">La plus grande communauté Angular FR au monde</a></blockquote><h3>ComponentInputBinding</h3><p>C’est une grosse nouveauté arrivée en version 16, @Input() peut maintenant récupérer les données de la route (paramètres du path, query, data, ou du resolver).</p><p>Par exemple, si on imagine cette route.</p><pre>{<br>  path: &#39;products/:id&#39;,<br>  component: ProductRoute,<br>  data: {<br>    showCart: true,<br>  },<br>},<br><br>// domain.com/products/10?foo=123</pre><p>Nous pouvons récupérer ces données ainsi.</p><pre>@Component({<br>  template: `<br>    {{id}}<br>    {{foo}}<br>    {{showCart}}<br>  `<br>})<br>export class ProductsComponent {<br>  @Input() id: string;<br>  @Input() foo: string;<br>  @Input() showCart: boolean;<br>}</pre><p>Il suffit simplement de nommer votre @Input() comme le nom de la donnée sur laquelle vous voulez être bindé, et c’est tout !</p><p>Pour activer cette option, il faut ajouter withComponentInputBinding dans le provideRouter.</p><pre>export const appConfig: ApplicationConfig = {<br>  providers: [<br>    provideRouter(routes, withComponentInputBinding()),<br>  ],<br>};</pre><p>Conjointement à cela, je conseille d’activer le paramsInheritanceStrategy.</p><pre>export const appConfig: ApplicationConfig = {<br>  providers: [<br>    provideRouter(<br>      routes,<br>      withComponentInputBinding(),<br>      withRouterConfig({ paramsInheritanceStrategy: &#39;always&#39; })<br>    ),<br>  ],<br>};</pre><p>Cette option vous permet de récupérer les données d’une route même depuis une route enfant. Par exemple si je suis sur domain.com/products/10/details, je peux quand même récupérer 10 depuis la route DetailsRoute.</p><p>A noter tout de même qu’étant donné que @Input() nous renvoie une donnée primitive, et non un Observable contrairement à ActivatedRoute, il est plus difficile de réagir au changement d’un input pour effectuer un nouveau call http par exemple.</p><h3>Signal Inputs</h3><p>Et pour terminer, une fonctionnalité qui va très bientôt sortir : nos @Input() seront directement des Signals, nous pourrons donc créer des computed très facilement ou pourquoi pas utiliser effect() plus régulièrement.</p><pre>@Component({...})<br>export class SomeComponent  {<br>  firstname = input&lt;string&gt;({required: true});<br>  lastname = input&lt;string&gt;({required: true});<br>  fullname = computed(() =&gt; `${this.firstname} ${this.lastname}`);<br>  something= input&lt;Something | null&gt;(null);<br>}</pre><p>Personnellement c’est une des fonctionnalités à venir que j’attends le plus ! Comme vous le voyez, le décorateur des Inputs part et la fonctionnalité est remplacée par une simple fonction.</p><p>Cela devrait alléger beaucoup notre code, a priori cela sortira avant Angular 18 ! Je vous tiendrai au courant, bien entendu.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a16d91eeb5d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quoi de neuf dans Angular 17]]></title>
            <link>https://kevin-tale.medium.com/quoi-de-neuf-dans-angular-17-2b6ca15db313?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b6ca15db313</guid>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Tue, 07 Nov 2023 10:29:31 GMT</pubDate>
            <atom:updated>2023-11-07T12:20:43.607Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iZemfjm2ZmASmzFZHv7JFA.png" /></figure><p>Lundi 6 novembre 2023 a eu lieu le <a href="https://www.youtube.com/watch?v=Wq6GpTZ7AX0&amp;ab_channel=Angular">Angular Special Event</a>, l’occasion de nous montrer toutes les nouveautés Angular 17 ainsi que quelques surprises !</p><p>Dans cette article, je vous fais un résumé de ce qu’il s’est dit durant ce livestream et vous explique pourquoi cette version signe le véritable démarrage du renouveau du framework.</p><h3>Nouvelle image de marque</h3><p>Le logo rouge, c’est terminé ! Angular adopte une nouvelle image de marque avec un logo qui représente son renouveau et, surtout, un désir de mettre fin à la confusion qu’apportait l’ancien logo d’AngularJS, trop proche de ce qu’ils avaient jusqu’à maintenant.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ujS1BEG15a2ncM9AgeG9fw.png" /></figure><p>Nous avons donc quelque chose de beaucoup plus moderne que personnellement j’apprécie beaucoup !</p><p>Vous pouvez retrouver tout le <a href="https://angular.dev/press-kit">press-kit ici</a>.</p><h3>Nouvelle documentation</h3><p>Ma news préféré de la soirée : une toute nouvelle experience d’apprentissage a été mis en ligne ce lundi 6 novembre.</p><p>Rendez-vous sur <a href="https://angular.dev/">angular.dev</a> pour trouver une refonte totale de la documentation mais aussi des tutorials et playground.</p><p>A vrai dire, l’ancienne documentation et tuto (tour of heroes) étaient vraiment trop vieillissants, avec des patterns peu recommandés et des difficultés pour trouver des informations pertinentes.</p><p>Maintenant, la doc’ nous donne accès facilement à tous les points clés d’une application Angular moderne. Nous avons également des tutorials avec IDE intégré pour nous montrer les bases du framework et un Playground pour tester le framework directement dans le navigateur.</p><h3>Nouveau Control Flow dans vos templates</h3><p>On le savait déjà, le Control Flow a complètement été revu. Cela signifie que les directives structurelles *ngIf et *ngForsont remplacés par respectivement @if et @for.</p><pre>@if (user.isHuman) {<br>  &lt;human-profile [data]=&quot;user&quot; /&gt;<br>}<br>@else if (user.isRobot) {<br>  &lt;robot-profile [data]=&quot;user&quot; /&gt;<br>}<br>@else {<br>  &lt;p&gt;The profile is unknown!<br>}</pre><pre>@for (product of products(); track product.id) {<br>    &lt;h2&gt;{{product.name}}&lt;/h2&gt;<br>}<br>@empty {<br>    &lt;p&gt;No Products found!&lt;/p&gt;<br>}</pre><p>Les directives sont pour le moment toujours supportés mais utiliser la nouvelle syntaxe vous offrira une meilleure séparation entre vos éléments HTML et ce qui les conditionne.</p><p>De plus, l’algorithme de @for a été revu pour offrir des performances <a href="https://www.linkedin.com/posts/kevin-tale_angular-est-plus-rapide-que-react-ou-svelte-activity-7122870044597858304-sOXP?utm_source=share&amp;utm_medium=member_desktop"><strong>bien </strong>plus grandes qu’avant</a>.</p><p>Vous pouvez migrer vers le nouveau control flow très facilement en utilisant la schematic :</p><pre>ng g @angular/core:control-flow</pre><p>Je ferai un article dédié sur le nouveau Control Flow très bientôt.</p><h3>Lazy loading dans vos templates</h3><p>Vous connaissiez le lazy loading de routes où le navigateur ne charge le JS d’une route que lorsque l’utilisateur y accède, et bientôt vous pouvez maintenant lazy loader des parties de vos templates pour encore plus de performances !</p><p>Grâce au mot-clé @defer , tout ce qui se trouvera à l’intérieur de ce block ne sera chargé par le navigateur que lors d’évènement précis.</p><pre>@defer (on viewport) {<br>  &lt;app-chart [data]=&quot;data()&quot;&gt;<br>}</pre><p>Dans mon exemple, le composant app-chart ne se chargera que lorsque celui-ci atteindra le viewport du navigateur, c’est à dire quand l’utilisateur aura scrollé à ce niveau.</p><p>Vous pouvez également préciser des placeholders qui durera le temps du chargement.</p><pre>@defer (on viewport) {<br>  &lt;app-chart [data]=&quot;data()&quot;&gt;<br>}<br>@placeholder {<br>  &lt;app-skeleton /&gt;<br>}</pre><p>Il existe beaucoup d’autres façons d’utiliser @defer , je ferai un article à ce sujet bientôt également.</p><h3>Nouvel Application Builder</h3><p>Jusqu’à maintenant Webpack était la solution par défaut d’Angular. Mais de nouveaux outils plus rapides sont venus le challenger, notamment ESBuild et Vite.</p><p>Dans la version 17 d’Angular, ces deux outils viennent par défaut et remplacent donc Webpack. Cela signifie que vous builds ( ng serve et ng build ) iront beaucoup plus vite qu’avant. On parle d’un facteur de 2 à 4 !</p><h3>SSR par défaut</h3><p>Lorsque vous lancerez ng new my-app , la CLI d’Angular vous demandera désormais si vous voulez utiliser le SSR et SSG/Prerendering.</p><p>Nous avons donc un framework qui emboîte le pas de ses concurrents en explorant à fond le côté SSR/SSG.</p><p>Il est à noter que Angular Universal n’existe plus en tant que tel et que son code a été fusionné sur le repo principal sous le package @angular/ssr.</p><p>Donc avec Angular 17, lorsque vous lancez ng serve, l’application se rend côté serveur si vous avez choisi l’option SSR ! A noter que vous pouvez également utiliser le flag comme ceci : ng new my-app --ssr</p><blockquote>Petite parenthèse !<br>Si vous voulez devenir autonome sur Angular, je vous propose de suivre <a href="https://www.eventbrite.fr/e/billets-devenir-autonome-sur-angular-moderne-2023-699654374067">ma formation live</a>, où je vous apprendrai en une journée comment maîtriser l’approche moderne du framework que vous soyez novice ou intermédiaire sur Angular !</blockquote><h3>Autres informations</h3><h4>View transitions</h4><p>Le router d’Angular supporte le nouvelle API View Transition afin que vous puissiez contrôler les animations de transitions entre les routes.</p><pre>export const appConfig: ApplicationConfig = {<br>    providers: [<br>        provideRouter(<br>            routes,<br>            withViewTransitions(),<br>        ), <br>    ]<br>};</pre><h4>Les signals sont stables</h4><p>Les Signals sont désormais stables en version 17, vous pouvez donc les utiliser sans crainte de changements ultérieurs trop impactant.</p><p>A noter que la méthode mutate a disparu car il a été décidé que les Signals devaient fonctionner uniquement de manière immuable. Egalement, la fonction effect est toujours en developer preview car l’équipe Angular aimerait explorer un peu plus longuement ce sujet.</p><h4>Une meilleure change detection</h4><p>En V17, lorsque vous utiliserez les Signals dans vos composants OnPush, le framework pourra marquer uniquement le composant où il y a eu un changement comme étant <em>dirty.</em> Cela s’oppose au fonctionnement d’avant où tous les composants parents étaient marqués comme <em>dirty.</em></p><p>C’est le premier pas vers une détection de changement très granulaire que nous apporteront les versions prochaines !</p><h3>Conclusion</h3><p>De version en version, l’équipe Angular parvient à tacler tous les problèmes qu’on reproche au framework :</p><ul><li>une learning curve trop raide</li><li>une DX à améliorer</li><li>une performance mitigée</li><li>une documentation à revoir</li></ul><p>Aujourd’hui, nous faisons les premiers pas de la renaissance d’Angular, et ce nouveau logo en est la preuve !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b6ca15db313" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comment coder de manière réactive et déclarative en Angular ?]]></title>
            <link>https://kevin-tale.medium.com/comment-coder-de-mani%C3%A8re-r%C3%A9active-et-d%C3%A9clarative-en-angular-a698b95da9f6?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/a698b95da9f6</guid>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Sun, 22 Oct 2023 15:22:56 GMT</pubDate>
            <atom:updated>2023-10-23T09:38:24.270Z</atom:updated>
            <content:encoded><![CDATA[<h3>Comment coder de manière réactive et déclarative en Angular ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VQoHodzweoY8I6k3MEgjoA.png" /></figure><p>Un conseil que l’on voit souvent dans les bonnes pratiques Angular, c’est de coder de manière réactive et déclarative.</p><p>Pour être honnête, je crois bien que c’est l’une des compétences les plus importantes à avoir lorsque l’on fait du développement d’applications Angular.</p><p>Quand on programme de manière réactive et déclarative, notre code devient plus prévisible, plus explicite et moins verbeux. De ce fait, on arrive à produire plus rapidement et de manière plus agréable.</p><p>C’est un véritable état d’esprit à avoir, et quand on l’a, on n’a plus envie de faire marche arrière tant le gain est évident.</p><p>C’est bon, je vous ai assez vendu le truc comme ça ? Très bien. Alors répondons à cette phrase : que veut dire “programmer de manière réactive et déclarative” ?</p><p>Démarrons avec ce composant.</p><pre>@Component({<br>  template: `<br>   &lt;p&gt;{{ celsius }}&lt;/p&gt;<br>   &lt;p&gt;{{ fahrenheit }}&lt;/p&gt;<br>   &lt;button (click)=&quot;doubleCelsius()&quot;&gt;Doubler celsius&lt;/button&gt;<br>  `<br>})<br>export class SomeComponent {<br>  celsius = 25;<br>  fahrenheit = this.celsius * 1.8 + 32;<br><br>  doubleCelsius() {<br>    this.celsius = this.celsius * 2;<br>  }<br>}</pre><p>A l’état initial, j’affiche des degrés Celsius et son équivalent en Fahrenheit. Au clique sur le bouton, je double le degré Celsius.</p><p>L’objectif est simple, j’aimerais que fahrenheit soit toujours égal à son équivalent en Celsius même si ce dernier change.</p><p>Maintenant, je clique sur Doubler Celsius.</p><p>Question : est-ce que fahrenheit a changé ?<br>Réponse : non !</p><p>Et après tout c’est logique, fahrenheit n’est interprété que lors de l’initialisation du composant. Donc à sa création il se base sur celsius mais plus tard même si celsius change, ce n’est pas le cas de fahrenheit.</p><p>On dit que fahrenheit n’est pas <strong>réactif</strong>, il ne réagit pas lorsque ses dépendances changent.</p><p>Une façon de régler le problème pourrait être ceci.</p><pre>...<br>doubleCelsius() {<br>    this.celsius = this.celsius * 2;<br>    this.fahrenheit = this.celsius * 1.8 + 32;<br>}<br>...</pre><p>Mais vous voyez vite les problèmes :</p><ul><li>La Single Responsibility Principle est brisée car la fonction fait plus que ce qu’elle prétend faire</li><li>Il est facile d’oublier de mettre à jour une donnée qui dépendrait de celsius</li><li>Il est compliqué de suivre “l’état de vie” de fahrenheit car il est modifié à divers endroit de mon fichier</li></ul><p>Ce dernier point est important car c’est ce qui crée rapidement l’effet “spaghetti code”, c’est à dire un code où il faut parcourir plusieurs méthodes voire fichiers pour déterminer le flux de fonctionnement principal.</p><p>Là mon cas est simple mais imaginez dans une vraie applications avec des centaines de composants, services etc…</p><blockquote>Petite parenthèse !<br>Si vous voulez devenir autonome sur Angular, je vous propose de rejoindre <a href="https://bonjour-angular.com/"><strong>Bonjour Angular</strong></a>, le plus grand écosystème francophone au monde pour apprendre Angular.<br>Vous y trouverez articles, conseils, formations, entraide, veille techno et opportunités de boulot le tout autour d’Angular !</blockquote><h4>La programmation réactive et déclarative à la rescousse !</h4><p>La programmation réactive fera en sorte que fahrenheit <strong>réagisse</strong> automatiquement lorsque celsius changera. Et la programmation déclarative rendra ce code facilement compréhensible.</p><p>Et les Signal sont parfait pour ça !</p><pre>@Component({<br>  template: `<br>   &lt;p&gt;{{ celsius() }}&lt;/p&gt;<br>   &lt;p&gt;{{ fahrenheit() }}&lt;/p&gt;<br>   &lt;button (click)=&quot;doubleCelsius()&quot;&gt;Doubler celsius&lt;/button&gt;<br>  `<br>})<br>export class SomeComponent {<br>  celsius = signal(25);<br>  fahrenheit = computed(() =&gt; this.celsius() * 1.8 + 32);<br><br>  doubleCelsius() {<br>    this.celsius.update(celsius =&gt; celsius * 2);<br>  }<br>}</pre><p>Ici, celsius est un Signal, je le modifie avec la méthode .update(). fahrenheit est définie grâce à computed.</p><p>Dès qu’un Signal est utilisé dans computed() celui-ci est enregistré en tant que dépendance. Ainsi, lorsque l’une de ses dépendances est modifiées alors computed() se recalcule, permettant ainsi de réagir aux changements automatiquement ! C’est donc très pratique pour créer des valeurs dérivées et est une représentation parfaite d’un code réactif.</p><p>Mais en quoi est-ce un code déclaratif ?</p><p>Et bien, je disais plus haut que le code déclaratif est plus facile à comprendre. C’est le cas ici. Dans la déclaration de fahrenheit j’y <strong>décris</strong> tout son cycle de vie, je n’ai pas à écrire étape par étape ce qu’il advient de cette propriété. Je me repose sur des abstractions, en l’occurrence computed.</p><p>On retrouve également ça avec les méthodes des tableaux en JS.</p><pre>// Code Impératif<br>let numbers = [1, 2, 3, 4, 5];<br>let oddNumbers = [];<br><br>for (let i = 0; i &lt; numbers.length; i++) {<br>    if (numbers[i] % 2 !== 0) {<br>        oddNumbers.push(numbers[i]);<br>    }<br>}<br><br>// Code Déclaratif<br>let numbers = [1, 2, 3, 4, 5];<br>let oddNumbers = numbers.filter(num =&gt; num % 2 !== 0);</pre><p>La plupart du temps la programmation déclarative consiste à se reposer sur des fonctions déjà existantes pour obtenir ce que l’on veut. C’est le cas ici avec filter ou avec les Signals et computed.</p><p>Un autre exemple avec les Signal</p><pre>@Component({<br>  template: `<br>    ...<br>    &lt;input<br>      type=&quot;text&quot;<br>      placeholder=&quot;Filter products&quot;<br>      (input)=&quot;setFilter($event)&quot;<br>    /&gt;<br>    ...<br>  ` <br>})<br>export class ProductsComponent {<br>  #products = signal([...]);<br>  #filter = signal(&#39;&#39;); <br><br>  filteredProducts = computed(() =&gt;<br>    this.#products().filter(product =&gt; product.includes(this.#filter()))<br>  );<br>  isFilteredProductsEmpty = computed(<br>    () =&gt; this.filteredProducts().length === 0<br>  );<br><br>  setFilter(event: Event): void {<br>    const input = event.target as HTMLInputElement;<br>    this.#filter.set(input.value);<br>  }<br>}</pre><p>Comme vous le voyez, il est très facile de faire des “cascades” de réactivité. C’est le cas ici car setFilter fait uniquement ce qu’il prétend faire : changer le filtre. Puis tout les changements suivants surviennent en cascade.</p><p>Voyez sa version impérative (à ne pas reproduire chez soi !)</p><pre>@Component({<br>  template: `<br>    ...<br>    &lt;input<br>      type=&quot;text&quot;<br>      placeholder=&quot;Filter products&quot;<br>      (input)=&quot;setFilter($event)&quot;<br>    /&gt;<br>    ...<br>  ` <br>})<br>export class ProductsComponent {<br>  private products: string[] = [...];<br>  private filter: string = &#39;&#39;;<br>  <br>  public filteredProducts: string[] = this.products;<br>  public isFilteredProductsEmpty: boolean = this.products.length === 0;<br><br>  setFilter(event: Event): void {<br>    const input = event.target as HTMLInputElement;<br>    this.filter = input.value;<br>    this.updateFilteredProducts();<br>    this.checkIfFilteredProductsEmpty();<br>  }<br><br>  private updateFilteredProducts(): void {<br>    this.filteredProducts = this.products.filter(product =&gt; product.includes(this.filter));<br>  }<br><br>  private checkIfFilteredProductsEmpty(): void {<br>    this.isFilteredProductsEmpty = this.filteredProducts.length === 0;<br>  }<br>}</pre><p>La version déclarative et réactive offre donc un avantage très clair en terme de lecture et de prédictibilité. Il est moins aisé d’introduire des effets de bords ou d’oublier de mettre à jour certaines données.</p><h3>Un exemple avec RxJS</h3><pre>@Component({...})<br>export class ProductComponent {<br>  route = inject(ActivatedRoute);<br>  productService = inject(ProductService);<br>  <br>  product$ = this.route.params.pipe(<br>    switchMap(params =&gt; this.productService.getProductById(params[&#39;id&#39;]))<br>  );<br>}</pre><p>Ce code est à la fois réactif et déclaratif car il me suffit de lire la propriété product$ pour comprendre ce qui le constitue, je ne la réassigne jamais. Et il est réactif car il se repose sur RxJS et plus particulièrement l’Observable params qui vient de ActivatedRoute. Dès que l’id va changer alors params va émettre une nouvelle donnée dans son flux et donc cela va rentrer dans mon switchMap qui va faire un nouveau call HTTP.</p><p>Je peux même renforcer le fait que je veux du code déclaratif en mettant la propriété en readonly :</p><pre>readonly product$ = this.route.params.pipe(<br>  switchMap(params =&gt; this.productService.getProductById(params[&#39;id&#39;]))<br>);</pre><p>Ainsi, je suis certain qu’il n’y a pas d’effet de bord possible, mon code est plus robuste et prévisible.</p><h3>Un code réactif mais pas déclaratif</h3><p>Même si les deux notions sont très souvent associées, vous pouvez faire du code réactif mais pas déclaratif.</p><pre>@Component({...})<br>export class ProductComponent {<br>  route = inject(ActivatedRoute);<br>  productService = inject(ProductService);<br>  <br>  product!: Product;<br><br>  constructor() {<br>    this.route.params.pipe(<br>      switchMap(params =&gt; this.productService.getProductById(params[&#39;id&#39;]))<br>    ).subscribe(product =&gt; this.product = product);<br>  }<br><br>}</pre><p>Ce code se retrouve beaucoup dans les applications Angular. product est réassignée dans le subscribe(), je suis donc typiquement dans du code impératif où je décris étape par étape ce qu’il advient de ma propriété. Cela rend le code plus verbeux et ça créé un subscribe manuel là où un | async ou toSignal serait plus judicieux.</p><h3>Conclusion</h3><p>Si je devais résumer ces deux termes, je dirais :<br>- <strong>La programmation réactive consiste à créer du code qui réagit lorsque des données changent ou lorsqu’un évènement survient.<br>- La programmation déclarative consiste à décrire ce que l’on souhaite obtenir sans préciser les étapes détaillées pour y parvenir.</strong></p><p>Pour être efficaces, vos applications doivent être construites sur une logique réactive et déclarative, vous devez penser “évènements” et “flux de données”, cela évitera le spaghetti code et donc retardera le legacy !</p><p>PS: si vous voulez devenir autonome sur Angular, je vous propose de rejoindre <a href="https://bonjour-angular.com/"><strong>Bonjour Angular</strong></a>, le plus grand écosystème francophone au monde pour apprendre Angular.<br>Vous y trouverez articles, conseils, formations, entraide, veille techno et opportunités de boulot le tout autour d’Angular !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a698b95da9f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Avez-vous besoin de NgRx ?]]></title>
            <link>https://kevin-tale.medium.com/avez-vous-besoin-de-ngrx-3a09a02cea28?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a09a02cea28</guid>
            <category><![CDATA[rxjs]]></category>
            <category><![CDATA[ngrx]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Wed, 06 Sep 2023 07:10:41 GMT</pubDate>
            <atom:updated>2024-04-14T10:53:06.129Z</atom:updated>
            <content:encoded><![CDATA[<h3>Avez-vous besoin de NgRx ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2S8gl-GHNJaiIiEi0rAVQQ.png" /></figure><blockquote>“On a pas besoin de NgRx dans notre projet, on fait la même chose avec des BehaviorSubject ou des Signals !”<br>“NgRx est trop verbeux, il y a trop de fichiers !”<br>“NgRx c’est bien mais uniquement pour les gros projets !”</blockquote><p>Ca vous parle ça ? Moi oui. C’est le discours que j’entends depuis 5 ans que j’utilise NgRx. Certains personnes peuvent être réfractaire à l’idée d’utiliser cet outil car il est parfois vu comme une usine à gaz difficile à utiliser pour peu de bénéfice à la fin.</p><p>Mais est-ce vrai ?</p><p>Est-ce que les dernières versions d’Angular avec les Signals peuvent rendre NgRx superflue ?<br>Est-ce que les dernières versions de NgRx viennent suffisamment réduire la complexité de l’outil pour justifier son utilisation ?</p><p>Dans cette article, nous allons voir si vous avez <strong>besoin</strong> de NgRx mais également si vous avez <strong>intérêt</strong> à l’utiliser.</p><blockquote>Note : il existe d’autres solutions tout aussi intéressantes que NgRx (Akita, Elf, NgXs, StateAdapt…) mais ici on va s’intéresser à NgRx car c’est la plus souvent utilisée.</blockquote><blockquote>Autre note : même si je fais un récap’ dans l’article, il est recommandé de connaître le principe de NgRx pour pleinement apprécier cette article (actions, reducer, effects, selectors). Je prévois un article et une formation sur le sujet !</blockquote><p>Je dois bien avouer que quand on voit ça :</p><pre>@Injectable()<br>export class TodosService {<br>  readonly #http = inject(HttpClient);<br><br>  readonly todos = signal&lt;Todo[]&gt;([]);<br>  readonly error = signal&lt;string | null&gt;(null);<br>  readonly hasTodos = computed(() =&gt; this.todos().length &gt; 0);<br><br>  loadTodos() {<br>    this.#http<br>      .get&lt;Todo[]&gt;(&#39;api/todos&#39;)<br>      .pipe(<br>        takeUntilDestroyed()<br>      )<br>      .subscribe({<br>         next: (todos) =&gt; this.todos.set(todos),<br>         error: (error) =&gt; this.error.set(error.message),<br>       });<br>  }<br><br>  removeTodo(id: number) {<br>    this.todos.update((todos) =&gt; todos.filter((todo) =&gt; todo.id !== id));<br>  }<br>}</pre><pre>@Component({<br>  template: `<br>    &lt;p *ngIf=&quot;service.error()&quot;&gt;<br>      Error: {{ service.error() }}<br>    &lt;/p&gt;<br><br>    &lt;ul *ngIf=&quot;service.hasTodos()&quot;&gt;<br>      &lt;li *ngFor=&quot;let todo of service.todos()&quot;&gt;<br>        {{todo.title}}<br>        &lt;button (click)=&quot;service.removeTodo(todo.id)&quot;&gt;remove&lt;/button&gt;<br>      &lt;/li&gt;<br>    &lt;/ul&gt;<br>  `,<br>  providers: [TodosService]<br>})<br>export class Todos {<br>  readonly service = inject(TodosService);<br><br>  constructor() {<br>    this.service.loadTodos();<br>  }<br>}</pre><p>On peut se demander pourquoi on s’embêterait à faire ça :</p><pre>export interface State {<br>  todos: Todo[];<br>  error: string | null;<br>}<br><br>export const initialState: State = {<br>  todos: [],<br>  error: null,<br>};<br><br>// actions<br>export const todosActions = createActionGroup({<br>  source: &#39;Todos Page&#39;,<br>  events: {<br>    todosComponentInitialized: emptyProps(),<br>    loadTodosSucceeded: props&lt;{ todos: Todo[] }&gt;(),<br>    loadTodosFailed: props&lt;{ error: string }&gt;(),<br>    removeTodoRequested: props&lt;{ id: string }&gt;(),<br>  },<br>});<br><br>// reducer et selectors<br>export const todosFeature = createFeature({<br>  name: &#39;todos&#39;,<br>  reducer: createReducer(<br>    initialState,<br>    on(TodoActions.loadTodosSucceeded, (state, { todos }) =&gt; ({ ...state, todos })),<br>    on(TodoActions.loadTodosFailure, (state, { error }) =&gt; ({ ...state, error })),<br>    on(TodoActions.removeTodoRequested, (state, { todoId }) =&gt; ({ ...state, todos: state.todos.filter(todo =&gt; todo.id !== todoId) })),<br>  ),<br>  extraSelectors: ({ selectTodos }) =&gt; ({<br>    selectHasTodos: createSelector(selectTodos, (todos) =&gt; todos.length &gt; 0),<br>  }),<br>});<br><br>// effects<br>export const loadTodos = createEffect(<br>  (<br>    actions$ = inject(Actions),<br>    http = inject(HttpClient)<br>  ) =&gt;<br>    actions$.pipe(<br>      ofType(todosActions.todosComponentInitialized),<br>      switchMap(() =&gt;<br>        http.get&lt;Todo[]&gt;(&#39;api/todos&#39;).pipe(<br>          map((todos) =&gt; todosActions.loadTodosSucceeded({ todos })),<br>          catchError((error) =&gt; of(todosActions.loadTodosFailed({ error })))<br>        )<br>      )<br>    ),<br>  { functional: true }<br>);<br><br>// facade<br>export function injectTodosStore() {<br>  const store = inject(Store);<br><br>  return {<br>    removeTodoRequested: (id: number) =&gt; store.dispatch(todosActions.removeTodoRequested({ id })),<br>    todosComponentInitialized: () =&gt; store.dispatch(todosActions.todosComponentInitialized()),<br>    todos: store.selectSignal(todosFeature.selectTodos),<br>    error: store.selectSignal(todosFeature.selectError),<br>    hasTodos: store.selectSignal(todosFeature.selectHasTodos),<br>  };<br>}</pre><pre>@Component({<br>  template: `<br>    &lt;p *ngIf=&quot;todosStore.error()&quot;&gt;<br>      Error: {{ todosStore.error() }}<br>    &lt;/p&gt;<br><br>    &lt;ul *ngIf=&quot;todosStore.hasTodos()&quot;&gt;<br>      &lt;li *ngFor=&quot;let todo of todosStore.todos()&quot;&gt;<br>        {{todo.title}}<br>        &lt;button (click)=&quot;todosStore.removeTodoRequested(todo.id)&quot;&gt;remove&lt;/button&gt;<br>      &lt;/li&gt;<br>    &lt;/ul&gt;<br>  `,<br>})<br>export class TodosListComponent {<br>  readonly todosStore = injectTodosStore();<br><br>  constructor() {<br>    this.todosStore.todosComponentInitialized();<br>  }<br><br>}</pre><p>La version NgRx est clairement plus verbeuse :</p><p>👉23 lignes de code sans NgRx<br>👉54 lignes de code avec NgRx (en comptant l’interface du state et la facade, sinon on est à 36)</p><p>Et le tout pour un résultat fonctionnellement identique. Alors pourquoi s’embêter à utiliser NgRx ?</p><p><strong>Réponse : parce que l’approche de NgRx propose des avantages qui rendront vos codebases plus maintenables.</strong></p><blockquote>Vous vous demandez peut-être ce qu’est cette syntaxe NgRx, notamment createActionGroup et createFeature ? C’est la syntaxe moderne de NgRx ! Et oui, vous ne le saviez peut-être pas mais l’API moderne de NgRx est probablement très différente de ce que vous utilisez au quotidien. Grâce à elle on peut avoir des stores d’un seul fichier !</blockquote><blockquote>J’en parle plus longuement dans mon article “<a href="https://medium.com/@kevin.tale/ngrx-en-2023-les-bonnes-pratiques-a631a366aeaa">NgRx en 2023 : les bonnes pratiques</a>”.</blockquote><h3>La différence fondamentale entre l’approche de NgRx et l’approche “classique”</h3><p>NgRx se repose sur le pattern Flux proposé par Facebook et utilisé maintenant par bons nombres de solutions de State Management. Ce pattern repose sur la gestion d’un store qui contient un state, des actions, des reducers, des effects et des selectors.</p><p>Voilà en quelques mots comment ça fonctionne :</p><ul><li>A l’état initial, mon application écoute toutes les actions en même temps. Une action est un évènement, par exemple todosComponentInitialized ou removeTodoButtonClicked ou encore fetchTodosFailed.</li><li>Lorsqu’un évènement survient dans un endroit de mon application alors on “dispatch” (déclenche) une action qui dit “il vient de se passer cet évènement”.</li><li><strong>Un ou plusieurs endroits (reducers et/ou effects) réagissent à cette action </strong>en modifiant le state ou en dispatchant une nouvelle action</li><li>Mon state est mis à jour, je peux l’utiliser dans mes composants et/ou services</li></ul><p>C’est exactement ce que je fais dans mon store NgRx plus haut :</p><pre>// le composant dispatch l&#39;action dans le constructor<br>// cette action décrit l&#39;évènement qui vient de se passer<br>constructor() {<br>  this.todosStore.todosPageInitialized();<br>}<br><br>// l&#39;effect dans todos.store.ts<br>export const loadTodos = createEffect(<br>  (<br>    actions$ = inject(Actions), // 👈 le bus d&#39;actions de mon app<br>    http = inject(HttpClient)<br>  ) =&gt;<br>    actions$.pipe(<br>      ofType(todosActions.todosComponentInitialized), // 👈 j&#39;écoute l&#39;action qui m&#39;intéresse<br>      switchMap(() =&gt;<br>        http.get&lt;Todo[]&gt;(&#39;api/todos&#39;).pipe(<br>          // 👇 je dispatch l&#39;action correspondante selon le success ou fail<br>          map((todos) =&gt; todosActions.loadTodosSucceeded({ todos })),<br>          catchError((error) =&gt; of(todosActions.loadTodosFailed({ error })))<br>        )<br>      )<br>    ),<br>  { functional: true }<br>);<br><br>// le reducer dans todos.store.ts<br>export const todosFeature = createFeature({<br>  name: &#39;todos&#39;,<br>  reducer: createReducer(<br>    initialState,<br>    // 👇je modifie mon state ici <br>    on(TodoActions.loadTodosSucceeded, (state, { todos }) =&gt; ({ ...state, todos })),<br>    on(TodoActions.loadTodosFailed, (state, { error }) =&gt; ({ ...state, error })),<br>  )<br>});</pre><p>Tandis que sur l’approche classique où j’exécute une fonction, on passe par moins d’étapes :</p><pre>// le composant exécute la fonction dans le constructor<br>constructor() {<br>  this.todosService.loadTodos();<br>}<br><br>// dans todos.service.ts<br>readonly todos = signal&lt;Todo[]&gt;([]);<br>readonly error = signal&lt;string | null&gt;(null);<br><br>loadTodos() {<br>  this.#http<br>    .get&lt;Todo[]&gt;(&#39;api/todos&#39;)<br>    .pipe(<br>      takeUntilDestroyed()<br>    )<br>     // 👇je modifie mes signals ici<br>    .subscribe({<br>       next: (todos) =&gt; this.todos.set(todos),<br>       error: (error) =&gt; this.error.set(error.message),<br>     });<br>}</pre><p>En terme de lisibilité une approche classique gagne à plat de couture. Et vous commencez à me connaître si vous me lisez souvent, je suis un amoureux de la simplicité et de la DX agréable.</p><p>Mais il y a désavantage clair à l’approche classique : si j’ai besoin de réagir à loadTodos à un autre endroit de mon application alors les ennuis commencent.</p><p>Je m’explique.</p><p>Admettons que mon PO me demande une évolution. Désormais quand les todos sont chargés je dois déclencher 3 autres requêtes HTTP et/ou changer une donnée d’un autre state de mon app.</p><p>Comment faire évoluer mon code en ce sens ?</p><h4>Sans NgRx</h4><p>Est-ce la fonction loadTodos de mon service qui doit porter cette logique ?</p><pre>// le composant exécute la fonction dans le constructor<br>constructor() {<br>  this.todosService.loadTodos();<br>}<br><br>// dans todos.service.ts<br>// j&#39;injecte mes autres services 👇<br>readonly #service1 = inject(Service1);<br>readonly #service2 = inject(Service2);<br>readonly #service3 = inject(Service3);<br><br>readonly todos = signal&lt;Todo[]&gt;([]);<br>readonly error = signal&lt;string | null&gt;(null);<br><br>loadTodos() {<br>  this.#http<br>    .get&lt;Todo[]&gt;(&#39;api/todos&#39;)<br>    .pipe(<br>      takeUntilDestroyed()<br>    )<br>    .subscribe({<br>       next: (todos) =&gt; {<br>        this.todos.set(todos);<br>        // j&#39;appelle le load des autres services<br>        this.#service1.load();<br>        this.#service2.load();<br>        this.#service3.load();<br>       },<br>       error: (error) =&gt; this.error.set(error.message),<br>     });<br>}</pre><p>Mais dans ce cas-là ma separation of concerns est complètement brisée, mon loadTodos fait bien plus que ce qui prétend faire, mon code devient complètement impératif et plus lourd à tester car je dois mock plusieurs services.</p><p>Alors si ce n’est pas le service qui doit porter cette logique, c’est peut-être le composant ?</p><pre>// dans todos.component.ts<br>readonly #service1 = inject(Service1);<br>readonly #service2 = inject(Service2);<br>readonly #service3 = inject(Service3);<br><br>constructor() {<br>  this.todosService.loadTodos()<br>    .subscribe({<br>       next: (todos) =&gt; {<br>        this.#service1.load();<br>        this.#service2.load();<br>        this.#service3.load();<br>       },<br>     })<br>}<br><br>// dans todos.service.ts<br>// j&#39;ai du modifier mon ancien code pour qu&#39;il return l&#39;observable<br>// et qu&#39;il set les &#39;signals&#39; dans l&#39;opérateur &#39;tap&#39;<br>loadTodos() {<br>  return this.#http<br>    .get&lt;Todo[]&gt;(&#39;api/todos&#39;)<br>    .pipe(<br>      takeUntilDestroyed(),<br>      tap({<br>       next: (todos) =&gt; this.todos.set(todos),<br>       error: (error) =&gt; this.error.set(error.message),<br>     })<br>    )<br>}</pre><p>Ce n’est pas spécialement mieux. Le composant à maintenant trop de logique impérative, la separation of concerns est également brisée.</p><p>Bref, dans les deux cas on sent venir le spaghetti code et faire des TUs devient complexe. Mais également : <strong>on a du replonger dans les features qu’on avait déjà codé pour les modifier</strong>.</p><p>Mais avec NgRx ?</p><blockquote>Petite parenthèse !<br>Si vous voulez devenir autonome sur Angular, je vous propose de rejoindre <a href="https://discord.com/invite/c8XThfW9a7"><strong>Bonjour Angular</strong></a>, la plus grande communauté Angular francophone au monde.<br>Vous y trouverez conseils, entraide, veille techno et opportunités de boulot le tout autour de Angular !</blockquote><h4>Avec NgRx</h4><pre><br>// le composant ET l&#39;effect restent inchangés ! <br>// AUCUNE modification n&#39;est nécessaire sur l&#39;ancien code !<br><br>// Dans mes autres stores j&#39;écoute sur le loadTodosSucceeded que <br>// j&#39;avais dispatché au retour API dans todos.store.ts<br>export const doSomething = createEffect(<br>  (actions$ = inject(Actions)) =&gt; <br>    actions$.pipe(<br>      // 👇 ici<br>      ofType(TodosActions.loadTodosSucceeded), <br>      ...<br>    )<br>  ,<br>  { functional: true }<br>);<br><br><br>export const someStoreFeature = createFeature({<br>  name: &#39;someStore&#39;,<br>  reducer: createReducer(<br>    initialState,<br>    // 👇 et là<br>    on(TodosActions.loadTodosSucceeded, (state) =&gt; ...),<br>  )<br>});<br></pre><p>Vous voyez ce que je viens de faire ? Avec NgRx les autres stores de mon application écoutent également les actions des stores qui les intéressent !</p><p>Et ça change <strong>TOUT</strong> !</p><p>Les paradigmes sont complètements différents, avec l’approche classique, qu’on appelle <strong>“Command Pattern”,</strong> j’appelle une fonction qui appelle une fonction qui appelle une fonction tandis qu’avec NgRx je dispatch une action qui peut être écoutée par tout le monde et réagir de manière différente selon qui l’écoute !</p><p><strong>C’est une approche impérative versus une approche déclarative et réactive.</strong></p><ul><li>Avec une approche classique, vous donnez des ordres : “charge les todos, puis charge cela, puis fais ceci !” et dans chaque “ceci ou cela” des ordres subséquents peuvent être également donnés.</li><li>Avec NgRx (Flux Pattern), quand un évènement survient (ex: “le composant vient de se charger”) vous le poussez dans un flux d’actions et ceux qui écoutent dessus peuvent réagir comme bon leur semble.</li></ul><p>En résumé, avec le Flux Pattern, n’importe quel endroit de l’application peut réagir à cet évènement alors que le Command Pattern exige que l’on exécute explicitement les fonctions.</p><p>On peut même faire ce genre de choses avec NgRx :</p><pre>export const someEffect = createEffect(<br>  (actions$ = inject(Actions)) =&gt; <br>    $actions.pipe(<br>      ofType(<br>        someAction1,<br>        someAction2,<br>        someAction3,<br>       ),<br>      ...<br>    )<br>);<br><br>export const someStoreFeature = createFeature({<br>  name: &#39;someStore&#39;,<br>  reducer: createReducer(<br>    initialState,<br>    on(<br>      someAction1,<br>      someAction2,<br>      someAction3, <br>      (state) =&gt; ...<br>    ),<br>  )<br>});</pre><p>En gros, un effect ou un reducer peuvent écouter sur plusieurs actions. Dans une approche classique le résultat serait beaucoup moins agréable à gérer car on devrait :</p><ul><li>Replonger dans l’ancienne feature pour ajouter l’exécution de fonctions d’autres services</li><li>Adapter le TU en conséquence</li><li>Serrer les fesses pour espérer ne pas avoir introduit de régressions</li></ul><p>Et là mon exemple est simple, une simple todos list avec une feature de load et de remove. Imaginez une application avec des dizaines de pages, des centaines de features et des dizaines de personnes qui l’ont maintenu pendant des années. L’effet se multiplierait de plus en plus ! 🤯</p><p>Avec NgRx <strong>correctement appliqué</strong>, on minimise cet impact car chaque partie logique de l’app est isolé. On a pas de relation direct entre les features, on a des évènements et des réactions.</p><p>Nos composants ne servent que la UI, ils vont uniquement dispatch des actions qui décrivent les évènements, par exemple pageInitialized, et des morceaux de codes vont catch cet évènement pour faire des calls HTTP ou autres.</p><p>Voyez-vous maintenant la puissance du Flux Pattern sur lequel se base NgRx et pourquoi cela peut rendre vos applications plus maintenable ?</p><p>Et ce n’est pas tout ! L’écosystème NgRx possède beaucoup de fonctionnalités là pour vous aider.</p><h3>L’écosystème NgRx</h3><p>NgRx est bien plus qu’une librairie, c’est un écosystème disposant d’une multitude d‘extensions pour vous aider dans vos besoins quotidiens. Par exemple effects est l’une de ces extensions. Mais il en existe d’autres.</p><h4>Router-Store</h4><p>On y trouve “@ngrx/router-store” qui nous renvoie un tas de selectors très utile :</p><pre>import { getRouterSelectors, RouterReducerState } from &#39;@ngrx/router-store&#39;;<br> <br>export const {<br>    selectCurrentRoute, // select the current route<br>    selectFragment, // select the current route fragment<br>    selectQueryParams, // select the current route query params<br>    selectQueryParam, // factory function to select a query param<br>    selectRouteParams, // select the current route params<br>    selectRouteParam, // factory function to select a route param<br>    selectRouteData, // select the current route data<br>    selectRouteDataParam, // factory function to select a route data param<br>    selectUrl, // select the current url<br>    selectTitle, // select the title if available<br>} = getRouterSelectors();</pre><p>C’est très utile pour faire de la composition de selectors ou pour utiliser dans vos effects.</p><h4>Developer Tools</h4><p>C’est le gros plus de NgRx/store ! On a accès au state global de notre application dans le <em>Redux Devtools Extension. </em>Ainsi, on peut voir à tout moment chacun de nos states, l’historique des actions dispatchées avec leurs payload et même rejouer ces dernières !</p><p>C’est vraiment un must-have et c’est une merveille pour le debugging. 🤩</p><p><a href="https://ngrx.io/guide/store-devtools">Plus d’infos ici.</a></p><h4>Component Store</h4><p>Voici une super extension que j’ai beaucoup utilisé.<br>Elle vous permet de gérer un store local (pour votre composant) sans les actions, reducers etc mais tout en gardant de bonnes pratiques et performances.</p><p>On peut voir l’équivalent de notre applications todos sous Component Store :</p><pre>export interface State {<br>  todos: Todo[];<br>  error: string | null;<br>}<br><br>export const initialState: State = {<br>  todos: [],<br>  error: null,<br>};<br><br>@Injectable()<br>export class TodosListStore extends ComponentStore&lt;State&gt; {<br>  readonly #todosService = inject(TodosService);<br><br>  readonly todos = this.selectSignal(state =&gt; state.todos);<br>  readonly error = this.selectSignal(state =&gt; state.error);<br>  readonly hasTodos= this.selectSignal(state =&gt; state.todos &gt; 0);<br><br>  constructor() {<br>    super(initialState);<br>  }<br><br>  readonly loadTodos= this.effect&lt;void&gt;(<br>     (trigger$) =&gt; trigger$.pipe(<br>      switchMap(() =&gt;<br>        this.#todosService.loadTodos().pipe(<br>          tapResponse({<br>            next: (todos) =&gt; this.patchState({ todos },<br>            error: (error: HttpErrorResponse) =&gt; this.patchState({ error},<br>          })<br>        )<br>      )<br>    )<br>  );<br><br>  removeTodo(id: number) {<br>    this.todos.setState(state =&gt; ({...state, todos: todos.filter(todo =&gt; todo.id !== id)}))<br>  }<br>}</pre><p>C’est une bonne alternative si vous voulez une approche simple du State Management. Je vous conseille cette extension plutôt que d’implémenter une solution de State Management faite maison.</p><p>En revanche il est à noter que :</p><ul><li>Le Developer Tool ne fonctionne pas avec Component Store</li><li>Cela reste du Command Pattern</li></ul><h3>D’autres bonnes raisons d’utiliser NgRx</h3><p>Si vous utilisez <strong>correctement</strong> NgRx, vous pourrez être certains que même une nouvelle personne qui rejoint l’équipe prendra en mains rapidement votre application.</p><p>Aussi, NgRx est constamment mis à jour et ils travaillent avec la team Angular pour toujours avancer dans la même direction. C’est pour cela que NgRx est très performants et les features très adaptés au framework Angular.</p><p>Vous avez peut-être envie de créer votre propre solution basée sur les principes de Redux <a href="https://www.youtube.com/watch?v=R4Ff2bPiWh4&amp;ab_channel=JoshuaMorony">comme certains le font</a> et il serait intéressant de le faire car cela vous aidera à comprendre parfaitement les avantages de cette approche. Mais ayez en tête qu’en faisant cela, il y a de fortes chances que vous ne fassiez que recréer la roue (en probablement moins bien). Vous devrez la maintenir, la faire évoluer, la documenter… Bref c’est un boulot à pleins temps ! Et croyez moi, des projets qui utilisent correctement NgRx ça ne court pas les rues, alors leurs propres solutions faites maison… 😬</p><p>Sachez également que connaître NgRx aide très largement à l’embauche car beaucoup de projets l’utilisent. Maîtriser cette outil et l’indiquer sur son CV est un gros plus.</p><p>Enfin, des travaux sont en cours pour proposer un ngrx/signals. Vous pouvez découvrir <a href="https://github.com/markostanimirovic/ngrx-signal-store-playground#ngrx-signals">la doc ici</a>.<br>Cela semble très prometteur, le boilerplate est encore plus réduit que pour component-store ! J’ai l’impression qu’on reste sur du Command Pattern mais j’ai hâte de voir ça. Ce n’est franchement pas impossible qu’à terme cela devienne ma solution par défaut. A voir quand ça sortira ! Je ferai un article dessus of course !</p><h3>Des raisons de ne pas utiliser NgRx</h3><p>Si votre équipe n’arrive pas à prendre NgRx/store en mains, alors ne l’utilisez pas. Après tout le but est d’être productif, et NgRx/store à un coût non négligeable en terme d’apprentissage.</p><p>Donc si vous êtes dans un rush, que vous avez des deadline serrées et que le rapport risque/coût n’est pas bon, utilisez plutôt NgRx/component-store voire les Signals en “vanilla”.</p><p>Ce n’est évidemment pas non plus garanti que votre équipe fasse du travail propre avec component-store ou les Signals, mais au moins il n’y a pas tout une mécanique à apprendre, c’est déjà ça !</p><p>Mais c’est indéniable : NgRx est verbeux et je comprends que ça puisse en rebuter certains. Cependant à mon sens cette verbosité vaut le coup sur le long terme car vous aurez une application parfaitement réactive, déclarative et qui permet une meilleure separation of concerns.</p><h3>Conclusions</h3><p>A la question “avez-vous besoin de NgRx” je réponds : non, vous pouvez faire des applications qualitatives sans.</p><p>Mais à la question “avez-vous intérêt à utiliser NgRx”, je réponds : <strong>OUI</strong> ! Votre application n’en sera que plus qualitative, maintenable et suivra de meilleures pratiques qui se reposent sur la programmation déclaratives et réactives !</p><p>Si vous avez des questions ou des commentaires, n’hésitez pas à les partager ici ou directement sur <a href="https://discord.gg/c8XThfW9a7">Bonjour Angular</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a09a02cea28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[L’architecture Angular parfaite ?]]></title>
            <link>https://kevin-tale.medium.com/larchitecture-angular-parfaite-4ae7bd9335aa?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ae7bd9335aa</guid>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Fri, 30 Jun 2023 10:51:31 GMT</pubDate>
            <atom:updated>2024-01-30T09:30:35.023Z</atom:updated>
            <content:encoded><![CDATA[<h3>L’architecture Angular parfaite ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KYfTIJFCgbwTpWyqP_dxBw.png" /></figure><blockquote>“Architecture” ici fait référence à la structure de fichiers, à la façon dont vous la découpez en différents composants, services, modules etc et de l’endroit où vous les placez. Aussi, ce qui va suivre est basé sur mon expérience personnelle, et doit être considéré comme une boîte à outils qui, comme toute approche, présente des avantages et des inconvénients.</blockquote><p>Chaque fois que je crée ou modifie une architecture Angular, je me pose <strong>3 questions</strong> :</p><ol><li>Est-ce que les devs’ trouveront mon architecture agréable à utiliser au quotidien ?</li><li>Est-ce qu’elle pourra encaisser les évolutions à venir ?</li><li>Est-ce que mon architecture reflète mon besoin métier au mieux ?</li></ol><p>Chacun de mes choix est confronté à ces 3 questions.</p><p>Si les réponses sont “oui”, alors je sais que mon architecture est parfaite, ou plutôt qu’elle est <strong>parfaitement adaptée à mon contexte métier actuel</strong>.</p><p>Car oui, la réponse à ces 3 questions dépendent du logiciel que l’on doit créer et de l’équipe en charge. Ce que je veux dire par là c’est qu’une certaine architecture pourrait très bien fonctionner dans une situation mais pas une autre car le contexte métier (qu’on appelle la complexité inhérente) est différent.<br>Ainsi, <strong>deux architectures dans deux contextes différents peuvent varier drastiquement et il n’existe pas d’architecture qui couvre 100% des cas.</strong></p><p>Cependant, les 3 questions que j’ai énoncé plus haut ainsi que des principes éprouvées vont nous permettre d’atteindre notre objectif : concevoir l’architecture Angular parfaite pour <strong>votre besoin</strong>.</p><p>Dans cette article, nous allons tenter de comprendre <strong>pourquoi ces questions sont importantes et surtout comment y répondre</strong> !</p><h3>Est-ce que mon architecture est agréable ?</h3><p>L’agréabilité ressentie par les devs est <strong>primordiale</strong> dans vos architectures et doit être au cœur de chacune de vos décisions. Cela fait partie d’un principe qu’on appelle la <strong>Developer eXperience (DX). </strong>C’est à dire l’aisance qu’ont les devs à faire leur métier.</p><p>Pour moi, la DX est la top prio. Nous vivons dans un milieu où les technologies et les besoins métiers évoluent constamment, l’impact de ça c’est que vous allez régulièrement mettre votre code à jour car l’API d’une librairie ou la version de votre framework ont changé. Egalement, d’un point de vue business, vos PO/PM vous demanderont d’ajouter des fonctionnalités ou d’en modifier très régulièrement. Bref, on passe nos journées à modifier notre code et notre architecture de manière micro ou macro.</p><p>Et changer les choses dans une codebase c’est le début des embrouilles :</p><ul><li>introduction de bugs dus à des effets de bords</li><li>lassitude, agacement ou inquiétudes des devs qui doivent replonger dans un code obscur</li></ul><p>Une mauvaise architecture entraîne une mauvaise DX qui entraîne une équipe anxieuse et peu efficace. On aura peur de modifier les choses par incompréhension de la codebase et/ou on aura la flemme de “faire propre” car les patterns sont lourds : c’est le début de la dette technique.</p><p>Ainsi, <strong>l’importance d’avoir une architecture agréable à utiliser est primordiale pour la santé mentale des devs et donc la pérennité du business</strong>.</p><p>Si l’équipe de développement trouve la structure de fichiers cohérentes et facile à naviguer alors elle pourra ajouter, modifier ou supprimer des éléments plus rapidement et sans crainte d’effet de bord.</p><p>Ce qui participe également à l’agréabilité de navigation dans une architecture c’est de <strong>garder le nombre de fichiers et dossiers bas tout en respectant la <em>separation of concerns</em></strong>. La multiplication de fichiers peut tout à fait répondre à un besoin, mais elle peut également être vecteur d’erreurs. On doit trouver des noms adéquats, on doit faire attention à ne pas mélanger les responsabilités des fichiers, et au-delà de ça cela apporte de la lourdeur à la navigation entre fichiers.</p><p>Après tout, si Angular et NgRx s’évertuent à réduire le boilerplate de leurs produits, c’est parce qu’ils ont bien compris l’importance d’avoir un workspace léger.</p><p>Ne vous méprenez pas sur ce que je dis, je ne vous incite pas à avoir un seul gros composant, service ou store avec tout dedans. Je vous incite à découper les choses quand il y a réellement une raison de le faire. Lorsque vous vous apprêtez à découper un fichier en plusieurs , posez vous la question du gain et utilisez votre bon sens. Gardez la <em>separation of concerns </em>comme indicateur.</p><p>Ne sous-estimez pas l’importance de la DX. C’est le nerf de la guerre. Posez vous la question de savoir si une nouvelle personne qui intègre l’équipe arriverait à comprendre l’architecture frontend en quelques minutes.</p><h3>Est-ce que mon architecture est évolutive ?</h3><p>Je le disais en introduction, les besoins métier évoluent en permanence. Une feature en plus, une autre utilisée à plusieurs endroits qui devient un peu différente selon là où elle est consommée.</p><p>Le problème c’est que ni les devs ni les PO/PM ne voient dans le futur, donc oubliez tout de suite l’idée que vous ferez une architecture qui encaissera tous les changements futurs. Ca n’arrivera pas.</p><p>Alors on pourrait se dire que de sortir l’artillerie lourde dès le départ est une bonne idée. Partons sur une architecture hexagonale en monorepo et full microfrontends. Au moins on aura quelque chose d’évolutif.</p><p>C’est peut-être le cas, mais cela implique que l’équipe, incluant vous-même, soit <strong>hautement </strong>qualifiés pour entretenir ce genre d’architecture. Et, spoiler alert, ça n’arrive pas non plus ou dans de trop rares cas.</p><p><strong>Une architecture évolutive est avant tout quelque chose de facilement incrémentale et dont on a la maîtrise</strong>. C’est à dire quelque chose qui diminue les contraintes : si on veut poser une nouvelle brique par dessus de manière isolée ou non, on peut le faire.</p><p>Si je devais donner un choix stratégique offrant beaucoup de valeurs sans demander une maturité technique démesurée, c’est l’utilisation d’un <strong>monorepo</strong>.</p><p>Un monorepo, c’est le fait d’avoir un seul repository git avec plusieurs apps et libs. Cela permet notamment de faciliter le partage et la réutilisation de code entre vos différentes briques techniques et de profiter d’un écosystème très évolutif. Ma solution préférée est NX.</p><p><a href="https://nx.dev/">NX</a> est un écosystème facilitant la mise en place et le maintient d’architecture web. Vous profiterez de ses outils qui permettent d’intégrer facilement les outils et patterns populaires du web (Angular, React, Jest, Cypress, Storybook…). NX est surtout utilisé dans les architectures monorepo mais vous pouvez tout à fait utiliser NX pour une simple application.</p><p>Personnellement je l’utilise beaucoup dans mon quotidien et contrairement à ce qu’il se dit ce n’est pas uniquement adapté aux gros projets. Mais ce n’est pas trivial non plus, cela nécessite une bonne coordination entre les membres de l’équipe.</p><p>Je prévois un article dédié sur le sujet ! Stay tuned!</p><p>A part ça, une erreur que je vois souvent et qui impacte négativement l’évolutivité, c’est la mauvaise compréhension du principe <strong>DRY</strong> (Don’t Repeat Yourself).</p><p>J’ai travaillé pour une société qui fabriquait des logiciels en marque blanche. En gros, on avait plusieurs clients, chacun désirant une application dédiée avec certaines fonctionnalités. Ces fonctionnalités étaient parfois les mêmes entre les différentes apps (donc pour les différents clients), parfois non, ou parfois c’était les mêmes mais avec quelques différences subtiles. Donc les apps avaient quelques bases communes entre elles mais aussi beaucoup de spécificités.</p><p>Le choix (qui avait été fait bien avant mon arrivé) a été de concevoir une seul app Angular avec toutes les fonctionnalités à l’intérieur, chaque client partageait les mêmes pages où un tas de if se trouvaient et un fichier de configs par client qui pilotait l’activation des fonctionnalités à coup de shouldActivateThisFeature: true.</p><p>Résultat : on s’est retrouvés avec une app gigantesque avec des fichiers de 3k lignes qui contenaient les différentes logiques des différents clients. C’était impossible à tester, très difficile à isoler et l’évolution était très limitée.</p><p>Comment on en est arrivé là ? Parce qu’il y a une incompréhension sur la définition de DRY.</p><p><strong>Ce n’est pas parce que quelque chose à le même nom que c’est la même chose.</strong></p><p>Ici, les applications avaient le même nom, les pages et fonctionnalités aussi, donc on a considéré que c’était la même chose. On a donc tout mis dans une seule et même app.</p><p>Une solution viable aurait été de faire une app distincte par client où chacune d’entre elle déclarait son propre routing avec ses propres pages et de considérer chaque fonctionnalité comme une librairie consommable par les apps.</p><p>Pensez toujours à respecter une <em>separation of concerns</em> dans vos applications. Si deux features semblent très similaires mais divergent en quelques points, c’est souvent le signal que ce sont en réalité deux features différentes.</p><h3>Est-ce que mon architecture reflète mon besoin métier ?</h3><p>Ce point là est la résultante des deux précédents. En fait, une architecture qui reflète le besoin métier est la porte d’entrée vers une architecture agréable et évolutive.</p><p>Ceci est l’un des principes du <strong>DDD </strong>(Domain Driven Design) : concevoir une application en suivant le contexte métier. Cela veut dire que mon architecture est le reflet de mon business, si bien qu’un PO/PM devrait pouvoir se balader dans mon repository et comprendre son architecture (j’exagère un peu mais pas tant).</p><p>Il y a une phrase d’<a href="https://twitter.com/Lilobase">Arnaud Lemaire</a> que j’aime beaucoup et qui résume une architecture DDD réussie : <strong>des petits changements métiers doivent entraîner des petits changements dans la codebase et des grands changements métiers doivent entraîner des grands changements dans la codebase</strong>.</p><p>Bon, ceci étant dit, je ne ferai pas une explication exhaustive du DDD, déjà parce que ça pourrait tenir dans un bouquin, mais aussi parce que je ne prétends pas pouvoir le faire. En revanche, je peux vous expliquer comment appliquer certains de ses principes à la création d’architecture !</p><p>Il y a notamment deux voies pour mettre en place une architecture qui suit la logique métier :</p><ol><li>un découpage de dossiers qui suit la navigation utilisateur</li><li>de la colocation de code</li></ol><p>Le premier point consiste à avoir un folder routes avec les différentes routes de votre applications (vos pages). Et dans chacune des routes on a potentiellement des sous routes. En somme, le code de la page domain.com/products-list sera contenu dans routes/products-list. Certains frameworks disposent de ce principe de manière naturelle, par exemple NextJS ou AnalogJS. C’est ce qu’on appelle le <strong>file base routing.</strong> C’est très intéressant car ainsi la logique de notre structure de fichiers est liée et pilotée par le métier, l’évolution de notre codebase sera donc toujours fait au même rythme que le métier tout en ayant quelque chose de facilement compréhensible. L’avantage est que si vous avez un ticket de bug sur une page, vous saurez immédiatement où intervenir.</p><p>Le second point concerne la colocation de code. Cela fait référence au fait de regrouper le code et les fichiers traitant du même domaine métier au même niveau dans votre arborescence de fichiers Cela assure une compréhension claire des dépendances des différentes parties de votre code et des potentielles effets de bords.</p><p>Nous allons voir dans la section suivante des exemples d’architectures qui mettent en pratique tous les principes énumérées jusqu’ici.</p><blockquote>Petite parenthèse !<br>Si vous voulez être au top niveau sur Angular, je vous propose de rejoindre<a href="https://discord.gg/c8XThfW9a7"> la plus grande communauté Angular francophone au monde</a>.<br>Vous y trouverez conseils, entraide, veille techno et opportunités de boulot le tout autour de Angular !</blockquote><h3>La mise en pratique</h3><p>Je vous parlais de file base routing, voici comment faire l’équivalent dans Angular en partant d’une application en version 16 :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/337/1*EIN0oaAMFMIas0zUM_7avA.png" /></figure><p>Ici, la structure de mes fichiers suit parfaitement la navigation de l’utilisateur dans l’application. Si je suis sur la page domain.com/product alors je sais immédiatement où se trouve le code impliqué. Et à l’intérieur de chaque folder on retrouve la route en question avec leurs sous routes éventuelles (c’est le cas pour my-account). C’est le fichier app.routing.ts qui pilote le routing de premier niveau et celui de second niveau est géré par des fichiers comme my-account.routing.ts par exemple.</p><p>C’est très pratique pour l’agréabilité comme je le disais plus haut, si vous avez un bug sur une page alors vous pourrez identifier en un clin d’œil où intervenir.<br>Vous avez sans doute remarqué quelque chose : je ne suis pas la convention Angular et je nomme mes routes en xxx.route.ts. Cela me permet d’identifier rapidement ce qu’est ce fichier plutôt que de nommer tous mes composants xxx.component.ts. Je vous invite à faire de même !</p><p>Maintenant, imaginez que vous avez un header et footer présents sur toutes vos pages et que vous voulez en faire deux composants. Ces composants vont être utilisés dans le AppComponent. Mais où allez vous les placer dans votre architecture ?</p><p>La réponse est : au plus proche de là où ils sont utilisés. C’est le principe de colocation de code !</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*8nP0j7-ekTyC_iZckZAjXg.png" /><figcaption>Les composants sont au même niveau de leur endroit d’utilisation</figcaption></figure><p>Ainsi, des xxx.component.ts vivant à côté d’un xxx.route.ts signifient qu’ils sont utilisé dedans. Tout simplement ! Pas besoin d’utiliser de dossier shared ou core dans ce cas-là. Cela ne ferait que rajouter du bruit inutile.</p><p>Je suis cette même logique pour toutes les routes et pas uniquement pour les composants :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/331/1*I48nsyQi7rqQkvbElMaOXQ.png" /></figure><p>Et oui ! Je parie que vous n’aviez jamais vu ce genre d’approche avant. Et bien je peux vous assurer qu’après avoir essayé des tas d’approche, celle-ci apporte la meilleure DX au quotidien et sur le long terme.<br>Ici donc, tout est aplati, on minimise les dossiers et on suit une règle simple : <strong>les fichiers qui sont utilisés ensemble sont côte à côte</strong>.<br>Par exemple, j’ai besoin de créer un interceptor pour ajouter mon token JWT à chaque requête HTTP. Cet interceptor est utilisé dans mon app.config.ts donc je le place à son niveau !<br>Il en va de même pour les guards, les services etc.</p><p>C’est de la <strong>colocation de code</strong>. Le but est de comprendre en un clin d’œil <strong>les responsabilités et dépendances de mes fichiers</strong>.</p><p>Vous allez peut-être vous dire qu’on va potentiellement avoir des dossiers avec 15 fichiers à l’intérieur, voire plus. En effet, et devinez quoi : <strong>c’est vraiment pas grave, au contraire !<br></strong>Croyez moi, les devs comprendront bien plus vite ce découpage là que d’obscurs dossiers core ou autres qui entraînent des réflexions supplémentaires et donc de potentielles erreurs et c’est là que la dette technique s’accumule.</p><p>Prenez ces conseils comme des indications, si votre équipe se sent plus à l’aise avec un dossier par-ci par-là alors faites le, mais gardez toujours en tête la DX et de réduire les chances d’augmenter la dette technique.</p><p>Bon, on garde les fichiers en commun ensemble au même endroit, très bien, mais qu’en est-il des éléments partagés ?</p><p>Typiquement :</p><ul><li>des composants UI</li><li>des features</li><li>des utilitaires</li></ul><p>Une solution est un dossier shared au même niveau que routes qui contient les éléments partagés de l’application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/303/1*UHIVBS0f0zdB8HCU5vc1_Q.png" /></figure><p>Ainsi en tant que dev, si un élément est réutilisé à plusieurs endroits alors je le mettrais ici.</p><p>Par exemples les composants :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/1*OrVDsqW9uJmoqVbOywuNfA.png" /></figure><p>Ces composants représentent des éléments qui ne sont pas attachés à la logique métier exactement comme les composants de Angular Material par exemple.</p><p>Il existe des solutions encore plus puissantes comme les design system. Un design system gère l’ensemble de l’apparence de votre métier, on y trouve les composants, les styles et les règles UI. Une méthodologie éprouvée pour la création de design system est l’Atomic Design. Je n’en parlerai pas ici car ce n’est pas le sujet mais je vous invite à faire vos propres recherches !</p><p>Pour les utilitaires, rien de bien compliqué, on a des folders qui correspondent à nos besoins utilitaires :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/318/1*OdqGgfl7pCX0CTkOuESstQ.png" /></figure><p>Pour les features, c’est la même idée. Une feature est un regroupement d’éléments métiers <strong>réutilisables</strong>. Cela peut être des stores, des services, de la UI ou même une combinaison de tout cela.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/335/1*K-9QivqSoNsMLCJmQtSorQ.png" /></figure><p>Dans cette exemple nous avons deux features, payment et user. Chacun ayant un index.ts pour exposer l’API aux consommateurs. <br>On peut facilement imaginer que dans mon application j’ai besoin des informations du user à plusieurs endroits, ainsi j’importe ce dont j’ai besoin depuis la feature user. Il en va de même pour payment, le service pourrait exposer des méthodes de paiement déclenchable à plusieurs endroits de mon application, et on peut imaginer que le cart soit affichable à plusieurs endroits également.</p><p><strong>Important</strong> : entendons nous bien, je possède un folder shared mais pas de SharedModule ou que sais-je encore. Le folder shared apporte l’indication que les éléments à l’intérieur sont réutilisés à plusieurs endroits, mais pas qu’ils sont tous packagés ensemble ! Ils ont tous leurs propres responsabilités et ne communique pas ensemble, comme les éléments dans routes par exemple.</p><p>Bref, chaque feature est un sous-ensemble de mon domaine d’application et contient des éléments réutilisables. Dans l’idée si une fonctionnalité émerge pour une seule page de l’application alors elle ne devrait pas être dans shared/features/xxx. Par exemple si un administrateur à la possibilité de supprimer un user en faisant un http.delete sur un endpoint user/${id} via une page admin/delete-users alors <strong>en théorie</strong> cette logique devrait être contenue dans routes/admin/delete-users/delete-users.service.ts. Donc pas dans la feature user car cette fonctionnalité n’est pas partagée.</p><p>Je dis bien “en théorie” car c’est typiquement sur ce genre de choix où on va adapter son architecture selon le métier et les préférences de l’équipe, on pourrait préférer mettre cette logiquement également dans la feature user pour certaines raisons. Et en poussant l’idée un peu plus loin, on pourrait même avoir ceci :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/302/1*qwuUZXpZCTDwwaqjW6x-Ug.png" /></figure><p>Ici, j’ai carrément fait sauter la notion de shared. Les composants sont déplacés dans un design-system, utils est directement à la racine ainsi que features signifiant qu’ils pourraient être partagés ou non.</p><p>C’est, à mon sens, une architecture très solide (hormis monorepo) si l’équipe à un haut niveau de maturité. Le risque réside dans le fait de perturber l’agréabilité au quotidien, j’imagine facilement qu’une feature devienne mal isolée et qu’on y introduise des notions qui ne devraient pas y être. Préférez la colocation de code tant que c’est possible.</p><h3>Pour aller plus loin</h3><p>Il y a beaucoup de méthodologies dont je n’ai pas parlé :</p><ul><li>microfrontends</li><li>clean architecture</li><li>architecture hexagonale</li></ul><p>Ce sont des sujets poussés et qui nécessite un haut niveau de maturité technique mais qui peuvent apporter beaucoup à la pérennité de vos projets. Assurez vous de maîtriser les points précédents avant pour comprendre l’essence d’une bonne architecture avant de vous lancer dans ces recherches.</p><h3>Résumé</h3><ul><li>Pensez toujours à vos collègues qui récupèreront votre code en priorisant la DX</li><li>Si je reçois un ticket qui me dit “il y a un bug sur cette feature”, je dois trouver où intervenir en quelques secondes</li><li>Si une nouvelle personne intègre l’équipe (et quelque soit son niveau de séniorité à peu de chose près) alors elle doit comprendre l’architecture en quelques minutes</li><li>L’organisation de vos fichiers doit être logique et consistant</li><li>Méfiez vous du DRY qui est parfois trompeur</li><li>Mettez un folder routes qui suivra la navigation de l’utilisateur</li><li>Aplatissez vos fichiers et utilisez de la colocation de code au maximum tant que cela respecte la <em>separation of concerns</em></li><li>Utilisez un dossier shared pour y mettre des sous dossiers components, utils, features etc contenant vos éléments partagés</li><li>Alternativement, vous pouvez mettre ces sous dossiers directement à la racine au même niveau que routes</li><li>Considérez sérieusement l’approche monorepo avec NX</li></ul><h3>Conclusion</h3><p>Une architecture parfaite <strong>pour votre business </strong>mettra du temps à être mise en place. Il faudra faire, défaire et refaire régulièrement. Mais si vous suivez ces conseils et que vous priorisez la DX alors tout ce passera pour le mieux et vos collègues et clients/responsables vous remercieront !</p><p>Si vous avez des questions ou des commentaires, n’hésitez pas à les partager ici ou directement sur <a href="https://discord.gg/c8XThfW9a7">mon Discord Angular 100% francophone</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ae7bd9335aa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tout ce que je sais sur RxJS : les opérateurs]]></title>
            <link>https://kevin-tale.medium.com/tout-ce-que-je-sais-sur-rxjs-partie-2-a092c3d920a6?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/a092c3d920a6</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[rxjs]]></category>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Mon, 19 Jun 2023 09:30:29 GMT</pubDate>
            <atom:updated>2023-07-01T21:50:51.948Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*11QgDc_mSFhxCsy3-B5T7A.png" /></figure><p>Dans la première partie de cette série, nous avons exploré les fondations sur lesquelles repose RxJS. Nous avons parlé des flux de données et plus particulièrement des Observables et Subjects . Nous avons vu ce qu’ils sont et également examiné leurs différences puis nous avons évoqué quelques best practices. Si vous n’avez pas encore eu l’occasion de lire cette introduction à RxJS, <a href="https://medium.com/@kevin.tale/tout-ce-que-je-sais-sur-rxjs-partie-1-7af99a9edded">je vous invite à commencer par là !</a></p><p>Dans ce second article, nous allons plonger dans l‘une des grandes forces de RxJS : les opérateurs. Ces outils puissants (et parfois difficiles à maîtriser) vous permettront d’appréhender la programmation réactive au sein de vos applications Angular. Pour guider cette article, nous tenterons de répondre à deux questions :</p><ol><li>Qu’est-ce qu’un opérateur RxJS?</li><li>Quels sont les opérateurs les plus utilisés et pour quelles raisons ?</li></ol><h3>Qu’est-ce qu’un Opérateur</h3><p>Comme vous le savez déjà, un Observable est un mécanisme de gestion de flux de données. Chaque fois qu’une donnée est injectée dans un Observable (via une méthode .next()), cette donnée est émise à tous les abonnés (via un subscribe()ou | async).</p><p>C’est là qu’interviennent les opérateurs. Leur rôle est d’<strong>intervenir dans le flux de données et de faire quelque chose à chaque émission</strong>, par exemple transformer la donnée, la filtrer, et bien d’autres encore.</p><p>Il existe également des opérateurs qui vont créer des Observables à partir de rien, ceux-là ne vont donc pas modifier les valeurs émient mais bel et bien construire leurs propres flux.</p><p>Il existe donc deux grandes catégories d’opérateurs :</p><ol><li>les opérateurs de réaction, car ils font quelque chose à chaque émission de donnée</li><li>les opérateurs de création, car ils permettent de créer des Observables</li></ol><p>Voici un exemple qui illustre comment utiliser les opérateurs dans un contexte Angular :</p><pre>import { interval } from &#39;rxjs&#39;;<br><br>@Component({<br>  template: `Compteur : {{counter$ | async}}`<br>})<br>export class AppComponent{<br>  // va émettre 0..1..2..3..4.. chaque seconde dès qu&#39;on s&#39;abonne<br>  readonly counter$ = interval(1000);  <br>}</pre><p>Dans cet exemple, grâce à l’opérateur de création interval(), j’ai crée un Observable qui va émettre 1, puis 2, puis 3, puis 4 etc chaque seconde (car j’ai précisé 1000 dans ses paramètres) dès lors qu’on s’abonne dessus, c’est donc utile pour faire des compteurs.</p><p>Maintenant, admettons que j’ai envie de doubler la valeur de chacune des émissions. Je pourrais faire comme ça :</p><pre>import { interval } from &#39;rxjs&#39;;<br><br>@Component({<br>  template: `Compteur : {{counter}}`<br>})<br>export class AppComponent {<br>  doubleCounter = 0;<br>  readonly counter$ = interval(1000)<br>    .subscribe((value) =&gt; this.doubleCounter = value * 2);<br>}<br><br></pre><p>Cela marcherait très bien, mais imaginez que j’ai besoin de ce compteur doublé à plusieurs endroits dans mon application, je devrais refaire ça à chaque fois, donc pas top pour d’éventuelles évolutions ou refacto et en plus il faut penser au unsubscribe.</p><p>Et c’est exactement là que les opérateurs entrent en jeu.</p><pre>import { interval, map } from &#39;rxjs&#39;;<br><br>@Component({<br>  template: `Compteur : {{doubleCounter$ | async}}`<br>})<br>export class AppComponent {<br>  // va émettre 0..2..4..6..8.., chaque seconde<br>  readonly doubleCounter$ = interval(1000).pipe(<br>    map(value =&gt; value * 2),<br>  );<br>}</pre><p>Les opérateurs se mettent dans myObs$.pipe(...), il faut vraiment le voir comme une opération qui se déclenche à chaque émission. Ici, j’utilise l’opérateur map qui a pour but de transformer la donnée à chaque émission, et là en l’occurrence je double sa valeur.</p><p>Et ce qui est formidable (et très important), c’est qu’on peut <strong>enchainer les opérateurs</strong> dans la fonction pipe.</p><pre>import { interval, map } from &#39;rxjs&#39;;<br><br>@Component({<br>  template: `Compteur : {{doubleCounter$ | async}}`<br>})<br>export class AppComponent {<br>  readonly doubleCounter$ = interval(1000).pipe(<br>    tap(value =&gt; console.log(value)), // 0..1..2..3..<br>    map(value =&gt; value * 2), // double la donnée à chaque émission<br>    tap(value =&gt; console.log(value)), // 0..2..4..6..<br>    filter(value =&gt; value &gt; 10) // bloque les émissions si inférieur à 10<br>  );<br>}</pre><p>Ici on fait pleins de trucs :</p><ul><li>tap a pour but d’effectuer des effets de bords, c’est à dire qu’on ne modifie pas le flux actuel, mais on y a accès quand même. Ici je l’utilise deux fois, la première fois pour faire un console.log AVANT le map et la seconde fois APRES. C’est très utile pour se rendre compte de ce qu’émet notre Observable.</li><li>map modifie chaque émission, comme dit précédemment.</li><li>filter qui va bloquer les émissions si la valeur renvoyée par la fonction est false. Ici donc l’Observable ne va émettre que si la valeur est plus grande que 10.</li></ul><p>Les opérateurs sont donc un excellent moyen de contrôler nos flux de données ! C’est difficile de se rendre compte de la puissance des opérateurs donc je vous invite à essayer par vous-même <a href="https://stackblitz.com/edit/stackblitz-starters-qfmt9d?file=src%2Fmain.ts">sur ce lien Stackblitz</a>.</p><h3>Mais à quoi ça sert tout ça ?</h3><p><em>“Je pourrais faire la même chose avec une fonction qui utilise un </em><em>setInterval et quelques </em><em>if non ?”</em></p><p>C’est vrai, mais RxJS vous ouvre les voies de la programmation réactive et déclarative. C’est à dire que vous déclarez ce qui doit se passer en réponse à certains événements, sans avoir à vous soucier des détails de mise en œuvre.</p><p>Avec setInterval, vous devez gérer manuellement les cas où vous souhaitez arrêter l’intervalle, reprendre l’intervalle ou gérer des erreurs.</p><p>Par contre, avec l’opérateur interval de RxJS, vous obtenez un Observable qui émet des événements à un intervalle régulier. Cet Observable peut être facilement composé avec d’autres Observables, manipulé avec d’autres opérateurs, ou arrêté ou repris à tout moment. En cas d’erreur, vous pouvez gérer cela de manière déclarative avec les opérateurs d’erreur.</p><p>Le véritable pouvoir de RxJS réside dans la combinaison de ces opérateurs pour créer des flux de données complexes et gérables de manière très lisible et maintenable.</p><p>Par exemple, imaginez que vous souhaitez émettre un événement toutes les secondes, mais seulement pendant les 10 premières secondes. Avec setInterval, vous devriez mettre en place un compteur, un if pour vérifier le compteur, et un clearInterval pour arrêter l’émission. Avec RxJS, vous pouvez simplement combiner les opérateurs interval et take :</p><pre>import { interval } from &#39;rxjs&#39;;<br>import { take } from &#39;rxjs/operators&#39;;<br><br>interval(1000).pipe(<br>    take(10)<br>).subscribe(console.log);</pre><p>Cela émettra un nombre croissant chaque seconde, de 0 à 9. C’est la beauté de la programmation réactive : vous déclarez ce que vous voulez faire, et RxJS s’occupe du comment. Je prépare un article sur la programmation réactive qui devrait sortir au mois de juillet !</p><p>Ok, maintenant que l’intro est faite, découvrons ensemble les opérateurs RxJS les plus fréquents qui vous suffiront pour 99% des scénarios.</p><blockquote>Petite parenthèse !<br>Si vous voulez être au top niveau sur Angular, je vous propose de rejoindre<a href="https://discord.gg/c8XThfW9a7"> mon serveur Discord Angular 100% francophone</a>.<br>Vous y trouverez conseils, entraide, veille techno et opportunités de boulot le tout autour de Angular !</blockquote><h3>Les opérateurs de création</h3><h4>of()</h4><p>Cet opérateur permet de créer un Observable à partir d’une valeur qu’on lui passe.</p><pre>import { of } from &#39;rxjs&#39;;<br><br>const products$ = of([<br>  {id: 1, name: &#39;product1&#39;, price: 10},<br>  {id: 2, name: &#39;product2&#39;, price: 30},<br>  {id: 3, name: &#39;product3&#39;, price: 5},<br>]).subscribe(console.log);<br>// affiche le tableau passé en argument.</pre><p><em>Cela peut être utile lorsque vous devez créer rapidement un Observable à partir de valeurs statiques, par exemple dans un service pour simuler une donnée qui viendrait du backend.</em></p><h4>interval()</h4><p>Crée un Observable qui émet une séquence infinie de valeurs entières à intervalles réguliers.</p><pre>import { interval } from &#39;rxjs&#39;;<br><br>const counter = interval(1000).subscribe(console.log);<br>// affiche 0..1..2..3..4 chaque seconde</pre><p><em>C’est utile pour créer des compteurs, des délais ou des intervalles de temps, par exemple pour une fonctionnalité de minuterie dans une application.</em></p><h4>combineLatest()</h4><p>Cet opérateur combine les dernières valeurs de plusieurs Observables. Il émet une nouvelle valeur chaque fois que l’un des Observables qu’il combine émet une valeur. Il est à noter que combineLatest ne va pas émettre tant que chacun de ses Observables n’a pas émis au moins une valeur.</p><pre>import { combineLatest, of } from &#39;rxjs&#39;;<br>import { delay } from &#39;rxjs/operators&#39;;<br><br>const products$ = http.get(&#39;api/products&#39;);<br>const orders$ = http.get(&#39;api/orders&#39;);<br>const result$ = combineLatest({products: products$, orders: orders$});<br><br>result$.subscribe(({products, orders}) =&gt; {<br>  console.log(products); <br>  console.log(orders);<br>});</pre><p><em>C’est pratique lorsque vous voulez combiner les résultats de plusieurs requêtes HTTP ou lorsque vous souhaitez synchroniser plusieurs flux de données pour faire une opération basée sur plusieurs flux.</em></p><h4>merge()</h4><p>Cet opérateur combine plusieurs Observables en un seul, en émettant les valeurs de chaque Observable dès qu’elles sont disponibles.</p><pre>import { merge, of } from &#39;rxjs&#39;;<br>import { delay } from &#39;rxjs/operators&#39;;<br><br>const obs1 = of(&#39;Hello&#39;);<br>const obs2 = of(&#39;World&#39;).pipe(delay(1000));<br>const merged = merge(obs1, obs2);<br><br>merged.subscribe(value =&gt; console.log(value));<br>// Affiche &#39;Hello&#39;, puis &#39;World&#39; après un délai</pre><p><em>Utile lorsque vous voulez fusionner plusieurs flux de données en un seul, par exemple lors de l’agrégation de données à partir de plusieurs sources de données dans divers services.</em></p><h4>defer()</h4><p>Il permet de retarder la création de l&#39;Observable jusqu&#39;à ce qu&#39;un Observateur s&#39;y abonne. Cela signifie que l&#39;Observable n&#39;est créé qu&#39;au moment de l&#39;abonnement, ce qui permet de s&#39;assurer que l&#39;Observable encapsule toujours les données les plus à jour.</p><pre>import { defer } from &#39;rxjs&#39;;<br><br>const currentTime$ = defer(() =&gt; of(new Date().getTime()));<br><br><br>currentTime$.subscribe(console.log);<br>// 👆 m&#39;affiche bien le moment actuel <br>// qu&#39;importe à quel moment je subscribe<br>// si j&#39;avais utilisé simplement of(new Date().getTime())<br>// alors cela m&#39;aurait retourné le même résultat à chaque subscribe</pre><p><em>C’est utile quand vous voulez retarder l’exécution de la fonction qui génère l’Observable jusqu’à ce qu’un abonné soit présent.</em></p><h3>Les opérateurs de réaction</h3><h4>map()</h4><p>Cet opérateur est utilisé pour appliquer une fonction à chaque valeur émise par l’Observable source.</p><pre>import { of } from &#39;rxjs&#39;;<br>import { map } from &#39;rxjs/operators&#39;;<br><br>const nums = of(1, 2, 3);<br>const squareNums = nums.pipe(map(n =&gt; n * n));<br><br>squareNums.subscribe(x =&gt; console.log(x)); // Affiche 1, 4, 9</pre><p><em>C’est utile lorsque vous voulez transformer les données reçues d’un Observable, par exemple pour reformater les données reçues d’une API.</em></p><h4>mergeMap()</h4><p>Il permet de gérer les situations où on voudrait subscribe dans un subscribe. C’est à dire les situations où les valeurs émient par le flux de données sont elles-mêmes des Observable ou bien qu’on veut renvoyer un Observable grâce à la donnée émise. mergeMap va s’abonner à la valeur et renvoyer le résultat de l’abonnement.</p><pre><br><br>import { mergeMap } from &#39;rxjs/operators&#39;;<br><br>@Component(...)<br>export class AppComponent {<br>  http = inject(HttpClient);<br>  productID$ = new FormControl();<br><br>  product$ = productID$.pipe(<br>    mergeMap(productID =&gt; this.http.get(`api/products/${productID}`))<br>  )<br>}</pre><p><em>Il est particulièrement utile pour gérer les scénarios où chaque valeur émise par un Observable est elle-même un Observable, comme lors de l’envoi de requêtes HTTP en réponse à des événements de l’utilisateur.</em></p><h4>switchMap()</h4><p>Cet opérateur est similaire à mergeMap(), mais annule les valeurs précédentes chaque fois qu&#39;une nouvelle valeur est émise.</p><pre>import { switchMap } from &#39;rxjs/operators&#39;;<br><br>@Component(...)<br>export class AppComponent {<br>  http = inject(HttpClient);<br>  productID$ = new FormControl();<br><br>  // si productID$ émet avant que le http.get se termine<br>  // alors le call HTTP sera cancel et remplacé par le suivant<br>  product$ = productID$.pipe(<br>    switchMap(productID =&gt; this.http.get(`api/products/${productID}`))<br>  )<br>}</pre><p><em>C’est pratique lorsque vous voulez ignorer les anciennes valeurs en faveur des nouvelles, par exemple lors de l’implémentation d’une fonction de recherche autocomplète où seule la dernière requête est pertinente.</em></p><h4>exhaustMap()</h4><p>Cet opérateur est aussi similaire à mergeMap(), mais il ignore les nouvelles valeurs tant que chaque valeur émise n&#39;a pas terminé.</p><pre>import { exhaustMap } from &#39;rxjs/operators&#39;;<br><br>@Component(...)<br>export class AppComponent {<br>  http = inject(HttpClient);<br>  productID$ = new FormControl();<br><br>  // si productID$ émet avant que le http.get se termine<br>  // alors cette émission sera ignorée<br>  product$ = productID$.pipe(<br>    exhaustMap(productID =&gt; this.http.get(`api/products/${productID}`))<br>  )<br>}</pre><p><em>C’est utile dans des situations où vous voulez ignorer les nouvelles valeurs jusqu’à ce que chaque valeur émise ait terminé son traitement, comme lors de la gestion des clics sur un bouton pour empêcher les doubles soumissions.</em></p><h4>filter()</h4><p>Cet opérateur émet uniquement les valeurs qui satisfont une certaine condition.</p><pre>import { of } from &#39;rxjs&#39;;<br>import { filter } from &#39;rxjs/operators&#39;;<br><br>const nums = of(1, 2, 3, 4, 5);<br>const evens = nums.pipe(filter(n =&gt; n % 2 === 0));<br><br>evens.subscribe(x =&gt; console.log(x)); // Affiche 2, 4</pre><p><em>Il est utile lorsque vous voulez filtrer certains résultats, par exemple en filtrant certaines entrées utilisateur ou certains résultats d’une API.</em></p><h4>scan()</h4><p>Cet opérateur fonctionne comme reduce() pour les tableaux. Il applique une fonction à chaque valeur émise par l&#39;Observable source et émet le résultat cumulatif.</p><pre>import { of } from &#39;rxjs&#39;;<br>import { scan } from &#39;rxjs/operators&#39;;<br><br>const nums = of(1, 2, 3);<br>const sum = nums.pipe(scan((acc, curr) =&gt; acc + curr, 0));<br><br>sum.subscribe(x =&gt; console.log(x)); // Affiche 1, 3, 6</pre><p><em>C’est utile lorsque vous voulez accumuler des valeurs au fil du temps, par exemple pour calculer une somme totale ou pour construire un tableau de valeurs émises.</em></p><h4>distinctUntilChanged()</h4><p>Cet opérateur émet une valeur uniquement si elle est différente de la dernière valeur émise.</p><pre>import { of } from &#39;rxjs&#39;;<br>import { distinctUntilChanged } from &#39;rxjs/operators&#39;;<br><br>const nums = of(1, 1, 2, 2, 3, 3);<br>const distinctNums = nums.pipe(distinctUntilChanged());<br><br>distinctNums.subscribe(x =&gt; console.log(x)); // Affiche 1, 2, 3</pre><p><em>C’est utile lorsque vous voulez ignorer les valeurs en double, par exemple lorsqu&#39;on créé un strore fait-maison ou chaque selector utilise distinctUntilChanged() pour éviter d’émettre à nouveau si la valeur est la même.</em></p><h4>tap()</h4><p>Cet opérateur est utilisé pour effectuer des effets de bord. Il applique une fonction à chaque valeur émise par l’Observable source, mais retourne la valeur sans la modifier.</p><pre>import { of } from &#39;rxjs&#39;;<br>import { tap } from &#39;rxjs/operators&#39;;<br><br>const nums = of(1, 2, 3).pipe(tap(console.log)).subscribe();</pre><p><em>C’est utile lorsque vous voulez déclencher une action secondaire en réaction à une valeur émise, la mise à jour d’un état (loader par exemple) ou un console.log() pour regarder l’état du flux.</em></p><h4>delay()</h4><p>Permet de décaler le moment où les valeurs émises par un Observable sont réellement émises. Cela retarde essentiellement l&#39;émission de chaque valeur d&#39;un certain nombre de millisecondes.</p><pre>import { delay } from &#39;rxjs/operators&#39;;<br><br>const data$ = of({some: &#39;data&#39;});<br><br>data$.pipe(<br>  delay(2000)<br>).subscribe(console.log);<br>// affiche l&#39;objet passé en paramètre mais au bout de 2 secondes</pre><p><em>C’est utile lorsque vous voulez retarder une action, comme l’affichage d’un message de succès après une action de l’utilisateur.</em></p><h4>take()</h4><p>Cet opérateur n’émet que les n premières valeurs puis complète l&#39;Observable.</p><pre>import { interval } from &#39;rxjs&#39;;<br>import { take } from &#39;rxjs/operators&#39;;<br><br>const numbers = interval(1000);<br>const takeFourNumbers = numbers.pipe(take(4));<br><br>takeFourNumbers.subscribe(console.oog);<br>// Affiche la valeur quatre fois puis se complète</pre><p><em>C’est utile lorsque vous ne voulez traiter qu’un certain nombre de valeurs, comme pour paginer les résultats d’une requête ou limiter le nombre de tentatives d’une action.</em></p><h4>takeUntil()</h4><p>Cet opérateur complète l’Observable dès qu’une autre Observable émet une valeur.</p><pre>import { interval, of } from &#39;rxjs&#39;;<br>import { takeUntil, delay } from &#39;rxjs/operators&#39;;<br><br>const numbers = interval(1000);<br>const stopper = of(true).pipe(delay(3500));<br>const takeUntilStopped = numbers.pipe(takeUntil(stopper));<br><br>takeUntilStopped.subscribe(console.log); <br>// Affiche la valeur jusqu&#39;à ce que stopper émette une valeur</pre><p><em>C’est utile lorsque vous voulez arrêter une action dès qu’un autre événement se produit, comme arrêter un intervalle lorsqu’un utilisateur clique sur un bouton ou unsubscribe d’un flux.</em></p><h4>takeWhile()</h4><p>Cet opérateur émet des valeurs tant qu’une condition est vraie et complète l’Observable dès que la condition devient fausse.</p><pre>import { interval } from &#39;rxjs&#39;;<br>import { takeWhile } from &#39;rxjs/operators&#39;;<br><br>const numbers = interval(1000);<br>const takeWhileLessThanFive = numbers.pipe(takeWhile(n =&gt; n &lt; 5));<br><br>takeWhileLessThanFive.subscribe(console.log); <br>// Affiche la valeur tant que n est inférieur à 5</pre><p><em>C’est utile lorsque vous voulez continuer à émettre des valeurs en fonction d’une condition, comme arrêter un défilement automatique quand l’utilisateur atteint le bas de la page.</em></p><h4>skip()</h4><p>Cet opérateur ignore les n premières valeurs émises par l&#39;Observable source.</p><pre>import { interval } from &#39;rxjs&#39;;<br>import { skip } from &#39;rxjs/operators&#39;;<br><br>const numbers = interval(1000);<br>const skipTwoNumbers = numbers.pipe(skip(2));<br><br>skipTwoNumbers.subscribe(console.log); <br>// Ignore les deux premières valeurs</pre><p><em>C’est utile lorsque vous voulez ignorer les premières valeurs, comme lors de la mise en place d’une fonction de pagination.</em></p><h4>debounceTime()</h4><p>Cet opérateur n’émet une valeur que si un certain temps s’est écoulé sans qu’une autre valeur soit émise.</p><pre>import { debounceTime } from &#39;rxjs/operators&#39;;<br><br>inputFormControl = new FormControl();<br><br>inputFormControl.valueChanges.pipe(debounceTime(300)).subscribe(console.log);<br>// Émet une valeur 300ms après la dernière saisie de l&#39;utilisateur</pre><p><em>C’est utile lorsque vous voulez limiter le taux de traitement, comme pour éviter de faire trop de requêtes pendant la frappe de l’utilisateur dans une recherche en direct.</em></p><h4>catchError()</h4><p>Cet opérateur attrape les erreurs sur l’Observable source et permet de renvoyer un nouvel Observable.</p><pre>import { catchError } from &#39;rxjs/operators&#39;;<br><br>@Component(...)<br>export class AppComponent {<br>  http = inject(HttpClient);<br><br>  products$ = this.http.get(&#39;api/products&#39;).pipe(<br>      catchError(error =&gt; {<br>        console.error(&#39;Une erreur est survenue lors de la récupération des données :&#39;, error);<br>        // On peut afficher un message d&#39;erreur également<br><br>        // On retourne un Observable avec des données par défaut en cas d&#39;erreur<br>        return of({ data: &#39;Données par défaut&#39; });<br>      })<br>    );<br><br>}<br><br></pre><p><em>C’est utile lorsque vous voulez gérer les erreurs et peut-être remplacer les valeurs erronées par des valeurs par défaut.</em></p><h4>retry()</h4><p>Cet opérateur re-souscrit à l’Observable source si une erreur est produite, en permettant un certain nombre de tentatives.</p><pre>import { retry } from &#39;rxjs/operators&#39;;<br><br>@Component(...)<br>export class AppComponent {<br>  http = inject(HttpClient);<br><br>  products$ = this.http.get(&#39;api/products&#39;).pipe(<br>    retry(3) // Réessaye la requête HTTP 3 fois en cas d&#39;erreur<br>  );<br><br>}</pre><p><em>C’est utile lorsque vous voulez réessayer une action en cas d’erreur, comme pour retenter une requête HTTP qui a échoué.</em></p><h4>startWith()</h4><p>Cet opérateur fait en sorte que l’Observable source commence par émettre une ou plusieurs valeurs spécifiques.</p><pre>import { of } from &#39;rxjs&#39;;<br>import { startWith } from &#39;rxjs/operators&#39;;<br><br>const numbers = of(1, 2, 3);<br>const startWithZero = numbers.pipe(startWith(0));<br><br>startWithZero.subscribe(x =&gt; console.log(x)); // Affiche 0, 1, 2, 3</pre><p><em>C’est utile lorsque vous voulez fournir des valeurs initiales, comme pour pré-remplir un champ de formulaire ou afficher une valeur par défaut pendant le chargement des données.</em></p><h3>Conclusion</h3><p>Les opérateurs<em> </em>RxJS sont des outils puissants qui nous permettent de manipuler et de contrôler les flux de données dans nos applications Angular. Ils peuvent transformer les valeurs émises, filtrer les valeurs selon certaines conditions, retarder l’émission de valeurs, répéter des flux de données, parmi tant d’autres opérations.</p><p>Le plus important n’est pas nécessairement de connaître tous les opérateurs mais avant tout de comprendre le logique</p><p>Nous avons exploré les opérateurs les plus couramment utilisés dans ce deuxième volet, chacun avec ses propres utilisations et avantages. Bien que nous ayons couvert beaucoup de terrain, il y a encore beaucoup plus d’opérateurs à découvrir. Je vous encourage à explorer le site <a href="https://rxmarbles.com/">RxMarbes</a> qui recense tous les opérateurs avec des diagrammes interactifs.</p><p>Si vous avez des questions ou des commentaires, n’hésitez pas à les partager ici ou directement sur <a href="https://discord.gg/c8XThfW9a7">mon Discord Angular 100% francophone</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a092c3d920a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[L’avenir d’Angular : nouveau Control Flow et Defer]]></title>
            <link>https://kevin-tale.medium.com/lavenir-d-angular-nouveau-control-flow-et-defer-838fc82c9b9e?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/838fc82c9b9e</guid>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Thu, 15 Jun 2023 05:54:32 GMT</pubDate>
            <atom:updated>2023-07-02T09:52:56.323Z</atom:updated>
            <content:encoded><![CDATA[<h3>L’avenir d’Angular : nouveau Control Flow et Defer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kDyWnUmHnOMj9vvG96p9SQ.png" /></figure><p>Dans la continuité de tous les changements que l’équipe derrière Angular met en place depuis plus d’un an, deux nouvelles ont été annoncé lors de la ng-conf 2023 :</p><ol><li>Un nouvel API pour le Control Flow (les *ngIf, *ngFor et [ngSwitch])</li><li>Le mot-clé defer pour gérer aux petits oignons la performance de vos futures applications Angular</li></ol><p>C’est donc à travers deux RFC (liens tout en bas de l’article) que l’équipe présente plus amplement ces nouveautés.</p><blockquote>Disclaimer: tout ce qui va suivre est toujours en <em>work in progress </em>chez Angular et les APIs ne sont en aucun cas en version finale. Nous devrons attendre de longs mois avant la mise en production de ces propositions.</blockquote><h3>Control Flow</h3><p>La façon de gérer le contrôle de l’affichage des parties d’un template va changer ! Comparons tout cela.</p><h4>Avant</h4><pre>&lt;p *ngIf=&quot;someCondition;else other&quot;&gt;<br>  someCondition is true<br>&lt;/p&gt;<br><br>&lt;ng-template #other&gt;<br>  &lt;p&gt;someCondition is false&lt;/p&gt;<br>&lt;/ng-template&gt;<br></pre><pre>&lt;ng-container *ngIf=&quot;products.length &gt; 0; else noProducts&quot;&gt;<br>  &lt;div *ngFor=&quot;let product of products; trackBy: trackByProductId&quot;&gt;<br>    {{product.name}}<br>  &lt;/div&gt;<br>&lt;/ng-container&gt;<br><br>&lt;ng-template #noProducts&gt;<br>  &lt;p&gt;No products available.&lt;/p&gt;<br>&lt;/ng-template&gt;</pre><pre>&lt;div [ngSwitch]=&quot;role&quot;&gt;<br>  &lt;p *ngSwitchCase=&quot;&#39;director&#39;&quot;&gt;You are a director&lt;/p&gt;<br>  &lt;p *ngSwitchCase=&quot;&#39;teacher&#39;&quot;&gt;You are a teacher&lt;/p&gt;<br>  &lt;p *ngSwitchCase=&quot;&#39;student&#39;&quot;&gt;You are a student&lt;/p&gt;<br>  &lt;p *ngSwitchDefault&gt;You are a student&lt;/p&gt;<br>&lt;/div&gt;</pre><h4>Après</h4><pre>{#if someCondition}<br> &lt;p&gt;someCondition is true&lt;/p&gt;<br>{:else}<br>  &lt;p&gt;someCondition is false&lt;/p&gt;<br>{/if}</pre><pre>{#for product of products; track product.id}<br>  &lt;div&gt;{{ product.name }}&lt;/div&gt;<br>{:empty}<br>  &lt;p&gt;No products available.&lt;/p&gt;<br>{/for}</pre><pre>{#switch role}<br>  {:case &#39;director&#39;}<br>    &lt;p&gt;You are a director&lt;/p&gt;<br>  {:case &#39;teacher&#39;}<br>    &lt;p&gt;You are a teacher&lt;/p&gt;<br>  {:case &#39;student&#39;}<br>    &lt;p&gt;You are a student&lt;/p&gt;<br>  {:default}<br>    &lt;p&gt;You are a student&lt;/p&gt;<br>{/switch}</pre><p>Nous passons donc à un Control Flow par <strong>bloc</strong>, tout cela a été mis en place pour plusieurs raisons :</p><ul><li>Se rapprocher davantage d’une syntaxe JS classique</li><li>Moins de complexité avec les &lt;ng-template /&gt;</li><li>et surtout permettre une adoption des applications <em>zoneless</em> plus simple</li></ul><p>Ce dernier point est intéressant. Aujourd’hui les applications Angular repose sur zone.js pour gérer leurs détection de changement, dans un avenir très proche cette librairie externe ne sera plus nécessaire grâce aux Signal. Cependant rendre cela possible n’est pas une mince affaire pour l’équipe d’Angular car un changement des directives du Control Flow (ngIf, ngFor etc) était nécessaire. Ils ont préféré opté pour un changement total de syntaxe et en ont profité pour apporter de nouvelles choses comme le {:empty} du {:for} par exemple.</p><p>Pour informations, cette syntaxe est grandement inspirée de Svelte !</p><p>Nous n’aurons donc plus besoin d’utiliser &lt;ng-template&gt; dans nos composants et nos templates sont plus proches d’une syntaxe “purement JS et HTML”. Aussi, nous n’aurons plus à importer CommonModule ou NgIf etc dans le tableau d’importations, puisque c’est désormais built-in !</p><p>Deux infos importantes :</p><ol><li>Les directives actuelles vont devenir deprecated.</li><li>Le track de {:for} est désormais obligatoire pour des questions de performances ! Pour ça rien de plus simple, on a simplement à faire {#for item of items; track item}.</li></ol><blockquote>Petite parenthèse !<br>Si vous voulez être au top niveau sur Angular, je vous propose de rejoindre<a href="https://discord.gg/c8XThfW9a7"> mon serveur Discord Angular 100% francophone</a>.<br>Vous y trouverez conseils, entraide, veille techno et opportunités de boulot le tout autour de Angular !</blockquote><h3>defer</h3><p>Autre nouveauté : l’apparation d’un mot-clé defer.</p><p>L’idée est d’apporter une façon agréable et facile de gérer le chargement des différentes parties de nos pages. Actuellement le lazy loading nous permet de retarder le chargement du code JS d’une route via loadComponent()ou loadChildren() directement dans nos fichiers de routing. Et bien grâce à defer nous pourront carrément lazy loader des parties distincts de nos pages (typiquement les composants utilisés dans nos pages).</p><p><strong>Il s’agit donc d’optimisation de performance</strong>.</p><p>Voyons à quoi ça ressemble :</p><pre>&lt;p&gt;some content&lt;/p&gt;<br><br>&lt;my-list /&gt;<br><br>{#defer}<br>  &lt;some-component /&gt;<br>{/defer}<br><br></pre><p>Tout ce qui sera se trouvera à l’intérieur du bloc {#defer}...{/defer} sera lazy loadé de manière asynchrone, c’est à dire après que tout le reste soit chargé.</p><p>Et il existe des façons pour nous, les devs, d’indiquer de manière plus précise quand est-ce que le bloc doit se charger.</p><p>Voilà l’exemple le plus basique :</p><pre>{#defer when someCondition}<br>  &lt;some-component /&gt;<br>{/defer}</pre><p>Ici, &lt;some-component /&gt; ne sera chargé que lorsque someConditionrenverra true. Il est important de comprendre ce j’entends par “sera chargé”. En fait, c’est exactement le même principe que le lazy loading des pages : tout le code JS nécessaire au fonctionnement de ce qui se trouve dans le bloc defer ne sera chargé et exécuté que lorsque le bloc est trigger. C’est différent que de mettre son code autour d’un ngIf car un ngIf ne fait que apparaître ou disparaître le html dans le template mais le JS reste chargé et exécuté par le browser. Ici ce n’est pas le cas ! Le code se chargera dès lors que le bloc defer sera trigger.</p><p>Ok alors, comment faire pour trigger ce bloc defer ?</p><p>Il y a plusieurs façons de faire :</p><ul><li>On a le mot-clé when qui permet une gestion impérative du bloc comme montré plus haut. On a simplement à passer une expression qui retourne un booléen.</li><li>On a le mot-clé on qui permet une gestion plus déclarative, on lui passe un évènement dont voici quelques exemples :</li></ul><pre>// Si le user passe sa souris par dessus le bloc<br>{#defer on hover}<br>  &lt;some-component /&gt;<br>{/defer}<br><br>// Si le user clique sur le composant ou lors d&#39;évènements claviers notamment<br>{#defer on interaction}<br>  &lt;some-component /&gt;<br>{/defer}<br><br>// après n millisecondes <br>{#defer on timer(500)}<br>  &lt;some-component /&gt;<br>{/defer}<br><br>// lorsque le bloc entre dans le viewport <br>{#defer on viewport}<br>  &lt;some-component /&gt;<br>{/defer}</pre><p>Par défaut, les blocs defer n’affichent rien lorsqu’ils ne sont pas trigger. Mais on peut spécifier un contenu qui s’affiche avant que les blocs ne soient eux-mêmes affichés :</p><pre>{#defer on viewport}<br>  &lt;some-component /&gt;<br>{:loading}<br>  &lt;div class=&quot;loading&quot;&gt;Loading the component...&lt;/div&gt;<br>{/defer}</pre><p>Ici dès que le bloc arrivera dans le viewport alors le bloc sera trigger et le composant se chargera. Mais cela peut prendre du temps s’il est gros, par conséquent on peut ajouter un contenu de loading qui s’affichera dès lors où le composant sera en train de charger.</p><p>Un autre exemple :</p><pre>{#defer when someCondition}<br>  &lt;some-component /&gt;<br>{:placeholder minimum 500ms}<br>  &lt;img src=&quot;placeholder.png&quot; /&gt;<br>{/defer}</pre><p>{:placeholder} va s’afficher tant que la condition retournée après le when sera false. On peut préciser un minimum, en gros ça signifie que même si le bloc a trigger puis que &lt;some-component /&gt; a fini de charger, on affiche quand même le placeholder pendant 0.5 seconde, ça peut être utile pour une meilleure UX (à voir à l’utilisation !).</p><p>Nous avons également la gestion d’erreur :</p><pre>{#defer when someCondition}<br>  &lt;some-component /&gt;<br>{:error}<br>  &lt;p&gt; Failed to load&lt;/p&gt;<br>  &lt;p&gt;&lt;strong&gt;Error:&lt;/strong&gt; {{$error.message}}&lt;/p&gt;<br>{/defer}</pre><p>Il peut arriver que le composant ne parvient pas à être chargé, par exemple si la connexion se perd entre le moment où l’utilisateur arrive sur la page et où le bloc est censé s’afficher. A noter que le bloc d’erreur envoie un contexte via $error.</p><p>Il existe d’autres subtilités et précisions sur defer que je vous invite à découvrir par vous mêmes mais le principal est là !</p><p>Le RFC finit par préciser que la team Angular est en train de réfléchir à comment l’intégration de tout cela se fera avec le SSR et l’hydration partiel. Il est donc à prévoir des APIs spécifiques pour configurer l’utilisation de defer avec le SSR.</p><h3>Conclusion</h3><p>C’est donc de très gros changements sur notre façon de créer des applications Angular qui est à venir. Encore une fois, ce n’est pas pour tout de suite et les différents APIs sont sujets à modifications.<br>Mais je suis très enthousiaste à l’idée de ce que va devenir Angular grâce à tout cela et je suis certain que nous pourrons obtenir un framework ultra performant avec une bonne DX et UX.</p><p>Le nouveau Control Flow semble très simple d’utilisation donc je ne me fais aucun souci quant à l’adoption par la communauté, je pense en revanche qu’on devra passer par pas mal de tests avant d’appréhender pleinement le defer. C’est un outil puissant et qui nécessite de bonnes connaissances en UX pour savoir à quel point il est important d’apporter un délai (et sous quelles conditions) aux différentes parties d’une application.</p><p>J’ai hâte de vous en dire plus ! Pour être sûr de ne rien manquer, venez nous rejoindre sur le plus grand <a href="https://discord.gg/c8XThfW9a7">Discord Angular 100% francophone</a> !</p><p><a href="https://github.com/angular/angular/discussions/50719">Lien du RFC sur le Control Flow</a><br><a href="https://github.com/angular/angular/discussions/50716">Lien du RFC sur </a><a href="https://github.com/angular/angular/discussions/50716">defer</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=838fc82c9b9e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tout ce que je sais sur RxJS (partie 1)]]></title>
            <link>https://kevin-tale.medium.com/tout-ce-que-je-sais-sur-rxjs-partie-1-7af99a9edded?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/7af99a9edded</guid>
            <category><![CDATA[rxjs]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Wed, 07 Jun 2023 07:24:58 GMT</pubDate>
            <atom:updated>2023-06-24T12:23:20.715Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j63NcEOt_vD4WQYfZ8xNxA.png" /></figure><blockquote><a href="https://medium.com/@kevin.tale/tout-ce-que-je-sais-sur-rxjs-partie-2-a092c3d920a6">La partie 2 sur les opérateurs est disponible ici !</a></blockquote><p>L’autre jour un membre de <a href="https://discord.gg/c8XThfW9a7">ma communauté Discord</a> a posé une question très intéressante :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*U-8acQ7GrLZ40se4a8jLYA.png" /><figcaption>Bonne question safaa !</figcaption></figure><p>Je lui ai écrit une réponse qui m’a pris 45min à rédiger tant cette question implique beaucoup de choses. Et ça m’a donné l’envie de me lancer dans un article sur un sujet que j’aime : RxJS. Et la question Observable vs Subject est un bel angle par lequel étudier tout cela.</p><p>Alors faisons un grand plongeon dans RxJS pour essayer de démystifier de manière la plus simple possible tous les rouages de cette librairie.</p><p>RxJS, ça devrait vous être familier. C’est une librairie qui permet de gérer l’asynchronicité des évènements et des données au sein d’une application Javascript, et RxJS est largement utilisé dans Angular.</p><p>Et même si<a href="https://blog.kevin-tale.dev/tout-comprendre-sur-les-signals-dans-angular-7bbbbf00b975"> les Signal vont probablement réduire l’utilisation de la librairie</a>, ce n’est pas prévu de si tôt et ça ne sera pas complètement le cas, alors faisons un point sur une question fondamentale qui va nous permettre de comprendre RxJS dans son intégralité : c’est quoi la différence entre un Observable et un Subject ?</p><p>Avant de parler de leurs différences, parlons de leurs ressemblances.</p><pre>import { Observable, Subject } from &#39;rxjs&#39;;<br><br>const obs = new Observable();<br>const sub = new Subject();</pre><p>Ce qu’on peut voir, c’est que ce sont tous les deux des class que l’on peut instancier.</p><pre>import { Observable, Subject } from &#39;rxjs&#39;;<br><br>const obs = new Observable();<br>const sub = new Subject();<br><br>obs.subscribe(data =&gt; console.log(`Obs ${data}`));<br>sub.subscribe(data =&gt; console.log(`Sub ${data}`));</pre><p>Mais l’intérêt de ces deux class, c’est surtout qu’on peut <strong>s’abonner </strong>dessus avec la fonction subscribe. “S’abonner” veut dire qu’à l’instant où une donnée va être poussée dans l’Observable ou le Subject alors ces derniers vont émettre cette donnée, ainsi chaque abonné va recevoir cette nouvelle donnée immédiatement et ce qu’il y a dans le .subscribe()va se trigger.</p><p>On peut donc en conclure que les Observable et Subject permettent de créer des flux de données, ce flux est continu, il ne s’interrompt pas (sauf si on lui dit explicitement). Et pour ouvrir ce flux de données, il faut s’abonner en utilisant .subscribe().</p><p>Dans mon exemple je me suis abonné à la fois à obs et sub, ainsi dès qu’une donnée va être poussée dans l’un ou l’autre alors le console.log va s’exécuter.</p><p>Mais <strong>pas avant !</strong></p><p>Ce que je veux dire par là, c’est que si j’exécute ce script, rien ne va s’afficher. Pourquoi ? Parce qu’à aucun moment je n’ai poussé de nouvelle donnée. Mes deux abonnements sont faits, les flux sont ouverts, mais étant donné que je n’ai pas encore poussé de donnée alors obsou sub n’émettent rien, donc je ne rentre pas dans le callback du tout.</p><p>En résumé, voilà comment le déroulé de “vie” d’un Observable (ça marche pareil pour un Subject)</p><ol><li>Je créé l&#39;Observable avec const obs = new Observable();</li><li>Dans divers endroits de mon application je m’abonne à mon Observable en faisant obs.subscribe(...)</li><li>Dès qu’une donnée est poussée dans l’ Observable (on va voir comment juste après) alors obs va l’émettre, en d’autres termes il va la pousser dans son flux</li><li>-Les abonnées vont recevoir cette donnée car ils écoutent le flux et pourront faire des trucs divers et variés avec cette donnée</li></ol><h3>.next() pour pousser des données</h3><pre>import { Subject } from &#39;rxjs&#39;;<br><br>const sub = new Subject();<br><br>sub.subscribe(data =&gt; console.log(`Sub ${data}`));<br><br>sub.next(&#39;Salut !&#39;);</pre><p>Mesdames et messieurs, devant aux yeux ébahis je viens de pousser une donnée dans sub ! 👏</p><p>Maintenant, que se passe t-il si j’exécute ce code ? Et bien vous l’aurez deviné, je verrais Sub Salut ! qui provient du console.log(`Sub ${data}`). Tout simplement parce que lorsque j’ai faitsub.next(&#39;Salut !), j’ai poussé une nouvelle donnée dans le Subject et ce dernier l’a émise, ainsi tous les abonnés l’ont reçues.</p><p>Je dis bien “tous les abonnés” car je peux m’abonner plusieurs fois :</p><pre>import { Subject } from &#39;rxjs&#39;;<br><br>const sub = new Subject();<br><br>sub.subscribe(data =&gt; console.log(`Sub1 ${data}`));<br>sub.subscribe(data =&gt; console.log(`Sub2 ${data}`));<br>sub.subscribe(data =&gt; console.log(`Sub3 ${data}`));<br><br>sub.next(&#39;Salut !&#39;);</pre><p>Ainsi, tous les abonnés vont recevoir cette même valeur. A noter que si j’avais mis le sub.next(&#39;Salut !&#39;); avant les subscribe() alors les abonnés n’auraient reçu aucune donnée car la valeur aurait été émise <strong>avant</strong> un quelconque abonnement.</p><h3>Utiliser les Subject dans Angular</h3><p>Mais alors à quoi ça sert ? Comment tirer profit de cela ?</p><p>Et bien RxJS est très utile dans le monde JS pour gérer des évènements de manières isolées. Par exemple si je veux que le clique d’un bouton mette à jour un compteur et que la valeur de ce compteur soit affiché dans plusieurs composants différents au sein de mon application, je peux utiliser un Subject. Ce Subject je vais le créer dans un fichier à part et pas directement dans un composant car sa valeur n’appartient à aucun composant en particulier. Et ce fichier, dans le cas de Angular, sera un service.</p><pre>@Injectable({providedIn: &#39;root&#39;})<br>export class CounterService {<br>  readonly count = new Subject&lt;number&gt;();<br><br>  constructor() {<br>    this.count.next(0); // j&#39;initialise la valeur à 0<br>  }<br><br>  increment() {<br>    this.count.next(???);<br>  }<br><br>}</pre><p>Attendez une minute… Comment on fait pour récupérer la valeur actuelle de count pour l’incrémenter ?</p><p>BehaviorSubject à la rescousse !</p><pre>import { BehaviorSubject } from &#39;rxjs&#39;;<br><br>@Injectable({providedIn: &#39;root&#39;})<br>export class CounterService {<br>  readonly count = new BehaviorSubject&lt;number&gt;(0);<br><br>  increment() {<br>    this.count.next(this.count.value + 1);<br>  }<br><br>}</pre><p>BehaviorSubject c’est une autre class qui vient de RxJS et qui est très similaire à Subject, sauf que :</p><ul><li>BehaviorSubject a une notion de “valeur courante”. Quand un BehaviorSubject émet une donnée, il va également l’enregistrer en son sein. Par conséquent, on a accès à la propriété .value qui va nous renvoyer cette valeur</li><li>Quand on initialise un BehaviorSubject on doit lui passer une valeur initiale, c’est exactement ce que je fais en faisant readonly count = new BehaviorSubject&lt;number&gt;(0). Du coup, plus besoin de faire le this.count.next(0) dans le constructor !</li></ul><p>Plutôt pas mal non ? Je peux maintenant utiliser les valeurs émient par count en m’abonnant à celui-ci directement dans mes composants et également pousser une valeur incrémentée :</p><pre>@Component({<br>  standalone: true,<br>  template: `<br>    &lt;p&gt;Counter: {{count}}&lt;/p&gt;<br>    &lt;button (click)=&quot;counterService.increment()&quot;&gt;+1&lt;/button&gt;<br>  `<br>})<br>export class SomeComponent implements OnInit {<br>  readonly countService = inject(CounterService);<br>  count!: number;<br><br>  ngOnInit() {<br>    this.countService.count.subscribe(value =&gt; this.count = value)<br>  }<br>  <br>}</pre><p>Je peux implémenter cette fonctionnalité partout où je veux dans mon application, certains autres composants pourraient utiliser une fonction decrement, ou simplement afficher la valeur de count. J’ai une application où la <a href="https://fr.wikipedia.org/wiki/S%C3%A9paration_des_pr%C3%A9occupations">separation of concerns</a> est respectée ! Le CounterService créé est ce qu’on appelle un “store” : une source de vérité qui contient mes données, le moyen d’accéder à ces données par d’autres briques de mon application, et les méthodes qui modifient ces données.</p><p>En bref, utilisez BehaviorSubject lorsque vous voulez créé un store manuellement sans librairie tièrce ! C’est d’ailleurs ce qu’utilise NgRx sous la capot.</p><p>Mais… Mon implémentation actuel est loin d’être parfaite ! Améliorons tout ça en introduisant une notion : les Observable.</p><pre>import { Observable } from &#39;rxjs&#39;;<br><br>@Injectable({providedIn: &#39;root&#39;})<br>export class CounterService {<br>  readonly private count = new BehaviorSubject&lt;number&gt;(0);<br>  readonly count$ = this.count.asObservable();<br><br>  increment() {<br>    this.count.next(this.count.value + 1);<br>  }<br><br>}</pre><p>Ici il y a deux différences :</p><ul><li>J’ai créé une propriété publique count$ qui est égale à this.count.asObservable()</li><li>J’ai mis le BehaviorSubject en privé</li></ul><p>count$ est donc un Observable grâce à .asObservable(). <strong>Un </strong><strong>Observable est un flux de données tout comme un </strong><strong>Subject</strong> ce qui signifie qu’on peut faire un subscribe() dessus. Mais la grande différence est la suivante : <strong>sur un </strong><strong>Observable on ne peut pas faire de </strong><strong>.next().</strong></p><p>Un Observable est comme un Subject mais read-only, on ne peut pas lui pousser des données. C’est donc très utile pour exposer aux autres parties de mon application des données sans leurs donner la possibilité de les modifier directement car cette responsabilité incombe au service où est déclarée ma donnée.</p><p>Je peux donc changer le code de mon composant afin d’utiliser count$, j’en profite le rendre plus optimal en utilisant le pipe async qui a pour but subscribe automatiquement et de unsubscribe quand mon composant est détruit (par exemple quand je change de page) :</p><pre>@Component({<br>  standalone: true,<br>  template: `<br>    &lt;p&gt;Counter: {{countService.count$ | async}}&lt;/p&gt;<br>    &lt;button (click)=&quot;counterService.increment()&quot;&gt;increment&lt;/button&gt;<br>  `<br>})<br>export class SomeComponent {<br>  readonly countService = inject(CounterService);<br>}</pre><h3>Comment fonctionne les Observable</h3><p>Allons plus loin dans la découverte des Observable en n’en créant un.</p><pre>import { Observable} from &#39;rxjs&#39;;<br><br>const obs = new Observable();</pre><p>Comme je le disais plus haut, cet obs ne fait rien, en réalité on ne créé jamais d’ Observable comme ça car un Observable attend une fonction en callback :</p><pre>import { Observable} from &#39;rxjs&#39;;<br><br>const obs = new Observable(subscriber =&gt; {<br>  subscriber.next(&#39;Salut !&#39;);<br>});<br><br>obs.subscribe(data =&gt; console.log(data)); // Salut !</pre><p>C’est en réalité dans le callback d’un Observable que l’on doit faire notre .next(), et on le fait sur l’argument subscriber qui correspond en réalité au flux de données que chaque abonné écoutera lorsqu’il fera .subscribe().</p><pre>import { Observable} from &#39;rxjs&#39;;<br><br>const obs = new Observable(subscriber =&gt; {<br>  subscriber.next(&#39;Salut &#39;);<br>  subscriber.next(&#39;comment &#39;);<br>  subscriber.next(&#39;ça va ?&#39;);<br>});<br><br>obs.subscribe(data =&gt; console.log(data));</pre><p>Ici je vais bel et bien avoir 3 console.log() comme ceci :</p><pre>Salut ! // premier console.log<br>comment // deuxième console.log<br>ça va ? // troisième console.log</pre><p>Mon Observable, et plus particulièrement son callback, fait 3 .next() sur le flux de données, poussant donc 3 valeurs, ainsi au moment où je vais subscribe() le flux va émettre trois fois, donc je passerai 3 fois à l’intérieur du subscribe().</p><p>Il est important de comprendre que c’est le fait de .subscribe() qui déclenche l’ouverture du flux et donc qui trigger le callback passé dans le Observable. C’est exactement comme le http.get() (et les autres requêtes) du HttpClient de Angular, si je ne subscribe() pas, le call http ne se lance pas. A chaque fois qu’on va subscribe() ça déclenchera un nouveau call http et créera un nouveau flux indépendant.</p><blockquote>Petite parenthèse !<br>Si vous voulez être au top niveau sur Angular, je vous propose deux choses :<br>1) De vous inscrire à ma newsletter.<br>2) De rejoindre mon serveur Discord Angular 100% francophone.<br>Vous y trouverez conseils, entraide, veille techno et opportunités de boulot le tout autour de Angular !<br>Tout ce passe ici : <a href="https://kevin-tale.dev/">https://kevin-tale.dev/</a></blockquote><h3>Observable et valeurs dynamiques</h3><p>Les Observable ne vont pas systématiquement pousser des données statiques !</p><pre>import { Observable} from &#39;rxjs&#39;;<br><br>const rand = new Observable(subscriber =&gt; {<br>  subscriber.next(Math.random());<br>});<br><br>rand.subscribe(data =&gt; console.log(data)); // 0.159812<br>rand.subscribe(data =&gt; console.log(data)); // 0.811699<br>rand.subscribe(data =&gt; console.log(data)); // 0.422368<br></pre><p>Comme vous le voyez, la donnée que l’on pousse dans le .next() n’est pas forcément une valeur figée. Ici c’est Math.random() que je pousse. De ce fait à chaque subscribe() le Math.random() va être executé, on aura donc une valeur différente.</p><p>Un autre exemple :</p><pre>const counter = new Observable(subscriber =&gt; {<br>  let counter = 0<br>  setInterval(() =&gt; {<br>    subscriber.next(counter++);<br>  }, 1000)<br>});<br><br>counter.subscribe(data =&gt; console.log(data)); // émet toutes les secondes<br><br>// 5 secondes plus tard je m&#39;abonne à nouveau<br>setTimeout(() =&gt; {<br>  counter.subscribe(data =&gt; console.log(data)); // émet toutes les secondes<br>}, 5000)<br></pre><p>counter déclenche un intervalle où chaque seconde une nouvelle donnée est poussée, donc chaque abonnement va créer un nouvel intervalle. J’ai fait démarrer le second abonnement 5 secondes plus tard juste pour vous montrer que <strong>les flux sont vraiment indépendants</strong>.</p><p>Et c’est une différence fondamentale entre les Observable et les Subject !</p><ul><li>Avec les Observables, chaque abonné créé un flux de données indépendant entre lui et l’ Observable dès qu’il .subscribe(). On dit alors que les Observable font du <strong>unicasting</strong>.</li><li>Avec les Subject, tous les abonnés se branchent au même flux de données en faisant un .subscribe()et dès que le Subject émet suite à un .next() alors les abonnés vont tous recevoir cette nouvelle valeur. On dit alors que les Subjectfont du <strong>multicasting</strong>.</li></ul><p>Et cette différence repose uniquement sur la question de l’endroit où se fait le .next(), et en réalité c’est tout à fait logique, regardez cet exemple :</p><pre>import { Observable, Subject} from &#39;rxjs&#39;;<br><br>const randObs = new Observable(subscriber =&gt; {<br>  subscriber.next(Math.random());<br>});<br><br>randObs.subscribe(console.log);<br>randObs.subscribe(console.log);<br>randObs.subscribe(console.log);<br><br>const randSub = new Subject();<br><br>randSub.subscribe(console.log);<br>randSub.subscribe(console.log);<br>randSub.subscribe(console.log);<br><br>randSub.next(Math.random())</pre><p>Les trois abonnés sur randObs sont complètement indépendant, et dès qu’ils ont subscribe() ils ont créé un nouveau flux et relancer un nouveau Math.random(), donc ils n’ont pas reçu la même valeur !</p><p>Tandis que pour le Subject, j’ai d’abord créé trois abonnements puis je pousse un nouveau Math.random() donc les trois abonnements vont bien recevoir la même chose !</p><p>C’est également le cas avec un BehaviorSubject :</p><pre>const randSub = new BehaviorSubject(Math.random());<br><br>randSub.subscribe(console.log);<br>randSub.subscribe(console.log);<br>randSub.subscribe(console.log);</pre><p>Les trois abonnés vont recevoir la même donnée initiale, pourquoi ? Et bien tout simplement parce qu’un BehaviorSubject exécute ce qu’on lui passe en paramètre dès qu’il se créé.</p><h3>Le parallèle avec Angular</h3><p>Bon, c’est intéressant tout ça, mais comment ça s’inscrit dans la logique de création d’un application Angular ?</p><p>En fait, vous n’allez quasiment jamais faire de new Observable, en tout cas personnellement en 7 ans d’utilisation d’Angular je ne l’ai pas fait une seule fois. Tandis que new Subject ou new BehaviorSubject est relativement commun (moins si vous utilisez une librairie de State Management car celles-ci l’utilisent déjà sous le capot), ça vous servira à créer ce pattern où vous aurez une donnée indépendante que vous pourrez lire et écrire depuis n’importe quel composant ou service en respectant une <em>separation of concerns</em>.</p><p>En revanche, vous allez <strong>beaucoup</strong> utiliser les Observables mis à disposition par Angular :</p><ul><li>Le HttpClient et ses requêtes qui renvoient des Observables</li><li>ActivatedRoute qui permet de s’abonner à la route courante</li><li>valueChanges pour écouter les changements de valeurs des différents champs d’un formulaire</li><li>Et bien d’autres</li></ul><p>D’ailleurs on peut facilement imaginer ce à quoi pourrait ressembler l’implémentation de http.get() de Angular :</p><pre>const httpGet = (endpoint: string) =&gt; new Observable(subscriber =&gt; {<br>  // ici il y a la requêtte HTTP avec xhr en <br>  // utilisant l&#39;endpoint en paramètre<br>  const resultFromHttpRequest = ...;<br>  subscriber.next(dataFromHttpRequest);<br>  subscriber.complete()<br>})</pre><p>Bien entendu la vraie implémentation de la fonction est plus complexe car on gère les erreurs, les side effects, le HttpHeader etc, mais dans l’idée c’est bien ça ! Le subscriber.complete() sert à couper le flux de tous les abonnés, dans les requêtes de HttpClient c’est fait automatiquement.</p><p>D’ailleurs en parlant de ça, subscribe() ne prend pas forcément qu’une fonction callback, on peut aussi lui passer un objet pour préciser quoi faire en cas d’erreur ou lors du complete (quand le flux est coupé) :</p><pre>const obs = new Observable((subscriber) =&gt; {<br>  try {<br>    subscriber.next(Math.random());<br>    subscriber.complete();<br>  } catch (error) {<br>    throw new Error(error);<br>  }<br>});<br><br>obs.subscribe({<br>  next: (data) =&gt; console.log(data),<br>  error: (error) =&gt; console.error(error),<br>  complete: () =&gt; console.log(&#39;complete&#39;),<br>});</pre><ul><li>next() va s’exécuter à chaque émission de nouvelle donnée</li><li>error va s’exécuter quand obs va lever une erreur</li><li>complete va s’exécuter quand le flux va se couper</li></ul><h3>Conclusion</h3><p>Et voilà ! Hormis quelques petites subtilités, vous connaissez maintenant tous les fondamentaux de RxJS. C’est un sujet vaste et complèxe donc n’hésitez pas à expérimenter par vous-même ! C’est vraiment comme ça que vous allez comprendre les choses en profondeur.</p><p>Je prépare un second article sur RxJS où je vous parlerai des <em>operators</em> ! Stay tuned.</p><p>Vous avez des questions ? N’hésitez pas à me les poser en commentaires ou directement sur mon <a href="https://discord.gg/c8XThfW9a7">Discord Angular 100% francophone</a> !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7af99a9edded" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NgRx en 2023 : les bonnes pratiques]]></title>
            <link>https://kevin-tale.medium.com/ngrx-en-2023-les-bonnes-pratiques-a631a366aeaa?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/a631a366aeaa</guid>
            <category><![CDATA[ngrx]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Tue, 23 May 2023 12:38:09 GMT</pubDate>
            <atom:updated>2023-06-10T08:38:51.569Z</atom:updated>
            <content:encoded><![CDATA[<h3>NgRx en 2023 : les bonnes pratiques</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z98DDGVJ7YmOFGeFV6h-Dg.png" /></figure><blockquote>TLDR : vous voulez directement avoir accès au code ? C’est par ici : <a href="https://github.com/KevTale/ngrx-moderne">https://github.com/KevTale/ngrx-moderne</a></blockquote><p>J’utilise NgRx et son écosystème depuis 2018 et la moindre des choses qu’on puisse dire c’est que NgRx a <strong>énormément</strong> évolué ! Si vous n’avez pas suivi les nouvelles fonctionnalités de ces deux dernières années, cet article est fait pour vous ! En revanche il est tout de quand même recommandé de connaître les bases de NgRx (actions, reducers, selectors) mais je ferai un récap’ de ces notions là tout de même et probablement un article à l’avenir.</p><p>J’avoue avoir été longtemps gêné par le grand nombre de fichiers d’un store NgRx, après tout c’est vrai que pour la moindre fonctionnalité, on est censé avoir :</p><ul><li>un fichier actions</li><li>un fichier reducer</li><li>un fichier effects</li><li>un fichier selectors</li></ul><p>Et chacun de ces fichiers apportent son lot de verbosité.</p><p>Mais aujourd’hui, en 2023, cela n’a <strong>plus rien</strong> à voir, notamment grâce à :</p><ul><li>createFeature arrivé en version 12 en septembre 2021</li><li>createActionGroup arrivé en version 13 en mai 2022</li><li>La fonction inject de Angular 14 permettant les <em>functional effects</em> ainsi que d’autres patterns</li></ul><p>Toutes ces fonctionnalités nous permettent de réduire grandement la verbosité de NgRx et d’améliorer la DX de manière générale, et peut-être même avoir <strong>un store avec un seul fichier</strong> ?! <br>Voyons tout cela ensemble !</p><h3>Récap’ de NgRx</h3><p>Avant de rentrer dans le vif de sujet, faisons un petit récap’ de ce qu’apporte NgRx et des problèmes auxquels l’écosystème répond.</p><p>En fait, dans la pluspart des applications on aura besoin de gérer des données et de les faire communiquer entre les composants et services : qui détient quelles données, qui les modifient, comment etc…</p><p>Il faut trouver une façon de faire ça efficacement, avec des patterns testés et éprouvés, sans réinventer la roue. Sinon on va rapidement tomber dans du <em>spaghetti code.</em></p><p>Et c’est là que NgRx entre en jeu !</p><p>NgRx est basé sur le modèle <a href="https://redux.js.org/">Redux</a> et est adapté pour Angular, il offre une structure et une façon de gérer notre état applicatif de façon déterministique, c’est à dire qu’on doit faire “comme ça et pas autrement” !</p><p>Cela peut être vu comme un inconvénient si la structure n’est pas agréable à utiliser mais il y a aussi beaucoup d’avantages : une façon de faire répandue qui facilite le debugging, la facilité à comprendre le code de ses collègues, la facilité à l’embauche etc. Et au-delà de ça, NgRx propose de grandes performances, un écosystème complet avec les effects, le router store, les pipes et directives, le store-devtools, component-store et bien d’autres encore.</p><p>Nous, on va s’attarder sur le package principal <strong>ngrx/store</strong> et on va étudier la façon moderne de l’utiliser.</p><h3><strong>NgRx Moderne</strong></h3><p>Je ne vais pas réinventer la roue et je vais créer une todos app car elles ont tous les uses cases intéressants dont on a besoin pour éprouver un store NgRx.</p><p>Admettons donc que dans cette application, on a un composant TodosComponent qui affiche la liste des todos et permet d’en ajouter.</p><pre>@Component({<br>  standalone: true,<br>  imports: [NgFor, FormsModule],<br>  template: `<br>    &lt;button (click)=&quot;todosFeature.loadTodos()&quot;&gt;Load all todos&lt;/button&gt;<br>    &lt;form (ngSubmit)=&quot;addTodo()&quot;&gt;<br>      &lt;input name=&quot;todoName&quot; [(ngModel)]=&quot;todoName&quot; type=&quot;text&quot; /&gt;<br>    &lt;/form&gt;<br>    &lt;ul&gt;<br>      &lt;li *ngFor=&quot;let todo of todosFeature.todos()&quot;&gt;<br>        {{ todo.name }}<br>      &lt;/li&gt;<br>    &lt;/ul&gt;<br>  `,<br>})<br>export class ProductsComponent {<br>  readonly todosFeature = injectTodosFeature(); // c&#39;est ici que la magie opère<br><br>  todoName = &#39;&#39;;<br><br>  addTodo() {<br>    this.todosFeature.addTodo(this.todoName);<br>    this.todoName = &#39;&#39;;<br>  }<br>}</pre><p>Que se cache t-il derrière injectTodosFeature, telle est la question ! En tout cas, on peut voir qu’on a todosqui semble être un Signal puisqu’on l’exécute, et on a également la méthode add qui s’exécute au <em>submit</em> du formulaire, cette méthode semble ajouter une nouvelle todo avant de vider le champ todoName. Enfin, on a un bouton load all todos.</p><p>Bien, essayons ensemble de créer ce store avec ces fonctionnalités dans une toute nouvelle application Angular 16 !</p><p>On va commencer par installer NgRx : ng add @ngrx/store.</p><p>Puis on va créer le folder todosqui contiendra notre composant et <strong>un seul fichier</strong> store.ts :</p><pre>src/<br>  app/<br>    todos/<br>      todos.component.ts<br>      store.ts<br>    app.component.ts<br>    app.config.ts // automatiquement généré depuis Angular 16<br>    app.routes<br>  index.html<br>  main.ts<br>  style.css</pre><p>C’est ce seul fichier store.ts qui contiendra notre store. En effet, grâce aux dernières versions de NgRx, l’API a tellement été réduit qu’on peut se permettre de faire du <strong><em>single file </em></strong>!</p><pre>// todos/store.ts<br><br>export type Todo = {<br>  id: string;<br>  name: string;<br>  completed: boolean;<br>}<br><br>export type TodosState {<br>  todos: Todo[];<br>}<br>export const initialState: TodosState = {<br>  todos: [],<br>};</pre><p>La première étape consiste toujours à définir le contrat d’interface de notre feature et son état initial. Ici on a donc un tableau de todos initialement vide.</p><p>Une fois qu’on a l’état initial, on veut définir tous les évènements qui s’actionneront au sein de notre feature, et on appelle ça les <em>actions</em> ! Une action c’est comme un évènement qui va décrire quelque chose qui vient d’arriver dans notre application, et ces actions on les déclenche (dans le jargon NgRx on dit qu’on les dispatche), puis une fois déclenchée, différentes choses qui écoutent ces actions (reducers et effects) vont réagir et faire des choses, on va voir ça ensemble.</p><p>On peut imaginer que dans notre todos list on a ces actions là :</p><ul><li>Todo créée</li><li>Todo modifiée</li><li>Todo terminée</li><li>Todo supprimée</li><li>Reset des todos (pour supprimer tout et reprendre à zéro notre liste)</li></ul><p>Dans <strong>L’ANCIENNE </strong>façon de faire, on procédait comme ça pour définir les actions :</p><pre>import { createAction, props } from &#39;@ngrx/store&#39;;<br><br>export const addTodo = createAction(<br>  &#39;[Todos] Add Todo&#39;,<br>  props&lt;{ name: string }&gt;()<br>);<br><br>export const editTodo = createAction(<br>  &#39;[Todos] Edit Todo&#39;,<br>  props&lt;{ id: string; name: string }&gt;()<br>);<br><br>export const completeTodo = createAction(<br>  &#39;[Todos] Complete Todo&#39;,<br>  props&lt;{ id: string }&gt;()<br>);<br><br>export const removeTodo = createAction(<br>  &#39;[Todos] Remove Todo&#39;,<br>  props&lt;{ id: string }&gt;()<br>);<br><br>export const resetTodos = createAction(<br>  &#39;[Todos] Reset Todos&#39;<br>);</pre><p>Chaque action possède sa chaîne de caractères <strong>uniques, </strong>c’est ce qui va permettre à ceux qui vont écouter sur ces actions de les différencier, ce sont leur identifiants uniques. Les props c’est la donnée que l’action embarque avec elle pour que ceux qui écoutent les actions puissent s’en servir. A noter qu’une action n’a pas forcément besoin de props (exemple avec todosReset).</p><p>Pour informations, si vous utilisez store-devtools (ce que je vous conseille, j’y reviendrai plus bas) et bien lorsque vous dispatchez une action c’est bien ces chaînes de caractères que vous verrez dans les logs. Le [Todos] permet d’identifier à quelle feature appartient l’action pour nous les devs lorsqu’on regarde les logs.</p><p>Bon, voici la <strong>NOUVELLE </strong>façon de faire, attention les yeux :</p><pre>export const todosActions = createActionGroup({<br>  source: &#39;Todos&#39;,<br>  events: {<br>    &#39;Add Todo&#39;: props&lt;{ name: string }&gt;(), // [Todos] Add Todo<br>    &#39;Edit Todo&#39;: props&lt;{ id: string; name: string }&gt;(), // [Todos] Edit Todo<br>    &#39;Complete Todo&#39;: props&lt;{ id: string }&gt;(), // [Todos] Complete Todo<br>    &#39;Remove Todo&#39;: props&lt;{ id: string }&gt;(), // [Todos] Remove Todo<br>    &#39;Reset Todos&#39;: emptyProps(), // [Todos] Reset Todos<br>  },<br>});</pre><p>On a une fonction createActionGroup qui prend un objet en paramètre, cet objet à une clé source qui a pour valeur le nom de la feature (ce nom sera automatiquement entouré de [] dans les logs) et une clé events qui a pour valeur un objet où on va lister nos différentes actions. Dans cet objet, chaque clé correspond à la chaîne de caractères décrivant l’action, et sa valeur décrit le props. Si on n’a pas de props il faut mettre emptyProps().</p><p>Et ce n’est pas fini ! En fait, createActionGroup renvoie directement les actions ! Sous quelle forme ? Et bien il se base sur les chaînes de caractères des actions pour créer les actions elles-mêmes !</p><pre>export const {<br>  addTodo,<br>  completeTodo,<br>  editTodo,<br>  removeTodo,<br>  resetTodos,<br>} = createActionGroup({<br>  source: &#39;Todos&#39;,<br>  events: {<br>    &#39;Add Todo&#39;: props&lt;{ name: string }&gt;(),<br>    &#39;Edit Todo&#39;: props&lt;{ id: string; name: string }&gt;(),<br>    &#39;Complete Todo&#39;: props&lt;{ id: string }&gt;(),<br>    &#39;Remove Todo&#39;: props&lt;{ id: string }&gt;(),<br>    &#39;Reset Todos&#39;: emptyProps(),<br>  },<br>});</pre><p>Ici, j’ai déstructuré ce que renvoie createActionGroup et comme vous le voyez on a une méthode addTodo , une autre completeTodo etc. Et c’est précisément parce que j’ai appelé mon action Complete Todo que createActionGroup a crée l’action completeTodo, en gros ils mettent l’action en lower camel case.</p><p>Vous pouvez aussi directement le faire si vous préférez :</p><pre>export const todosActions = createActionGroup({<br>  source: &#39;Todos&#39;,<br>  events: {<br>    addTodo: props&lt;{ name: string }&gt;(), // [Todos] addTodo<br>    editTodo: props&lt;{ id: string; name: string }&gt;(), // [Todos] editTodo<br>    completeTodo: props&lt;{ id: string }&gt;(),<br>    removeTodo: props&lt;{ id: string }&gt;(),<br>    resetTodos: emptyProps(),<br>  },<br>});</pre><p>Je n’ai personnellement pas de préférence entre l’un ou l’autre. Peut-être que cette dernière version fait moins magique et plus facilement refactorable, à vous de voir !</p><p>Parlons maintenant de createFeature.</p><blockquote>Petite parenthèse !<br>Si vous voulez être au top niveau sur Angular, je vous propose deux choses : <br>1) De vous inscrire à ma newsletter. <br>2) De rejoindre mon serveur Discord Angular 100% francophone.<br>Vous y trouverez conseils, entraide, veille techno et opportunités de boulot le tout autour de Angular !<br>Tout ce passe ici : <a href="https://kevin-tale.dev/">https://kevin-tale.dev/</a></blockquote><p>Pour faire simple, createFeature c’est à la fois notre reducer et nos selectors.</p><p>Toujours dans le fichier todos/store.ts et à la suite du code précédent, on ajoute :</p><pre>export const todosFeature = createFeature({<br>  name: &#39;todos&#39;,<br>  reducer: createReducer(<br>    initialState,<br>    on(todosActions.addTodo, (state, action) =&gt; ({<br>      ...state,<br>      todos: [<br>        { id: uuid(), title: action.title, completed: false },<br>        ...state.todos,<br>      ],<br>    })),<br>    on(todosActions.completeTodo, (state, action) =&gt; ({<br>      ...state,<br>      todos: state.todos.map((todo) =&gt;<br>        todo.id === action.id ? { ...todo, completed: true } : todo<br>      ),<br>    })),<br>    on(todosActions.editTodo, (state, action) =&gt; ({<br>      ...state,<br>      todos: state.todos.map((todo) =&gt;<br>        todo.id === action.id ? { ...todo, title: action.title } : todo<br>      ),<br>    })),<br>    on(todosActions.removeTodo, (state, action) =&gt; ({<br>      ...state,<br>      todos: state.todos.filter((todo) =&gt; todo.id !== action.id),<br>    })),<br>    on(todosActions.loadTodosSuccess, (state, action) =&gt; ({<br>      ...state,<br>      todos: action.todos,<br>    })),<br>    on(todosActions.resetTodos, (state) =&gt; ({<br>      ...state,<br>      todos: [],<br>    }))<br>  ),</pre><p>createFeature prend un objet avec deux propriétés : name qui est le nom de notre feature et reducer qui est notre reducer classique qu’on utilise comme à l’accoutumé.</p><p>Ce qui est intéressant c’est ce que <em>return</em> createFeature :</p><pre>export const {<br>  name, // le nom de notre feature (&quot;todos&quot; ici)<br>  reducer, // le reducer de notre feature<br>  selectTodosState, // le selector global de notre feature<br>  selectTodos, // le selector de la propriété &quot;todos&quot;<br>} = createFeature({<br>  name: &#39;todos&#39;,<br>  reducer: createReducer(...)<br>})<br></pre><p>Et oui ! createFeature va automatiquement créer des selectors en se basant sur les propriétés de notre state ! Pour rappel, mon state est celui-ci :</p><pre>export type TodosState {<br>  todos: Todo[];<br>}</pre><p>Ainsi, createFeature va créer un selector automatiquement pour chacune des propriétés du state sous la forme selectXXX , par exemple si j’avais une propriété loading en plus de todos , ça aurait créé automatiquement selectLoading. Dingue non ?</p><p>Et si on a besoin de selectors en plus, createFeaturea une propriété supplémentaire appelée extraSelectors et comme son nom l’indique celle-ci nous permet de créer d’autres selectors à notre guise :</p><pre>export const {<br>  ...<br>  selectTodos, <br>  selectHasTodos, // le nouveau selector que je viens de créer !<br>  selectCompletedTodos // le nouveau selector que je viens de créer !<br>} = createFeature({<br>  name: &#39;todos&#39;,<br>  reducer: createReducer(...),<br>  extraSelectors: ({selectTodos}) =&gt; {<br>    return {<br>      selectHasTodos: createSelector(selectTodos, (todos) =&gt; todos.length &gt; 0),<br>      selectCompletedTodos: createSelector(selectTodos, (todos) =&gt; todos.filter((todo) =&gt; todo.completed)),<br>    }<br>  }<br>})</pre><p>extraSelectors prend une fonction en valeur, l’argument de cette fonction est un objet qui contient chacun de nos selectors déjà existant, ici je déstructure selectTodos pour créer deux autres nouveaux selectors : selectHasTodos et selectCompletedTodos ! C’est aussi simple que ça !</p><p>Personnellement j’adore cette nouvelle façon de faire, je trouve ça très agréable à utiliser.</p><p>Bon, nous avons nos actions, nos selectors, notre reducer… Il nous reste <strong>les effects</strong> !</p><p>Je vous en parlais en introduction, grâce à la fonction inject() arrivée avec Angular 14, nous avons accès aux <em>functional effects</em>. L’idée est de pouvoir écrire des effects en dehors de class. Avant nous étions obligé d’utiliser un Injectable (donc une class) car on injectait Actions de @ngrx/effects dans son constructor. Mais ce n’est plus le cas maintenant.</p><p>Voyons à quoi ça ressemble :</p><pre>export const loadTodos$ = createEffect(<br>  (actions$ = inject(Actions)) =&gt; {<br>    const http = inject(HttpClient);<br><br>    return actions$.pipe(<br>      ofType(todosActions.loadTodos),<br>      switchMap(() =&gt;<br>        http.get&lt;Todo[]&gt;(&#39;https://jsonplaceholder.typicode.com/todos&#39;).pipe(<br>          map((todos) =&gt; todosActions.loadTodosSuccess({ todos })),<br>          catchError((error) =&gt; of(todosActions.loadTodosFailure({ error })))<br>        )<br>      )<br>    );<br>  },<br>  { functional: true }<br>);</pre><p>Comme vous le voyez, on injecte actions$ grâce à la fonction inject(), de ce fait nous n’avons pas besoin d’inclure nos effects dans des class, d’où l’appellation <em>functional effects</em> ! On doit simplement ajouter { functional: true } pour que ça fonctionne.</p><p>Si on a besoin d’injecter un service dans notre effect, on peut le faire comme ça :</p><pre>export const loadTodos$ = createEffect(<br>  (actions$ = inject(Actions), todosService = inject(TodosService)) =&gt; {<br>    return actions$.pipe(<br>      ofType(todosActions.loadTodos),<br>      switchMap(() =&gt;<br>        todosService.getAll().pipe(<br>          map((todos) =&gt; todosActions.loadTodosSuccess({ todos })),<br>          catchError((error) =&gt; of(todosActions.loadTodosFailure({ error })))<br>        )<br>      )<br>    );<br>  },<br>  { functional: true }<br>);</pre><p>A noter que nous ne sommes pas obligés d’injecter dans les arguments de la fonction de l’effect, voilà à quoi ça ressemble en injectant directement dans le body de createEffect:</p><pre>export const loadTodos = createEffect(<br>  () =&gt; {<br>    const todosService = inject(TodosService);<br>    return inject(Actions).pipe(<br>      ofType(todosActions.loadTodos),<br>      switchMap(() =&gt;<br>        todosService.loadAll().pipe(<br>          map((todos) =&gt; todosActions.loadTodosSuccess({ todos })),<br>          catchError((error) =&gt; of(todosActions.loadTodosFailure({ error })))<br>        )<br>      )<br>    );<br>  },<br>  { functional: true }<br>);</pre><p>Mais il n’est pas recommandé de le faire pour faciliter le testing.</p><p>Aussi, dans les faits on peut faire du full <em>single file </em>et mettre nos effects dans le même fichier, mais ça peut vite monter à 300/400/500 lignes. Personnellement ça ne me dérange pas d’avoir un long fichier si le code est propre. J’ai toujours préféré scroller que cliquer pour changer de fichiers. Mais si ce n’est pas votre cas, n’hésitez pas à faire un autre fichier pour séparer vos effects !</p><p>Ok ! Vous vous rappelez que dans le composant que j’ai montré tout en haut, on a un readonly todosFeature = injectTodosFeature(); ? Et bien on va créer ça, et encore une fois c’est grâce à la fonction inject(). A la fin de notre todos/store.ts, on ajoute :</p><pre>export function injectTodosFeature() {<br>  const store = inject(Store);<br><br>  return {<br>    addTodo: (name: string) =&gt; store.dispatch(todosActions.addTodo({ name })),<br>    removeTodo: (id: string) =&gt; store.dispatch(todosActions.removeTodo({ id })),<br>    resetTodos: () =&gt; store.dispatch(todosActions.resetTodos()),<br>    loadTodos: () =&gt; store.dispatch(todosActions.loadTodos()),,<br>    todos: store.selectSignal(todosFeature.selectTodos),<br>    hasTodos: store.selectSignal(todosFeature.selectHasTodos),<br>    completedTodos: store.selectSignal(todosFeature.selectCompletedTodos),<br>  };<br>}</pre><p>C’est tout simplement une fonction qui va return un objet avec tous les dispatch d’actions et selectors dont on a besoin. Au final c’est comme une façade ! C’est très pratique car ça nous permet d’exposer à l’extérieur uniquement ce que les consommateurs du store auront besoin.</p><p>Vous aurez noter que j’utilise le nouveau store.selectSignal(), qui prend en argument en selector et qui renvoie le transforme en Signal. Si vous voulez en savoir plus sur les Signals,<a href="https://blog.kevin-tale.dev/tout-comprendre-sur-les-signals-dans-angular-7bbbbf00b975"> j’ai fait un article complet à ce sujet</a>.</p><p>Et voilà ! Notre store est terminé. Il ne reste plus qu’à le brancher pour que ça fonctionne. Ici, deux solutions, si vous voulez que votre store soit initialisé au bootstrap de l’application, il faudra aller dans votre app.config.ts (ou main.ts ) :</p><pre>export const appConfig: ApplicationConfig = {<br>  providers: [<br>    provideRouter(routes),<br>    provideHttpClient(),<br>    provideStore(), // pour que @ngrx/store fonctionne<br>    provideState(todosFeature), // on initialise notre store<br>    provideEffects({loadTodos}), // on provide nos effects<br>  ],<br>};</pre><p>Vous pouvez aussi provide votre store au niveau d’une route comme ça il ne se déclenchera que lorsque l’utilisateur est sur cette route :</p><pre>// app.routes.ts<br><br>export const routes: Routes = [<br>  {<br>    path: &#39;&#39;,<br>    redirectTo: &#39;todos&#39;,<br>    pathMatch: &#39;full&#39;,<br>  },<br>  {<br>    path: &#39;todos&#39;,<br>    loadComponent: () =&gt; import(&#39;./routes/todos/todos.route&#39;),<br>    providers: [provideState(todosFeature), provideEffects({ loadTodos })],<br>  },<br>];</pre><p>Tout est prêt ! Vous pouvez maintenant utiliser votre store dans vos composants !💪</p><h3>Conclusion</h3><p>Personnellement j’avais pendant longtemps délaissé ngrx/store au profit de ngrx/component-store car je préférais le fait qu’il y ait moins de fichiers et de verbosité de manière générale. Maintenant l’argument ne tient plus vraiment, avec la version moderne de NgRx je préfère largement l’utiliser. Sa rigueur, les patterns qu’il impose et les devtools (absents de component-store) me plaisent et je félicite l’équipe de NgRx d’avoir traité le plus gros soucis de NgRx : la DX. 👏</p><p>Vous avez des questions ? N’hésitez pas à me les poser en commentaires ou directement sur mon <a href="https://discord.gg/c8XThfW9a7">Discord Angular 100% francophone</a> !</p><p>Code source : <a href="https://github.com/KevTale/ngrx-moderne">https://github.com/KevTale/ngrx-moderne</a><br>Article sur NgRx 16 : <a href="https://dev.to/ngrx/announcing-ngrx-v16-integration-with-angular-signals-functional-effects-standalone-schematics-and-more-5gk6">https://dev.to/ngrx/announcing-ngrx-v16-integration-with-angular-signals-functional-effects-standalone-schematics-and-more-5gk6</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a631a366aeaa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tout comprendre sur les Signals dans Angular]]></title>
            <link>https://kevin-tale.medium.com/tout-comprendre-sur-les-signals-dans-angular-7bbbbf00b975?source=rss-285f1fc06b48------2</link>
            <guid isPermaLink="false">https://medium.com/p/7bbbbf00b975</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[signal]]></category>
            <dc:creator><![CDATA[Kevin Tale]]></dc:creator>
            <pubDate>Sun, 07 May 2023 13:40:48 GMT</pubDate>
            <atom:updated>2023-10-07T14:24:22.858Z</atom:updated>
            <content:encoded><![CDATA[<h4>Des applications Angular plus performantes avec les Signals… et avec une meilleure DX ?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HhKCNVsRsvuIOzuVgCiJZw.png" /></figure><p>Les Signals sont arrivés avec Angular 16 ce qui a mis la communauté Angular en effervescence ! Mais le sujet est complexe, c’est pourquoi j’ai écrit cette article qui compile toutes les infos importantes et qui explique <strong>le pourquoi du comment des Signals</strong> et comment ils vous aideront dans vos applications Angular.</p><p>Ok alors revenons aux bases. Les Signals c’est un sujet complexe, donc on va essayer d’y aller étape par étape.</p><h3>Le problème</h3><p>Considérons ce composant :</p><pre>@Component({<br>  template: `<br>   &lt;p&gt;{{ celsius }}&lt;/p&gt; // 25<br>   &lt;p&gt;{{ fahrenheit }}&lt;/p&gt; // 77<br>  `<br>})<br>export class SomeComponent {<br>  celsius = 25;<br>  fahrenheit = this.celsius * 1.8 + 32;<br>}</pre><p>Ca marche nickel, j’affiche 25 degrés Celsius et 77 degrés Fahrenheit.<br>Mais que se passe t-il si j’ajoute un bouton pour doubler celsius ?</p><pre>@Component({<br>  template: `<br>   // je clique sur ce bouton 👇<br>   &lt;button (click)=&quot;doubleCelsius()&quot;&gt;Doubler le degré celsius&lt;/button&gt;<br>   &lt;p&gt;{{ celsius }}&lt;/p&gt; // ça me renvoie bien 50<br>   &lt;p&gt;{{ fahrenheit }}&lt;/p&gt; // ça me renvoie toujours 77 😱<br>  `<br>})<br>export class SomeComponent {<br>  celsius = 25;<br>  fahrenheit = this.celsius * 1.8 + 32;<br><br>  doubleCelsius() {<br>    this.celsius = this.celsius * 2;<br>  }<br>}</pre><p>Patatra, ça marche plus ! fahrenheit me renvoie toujours 77. Il n’a pas été recalculé. Pourquoi ? Et bien cette propriété est initialisée lors de la construction du composant, et seulement à ce moment-là. A aucun momentfahrenheit ne se recalcule, cette propriété n’est pas <strong>réactive, ça veut dire qu’elle ne réagit pas (elle ne se recalcule pas) lorsque les valeurs auxquels elle dépend changent</strong>.</p><p>Une solution serait de transformer fahrenheit en getter.</p><pre>@Component({<br>  template: `<br>    &lt;button (click)=&quot;doubleCelsius()&quot;&gt;Doubler le degré celsius&lt;/button&gt;<br>    &lt;p&gt;{{ celsius }}&lt;/p&gt; <br>    &lt;p&gt;{{ fahrenheit }}&lt;/p&gt;<br>  `<br>})<br>export class AppComponent {<br>  celsius = 25;<br><br>  get fahrenheit() {<br>    return this.celsius * 1.8 + 32;<br>  }<br><br>  doubleCelsius() {<br>    this.celsius = this.celsius * 2;<br>  }<br>}</pre><p>Et là, ça fonctionne impec’ ! fahrenheit est bien recalculée quand je clique sur le bouton. Mais comment ça marche et pourquoi ce n’est pas une bonne solution ? En fait, le getter va se recalculer dès que la <em>change detection</em> d’Angular s’exécute et pas seulement quand celsius change, ce qui est mauvais pour la performance.</p><p>Bon… Quelle est la bonne solution alors ? RxJS to the rescue!<br>Voyons comment on peut facilement solutionner notre problème avec RxJS.</p><pre>@Component({<br>  template: `<br>   &lt;button (click)=&quot;doubleCelsius()&quot;&gt;Doubler le degré celsius&lt;/button&gt;<br>   &lt;p&gt;{{ celsius$ | async }}&lt;/p&gt; <br>   &lt;p&gt;{{ fahrenheit$ | async }}&lt;/p&gt;<br>  `<br><br>})<br>export class AppComponent {<br>  celsius$$ = new BehaviorSubject(25);<br>  celsius$ = this.celsius$$.asObservable();<br>  fahrenheit$ = this.celsius$.pipe(map((celsius) =&gt; celsius * 1.8 + 32));<br><br>  doubleCelsius() {<br>    this.celsius$$.next(this.celsius$$.value * 2);<br>  }<br>}</pre><p>Super ! Ca fonctionne très bien, l’observable fahrenheit$ dépend de celsius$ , lorsque ce dernier est modifié (grâce à this.celsiusSubject$$.next()) alors fahrenheit$ est également modifié. C’est ce que l’on appelle la programmation <strong>réactive car </strong>fahrenheit$ <strong>“écoute” ses dépendances et réagit lorsque la valeur de celles-ci changent.</strong></p><p><strong>Quel est le problème alors ?</strong></p><p>On en a deux :</p><ol><li>La performance. Sans entrer trop dans les détails car ça pourrait être un article à part entière, la détection de changement dans Angular fonctionne très bien <strong>mais n’est pas optimale</strong>. Pour gérer sa <em>change detection </em>Angular se repose sur zone.js, une librairie tierce qui écoute tous les évènements du browser (clique, mouvements de souris, setTimeout, setInterval…) et permet de faire des choses en callback dès qu’un évènement se termine. Angular tire partie de cela en lançant sa <em>change detection</em> ce qui met à jour les templates de <strong>tous</strong> les composants actuellement dans le DOM, et pas seulement sur les composants où il y a bel et bien un changement.</li><li>La complexité du code. Comme vous le voyez dans le code au dessus, on doit apprendre et comprendre RxJS pour construire des applications efficaces. Et rares sont ceux qui maîtrisent cette librairie et ses paradigmes. La team Angular a identifié que beaucoup de devs’ s’éloignent d’Angular à cause de cette complexité.</li></ol><p>Ils ont donc décider de simplifier les choses.</p><h3><strong>Introducing les Signals</strong></h3><p>Le principe des Signals n’est pas une invention d’Angular, en fait c’est un paradigme connu depuis des dizaines d’années. Et même dans l’écosystème frontend on a déjà des implémentations des Signals (SolidJS, Vue…). Il était donc temps que Angular s’y mette aussi !</p><p>Voici l’équivalent de la fonctionnalité d’avant mais avec les Signals.</p><pre>@Component({<br>  template: `<br>   &lt;button (click)=&quot;doubleCelsius()&quot;&gt;Doubler le degré celsius&lt;/button&gt;<br>   &lt;p&gt;{{ celsius() }}&lt;/p&gt; <br>   &lt;p&gt;{{ fahrenheit() }}&lt;/p&gt;<br>  `<br><br>})<br>export class AppComponent {<br>  celsius = signal(25);<br>  fahrenheit = computed(() =&gt; this.celsius() * 1.8 + 32);<br><br>  doubleCelsius() {<br>    this.celsius.update(celsius =&gt; celsius * 2); <br>    this.celsius.set(this.celsius() * 2); // on peut aussi faire comme ça, ça revient au même<br>  }<br>}</pre><p>Décortiquons ce qu’il se passe dans ce composant :</p><ul><li>On créé notre premier signal avec une valeur par défaut : celsius = signal(25) . Son type est WritableSignal&lt;number&gt; ce qui signifie que vous pouvez modifier ce signal (il n’est pas <em>readonly</em>).</li><li>Pour lire la donnée actuelle de mon signal, je l’exécute, je le fais à deux endroits : dans le template et dans la fonctioncomputed. C’est donc comme cela qu’on accède à la valeur courante d’un signal : celsius(). Et c’est bien ça tout le principe d’un Signal : c’est un “wrapper” par dessus une valeur. Quand on exécute la fonction qui wrap la valeur elle nous renvoie la dernière valeur connue du signal.</li><li>La fonction computed nous permet d’obtenir la réactivité que l’on désire tant ! computedprend une fonction en argument, dans cette fonction on utilise le signal celsius et on <em>return </em>le calcul qui permet de transformer des dégrés Celsius en Fahrenheit. La magie opère dès lors que celsius change, en fait dès que cela va arriver alors fahrenheit va se recalculer, et tout ça grâce à computed ! Cette fonctione traque ses dépendances (les Signals qui sont exécuter à l’intérieur) et se réexécute dès que l’une d’entre elles changent <strong>et </strong>est différent de la valeur précédente. A noter que le type de retour d’un computed est Signal&lt;T&gt;, et est <em>readonly</em> !</li><li>Pour modifier la valeur d’un signal, on peut utiliser .update() qui prend en argument une fonction dont l’argument est la valeur actuelle du signal.</li><li>Alternativement, on peut utiliser .set() pour modifier la valeur d’un signal si on a pas besoin de sa valeur courante.</li></ul><blockquote>Petite parenthèse !<br>Si vous voulez être au top niveau sur Angular, je vous propose deux choses : <br>1) De vous inscrire à ma newsletter. <br>2) De rejoindre mon serveur Discord Angular 100% francophone.<br>Vous y trouverez conseils, entraide, veille techno et opportunités de boulot le tout autour de Angular !<br>Tout ce passe ici : <a href="https://kevin-tale.dev/">https://kevin-tale.dev/</a></blockquote><p>Je ne l’ai pas mis dans mon exemple mais nous avons également la fonction effect. effect s’exécute dès qu’un signal utilisé en son sein change de valeur :</p><pre>@Component({<br>  template: `<br>   &lt;button (click)=&quot;doubleCelsius()&quot;&gt;Doubler le degré celsius&lt;/button&gt;<br>   &lt;p&gt;{{ celsius() }}&lt;/p&gt; <br>   &lt;p&gt;{{ fahrenheit() }}&lt;/p&gt;<br>  `<br><br>})<br>export class AppComponent {<br>  celsius = signal(25);<br>  fahrenheit = computed(() =&gt; this.celsius() * 1.8 + 32);<br><br>  doubleCelsius() {<br>    this.celsius.update(celsius =&gt; celsius * 2);<br>  }<br><br>  log = effect(onCleanUp =&gt; {<br>    console.log(`celsius vient de changer, il vaut ${this.celsius()}`);<br><br>    onCleanUp(() =&gt; {<br>      console.log(&#39;le composant est détruit&#39;);<br>    })<br>  })<br>}</pre><p>Dès que le signal celsius changera, alors l’effect s’exécutera, car je l’utilise dans le console.log. Et en plus de cela, les effects ont une cleanup function qui s’exécute au destroy du contexte de là où il a été appelé ! L’utilité de effect est encore sujet à débat, certains les utilisent pour faire leur call HTTP par exemple. Attendons d’avoir un peu de recule pour trouver les meilleures use cases.</p><h3><strong>Le gain en performance grâce aux Signals</strong></h3><p>Je le disais au début, l’objectif est notamment d’améliorer les performances de vos applications Angular. Avec la version 16 nous sommes à mi-chemin de cet objectif car le framework a pour le moment encore besoin de zone.js pour savoir quand exécuter sa change detection. Mais ça ne sera plus le cas très prochainement car nous pourrons ajouter un attribut signal: trueà nos composants (un peu comme standalone: true) pour complètement se passer de zone.js et exécuter la change detection directement au niveau des composants qui en ont besoin !</p><p>Ainsi, la change detection sera exécutée uniquement lorsque la valeur d’un signal utilisée dans un template changera et le framework procèdera à la mise à jour du template uniquement au composant affecté par le changement et non plus à l’arbre entier de composants. C’est une énorme différence ! Nous n’aurons même plus besoin de changeDetection: ChangeDetectionStrategy.OnPush !</p><h3>Bye bye RxJS alors ?</h3><p>On a vu que nous n’avions plus besoin de Subject ou des Observable pour créer nos données et les modifier, alors plus besoin de RxJS, si ?</p><p>Et bien… Pas si sûr !</p><p>RxJS ce n’est pas que des Observable , c’est aussi des operators. switchMap, filter, tap, debounceTime … Tous ces operators sont là pour nous faciliter la vie et bon courage pour implémenter un switchMap fait maison.</p><p>Forte heureusement, la team Angular a pensé à nous ! Ils mettent en avant l’intéropérabilité entre les Signals et RxJS, c’est à dire le fait que les deux “univers” peuvent fonctionner ensemble.</p><p>Nous avons donc accès à deux méthodes :</p><ol><li>toSignal() qui prend un observable et renvoie un signal</li><li>toObservable() qui prend un signal et renvoie un observable</li></ol><p>Voyons comment on peut utiliser ça :</p><pre>@Component({<br>  template: `<br>    &lt;ul&gt;<br>      &lt;li *ngFor=&quot;let product of availableProducts&quot;&gt;<br>        {{ product.title }}<br>      &lt;/li&gt;<br>    &lt;/ul&gt;<br>  `,<br>})<br>export class AppComponent {<br>  http = inject(HttpClient);<br>  // j&#39;utilise httpClient de manière classique pour <br>  // faire mon call http et passer mes operators rxjs<br>  availableProducts$ = this.http.get(&#39;api/products&#39;)<br>    .pipe(<br>      filter(product =&gt; product.quantity &gt; 0),<br>      map(...),<br>      catchError(...)<br>    );<br><br>  // je convertis mon observable en signal avec toSignal.<br>  // A noter que toSignal() subscribe et unsubscribe automatiquement !<br>  availableProducts = toSignal(<br>    this.availableProducts$,<br>    {initialValue: []} // sinon ça émet &quot;undefined&quot; au début<br>  );<br>}</pre><p>Ainsi, on peut toujours profiter de la puissance des operators RxJS et des Signals !</p><p>Un autre exemple montrant l’utilisation de toObservable :</p><pre>@Component({<br> template: `<br>    &lt;input type=&quot;number&quot; (input)=&quot;changeProductId($event)&quot; /&gt;<br>    &lt;p&gt;{{ product().title }}&lt;/p&gt;<br>  `,<br>})<br>export class AppComponent {<br>  http = inject(HttpClient);<br><br>  productId = signal(1);<br>  product$ = toObservable(this.productId)<br>    .pipe(<br>      switchMap((productId) =&gt; this.http.get(`api/products/${productId}`)<br>    )<br>  );<br><br>  product = toSignal(this.product$, { initialValue: {} });<br><br>  changeProductId(event: Event) {<br>    const id = (event.target as HTMLInputElement).value;<br>    this.productId.set(Number(id));<br>  }<br>  <br>}</pre><p>On caste en observable le signal qui contient l’id du produit afin d’écouter dessus et dès qu’il change (via l’input) on fait un switchMap() en utilisant l’endpoint avec la valeur de l’id du produit. Enfin notre propriété product convertit le résultat en signal.</p><h3>Conclusion</h3><p>En conclusion, les Signals font partie de la mouvance de la grande renaissance de Angular et vont changer beaucoup de choses. Il faudra attendre que les librairies tierces émergent et imposent les bonnes pratiques, je pense notamment à NgRx. Aussi, la team Angular va certainement passer aux Signals pour ses fonctionnalités genre HttpClient ou les formulaires (rien n’est sûr mais ça va sûrement arriver tôt ou tard).<br>Donc il est important de se mettre à jour sur les Signals et vous pouvez compter sur moi pour vous apporter toutes les infos nécessaires !</p><blockquote>Si vous voulez être au top niveau sur Angular, je vous propose deux choses : <br>1) De vous inscrire à ma newsletter. <br>2) De rejoindre mon serveur Discord Angular 100% francophone.<br>Tout ce passe ici : <a href="https://kevin-tale.dev/">https://kevin-tale.dev/</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bbbbf00b975" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>