Une discussion sur les modules de nœud est incomplète
sans parler des rappels et de la gestion des erreurs.
Que sont les rappels et pourquoi sont-ils essentiels pour
prendre en charge le calcul asynchrone qui est très
utile lorsque nous écrivons des applications Node.js ?
Comment la gestion des erreurs est-elle effectuée dans les applications Node ?
Parlons brièvement de ceux-ci dans cette conférence.
Avant de continuer à parler des modules de nœud et des rappels,
nous devons comprendre deux caractéristiques saillantes sur le langage JavaScript lui-même.
D' abord et avant tout, JavaScript prend en charge ce qu'on appelle des fonctions de première classe.
Qu' entend-on par fonctions de première classe ?
Est-ce qu'une fonction peut être traitée comme toute autre variable.
Et par conséquent, les fonctions peuvent être transmises en tant que
paramètres à l'intérieur des appels de fonction à d'autres fonctions.
Et cela nous permet essentiellement d'envoyer des fonctions en tant que fonctions de rappel qui peuvent être
appelées à partir d'un autre module Node afin d'obtenir du travail accompli.
Ensuite, regardez comment cela est très utile pour prendre en charge les rappels dans Node.js.
Le deuxième aspect à propos de JavaScript est le support de Fermetures.
Qu' entend-on par Fermetures ?
Surtout, si vous êtes familier avec les langages de programmation fonctionnels,
vous comprenez comment la fermeture fonctionne.
Une fonction définie dans une autre fonction
obtient automatiquement l'accès aux variables qui sont déclarées dans la fonction externe.
Donc, même si la fonction externe est terminée l'exécution,
lorsque la fonction interne s'exécute plus tard, la fonction interne aura toujours accès
aux valeurs des variables dans cette fonction externe.
Et c'est encore une fois,
très efficacement utilisé lorsque nous utilisons des callbacks dans les applications Node.
Si vous êtes habitué à la manière standard d'écrire des applications,
vous êtes familier avec le calcul synchrone où vous
spécifiez un calcul comme un ensemble d'étapes à effectuer l'une après l'autre.
Maintenant, si vous organisez votre calcul comme suit,
comme indiqué sur le côté gauche de la diapositive ici,
nous avons un calcul suivi d'un calcul long,
suivi du calcul 2 et du calcul 3.
Donc, dans cet arrangement,
supposons que le calcul deux dépend
du calcul à long terme qui complète son travail,
alors il est logique que le calcul deux attende que
le calcul à long terme soit terminé avant qu'il ne soit exécuté.
Maintenant, nous pourrions avoir un autre travail à
faire qui est défini par le calcul 3. Le
calcul trois peut ne dépendre en aucun cas du calcul deux,
ou du calcul à long terme à terminer avant qu'il ne soit exécuté.
Donc, dans ce cas,
si nous faisons l'exécution synchrone de ce
calcul, alors le calcul trois sera bloqué,
même si cela ne dépend pas de l'achèvement du calcul deux,
ou du calcul à long terme.
Ainsi, la quantité de travail à faire par le calcul 3,
sera retardée à cause d'aucune raison, n'est-ce pas ?
Au lieu de cela est retardé en raison de quelque chose qui le précède dans la séquence de calcul.
Maintenant, le calcul asynchrone, nous pouvons réorganiser ce travail de
telle sorte que le calcul un, une fois terminé,
puisse engendrer ces calculs longs à faire dans les coulisses indépendamment,
et puisque le calcul 2 dépend du calcul à long terme pour terminer,
alors le calcul deux peut être exécuté lorsque le calcul à long terme est terminé.
Maintenant, cela libère le calcul trois pour continuer,
juste après la fin du calcul un.
Donc, cette façon d'organiser,
garantit que le calcul trois finira beaucoup plus vite que
d'être coincé derrière le calcul à long terme, et le calcul deux.
Donc, cette approche de réorganisation de votre travail est très utile surtout,
lorsque vous avez un calcul à long terme en particulier, le
calcul lié aux E/S à faire.
Donc, dans ce cas, vous pouvez générer le calcul lié aux E/S,
et quand cela se termine,
alors tout ce qui doit être fait par la suite,
peut lui être envoyé en tant que callback.
Donc le calcul deux sera transformé en
un callback et ensuite donné au calcul à long terme.
Donc, quand cela terminera son travail,
alors il rappellera la fonction qui est incluse dans le rappel.
Donc, cela est exploité très efficacement par Node.js pour
réorganiser le calcul au sein de nos applications Node.
Maintenant, c'est très,
très utile lorsque nous regardons la façon dont Node.js fonctionne lui-même.
Donc, comme nous le réalisons,
Node.js est organisé en une seule boucle d'événement thread.
Cette boucle d'événement unique thread en gros,
ramasse les requêtes au fur et à mesure qu'elles entrent et l'exécute l'une après l'autre.
Chaque fois qu'il doit générer une demande d'E/S,
la demande d'E/S sera générée,
et tout travail qui doit être effectué après la fin de la demande d'E/S
sera inclus dans un rappel.
Donc, lorsque la demande d'E/S est terminée,
il mettra le rappel dans la file d'attente de requête,
et le rappel sera géré par la suite,
par la boucle d'événement.
Donc, la boucle d'événement est une boucle en cours d'exécution continue
qui capte essentiellement les demandes de la file d'attente de demandes,
puis les services une à la fois.
Donc, quand vous y pensez,
vous vous rendez compte que Node.js est un seul thread,
mais en même temps,
il est capable d'atteindre un taux d'achèvement beaucoup plus rapide du travail,
simplement en raison de l'utilisation judicieuse des rappels,
et l'exécution asynchrone des requêtes d'E/S,
comme pour le fichier accès ou base de données,
ou un long traitement qui peut être fait indépendamment dans les coulisses.
Maintenant, la façon dont la boucle d'événement Node.js gère tout cela,
est que la boucle d'événement est organisée dans une séquence de phases.
Ainsi, comme vous le voyez dans le diagramme illustré ici, les
phases incluent la gestion du minuteur, la
gestion du rappel d'E/S, puis vous avez inactif, préparer,
puis le sondage où les demandes entrantes de connexions ou de données sont traitées,
puis la phase de vérification,
puis enfin, la phase de rappel de fermeture.
Maintenant, quelques détails sur ce qui est fait dans chacune de ces phases sont listés sur le côté droit.
Dans la phase de temporisation,
la boucle d'événement gère tout ce qui est déclenché par la
fonction setTimeout () en JavaScript.
Les rappels d'E/S sont exécutés,
presque tous les rappels qui reviennent pour être
exécutés après une requête d'E/S seront gérés par la file d'attente de rappels d'E/S.
Ainsi, chacune de ces phases conserve sa propre file d'attente séparée,
et la boucle d'événement Node.js récupère les requêtes de chacune de ces files d'attente et les gère.
Le, inactif, prepare, est destiné à une utilisation interne par Node.js.
Le sondage est l'endroit où il récupère les nouveaux événements d'E/S à traiter et peut-être
les demandes venant de l'extérieur.
La phase de rappel de fermeture gère toutes les fermetures de socket qui doivent être gérées, et ainsi de suite.
Maintenant, nous n'avons pas besoin de trop nous inquiéter de
tous ces détails si nous avons besoin de vraiment écrire une application Node.js.
Lorsque cela est nécessaire, nous examinerons certains de ces détails au fur et à mesure
qu'ils sont essentiels pour comprendre comment fonctionne notre application Node.
Mais pour le moment, cela vous donne une vue d'ensemble
de la façon dont la boucle d'événement Node.js est gérée. Il
suffit de dire que c'est assez d'informations pour nous permettre de
comprendre les applications Node et comment elles fonctionnent pour le moment.
Si vous voulez en savoir plus de détails,
alors je vous ai donné un lien vers une description détaillée dans la
documentation Node.js qui explique la boucle d'événement plus en détail.
Avec cette compréhension rapide de la gestion des nœuds
, des rappels et des erreurs,
nous allons passer à l'exercice,
où nous allons examiner comment une application Node peut écrire avec des rappels,
et comment les erreurs peuvent être traitées dans une application Node.
Nous verrons l'utilisation répétée de ce modèle dans les exercices suivants,
et les leçons ultérieures spécifiquement,
lorsque nous examinons Express,
et comment nous construisons des applications côté serveur
en utilisant Express plus en détail dans la partie ultérieure de ce cours.