‫Instructeur : Dans cette vidéo, nous
‫promettons les fonctions de lecture de fichier et d'écriture de fichier.
‫Ce qui signifie que nous allons faire en
‫sorte qu'ils renvoient des
‫promesses au lieu de leur passer une fonction de rappel.
‫Donc, si vous le souhaitez, il s'agit essentiellement d'une fonction de
‫lecture de fichier qui renvoie
‫une promesse et qui ne reçoit qu'un nom de fichier, pas de rappel.
‫Alors faisons exactement cela.
‫Nous allons donc créer une fonction read file pro.
‫Donc pro pour promesse car encore une fois
‫il renvoie une promesse.
‫Et puis tout ce que nous faisons est de
‫transmettre le nom du fichier et, comme nous le disions, de retourner une promesse.
‫Alors, retournez une nouvelle promesse.
‫Nous utilisons donc ici le constructeur de
‫promesse qui a été introduit dans le langage avec ES6.
‫Donc avant ES6 comme ES5, ES4 et toutes
‫les versions précédentes,
‫il n'y avait pas de support pour les promesses en JavaScript.
‫Mais ils ont changé cela dans
‫ES6 et ont beaucoup amélioré le langage à cet égard.
‫Donc concernant JavaScript asynchrone.
‫Maintenant, ce constructeur de promesse
‫prend ici une fonction dite d'exécution, qui
‫sera appelée immédiatement lorsque la promesse sera créée.
‫Et cette fonction prendra deux arguments donc
‫résoudre et rejeter.
‫Alors résolvez et rejetez, mais
‫pour l'instant ne vous inquiétez pas pour eux,
‫nous allons en parler dans une minute.
‫Pour l'instant, concentrons-nous uniquement sur cette fonction d'exécution elle-même,
‫car c'est là que nous effectuons réellement
‫tout ce travail asynchrone.
‫Dans ce cas, le fichier lu fonctionne.
‫C'est donc ici que nous allons appeler fs. readfile avec
‫le nom de fichier qui
‫a été transmis, puis la fonction de rappel habituelle, d'accord.
‫Donc l'erreur et les données, donc
‫comme avant.
‫Gardez donc à l'esprit que
‫nous ne modifions pas réellement la fonction de lecture
‫de fichier, nous créons simplement une
‫nouvelle fonction qui, en coulisse, exécute toujours la fonction de
‫lecture de fichier intégrée, mais renvoie ensuite une promesse
‫afin que nous puissions utiliser
‫la promesse à
‫la place de la fonction de rappel.
‫D'accord.
‫Nous avons donc cette fonction de lecture de
‫fichier ici qui fera son
‫travail et quand elle sera prête, elle reviendra avec les données.
‫Et maintenant, c'est là que les
‫fonctions de résolution et de rejet entrent en jeu.
‫Parce que ces deux arguments qui sont disponibles
‫dans la fonction d'exécution, ils sont tous les deux des fonctions.
‫Maintenant, l'appel de la
‫fonction de résolution marquera la promesse comme réussie donc
‫comme remplie,
‫et renverra la valeur réussie de la promesse.
‫Alors faisons-le en fait.
‫Nous appelons donc résoudre avec des données.
‫Donc, quelle que soit la variable que nous passons dans la
‫fonction de résolution, c'est ce qui
‫sera plus tard disponible comme argument dans la méthode then, d'accord ?
‫Donc, ces données ici seront la
‫valeur que cette promesse nous rendra, d'accord.
‫Cela semble probablement un peu déroutant, non?
‫Encore une fois, tout ce que nous passons dans cette fonction ici,
‫dans la fonction de
‫résolution, est le résultat de
‫la promesse qui sera disponible dans le gestionnaire then.
‫D'un autre côté,
‫nous pouvons également marquer la promesse comme rejetée au cas
‫où il y aurait une erreur, d'accord.
‫Et nous le faisons en
‫appelant, comme vous
‫pouvez probablement le deviner, la fonction de rejet.
‫Donc, s'il y a eu une erreur
‫et que c'est similaire à ce que nous avons fait auparavant.
‫Donc, s'il y a eu
‫une erreur ici, appelez la fonction de rejet.
‫Et tout ce que nous passons
‫dans celui-ci sera l'erreur qui
‫sera ensuite disponible dans la méthode catch.
‫Donc, dans celui-ci ici.
‫D'accord?
‫Passons donc simplement une chaîne ici,
‫je n'ai pas pu trouver ce fichier, quelques emoji ici peut-être
‫pour le faire apparaître un peu plus dans
‫notre console. les journaux, d'accord ?
‫Et, d'accord.
‫C'est en fait déjà ça.
‫Alors, revoyons cela ici.
‫Nous avons donc créé un
‫nouveau fichier, nous y passerons un nom de fichier.
‫Donc cet argument.
‫Et tout ce que nous faisons ici est de rendre cette promesse.
‫Cette promesse comprend une fonction d'exécution, donc
‫celle-ci ici,
‫où nous effectuons notre travail asynchrone.
‫Dans ce cas, bien sûr, c'est notre
‫fs. fichier de lecture.
‫Ensuite, si nous obtenons nos données avec succès, nous
‫appelons la fonction de
‫résolution avec la valeur de résolution.
‫Et s'il y a
‫une erreur, nous appelons la fonction de rejet, d'accord ?
‫Et donc utilisons maintenant cela dans la pratique.
‫Lisez le fichier pro, nous passons
‫notre nom de fichier.
‫Alors c'est celui-ci bien sûr
‫et c'est tout.
‫Donc, cela va maintenant retourner une promesse.
‫Et donc, comme avant,
‫nous pouvons ensuite utiliser notre méthode then sur cela.
‫D'accord et donc cet argument de données ici sera exactement
‫ce que nous avons renvoyé de la promesse au
‫cas où cela aboutirait.
‫Alors, avec cette résolution.
‫Donc, pour le moment, notre
‫fichier de chien contient
‫du labrador et donc ces données ici seront du labrador.
‫Et cela est ensuite disponible plus tard
‫dans notre gestionnaire d'alors ici.
‫Mais bien sûr, il n'a pas besoin d'avoir le même nom, je
‫pourrais aussi l'appeler comme résultat ou quelque
‫chose comme ça n'a pas d'importance, d'accord ?
‫D'accord, prenons maintenant tout cela et
‫mettons-le ici.
‫D'accord.
‫Débarrassez-vous de tout cela, enregistrez-le et cela
‫le fera fonctionner.
‫Maintenant, nous obtenons cette erreur ici, donc
‫les données ne sont pas définies.
‫C'est parce que je l'ai changé ici en résultat.
‫Alors revenons en arrière et changeons-le en données car ici
‫nous avons des données
‫et ici nous
‫avons des données et donc de cette façon,
‫je n'ai pas à changer tous ces noms de variables.
‫Donnez-lui une autre sauvegarde
‫et c'est parti.
‫Donc ça a marché, tu vois ?
‫Nous avons en fait obtenu
‫la race, qui est
‫toujours labrador et cette fois de notre promesse, d'accord.
‫Donc, cela a vraiment fonctionné.
‫Ainsi, notre fonction read file
‫pro renvoie maintenant
‫une promesse et ces données ici sont alors disponibles sur notre gestionnaire d'alors.
‫Génial, donc cela fonctionne déjà
‫et nous pouvons l'améliorer
‫beaucoup et
‫nous allons le faire, mais pour l'instant, je
‫veux aussi promettre cette fonction d'écriture de fichier ici.
‫Donc, en gros, faites la même chose
‫que nous avons fait avec la fonction de lecture de fichier.
‫Maintenant, si vous en savez déjà un
‫peu plus sur no js, vous pensez peut-être qu'il existe en fait un
‫nœud de fonction qui promet automatiquement des fonctions pour nous.
‫Mais bien sûr, je voulais vous montrer
‫ici comment les promesses fonctionnent
‫réellement et comment
‫nous les construisons et c'est pourquoi je fais tout cela ici, d'accord.
‫Je veux donc vraiment que vous en appreniez davantage sur les promesses, non seulement
‫sur la façon dont nous les consommons, mais aussi
‫sur la façon de les construire.
‫Et c'est pourquoi je le fais de cette façon.
‫Alors, écrivez le fichier et comme une promesse.
‫Et celui-ci n'a pas seulement besoin du nom du
‫fichier, mais aussi des données qui doivent être écrites dans ce fichier.
‫Mais alors la logique ici est assez similaire.
‫Encore une fois, nous retournons une nouvelle
‫promesse, là-dedans nous avons notre fonction
‫d'exécution qui prend la résolution et le rejet comme argument.
‫Et ce sont en
‫quelque sorte des noms standard Alors
‫résolvez et rejetez, vous pouvez les appeler comme vous
‫le vouliez vraiment, mais c'est en quelque sorte la norme, d'accord.
‫Donc fs,
‫write
‫file, on passe dans
‫le fichier, les données puis la fonction callback.
‫Et maintenant quelque chose de très similaire à
‫avant, donc s'il
‫y avait une erreur, appelez la fonction de
‫rejet et transmettez-y un message.
‫Impossible d'écrire le fichier,
‫encore une fois avec cet emoji ici pour le faire ressortir
‫un peu plus et au cas où tout
‫fonctionnerait bien, eh bien, résolvez-le.
‫Maintenant, nous n'avons aucune donnée à transmettre ici, n'est-ce pas ?
‫Nous allons donc simplement passer dans une chaîne
‫aléatoire quelque chose comme dire succès, d'accord.
‫Ainsi, une promesse ne
‫doit pas toujours renvoyer une valeur significative.
‫Dans ce cas, tout ce que nous
‫essayons de faire
‫ici est d'écrire un fichier qui ne renvoie pas vraiment de valeur significative.
‫Nous sommes donc maintenant prêts à utiliser cette fonction promise mais
‫avant de
‫faire cela, implémentons réellement le chaînage
‫dont je vous parlais auparavant.
‫Donc pour
‫le moment, nous avons toujours des rappels à l'intérieur des rappels
‫à l'intérieur des rappels, n'est-ce pas ?
‫Nous avons donc
‫ceci, qui a ce rappel.
‫Et puis là-dedans, il y a un autre gestionnaire
‫puis qui a encore un autre rappel dedans.
‫Donc ça ne change vraiment rien, n'est-ce pas ?
‫Au lieu de cela, nous voulons enchaîner ces gestionnaires ici.
‫Et le secret pour y
‫parvenir est de faire en sorte que chaque gestionnaire retourne une nouvelle promesse.
‫Alors comment va-t-on faire ça ?
‫Eh bien, rappelez-vous que cette fonction renvoie ici une promesse.
‫Et donc tout ce que
‫nous avons à faire est de retourner cette promesse de ce gestionnaire d'abord.
‫Laisse-moi te montrer ça.
‫On dit donc retour superagent. obtenir et puis
‫la chaîne et c'est maintenant une promesse, d'accord.
‫Et puis nous fermons en fait cette
‫fonction de rappel ici et enchaînons cette méthode puis directement dessus.
‫Sauvegardez-le, nous avons maintenant une erreur ici et
‫c'est à la ligne 40.
‫Débarrassons-nous de ça ici
‫et d'accord.
‫Cela a encore changé le formatage ici
‫pour nous qui était plus
‫joli et nous l'avons déjà en fait déjà en train de fonctionner ici.
‫Alors pourquoi ça marche à nouveau ?
‫Eh bien, bien sûr, cette fonction que nous
‫avons créée au début renvoie une promesse.
‫Nous pouvons donc utiliser la méthode then.
‫Nous faisons ensuite en sorte que cette fonction de
‫rappel qui s'y trouve renvoie une promesse.
‫Et comme ça, nous
‫pouvons ensuite enchaîner le gestionnaire suivant sur celui-ci.
‫Donc, cette variable de
‫résultat ici sera alors la valeur résolue de
‫cette promesse renvoyée par le gestionnaire précédent, d'accord ?
‫Logique?
‫Maintenant, pour aller plus loin,
‫nous allons
‫également utiliser notre fonction d'écriture de fichier pro ici maintenant.
‫Et puisque nous voulons continuer à enchaîner les méthodes d'alors,
‫nous les renverrons à nouveau en fait.
‫Alors revenez, écrivez file pro pass dans le
‫nom du fichier, qui est celui-ci,
‫les données...
‫Et c'est en fait ça.
‫D'accord, nous n'avons plus besoin de tout cela ici,
‫commentons-le pour le moment.
‫Débarrassez-vous de cet espace
‫ici et là, nous pouvons enchaîner le prochain gestionnaire.
‫Alors, et rappelez-vous qu'ici
‫nous n'avions pas vraiment de valeur résolue significative.
‫Donc, nous ne voulons aucun
‫argument pour cette fonction de rappel ici,
‫tout ce que nous voulons faire est d'enregistrer cette chaîne, n'est-ce pas ?
‫Alors maintenant, nous pouvons vraiment nous en
‫débarrasser et d'accord.
‫Donc, ici, nous voyons
‫maintenant que cela fonctionne déjà.
‫Et encore une fois,
‫l'astuce pour pouvoir enchaîner toutes ces méthodes ici
‫est de retourner une promesse avant d'appeler chacune d'elles.
‫Donc, celui-ci ici renvoie évidemment une promesse ici afin
‫que nous puissions enchaîner la méthode then dessus.
‫Ensuite, ce morceau de
‫code ici renverra
‫une promesse et nous pourrons donc l'utiliser dessus.
‫Ensuite, ce morceau de code
‫renverra une promesse et nous pourrons donc l'utiliser à nouveau, d'accord ?
‫Voilà donc son secret.
‫Donnez-lui à nouveau une
‫sauvegarde et nous voyons ici que la race est toujours labrador.
‫Nous voyons que voici le lien, allons ici
‫et confirmons qu'il s'agit bien ici
‫du même que celui-ci.
‫Et il a donc écrit avec succès la chaîne dans le fichier
‫texte en utilisant notre fonction d'écriture de fichier promis, d'accord.
‫Et puis à la fin, nous avons ce gestionnaire d'erreurs.
‫Et la beauté ici est que pour toutes ces chaînes puis
‫gestionnaires à la
‫fin, nous avons simplement besoin d'un seul gestionnaire de capture.
‫Donc, une fonction gère
‫les erreurs provenant de l'une ou l'autre des trois promesses, d'accord.
‫En fait, enregistrons uniquement l'erreur sur la console
‫et essayons, par exemple,
‫de modifier ce fichier ici.
‫En fait, pas le
‫fichier, mais je vais changer le nom du fichier ici, l'enregistrer
‫et maintenant nous voyons que je n'ai pas pu trouver ce fichier.
‫Alors d'où ça vient ?
‫Cela vient juste
‫d'appeler la fonction de rejet, d'accord ?
‫Nous avons donc une erreur ici car nous n'avons pas pu trouver le
‫fichier et nous avons donc appelé la fonction de rejet.
‫Et cette fonction de rejet marquera alors cette promesse ici, alors
‫souvenez-vous qu'il s'agit d'une promesse.
‫Il le marquera comme rejeté.
‫Et par conséquent, la fonction catch est appelée.
‫Et puis nous enregistrons cette erreur sur la console.
‫Et le résultat est ce que vous pouvez voir ici.
‫Bon, remettons-le maintenant ça
‫marche.
‫Maintenant, allons dans le fichier, créons
‫un chien qui n'existe pas
‫et maintenant, oh, nous avons ici cette grosse erreur étrange et c'est parce
‫que nous enregistrons simplement l'erreur entière et non le
‫message d'erreur comme nous le faisions avant mais ne
‫pas d'importance.
‫Maintenant, sauvez-le ici maintenant, remettez-le
‫en place
‫et tout va bien.
‫Alors maintenant, tout fonctionne et
‫nous nous sommes débarrassés de cette forme
‫triangulaire que nous avions
‫dans notre code et avons maintenant une structure dite plate de promesses en chaîne.
‫Donc, encore une fois, c'est beaucoup
‫plus facile à gérer et j'espère que vous pouvez
‫commencer à l'apprécier et c'est aussi plus logique
‫de penser et de raisonner sur le code comme ça.
‫Maintenant, dans
‫la prochaine conférence, nous irons encore plus loin
‫et le rendrons encore plus lisible
‫et plus facile à utiliser.
‫Alors restez à l'écoute pour cela.