Dans l'exercice précédent,
nous avons appris deux nouveaux aspects de JavaScript,
leur prise en charge des fonctions de première classe et des fermetures.
Nous avons également vu comment Node gère l'aspect de programmation asynchrone et comment Node
prend en charge l'exécution asynchrone du code avec
l'utilisation de rappels et aussi la gestion des erreurs.
Regardons un exemple de la façon dont nous utilisons cela
dans notre application Node dans cet exercice.
En continuant avec l'endroit où nous nous sommes arrêté dans l'exercice précédent,
maintenant je vais aller modifier le module de nœud rectangle, de
sorte qu'il puisse prendre l'aide de rappels.
Donc, je vais supprimer ces exportations ici,
et à la place, ils vont modifier cette fonction.
Je vais utiliser ces deux fonctions un peu plus tard,
donc c'est pourquoi je les sauve en bas.
Laisse-moi les garder de côté.
Et puis je vais modifier ce module rectangle comme suit.
Donc, nous allons dire module.exports.
Nous utilisons donc la façon standard de gérer le module.
Et cela va exporter cette fonction qui prend ces trois paramètres,
x et y et callback.
Le rappel est une fonction qui va être fournie lorsque ce module est appelé.
C' est donc l'utilisation des fonctions de première classe dont nous avons parlé plus tôt.
Donc, à l'intérieur de ce rappel,
vous pouvez voir que vous obtenez deux paramètres, x et y.
Dans ce cas, pour
le rectangle, les x et y correspondent à la longueur et à
la largeur du rectangle qui est passé en tant que deux valeurs.
Donc, à l'intérieur, nous allons vérifier
si x est inférieur ou égal à zéro ou y est inférieur ou égal à zéro.
Nous avons écrit un code comme celui-ci ici.
Donc, je vais juste copier ce code d'ici
et puis l'amener ici et puis nous allons éditer.
Donc, dans ce cas, c'est si x est
inférieur ou égal à zéro ou y est inférieur ou égal à zéro.
Dans ce cas, que faisons-nous ?
Dans ce cas, nous remarquons que
les dimensions du rectangle sont inférieures ou égales à zéro.
Donc nous devons gérer ça différemment,
et nous ferons l'autre partie de ça.
L' autre partie où nous gérons la situation où le rectangle est un rectangle valide.
Donc, dans ce cas,
ce que nous allons faire est d'utiliser ensuite un setTimeout.
Donc ici, je simule le fait que tout ce qui
est fait dans ce rectangle va prendre un certain temps.
C' est donc le traitement asynchrone.
Maintenant, puisque je n'ai pas beaucoup de travail à faire en arrière-plan,
donc je vais simuler cela en utilisant simplement
la fonction setTimeout de JavaScript, puis
retarder avant que la fonction de rappel soit appelée.
Donc, la façon dont j'organise ceci est la suivante.
Donc, à l'intérieur du setTimeout,
je vais appeler cette fonction là
et organiser un délai de
2 000 millisecondes ou deux secondes après quoi cette fonction va être appelée.
Donc, si vous vous souvenez,
le setTimeout qui est pris en charge en JavaScript,
il prend comme premier
paramètre une fonction et le second paramètre serait la période pour laquelle cela va être retardé.
Laisse-moi mettre ça en retrait.
Maintenant, je dois remplir cette fonction ici.
J' ai donc commencé avec la fonction flèche ici
qui ne prend pas de paramètres et puis quand il est appelé,
je vais émettre un appel au rappel.
Ce rappel est une fonction de rappel qui
va être passée en tant que troisième paramètre ici.
Cette fonction de rappel, comme vous l'avez remarqué, prend deux paramètres.
Le premier est l'erreur et le second est la valeur de retour.
Donc, dans ce cas, puisque nous avons une erreur,
parce que x est inférieur ou égal à zéro et y est inférieur ou égal à zéro,
donc la première valeur que je vais transmettre en tant que nouvelle erreur,
et cette erreur est exactement cette chaîne que j'utilisais dans le console.log alors,
et c'est ce que je vais passer en tant que l'erreur ici.
Laissez-moi maintenant supprimer ce console.log,
je n'en ai plus besoin.
Donc, pour le rappel,
je vais générer un nouvel objet d'erreur, puis
le passer comme valeur de retour pour la fonction de rappel, le premier paramètre.
Donc, je dirai que les dimensions du rectangle doivent être supérieures à zéro.
Donc, nous allons dire l,
c'est la valeur x et y que nous avons obtenu en tant que valeurs d'entrée là-bas.
Donc, c'est le rappel.
Et la deuxième partie de ce rappel,
je vais passer comme null car cela va renvoyer une erreur.
Ainsi, lorsque vous retournez une erreur en tant que premier paramètre,
le second paramètre sera ignoré lorsque ce rappel vient d'être reçu par
le module de noeud d'où nous appelons cette fonction particulière là.
Donc, avec cet arrangement,
donc moins de zéro,
alors laissez-moi donner un peu d'espace ici pour qu'il soit correctement mis en retrait ici.
Donc, la façon dont j'organise ceci
ici est que si x est inférieur à zéro et y est inférieur
à zéro, je vais rappeler la fonction de rappel qui a été passée,
mais le premier paramètre passera par
erreur car ici nous remarquons qu'il y a une erreur,
et le deuxième paramètre sera nul.
Si ce n'est pas le cas,
alors je vais appeler le même rappel,
mais avec le premier paramètre.
Laisse-moi copier ce code ici.
Je vais toujours utiliser le setTimeout ici.
Mais cette première partie ne sera pas une erreur,
au lieu de cela, la première partie,
dans ce cas, il n'y a pas d'erreur.
Donc, je vais juste passer cette valeur comme nulle.
Cela signifie donc que l'erreur est définie sur null.
C' est donc un rectangle valide.
Nous pouvons donc calculer les valeurs pour le rectangle.
Mais au lieu de cela, je vais simplement passer
un objet JavaScript contenant les deux fonctions
comme les deux valeurs à l'intérieur de cet objet JavaScript.
Donc, ici, je vais prendre ces deux,
le périmètre et la zone,
et ensuite ces deux-là seront passés comme les deux valeurs ici,
périmètre et zone.
Et ces deux-là, puisqu'ils se trouvent être un objet JavaScript,
donc périmètre et zone seront
les deux propriétés que je vais transmettre à l'intérieur de ces objets JavaScript,
et c'est tout.
Donc ici, dans le second cas,
l'erreur est définie sur null car il n'y a pas d'erreur,
mais la deuxième partie,
remarquez que je passe dans un objet JavaScript contenant deux propriétés,
périmètre et zone, qui sont deux fonctions ici.
Donc, les deux fonctions sont la fonction de périmètre et la fonction de zone.
Donc, cet objet JavaScript sera transmis comme
valeur de retour pour le rappel ici, la deuxième valeur.
Et encore une fois, je vais retarder cela d'
un intervalle de deux secondes avant que la valeur ne soit transmise par cette fonction.
La raison pour laquelle j'utilise le setTimeout est de simuler
un délai avant que le rappel ne vienne de l'autre côté.
Donc, ce type de représente les situations où, par exemple,
vous émettez un appel de base de données à la base de données,
et la base de données doit être lue avant que la valeur vous soit transmise.
Cela va prendre un certain temps.
Donc, je simule fondamentalement cela en ce moment en utilisant la fonction setTimeout ici.
Plus tard, vous verrez que lorsque nous intégrons le MongoDB avec
notre Express dans les exercices ultérieurs,
ce délai devra être simulé,
il sera automatiquement causé en raison du fait que vous devez effectuer des
opérations de base de données dans les coulisses avant que les données ne soient obtenues.
Donc ici, après avoir terminé cette mise à jour des modules rectangle,
donc ici vous voyez que le module rectangle prend
trois paramètres car il s'agit d'un appel d'entrée ici,
x, y et callback.
Et donc, le rappel est la fonction de rappel qui est fournie ici.
Et cette fonction de rappel sera appelée ici,
et lorsque la fonction de rappel est appelée,
soit vous remettez une erreur ou vous remettez
une fonction qui vous permet de calculer le périmètre et la zone du rectangle.
Maintenant, ce modèle d'appel et de passage dans une fonction
de rappel à partir d'un module Node puis le second module Node qui, quand il se termine,
transmettra le résultat en utilisant la fonction de rappel est
exactement le modèle que vous verrez souvent répété dans les applications Node.
C' est la raison pour laquelle je l'illustre.
Bien sûr, c'est un exemple artificiel que j'illustre ici mais il montre
tous les modèles standard que vous utiliserez avec les
fonctions de noeud et de rappel et aussi la gestion des erreurs.
Maintenant, nous avons mis à jour le module rectangle ici.
Allons réparer ce fichier index.js afin qu'il puisse passer dans la fonction de rappel
, puis gérer la valeur de retour qui est renvoyée à partir du module rectangle.
Revenir à index.js,
maintenant nous allons mettre à jour le fichier index.js comme suit.
Je vais supprimer ceci du fichier index.js à la place.
Ici, ce que nous allons finir par faire est d'appeler
ce module rectangle
, puis de passer le l et le b comme les deux paramètres.
Et le troisième paramètre que je vais transmettre est cette fonction de rappel.
Ainsi, la fonction de rappel a deux paramètres, err et rectangle.
Et cette fonction de rappel est implémentée comme suit ici.
Donc, ici, vous voyez que j'appelle
ce module de noeud rectangle et je
passe dans la longueur et la largeur des deux premiers paramètres.
Et le troisième paramètre est, bien sûr,
une fonction de rappel que j'implémente ici.
Donc, c'est une fonction de flèche que j'implémente ici.
Donc, à l'intérieur de cette fonction de rappel,
comment puis-je gérer la valeur de retour ?
Donc ici, je vais dire si (err),
donc si la valeur d'erreur vous est retournée,
alors je vais simplement faire console.log et je dirai
« ERREUR » et puis la deuxième valeur est err.message.
Rappelons que dans le rectangle,
nous avions créé ce nouvel objet d'erreur,
puis passé dans cette chaîne à l'intérieur de cet objet d'erreur.
Cette chaîne sera attachée à
l'objet error à la propriété message de l'objet error ici.
Donc, dans le fichier index.js,
donc je récupère la propriété de message de l'objet erreur
, puis l'imprimer sur ma console ici.
Donc, si une erreur se produit,
je vais imprimer le message d'erreur en utilisant ceci.
Et donc, c'est ainsi que je gérerais l'erreur qui a été retournée par une fonction de rappel.
Sinon, bien sûr, dans ce cas,
le module rectangle a renvoyé la fonction rectangle,
l'objet qui contient le périmètre et les fonctions de zone,
donc je peux aller de l'avant et imprimer cette valeur.
Donc, ici, je vais dire la zone du rectangle
de dimensions égal à,
donc je vais dire,
et b égal à.
La raison pour laquelle je l'identifie
explicitement deviendra très claire lorsque nous exécutons cet exemple.
Je dirai que c'est rectangle.zone.
Maintenant, notez que pour cette zone,
je n'envoie aucun paramètre ici parce que va aux valeurs,
la longueur et le souffle ont déjà été passés ici dans le l et b,
et ceux-ci seraient déjà disponibles pour cela
et ici à cause de la fermeture que JavaScript prend en charge.
Parce que ces x et y sont entrés en tant que paramètres,
donc ceux-ci seront accessibles juste là dans cette fonction de rappel.
Donc, ces x_y seront automatiquement disponibles pour nous ici.
Donc, en fait,
je n'ai pas besoin de fournir ces paramètres x et y ici du tout parce que
ces x et y seront récupérés de ces x et y juste là.
Donc je n'ai même pas besoin de passer ces deux valeurs ici.
C' est pourquoi, juste là,
je peux appeler rectangle.area.
Et ce calcul de zone obtiendra automatiquement les l et b qui ont été passés
par l'appel rectangle au module de noeud direct plus tôt.
Donc, c'est la fermeture de JavaScript fonctionnant ici.
Donc, c'est le premier.
Je suis en train d'imprimer la zone du rectangle.
La même chose, laissez-moi aussi imprimer les périmètres.
Donc, pour imprimer les périmètres,
donc je vais dire console.log.
Le périmètre du rectangle sera le périmètre du rectangle.
Maintenant, je dois vous dire que ce genre d'approche d'implémentation nécessite un peu
d'effort pour comprendre et internaliser la capacité de fonction asynchrone.
Il faut un certain temps pour que vous compreniez complètement comment cela fonctionne vraiment.
Maintenant, pour illustrer le fait que
cet appel de fonction entraînera un appel au module Node
mais cette partie ne sera exécutée qu'après
un délai de deux secondes en raison du fait que nous utilisons la marque de temps définie.
Maintenant, comme nous avons étudié en opération asynchrone,
parce que nous avons déplacé le traitement à l'arrière,
permettez-moi également d'introduire un console.log de plus ici pour faire un point.
Donc, nous dirons que cette déclaration est
après l'appel à rect.
La raison pour laquelle j'illustre ce point est que lorsque vous émettez cet appel,
ce code ne sera exécuté qu'après un délai de deux secondes.
Donc, en attendant,
votre fonction, fonction principale ici,
continuera et exécutera la prochaine ligne de code que vous voyez ici.
C' est donc la suite que vous verrez ici.
Donc, avec ces modifications,
sauvegardons les modifications, puis regardons comment cette application s'exécute maintenant.
Donc, sauver les changements.
Allons au terminal et exécutons cette application de nœud.
Maintenant, allez au terminal, ajoutez l'invite.
Laissez-moi taper npm start et vous remarquerez immédiatement
que la résolution et cette déclaration ont été imprimées plus tôt.
Et puis après ce certain délai,
la zone et le périmètre ont été imprimés.
C' est donc un délai de deux secondes que nous avons introduit en utilisant le délai d'attente fixé.
Donc, vous avez remarqué que dans la version précédente,
cela a été imprimé et immédiatement la zone et le périmètre ont été imprimés juste en dessous.
Mais maintenant, notez que ces valeurs sont imprimées un peu plus tard.
Donc, entre les deux, leurs appels de fonction avec les différents paramètres qui sont déjà entrés
, puis les rappels sont rappelés après deux secondes de retard pour chacun d'eux.
Et en raison du fait qu'il y a la fermeture que le JavaScript prend en charge, de
sorte que les valeurs qui sont transmises sont préservées.
Et donc, lorsque la fonction de rappel est appelée,
la valeur appropriée est imprimée.
C' est pourquoi vous voyez que la zone et
le périmètre sont imprimés correctement et ces deux ici,
ces deux déclarations ici,
correspondent à cet appel particulier à diriger
avec l est égal à deux et b est égal à quatre.
Et puis ces deux,
le suivant à deux, bien sûr,
correspondent à celui-ci particulier et à ceux qui restent comme vous le voyez ici.
Donc, ce que je voulais illustrer est le fait que lorsque vous faites un calcul
asynchrone, le calcul asynchrone prend son propre temps
pour retourner la valeur tandis que votre calcul principal va avancer sans attendre que le rappel soit terminé.
Donc, lorsque vous avez besoin de faire une certaine quantité de travail,
vous avez passé en tant que rappel à cet autre module.
Et quand cet autre module termine son travail,
il va rappeler et ensuite ce code sera exécuté.
C' est donc le point que j'ai illustré en utilisant cet exemple.
Encore une fois, comme je l'ai dit,
cela prend un peu d'imagination et de compréhension
pour internaliser la façon dont cela fonctionne,
mais vous verrez cela avec Node et aussi Express et quand nous utilisons MongoDB,
vous verrez ce type de modèle se répéter très souvent dans la façon dont nous écrivons notre code.
Donc, avec cette simple illustration des rappels et de la gestion des erreurs,
nous terminons cet exercice.
C' est un bon moment pour vous de faire un commentaire get avec ce message,
nœud, rappels et la gestion des erreurs.