<?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 Michel Pereira on Medium]]></title>
        <description><![CDATA[Stories by Michel Pereira on Medium]]></description>
        <link>https://medium.com/@michel.pereira?source=rss-27c1d2be619b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ZDHfYgleX9vBoC0BIJYtjQ.png</url>
            <title>Stories by Michel Pereira on Medium</title>
            <link>https://medium.com/@michel.pereira?source=rss-27c1d2be619b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 12:31:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@michel.pereira/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[Quelques bonnes pratiques pour la performance web]]></title>
            <link>https://medium.com/ekino-france/quelques-bonnes-pratiques-pour-la-performance-web-7932cc0468a3?source=rss-27c1d2be619b------2</link>
            <guid isPermaLink="false">https://medium.com/p/7932cc0468a3</guid>
            <category><![CDATA[web]]></category>
            <category><![CDATA[html]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[js]]></category>
            <dc:creator><![CDATA[Michel Pereira]]></dc:creator>
            <pubDate>Fri, 16 May 2025 12:36:45 GMT</pubDate>
            <atom:updated>2025-05-20T11:06:56.299Z</atom:updated>
            <content:encoded><![CDATA[<h4>Synthèse et exemples des bonnes pratiques.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qjDSvIMmF17QbC4YSeE2ew.png" /><figcaption>Image généré par chatGPT</figcaption></figure><p>La performance web est un sujet vaste et en perpétuelle évolution. Elle a aussi une part de subjectivité, une part de ressenti. Par exemple, la perception de la réactivité d’un site n’est pas la même d’une personne à l’autre.<br>Dans ce contexte, il est difficile de définir des actions précises et arrêtées pour obtenir les meilleurs performances pour un site web.<br>Néanmoins, on peut donner quelques bonnes pratiques assez générales qui font les standards des sites web d’aujourd’hui.</p><p>Avec cet article mon optique est de donner une liste (non exhaustive) de bonnes pratiques pour vous donner toute les chances d’avoir un site web aux performances convenables. Il s’adresse plutôt aux débutants dans le web, mais les confirmés pourront peut-être apprendre un ou deux trucs !</p><p>Avant toute chose, quand on parle de performance, on doit forcément avoir des outils et des méthodes de mesure communs.<br>Je ne vais pas entrer dans le détail de ces outils et mesures dans cet article mais je peux vous conseiller le site <a href="https://www.webpagetest.org/">WebPageTest</a> qui permet de calculer le “First Contentful Paint”, “Largest Contentful Paint”, etc… Des valeurs qui vont vous permettre de savoir si votre site se trouve dans les standards de performance.</p><p>Pour plus de clarté, j’ai découpé les performances en 2 familles :</p><ul><li><strong>Les performances de chargement</strong><br>(requêtes http, premier affichage du site, tailles des images)</li><li><strong>Les performances du code<br></strong>(bonnes pratiques, algorithmie, temps d’exécution)</li></ul><h3>Les performances de chargement coté client</h3><ul><li><strong>Éviter les ressources sur plusieurs noms de domaines<br></strong>Chaque nom de domaine va demander un temps de résolution DNS. <br>Ce temps correspond à la recherche et la connexion à l’adresse de son serveur d’hébergement à travers le réseau.<br>Si vous n’utilisez qu’un seul nom de domaine (celui où est hébergé votre site), vous n’aurez qu’une fois ce temps de résolution à la première visite du site. Par contre, ce temps sera multiplié par le nombre de noms de domaine différents !<br>C’est pourquoi il faut éviter d’utiliser des ressources partagées sur un nom de domaine (ou CDN) qui n’est pas le vôtre (exemple les CDN pour les fonts google). Mieux vaut télécharger la font sur votre domaine (ou votre propre CDN) dans ce cas-là.<br>Si vous pouvez, il est bon d’utiliser un CDN car il permet de raccourcir ce temps de connexion en allant chercher les ressources au point le plus proche. Dans ce cas, il faut mettre toutes vos ressources dessus, mais pas une ressource sur un CDN et d’autres sur un autre.</li><li><strong>Ne mettre dans la balise &lt;head&gt; que les ressources qui sont strictement nécessaires pour afficher le premier rendu de la page<br></strong>Toutes les ressources qui se trouvent dans le &lt;head&gt; sont dites bloquantes. <br>C’est-à-dire que le premier rendu de la page ne se fera qu’après que toutes ces ressources soient chargées. <br>Le plus souvent ce sera la CSS et les fonts qui auront besoin d’être dans votre &lt;head&gt;, car vous en avez besoin pour afficher la page avec le bon rendu graphique.<br>Par contre le javascript peut être chargé en différé et peut être mis dans le &lt;body&gt; en dernière position. Vous pouvez aussi, de manière plus moderne, utiliser l’attribut “defer” ou “async” de la balise &lt;script&gt;.</li></ul><pre>&lt;html&gt;<br>  &lt;head&gt;<br>    &lt;link href=&quot;styles.css&quot; rel=&quot;stylesheet&quot;&gt;<br>  &lt;/head&gt;<br>  &lt;body&gt;<br>    &lt;div&gt;Your page content&lt;/div&gt;<br>    &lt;script src=&quot;main.js&quot; type=&quot;text/javascript&quot;&gt;&lt;/script&gt;<br>  &lt;/body&gt;<br>&lt;/html&gt;<br><br>ou<br><br>&lt;html&gt;<br>  &lt;head&gt;<br>    &lt;link href=&quot;styles.css&quot; rel=&quot;stylesheet&quot;&gt;<br>    &lt;script defer src=&quot;main.js&quot; type=&quot;text/javascript&quot;&gt;&lt;/script&gt;<br>  &lt;/head&gt;<br>  &lt;body&gt;<br>    &lt;div&gt;Your page content&lt;/div&gt;<br>  &lt;/body&gt;<br>&lt;/html&gt;</pre><ul><li><strong>Optimisation des images et du code JS<br></strong>Il est important de compresser au mieux les images que vous utilisez. Il existe des algorithmes de compression plutôt performants pour le web.<br>Utilisez aussi les images correspondant à la résolution de l’utilisateur avec l’attribut “srcset” des images et les “media queries”.<br>Et n’oubliez pas de “minifier” votre code JS.<br><strong>Librairies utiles :</strong><br>- <a href="https://github.com/lovell/sharp">sharp</a> (Node.js) : redimensionne et compresse les images côté serveur.<br>- <a href="https://github.com/imagemin/imagemin">imagemin</a> : compresse les images au moment du build.</li><li><strong>Chargement adaptatif<br></strong>Vous pouvez aller plus loin en adaptant les fonctionnalités, animations ou tout autres parties en tenant compte des contraintes matérielles et réseau spécifiques. <br><a href="https://web.dev/articles/adaptive-loading-cds-2019?hl=fr">Voici un article intéressant sur le chargement adaptatif</a>.</li><li><strong>Lazy loading</strong><br>Le lazy loading consiste à ne charger que ce qui est visible sur la page et charger le reste au fur et à mesure que l’utilisateur navigue et a besoin de voir les éléments.<br>Le plus souvent il s’agit des images car ce sont elles qui prennent le plus de poids. <br>Il existe <a href="https://developer.mozilla.org/fr/docs/Web/HTML/Reference/Elements/img#loading">la propriété native HTML “loading”</a> qui vous permet de mettre en place un lazy loading facilement avec la valeur “lazy”. Mais il existe aussi des librairie JS pour aller plus loin et gérer plus de cas.</li><li><strong>Code splitting<br></strong>Vous pouvez aussi faire du <strong>“code splitting“ </strong>pour le code JS. C’est à dire charger une partie du code JS (d’un composant par exemple) uniquement quand vous l’utilisez. Cela réduira le poids du JS principal pour afficher la première page du site.<br><strong>Exemple d’outils ou librairies (React) :</strong><br>- React.lazy + Suspense : standard natif pour charger les composants à la demande.<br>- <a href="https://github.com/gregberge/loadable-components">loadable-components</a> : plus avancé, compatible SSR.</li><li><strong>Mettre en cache certaines données API<br></strong>Il s’agit de garder en mémoire les réponses des appels API pour éviter de rappeler un même service dont les données ne changent pas souvent.<br>Vous pouvez mettre en place une politique de cache côté client et garder un certains temps ces données en cache pour réduire le nombre des appels API.<br><strong>Exemple de librairies de cache côté client (</strong>React, Solid, Svelte and Vue<strong>) :</strong><br>- <a href="https://tanstack.com/query/latest">TanStack Query</a> : inclut une gestion fine du cache.</li></ul><h3>Les performances de chargement côté serveur</h3><ul><li><strong>Algorithme de compression activé<br></strong>Activez toujours l’algorithme de compression des données (gzip ou autre) sur le serveur, cela réduit beaucoup le poids des données transférées.<br><strong>Exemple de librairies de compression :</strong><br>- <a href="https://github.com/expressjs/compression">compression</a> : middleware Express pour activer gzip facilement.</li><li><strong>Mettre en cache les requêtes http autant que possible<br></strong>De même que côté client, il s’agit de garder en mémoire certaines réponses des appels API pour éviter de rappeler un même service dont les données ne changent pas souvent.<br>Vous pouvez mettre en place une politique de mise en cache côté serveur en plus du cache client et garder un certain temps ces données en cache.</li></ul><h3>Les performances du code JS</h3><p>Il s’agit ici de bonnes pratiques et d’optimisations pour réduire la vitesse d’exécution du code.</p><ul><li><strong>Utiliser le state du composant quand c’est possible au lieu du state global<br></strong>Si vous utilisez redux par exemple (ou un state global à l’application) il est préférable d’éviter de stocker des données qui n’ont pas d’intérêt à être partagées avec le reste de l’application. Utilisez plutôt un “state” dédié à votre composant. Le fait de modifier votre state global peut avoir un coût non négligeable car beaucoup de composants peuvent écouter ce state.<br><strong>Exemple de librairies de gestion d’état (React) :</strong><br>- <a href="https://github.com/pmndrs/zustand">Zustand</a> : très léger et efficace pour un state local ou global.</li><li><strong>Mettre en cache les valeurs et les éléments dom qui ne changent pas pour éviter de re calculer la même chose<br></strong>Il s’agit tout simplement de garder dans une variable une valeur que vous utilisez beaucoup pour éviter de la re-calculer. <br>Exemple : un élément dom, un résultat de calcul.</li></ul><pre>// 1 day en milliseconds<br>export const DAY_IN_MS = 24 * 60 * 60 * 1000;<br><br>// To get the element header with cache<br>const headerElementCached;<br>export const getHeaderElement = () =&gt; {<br>  if(!headerElementCached) {<br>    headerElementCached = document.getElementById(&quot;headerId&quot;)<br>  }<br>  return headerElementCached; <br>}<br></pre><ul><li><strong>Mettre en cache le résultat de certaines requêtes pour éviter de faire un fetch<br></strong>Comme vu plus haut pour les performances de chargement, cacher certaines requêtes a aussi un bénéfice sur la vitesse d’exécution du code. Vous pouvez utiliser des librairies dédiées comme <a href="https://tanstack.com/query/latest">TanStack Query</a>, ou gérer vous-même le cache.</li></ul><p>Exemple avec “localStorage” (attention localStorage et sessionStorage ont une taille limite, 5Mb environ suivant le navigateur) :</p><pre>const HOUR_IN_MS = 60 * 60 * 1000; // 1 hour in milliseconds precalculated<br><br>// Promise return list of videos from an api.<br>// With localstorage cache of 1 hour.<br>const getListVideos = async () =&gt; {<br>  // try to get from localstorage<br>  const cacheObjectString = localStorage.getItem(&quot;getListVideos&quot;);<br>  if(cacheObjectString) {<br>    let cacheObject;<br>    try{<br>       cacheObject = JSON.parse(cacheObjectString);<br>    }catch(error){}<br><br>    // return data if it&#39;s not expired<br>    if(cacheObject &amp;&amp; cacheObject.expire &gt; Date.getTime()) {<br>      return Promise.ressolve(cacheObject.data);<br>    }<br>  }<br>  <br>  // if cache is not returned, we fetch the data<br>  const response = await fetch(url);<br>  if (!response.ok) {<br>    throw new Error(`Response status: ${response.status}`);<br>  }<br><br>  const json = await response.json();<br><br>  // save result data in localstorage<br>  const cacheObject = {<br>    expire: Date.getTime() + HOUR_IN_MS, // cache valid 1 hour<br>    data: json<br>  }<br>  localStorage.setItem(&quot;getListVideos&quot;, JSON.stringify(cacheObject));<br><br>  return json;<br>}</pre><ul><li><strong>Ré-utiliser des instances de composants<br></strong>Il s’agit de créer une seule instance d’un composant et la garder en mémoire pour la ré-utiliser quand on en a besoin.<br>A faire surtout sur les composants qui ont pas mal de choses à initialiser et qui sont utilisés souvent. Exemple : un player.<br>Il peut s’agir aussi d’une longue liste où il serait nécessaire d’afficher et instancier seulement ce qui est affiché à l’écran.<br><strong>Exemple de librairies utiles pour les listes ou composants lourds (React) :</strong><br>- <a href="https://tanstack.com/virtual/latest">TanStack Virtual</a> : rendu performant de grandes listes.</li></ul><h3>Quelques optimisations de code JS</h3><ul><li><strong>Conversion de nombre flottants<br></strong>Au lieu d’utiliser <strong>math.floor</strong>, <strong>math.ceil</strong> et <strong>math.round</strong> pour arrondir, utiliser <strong>“~” </strong>qui est plus rapide<strong> </strong>sur la plupart des navigateurs<strong> (</strong>à tester au cas par cas<strong>) :</strong></li></ul><pre>var testFloor = ~~15.8;<br>var testCeil = -~15.8;<br>console.log(testFloor); // 15<br>console.log(testCeil); // 16</pre><ul><li><strong>Vous pouvez utiliser</strong>length<strong>pour vider un tableau et éviter de créer une nouvelle instance :</strong></li></ul><pre>var array = [1, 2, 3, 4, 5, 6]; <br>array.length = 0; <br>console.log(array.length); // 0 <br>console.log(array); // []</pre><ul><li><strong>Concaténer 2 tableaux</strong><br>Pour concaténer de grands tableaux, utiliser plutôt Array.push.apply(arr1, arr2).<br>Le classique Array.concat()sur de grands tableaux consomme beaucoup de mémoire car<strong> </strong>il crée un nouveau tableau séparé.</li></ul><pre>var array1 = [1, 2, 3]; <br>var array2 = [4, 5, 6]; <br>console.log(Array.push.apply(array1, array2)); // [1,2,3,4,5,6];</pre><ul><li><strong>Obtenir le dernier élément d’un tableau<br></strong>Afin d’éviter d’appeler Array.length , une astuce consiste à utiliser Array.slice :</li></ul><pre>var array = [1, 2, 3, 4, 5, 6]; <br>console.log(array.slice(-1)); // [6] <br>console.log(array.slice(-2)); // [5,6] <br>console.log(array.slice(-3)); // [4,5,6]</pre><ul><li><strong>Boucle sur un tableau<br></strong>Les boucles <strong>for</strong> sont plus rapides que les boucles avec <strong>foreach </strong>ou <strong>map</strong> :</li></ul><pre>instead of <br><br>arr.forEach(function (item) {<br>   someFn(item);<br>})<br><br>Use:<br><br>for (var i = 0, len = arr.length; i &lt; len; i++) {<br>  someFn(arr[i]);<br>}</pre><h3>Pour aller plus loin</h3><p>Il est bien de connaître quelques bonnes pratiques mais le mieux, en matière de performances, est de faire des tests soi-même sur des cas précis.<br>Pour mesurer les performances du code JS, vous pouvez utiliser le débugueur du navigateur. La plupart des navigateurs inclut un outil de mesure de performance (Google Chrome Lighthouse par exemple).</p><p><strong>Outils de test et de benchmark :</strong></p><ul><li>J<a href="https://jsperf.app/latest">sperf.app</a> : pour publier et tester vos snippets JS.</li><li>J<a href="https://jsbench.me/">sbench.me</a> : alternative moderne à jsperf, plus rapide à utiliser.</li><li><a href="https://github.com/GoogleChrome/lighthouse">Lighthouse</a> : outil complet de Google pour tester performance, accessibilité, SEO…</li><li><a href="https://bundlephobia.com/">Bundlephobia</a> : pour connaître le poids réel de vos dépendances npm.</li></ul><p><strong>Sources :</strong></p><ul><li><a href="https://www.webpagetest.org/">Webpagetest</a></li><li><a href="https://jsperf.app/latest">Jsperf</a></li><li><a href="https://www.loginradius.com/blog/engineering/16-javascript-hacks-for-optimization/">Hacks-for-optimization</a></li><li><a href="https://web.dev/articles/adaptive-loading-cds-2019?hl=fr">Le chargement adaptatif</a></li></ul><p>Suivez les actualités d’<strong>ekino</strong> sur <a href="https://www.ekino.fr/">notre site</a> et sur <a href="https://www.linkedin.com/company/ekino">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7932cc0468a3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ekino-france/quelques-bonnes-pratiques-pour-la-performance-web-7932cc0468a3">Quelques bonnes pratiques pour la performance web</a> was originally published in <a href="https://medium.com/ekino-france">ekino-france</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pourquoi transformer les données externes (API, base de données, json) vers nos propres objets JS ?]]></title>
            <link>https://medium.com/ekino-france/pourquoi-transformer-les-donn%C3%A9es-externes-api-base-de-donn%C3%A9es-json-vers-nos-propres-objets-js-32868c30cd3d?source=rss-27c1d2be619b------2</link>
            <guid isPermaLink="false">https://medium.com/p/32868c30cd3d</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[data-modeling]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[typescript-with-react]]></category>
            <dc:creator><![CDATA[Michel Pereira]]></dc:creator>
            <pubDate>Mon, 27 Mar 2023 14:38:48 GMT</pubDate>
            <atom:updated>2023-04-12T16:01:03.427Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pourquoi transformer les données externes (API, base de données, json) vers nos propres objets JS ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BPcneFR_MgLYiymP5X5GWA.png" /><figcaption>Image <a href="https://pixabay.com/fr/service/terms/">Pixabay License</a></figcaption></figure><p>Le but de cet article est de montrer l’intérêt de travailler avec nos propres objets formatés dans notre application JS et pas directement avec la structure des données externes.</p><h3>Introduction</h3><p>A travers les divers projets auxquelles j’ai participé, j’ai pu voir quelques fois que les données API étaient utilisées directement dans le code ou le template HTML, sans traitement préalable dessus. Le projet fonctionne mais cela créer <strong>une dépendance forte à l’API</strong> sur laquelle est branchée l’application. Cette façon de faire peut rendre la maintenance et l’évolution du projet plus compliqué. Si la structure des données de l’<strong>API</strong> change par exemple, les changements à faire peuvent être dispatchés un peu partout dans le code de l’application.</p><p>Ce que j’essaie de pousser sur les projets et que je vous expose ici est d’insérer une couche de traitement relativement simple entre les données reçus de l’<strong>API</strong> et l’application. Nous verrons aussi les autres intérêts que l’on peut en tirer comme “mocker” plus facilement les <strong>API</strong> et commencer à travailler sans connaitre la structure exacte de leurs données.</p><h3>Mise en place à travers un exemple</h3><p>Dans cet exemple, nous allons travailler avec Typescript pour définir nos objets et React pour le rendu visuel. (Je propose une solution équivalente sans typescript un peu plus bas dans l’article).</p><p>L’exemple est simple, on appel une api qui nous renvoi une liste d’objets d’artistes et on affiche cette liste.</p><p>Voici le code :</p><ul><li>un fichier <a href="#">api.ts</a> qui s’occupe d’appeler l’<strong>API</strong> et retourner une promesse avec les données brutes non traités sous forme de json</li></ul><pre>// api.ts<br>export const getArtists = (): Promise&lt;ArtistApi[]&gt; =&gt; {<br>  return fetch(`/artists`).then((response: Response) =&gt; {<br>    return response.json();<br>  }).then((json: { list: ArtistApi[] }) =&gt; {<br>      return json.list;<br>    });<br>}</pre><ul><li>un fichier <a href="#">types.ts</a> qui contient l’interface ArtistApi renvoyé par l&#39;<strong>API</strong></li></ul><pre>// types.ts<br>export interface ArtistApi {<br>  name: string;<br>  last_update_date: string;<br>  informations: {<br>    perso: {<br>      description?: string;<br>      email?: string;<br>    },<br>  },<br>  medias: {<br>    photo1?: string;<br>    photo2?: string;<br>    photo3?: string;<br>  },<br>}</pre><ul><li>un fichier <a href="#">ListArtists.tsx</a> en React pour afficher les données récupérées de l’<strong>API</strong> :</li></ul><pre>// ListArtists.tsx<br>export const ListArtists = (): JSX.Element =&gt; {<br>  const [artists, setArtists] = useState&lt;ArtistApi[]&gt;([]);<br><br>  useEffect(() =&gt; {<br>    api.getArtists().then((list: ArtistApi[]) =&gt; {<br>      setArtists(list);<br>    });<br>  }, []);<br><br>  return (<br>    &lt;ul&gt;<br>      {artists.map((artist) =&gt; &lt;li&gt;<br>        &lt;h2&gt;{artist.name}&lt;/h2&gt;<br>        {artist.informations.perso.description &amp;&amp; &lt;p&gt;{artist.informations.perso.description}&lt;/p&gt;}<br>        {artist.informations.perso.email &amp;&amp; &lt;p&gt;{artist.informations.perso.email}&lt;/p&gt;}<br>        {artist.last_update_date &amp;&amp; &lt;p&gt;{artist.last_update_date}&lt;/p&gt;}<br>        {artist.medias.photo1 &amp;&amp; &lt;img src={artist.medias.photo1} /&gt;}<br>        {artist.medias.photo2 &amp;&amp; &lt;img src={artist.medias.photo2} /&gt;}<br>        {artist.medias.photo3 &amp;&amp; &lt;img src={artist.medias.photo3} /&gt;}<br>      &lt;/li&gt;)}<br>    &lt;/ul&gt;<br>  );<br>}</pre><p>Pour casser cette <strong>forte dépendance</strong>, le principe est de ne pas utiliser le type ArtisteApi en dehors du fichier <a href="#">api.ts</a>. On va créer un autre type correspondant Artist qui lui sera utilisé et partagé dans toute l&#39;application.<br>Avoir notre propre type permet aussi d’avoir un objet propre à manipuler car les données de L’<strong>API</strong> ne respectent pas forcément les règles de nommage du projet et peuvent aussi contenir des données superflus non consommées.</p><p>Voici le nouveau type simplifié :</p><pre>// types.ts<br>export interface Artist {<br>  name: string;<br>  lastUpdateDate: string;<br>  description: string;<br>  email: string;<br>  photos: string[];<br>}</pre><p>Pour bien séparer le code concernant l’<strong>API</strong>, il est préférable de créer un répertoire <strong>api</strong> et d’y mettre tous les fichiers la concernant dedans. On y met <a href="#">api.ts</a> et un fichier <a href="#">types.ts</a> qui contient le type ArtistApi.</p><p>On va créer une nouvelle couche de traitement à l’aide d’un nouveau fichier <a href="#">apiController.ts</a>, qui exporte une méthode <strong>getArtists</strong> (même nom que celle de l’API) et qui appel <strong>getArtists</strong> de <a href="#">api.ts</a>. On transforme les données reçues. Pour cela on utilise la méthode <strong>formatArtist</strong> (qu’on va créer dans un autre fichier) pour transformer le type ArtistApi en type Artist.</p><p>C’est ce controller qui sera maintenant appeler pour récupérer des données de l’<strong>API</strong> :</p><pre>// controller/apiController.ts<br>export const getArtists = (): Promise&lt;Artist[]&gt; =&gt; {<br>  return api.getArtists().then((list: ArtistApi[]) =&gt; {<br>    return list.map((artist: ArtistApi) =&gt; {<br>      return formatArtist(artist);<br>    });<br>  });<br>}</pre><p>On créer un nouveau fichier <a href="#">api/formatters.ts</a> avec la méthode <strong>formatArtist</strong> qui prends en entrer un objet de type ArtistApi et qui retourne un objet de type Artist Cette fonction va nous permettre de transformer l’objet reçu de l’<strong>API</strong> vers notre objet</p><pre>// api/formatters.ts<br>export const formatArtist = (artist: ArtistApi): Artist =&gt; <br>  const photos: string[] = [];<br><br>  artist.medias.photo1 &amp;&amp; photos.push(artist.medias.photo1);<br>  artist.medias.photo2 &amp;&amp; photos.push(artist.medias.photo2);<br>  artist.medias.photo3 &amp;&amp; photos.push(artist.medias.photo3);<br><br>  return {<br>    name: artist.name,<br>    lastUpdateDate: artist.last_update_date,<br>    description: artist.informations.perso.description,<br>    email: artist.informations.perso.email,<br>    photos,<br>  };<br>}</pre><p>Ensuite dans <a href="#">ListArtists.tsx</a> on utilise le controller <a href="#">controller/apiController.ts</a> et le nouveau type Artist :</p><pre>// ListArtists.tsx<br>export const ListArtists = (): JSX.Element =&gt; {<br>  const [artists, setArtists] = useState&lt;Artist[]&gt;([]);<br><br>  useEffect(() =&gt; {<br>    apiController.getArtists().then((list: Artist[]) =&gt; {<br>      setArtists(list);<br>    });<br>  }, []);<br><br>  return (<br>    &lt;ul&gt;<br>      {artists.map((artist) =&gt; &lt;li&gt;<br>        &lt;h2&gt;{artist.name}&lt;/h2&gt;<br>        {artist.lastUpdateDate &amp;&amp; &lt;p&gt;{artist.lastUpdateDate}&lt;/p&gt;}<br>        {artist.description &amp;&amp; &lt;p&gt;{artist.description}&lt;/p&gt;}<br>        {artist.email &amp;&amp; &lt;p&gt;{artist.email}&lt;/p&gt;}<br>        {artist.photos.map((photo) =&gt; &lt;img src={photo} /&gt;)}<br>      &lt;/li&gt;)}<br>    &lt;/ul&gt;<br>  );<br>}</pre><p>De cette manière le travail sur la structure de l’api est limité au fichier <a href="#">controller/apiController.ts</a>, le traitement est centralisé uniquement à un endroit. Par exemple si un jour la structure de l’objet ArtistApi change, il faudra seulement modifier la fonction de formatage <strong>formatArtist</strong>.</p><h3>Exemple sans Typescript</h3><p>Même si Typescript est fortement conseillé, il peut arriver que l’on travail sur un projet assez ancien et sur lequel il n’est pas possible de mettre typescript.<br>Dans ce cas, le code ne change pas beaucoup. Il suffit de retirer les types.<br>Je propose tout de même de rajouter quelque chose pour connaitre la structure des données manipulées par notre application.</p><p>Pour cela je propose d’utiliser les ‘pseudos’ Classes JS. Pour notre type Artist on créer une Classe <a href="#">artist.js</a> qu&#39;on met dans un répertoire model :</p><pre>// model/artist.js<br>export class Artist {<br>  constructor() {<br>    this.name = undefined;<br>    this.lastUpdateDate = undefined;<br>    this.description = undefined;<br>    this.email = undefined;<br>    this.photos = [];<br>  }<br>}</pre><p>Notre fonction de formatageformatArtist de <a href="#">api/formatters.js</a> utilise une instance de Artist pour renv<em>o</em>yer le nouvel objet :</p><pre>// api/formatters.js<br>// @return Instance of Artist (models/artist.js)<br>export const formatArtist = (artistApi) =&gt; {<br>  const artist = new Artist();<br>  artist.name = artistApi.name;<br>  artist.lastUpdateDate = artistApi.last_update_date;<br>  artist.description = artist.informations.perso.description,<br>  artist.email = artist.informations.perso.email,<br><br>  artist.medias.photo1 &amp;&amp; artist.photos.push(artist.medias.photo1);<br>  artist.medias.photo2 &amp;&amp; artist.photos.push(artist.medias.photo2);<br>  artist.medias.photo3 &amp;&amp; artist.photos.push(artist.medias.photo3);<br><br>  return artist;<br>}</pre><p>Ainsi l’application manipule des instances de Artist. On connait la structure des données manipulées partout dans notre application grâce aux Classes dans le répertoire models.</p><h3>Les autres intérêts</h3><p>Outre l’intérêt de centraliser à un seul endroit le traitement des données <strong>API</strong>, un des intérêts est de rendre possible le développement du front sans connaitre exactement quelle sera la structure des données API. Il faudra bien-sur créer vos objets en partant de ce qui doit être affiché et ce dont vous avez besoin.</p><p>Si on reprends notre exemple, imaginons que l’<strong>API</strong> n’est pas disponible et que l’on ne connait pas la structure qu’elle nous renvoi, <a href="#">controller/apiController.ts</a> ressemblera à ça :</p><pre>// controller/apiController.ts<br>export const getArtists = (): Promise&lt;Artist[]&gt; =&gt; {<br>  return new Promise((resolve) =&gt; {<br>    resolve([<br>      {<br>        name: &#39;test&#39;,<br>        lastUpdateDate: &#39;20/02/2022&#39;,<br>        description: &#39;test description1&#39;,<br>        email: &#39;email@test.com&#39;,<br>        photos: [],<br>      },<br>      {<br>        name: &#39;test2&#39;,<br>        lastUpdateDate: &#39;20/02/2022&#39;,<br>        description: &#39;test2 description2&#39;,<br>        email: &#39;email@test.com&#39;,<br>        photos: [&#39;http://testimage&#39;],<br>      }<br>    ]);<br>  });<br>}</pre><p>Cela permet de commencer le développement de l’interface en se basant sur un type définitif Artist. Vous devriez pouvoir déterminer les types à partir des données à afficher et des spécifications. Les appels AJAX et le formatage pourront être ajoutés plus tard. Cela touchera uniquement les fichiers <a href="#">api/api.ts</a> et <a href="#">controller/apiController.ts</a> (avec des ajouts d&#39;autres fichiers pour le formatage et les types de l&#39;<strong>API</strong>).</p><h3>Les inconvénients</h3><p>Les inconvénients sont plutôt limités. Le premier est que cela ajoute un peu plus de code pour le formatage, mais en face le gain est plutôt grand surtout pour des gros projets.</p><p>Le deuxième inconvénient est relatif à certains cas.<br>Si votre application doit réagir en temps réel avec une fréquence élevée.<br>Par exemple votre interface doit se mettre à jour toute les 100ms à partir de données (écoute continue par WebSocket). Dans ce cas il serait peut être préférable de ne pas transformer les données reçues et les exploiter telles quelles pour des raisons de performances, car le formatage peut être plus ou moins couteux.</p><h3>Pour aller plus loin</h3><p>Si vous avez la main sur le développement de la partie serveur qui sert l’<strong>API, </strong>il existe des solutions intéressantes comme <strong>GraphQL </strong>(<a href="https://graphql.org/">https://graphql.org/</a>) qui permet de demander la structure des données que l’on veut et obtenir seulement ce dont on a besoin.</p><figure><img alt="Logo GraphQL" src="https://cdn-images-1.medium.com/max/800/1*VkenI7sOfH6Rlw9qOisyaw.jpeg" /></figure><p>Il y a aussi <strong>tRPC (</strong><a href="https://trpc.io/">https://trpc.io/</a>) avec <strong>ZOD</strong> (<a href="https://zod.dev/">https://zod.dev/</a>) qui aide à “typer“ et formater les données échangées entre le serveur et le client.</p><figure><img alt="Logos tRPC et ZOD" src="https://cdn-images-1.medium.com/max/800/1*cQzZxdNPA9x7LLkyCBQ5_g.jpeg" /></figure><p>Ces solutions permettent aussi de gagner en performance dans les échanges avec l’API.</p><h3>Conclusion</h3><p>Ce qu’il faut retenir :</p><p>- <strong>On diminue notre dépendance à l’API<br></strong>- Permet de manipuler des objets “propres” dans l’application<br>- Permet une <strong>meilleur maintenabilité</strong> dans le temps <br>- Possibilité de <strong>développer notre application sans attendre que l’API soit prête</strong></p><p>J’espère que cet article vous a permis de comprendre l’intérêt de cette pratique et vous aidera à la mettre en place dans vos projets. La structure en exemple n’est qu’une proposition, libre à vous d’organiser le code suivant votre projet, tant que le principe est la.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32868c30cd3d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ekino-france/pourquoi-transformer-les-donn%C3%A9es-externes-api-base-de-donn%C3%A9es-json-vers-nos-propres-objets-js-32868c30cd3d">Pourquoi transformer les données externes (API, base de données, json) vers nos propres objets JS ?</a> was originally published in <a href="https://medium.com/ekino-france">ekino-france</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>