Transcription
1. Les bases du système de modules : aperçu: Bonjour et bienvenue au cours
Express Chairs. Module 2, nœud Système modulaire. Je m'appelle Shevin Agonci. Je suis un développeur
et un instructeur de technologie complète avec des années d'
expérience dans la création d' API évolutives et de systèmes en temps réel Je suis très heureuse d'être votre
professeur pour ce cours. Si vous vous êtes déjà
demandé comment Nojs gère les événements de manière aussi efficace,
cette classe est faite pour vous Cette classe est donc une continuation de la série ExpressJcurs, et vous pouvez également consulter
sa classe précédente intitulée The ExpressJSCurse,
Module one, Module one Dans cette section, nous allons examiner le
système de modules dans Node. Vous découvrirez ce que sont les modules, pourquoi nous en avons besoin
et comment ils fonctionnent. Tout au long de cette section, nous
explorerons plusieurs modules
intégrés au cœur du nœud, tels que le système d'exploitation,
le système de fichiers, les événements et le GTP Vous apprendrez également à créer vos propres
modules et, enfin, appliquer ces compétences pour créer un serveur GTP en direct qui gère les tâches de mise en réseau
dans le monde réel qui s'adresse ce cours ?
Cette classe est conçue pour les développeurs
NerdJS débutants et intermédiaires Si vous connaissez déjà JavaScript et que Nerd Js est installé, vous êtes prêt à commencer Vous ne vous contentez pas
d'apprendre des concepts, vous développez
des compétences pratiques. À la fin de ce cours, vous aurez les outils nécessaires pour
créer des modules réutilisables, comprendre la gestion avancée des
événements et gérer en toute confiance le réseau
NRGS Ces compétences changent la donne
pour les développeurs backend. Enfin, notre
projet pratique inclut la création d'un émetteur d'
événements entièrement fonctionnel doté fonctionnalités
avancées telles que écouteurs
prioritaires
et la gestion des erreurs Ensuite, vous l'
intégrerez dans un serveur NRGs
GDP gérant les requêtes
G et post dynamiques J'ai hâte de voir ce que vous allez
construire avec ces compétences. Commençons, et je vous verrai lors de
la première conférence.
2. Dans Node.js : l'objet global: Dans la dernière section, nous
utilisons cette fonction de
journalisation de la console pour enregistrer
quelque chose sur la console. Maintenant, cet objet de console est
ce que nous appelons un objet global. Cela signifie que cela fait partie
de la portée globale, laquelle nous pouvons accéder
n'importe où dans n'importe quel fichier. Nous avons un tas
d'autres objets, par
exemple, qui sont également disponibles dans
le monde entier dans node. Par exemple, nous
avons défini un délai d'attente, ce que nous avons
probablement déjà vu Nous l'utilisons pour appeler une fonction après un délai de 1 seconde, 2 secondes, etc. Ce n'est donc qu'une partie
du JavaScript standard. Nous pouvons l'utiliser sur le client. Nous pouvons l'utiliser dans
un navigateur ou même dans un nœud. Nous avons également un délai d'attente clair. De même, nous avons défini un intervalle, que nous appelons à plusieurs reprises une
fonction après un délai donné. Nous avons également un intervalle clair, que nous utilisons pour empêcher une fonction
d' être appelée à plusieurs reprises. Il s'agit
des objets globaux en JavaScript. Maintenant, dans node, nous avons quelques autres objets globaux que
vous découvrirez
plus loin dans cette conférence. Dans les navigateurs, nous avons cet objet Window qui
représente notre portée globale. Cela signifie que toutes les variables
et fonctions
définies globalement sont accessibles
via cet objet Window. Nous pouvons appeler window
point console point log ou simplement console point log. Le moteur Java Strip
préfixera cette instruction par Window, car c'est là que
cet objet est défini De même, toutes les fonctions que vous voyez ici appartiennent
à l'objet Window. Nous pouvons donc appeler window point
setTimeout ou l'appeler directement. De même, si
nous déclarons une variable, disons un message, cette variable est également disponible
via l'objet Window. C'est bon. Cependant,
dans la dernière section, je vous ai dit que dans node, nous n'avons pas l'objet Window. Au lieu de cela, nous avons un autre
objet appelé Global. Ainsi, toutes ces fonctions et objets que nous avons ici sont accessibles
via l'objet global. Cela signifie que nous pouvons effectuer un journal des
points global sur une console à points ou un paramètre global Set Time
out, etc. Bien entendu, il est plus facile d'utiliser un raccourci au lieu de le
préfixer par global. Mais une chose que vous devez
savoir à propos de node est que les variables que nous définissons ici ne sont pas ajoutées à
l'objet global. En d'autres termes, si nous établissons un journal par points de console contenant un message point
global, nous verrons apparaître un message non défini sur la console. Laisse-moi te montrer. Ouvrez maintenant le shell ou le terminal
et exécutez node app point js. Tu vois, on devient indéfinis. Comme vous pouvez le constater, les variables et les fonctions que
nous définissons ici ne
sont pas ajoutées à
l'objet global. Ils ne concernent que ce
fichier, app Js, et cela est dû
au système de modules nodaux que vous allez
découvrir dans la prochaine conférence
3. Modularisation dans Node.js : une approche modulaire: la dernière section, vous
avez appris que dans le JavaScript côté lien que
nous exécutons dans un navigateur, lorsque vous déclarez une
variable ou une fonction, elle est ajoutée à la portée globale. Par exemple, lorsque nous définissons
une fonction telle
que say hello, cette fonction est ajoutée
à la portée globale et elle est disponible via
l'objet window. Ce comportement présente
un problème. Dans une application du monde réel, nous divisons souvent notre
code Java en plusieurs fichiers. Il est donc possible que
nous ayons deux fichiers, et dans les deux fichiers, nous définissions cette fonction, disons bonjour avec le nom exact. Comme cette fonction est
ajoutée à la portée globale, lorsque nous la définissons dans un autre fichier,
cette nouvelle définition
remplacera la définition
précédente, ce qui pose un problème
de portée globale Afin de créer des applications fiables
et maintenables, nous devons éviter de définir variables et des fonctions
dans une portée globale Nous avons plutôt besoin de modularité. Nous devons créer de petits blocs de
construction ou modules dans lesquels nous définissons nos
variables et nos fonctions. Cela signifie que si vous
définissez une variable ou une fonction avec le nom exact dans différents fichiers ou modules, ils ne
se remplaceront pas car ils sont encapsulés dans
leurs modules respectifs Maintenant, au cœur du nœud, nous avons ce concept
appelé module. Ainsi, chaque fichier d' une application de nœud est
considéré comme un module. Les variables et les fonctions
que nous définissons dans ce fichier ou ce module s'appliquent à ce fichier
en particulier. En termes de
programmation orientée objet, nous disons qu'ils sont privés. Ils ne sont pas disponibles en dehors du conteneur ou
de ce module. Si vous souhaitez utiliser une variable ou fonction dans un module
extérieur à ce module, vous devez l'exporter
explicitement et la rendre publique. Et nous allons examiner
cela dans la prochaine conférence. Ce que je veux que vous
retiriez de cette conférence, c'est que chaque application de nœud possède au moins un fichier ou un module, que nous
appelons le module principal. Donc, dans ce cas, cette application
Js est notre module principal. Maintenant, je vais
vous montrer ce module. Je vais supprimer
tout ce code ici et
créer un journal à points du module dans la console. Cet objet de module
peut sembler global et vous pensez peut-être que nous
pouvons y accéder via objet
global tel que la console à points
globale. Mais il ne s'agit pas d'un objet global. Cela semble être mondial, mais ce n'est pas le cas et vous
découvrirez pourquoi très bientôt. Voyons la console de connexion. Ouvrez à nouveau votre terminal, node app point JS. Comme vous pouvez le constater, nous
avons un module objet. C'est un objet adjacent avec
ces paires clé-valeur. Nous avons donc une pièce d'identité. Chaque module possède un identifiant ou un identifiant unique. Nous avons les exportations, le chemin, le nom du fichier, le chargement, le taux de
désabonnement et les PAT Pour l'instant, ne vous
inquiétez pas pour ces propriétés. Au fur et à mesure que nous parcourrons cette section, vous vous
familiariserez progressivement avec ces propriétés. Ainsi, dans node, chaque
fichier est un module et les variables et
fonctions définies dans ce fichier sont limitées
à ce module Ils ne sont pas disponibles
en dehors de ce module. Dans la prochaine conférence,
nous allons
apprendre à créer
et à charger un module.
4. Créer un module Node.js personnalisé: C'est bon. Ajoutons maintenant un nouveau module à
cette application. Je vais donc créer un
nouveau fichier, logger point js. Supposons que nous
allons créer un nouveau module pour
enregistrer les messages, et que nous allons utiliser ce
module dans différentes parties de cette application ou potentiellement
dans d'autres applications. Donc, les bûcherons nous ont attaqués. Maintenant, dans ce module,
supposons que nous
allons utiliser l'un de
ces services de journalisation à distance
pour enregistrer nos messages. Il existe donc des sites Web
qui proposent la
journalisation en tant que service. Ils nous fournissent une URL,
et nous pouvons envoyer une requête TDP à cette URL pour
enregistrer les messages dans le cloud Donc, ici, je vais
déclarer une variable comme l'URL et la définir sur
quelque chose comme ça. HTTP suo over point slash log. Et bien sûr, j'invente que ce n'est peut-être pas un vrai
service, mais imaginons que lors de
sa mise en œuvre, nous allons envoyer une
requête HTTP à ce point de terminaison. Maintenant, nous avons également besoin d'une fonction appelée Milob qui prend les messages Et dans cette fonction, nous
allons envoyer une requête HTTP. Cependant, pour simplifier les choses, nous voulons simplement nous
concentrer sur la modularité Nous ne voulons pas nous laisser
distraire de
tous les détails de l'
envoi d'une demande HGTV Donc pour l'instant, je veux juste
enregistrer ce message sur la console, donc
message de journalisation par points de la console, d'accord ? Maintenant, cette variable
et cette fonction, Milog, sont toutes deux incluses dans ce
module. Ils sont privés. Ils ne sont pas visibles
de l'extérieur. Cependant, dans l'application Js, qui est notre module principal, nous voulons utiliser ce module
d'enregistrement Nous devrions donc pouvoir
accéder à cette fonction Milog. Nous devrions pouvoir l'appeler depuis
le module de l'application. Nous devons donc le rendre public. Nous devons le rendre
visible de l'extérieur. Dans la dernière conférence, vous avez vu cet objet de module. L'une des propriétés
ici est l'exportation. Vous pouvez voir que cette propriété
est définie sur un objet vide. Tout ce que nous ajouterons à cet
objet sera exporté depuis ce module et sera disponible
en dehors de ce module. Donc, de retour dans notre module logger, je vais définir le module
dot exports dot log J'ajoute donc une
méthode pour rock à cet objet d'exportation et je le définis simplement sur cette fonction
MLOPFunction, OK ? En d'autres termes, l'objet que nous exportons ici n'a qu'une seule méthode, log. De même, si vous
souhaitez exporter cette URL, nous pourrions faire quelque chose comme ce module dot exports dot URL. Nous avons défini ce paramètre sur URL. Et bien sûr, nous pouvons changer le nom qui est
exporté vers l'extérieur. Par exemple, en interne,
nous appelons cette variable URL, mais lorsque nous l'exportons, nous pouvons l'appeler endpoint. OK ? Dans ce cas, nous n'avons pas besoin d'exporter
cette variable d' URL car il s'agit uniquement d'un détail d'
implémentation. Ainsi, dans les applications du monde réel, chaque module peut avoir plusieurs
variables et fonctions. Nous voulons uniquement exporter un
sous-ensemble de ces membres vers l'extérieur, car nous
voulons que ce module reste facile à utiliser Permettez-moi de vous donner une métaphore.
Pensez à un ordinateur portable. Un ordinateur portable possède un écran et
un clavier à l'extérieur, et ce sont les boutons ou les objets avec lesquels nous interagissons Ces objets représentent donc l'interface publique
d'un ordinateur portable, n'est-ce pas ? Mais à l'intérieur de l'ordinateur portable, il y a beaucoup
d'autres objets. Nous n'avons pas besoin de savoir
quoi que ce soit à propos de ces objets. Ce sont des
détails de mise en œuvre et ils peuvent changer de
manière significative d'
un modèle à l'autre. Mais ce que nous voyons
à l'extérieur est presque stable ou statique
selon les modèles. Ainsi, dans notre module logger, cette URL est le détail de l'
implémentation Les autres modules n'ont pas besoin
de savoir quoi que ce soit à ce sujet. Il leur suffit d'appeler
la fonction log. Nous l'exportons donc, le rendons public et gardons l'URL privée. Je vais donc supprimer
cette dernière ligne, d'accord ? Nous en avons donc terminé avec
notre module d'enregistrement. Nous devons maintenant charger ce module et l'utiliser dans app point JS.
5. Chargement de modules dans Node.js: Pour charger un module, nous utilisons
la fonction requise. C'est l'une des
fonctions du nœud. Nous ne l'avons pas dans les navigateurs. Cette fonction prend
un argument, qui est le nom ou le chemin du module cible que
nous voulons charger. Nous voulons donc charger ici
le module logger. Vous pouvez maintenant voir que le module d'application et le
module d'enregistrement se trouvent dans le même dossier Nous utilisons donc une barre oblique pour
indiquer le dossier en cours, puis nous ajoutons le nom de notre module qui
est logger point js Ou nous pouvons le raccourcir
et simplement utiliser logger car le nœud suppose qu'il
s'agit d'un fichier Ja Scrap, et il
ajoute automatiquement l'extension Js Maintenant, si cet enregistreur
se trouve dans un sous-dossier, nous pouvons ajouter ce
sous-dossier ici, ou s'il se trouve dans
le dossier parent, nous pouvons utiliser une barre oblique. Nous utilisons donc ici le chemin relatif vers
le module cible. Dans ce cas, ce module
se trouve dans le même dossier. Maintenant, cette
fonction obligatoire renvoie l'objet exporté
depuis ce module cible. Donc, cela exporte l'objet ici, c'est
ce que nous obtenons lorsque nous appelons la fonction requise.
Laisse-moi te montrer. Je vais donc déclarer une
variable, l'appeler logger, le nom du module, et lui
attribuer la valeur
de retour de la fonction requise Maintenant, adorons cet enregistreur
et voyons ce que nous allons obtenir. Donc, aucune application ne nous indique. Regardez, nous avons trouvé un objet. Cet objet possède une seule
méthode appelée log. Vous pouvez voir que c'est une fonction. Nous pouvons donc appeler cette fonction pour cette méthode dans l'application qui est Js. Donc, de retour ici, nous
appelons Logger Dot. Et regardez, ici, nous avons de
l'intelligence dans le code VS, alors nous appelons Log et lui faisons
passer un message. Maintenant, de retour dans le terminal, nous recevons un message
sur la console. C'est ainsi que nous travaillons
avec les modules dans node. Lorsque nous définissons un module, nous exportons un ou plusieurs membres, puis pour charger le module, nous utilisons la fonction requise. Désormais, dans les
versions récentes de JavaScript, il est possible
de définir des constantes. est donc préférable de stocker le résultat
dans une constante comme
celle-ci
lors du chargement d'un module . La raison en est
que nous ne voulons pas remplacer accidentellement la valeur
de logger comme celle-ci ici Si nous le définissons sur un,
nous appelons la méthode log. Nous allons avoir une
exception. Laisse-moi te montrer. Donc encore une fois. Écoutez, nous avons un enregistreur qui indique que le journal n'
est pas une fonction. Maintenant, en revanche, disons que
nous définissons cela comme une constante. Donc, de retour dans le terminal, relançons ce programme
une fois de plus. Écoutez, nous avons un autre
type d'erreur, l' assignation à une variable constante. Maintenant, il existe des outils
qui vérifient notre code JavaScript
pour détecter de telles erreurs. Ainsi, en utilisant correctement ces
constructions, nous pouvons empêcher ces erreurs
de se produire lors de l'exécution Et l'un de ces outils
populaires est Jent. Si vous ne l'avez jamais
utilisé auparavant, ne vous inquiétez pas. Je vais juste
vous montrer une démonstration rapide. Donc, si vous exécutez Jsent app point JS nous obtenons cette erreur en tentant de remplacer le logger,
qui est Ainsi, avec des outils tels que JSN, nous pouvons scanner notre
code JavaScript pour détecter de telles erreurs Et c'est l'avantage d'utiliser une constante par opposition
à une variable ici. Si nous
réinitialisons accidentellement cet objet, nous allons
avoir une erreur au moment compilation plutôt qu'au moment
de l'exécution, d'accord ? Et une dernière chose avant
de terminer cette conférence. Parfois, au lieu d'exporter
un objet depuis un module, vous souhaiterez
n'exporter qu'une seule fonction. Par exemple, dans
notre module logger, nous n'avons pas nécessairement
besoin d'un objet car nous n'avons qu'une seule méthode Un objet serait utile si nous avions plusieurs méthodes
ou propriétés ici. Mais dans ce cas, au lieu
d'exporter un objet, nous pouvons exporter une seule fonction. Nous pouvons donc réinitialiser ces exportations
sur la fonction de journalisation. Au départ, c'était
un objet vide, mais nous l'avons redéfini
comme un fenton Avec cela, de retour dans app ou Js, logger n'est plus un objet C'est une fonction que nous pouvons
appeler directement comme ceci. Logger s'en souvient donc
et argumente. Maintenant, un meilleur nom pour
cette fonction est log. Je vais donc appuyer sur F deux
pour renommer ce journal comme ceci. Maintenant, revenons à Termino,
lançons node app Js et nous obtenons le même résultat Ainsi, dans vos modules, vous pouvez exporter une seule
fonction ou un objet.
6. Naviguer dans les chemins dans Node.js: Dans les conférences précédentes, je vous ai dit que dans node, nous avons des modules utiles
intégrés au cœur de node. Avec ces modules, nous
pouvons travailler avec les fichiers, avec le système d'exploitation, avec le réseau, etc. Jetons donc un coup d'
œil à ce module. Rendez-vous sur nods.org, puis cliquez sur DCS Sur le côté gauche, vous pouvez voir la dernière version stable, qui est 18.16 0.1 au
moment de l'enregistrement de cette vidéo Au moment où vous
regarderez cette vidéo, il est possible qu'elle soit mise à niveau vers une version plus récente, même si cela n'a pas d'
importance, alors cliquez dessus. Vous pouvez voir ici
une liste d'articles. Maintenant, il s'agit d'une
documentation sur les nœuds. Il n'est pas nécessaire que tous les éléments présentés
ici soient des modules. Certains d'entre eux sont également des objets tels que cet objet de console
ou cet objet de mémoire tampon, qui est également un objet global, et nous en apprendrons davantage à
ce sujet dans les prochaines vidéos. Cependant, il s'agit d'une liste
assez courte. Maintenant, permettez-moi de vous donner
un bref aperçu des modules que nous
allons apprendre. Tout d'abord, nous avons le système de fichiers, qui est un
module très utile pour travailler avec des fichiers. Un autre est le module SGTB, qui est très utile
pour créer des services pour la mise en réseau et
pour les requêtes HTP Faites défiler la page vers le bas et vous
trouverez le module OS
, très utile pour travailler
avec le système d'exploitation. Ensuite, nous avons le module path, qui propose un tas
de méthodes utiles pour travailler avec différents indicateurs. Ensuite, nous avons le module de processus grâce auquel nous
connaîtrons le processus en cours. Nous avons des chaînes de requête, ce qui est très utile lorsque
vous travaillez avec SgtbrQuest, puis nous avons
le module stream, qui est utile pour
travailler avec les flux de données et un tas
d'autres Dans cette conférence,
nous allons donc examiner ce module de chemin. Cliquez dessus. Comme vous pouvez le
voir dans la documentation , différentes
fonctions sont définies ici. Dans cette conférence, je vais utiliser la méthode
d'analyse syntaxique. Si vous faites défiler la page vers le bas, vous verrez comment utiliser
ce module de chemin. Ici, nous avons la
fonction requise que nous avons vue auparavant, et elle prend un argument, qui est le module path. Il dit nœud, puis
il est défini comme chemin. Ensuite, nous le stockons dans une
constante du chemin de l'objet. Je vais donc simplement le copier et
le retourner à VSCO. Dans l'application JS, je vais juste mettre la ligne en page
et elle est prête à être utilisée. Nous pouvons donc utiliser Path point ps
et cela prend un argument. Je vais donc écrire, souligner, souligner,
souligner le nom du fichier. C'est un argument que vous pouvez voir dans la fonction
wrapper du module, mais nous en reparlerons plus tard Je vais donc le stocker dans une constante
et l'appeler path object. Ensuite, nous allons simplement l'
enregistrer sur la console. Objet Path. Sauvegardez-le. Revenons maintenant au terminal. Dans le terminal, nous allons
simplement exécuter le code, node app point js. Et nous pouvons voir que nous
avons un objet avec un tas d'éléments tels que root, DIR, qui est le chemin complet
vers le dossier
contenant le fichier. Ensuite, nous avons l'application de
base point js, l'extension et
le nom du fichier. Dans la prochaine conférence, nous allons découvrir le module du système
d'exploitation.
7. Interfacage avec le système d'exploitation : module d'OS Node.js: Dans cette conférence, je
vais vous montrer comment obtenir des informations sur le système d'exploitation actuel. Revenez à la
documentation du nœud, faites défiler la page vers le bas et vous verrez le module du système
d'exploitation. Ici, cliquez dessus, et vous verrez les méthodes
définies dans ce module, comme nous avons libre MM pour obtenir la
mémoire libre de notre système. Nous avons également le nombre total
de MM pour obtenir la
mémoire totale du système. Nous pouvons également trouver
des informations sur les utilisateurs, ainsi que sur
le temps de disponibilité, etc. Alors faites défiler la page vers le bas, et vous
verrez comment utiliser ce module
comme n'importe quel autre module. Nous avons donc la fonction
requise. Nous allons définir le système d'exploitation du nœud ici et le stocker
dans un système d'exploitation constant. Je vais donc simplement le copier
et revenir au code du système d'exploitation. Ici, laissez-moi supprimer tout le code et simplement le coller ici. Le module du système d'exploitation est donc prêt à être utilisé. Je vais utiliser s
point fremm pour obtenir la mémoire libre de mon système et Total Mm pour obtenir la mémoire
totale de mon Et je vais
rapidement les stocker dans une mémoire totale variable. Et contre la mémoire libre. Il suffit maintenant de
les enregistrer sur la console. Donc, décalage de points sur la console, mémoire
totale et
ajoutez simplement la
variable de mémoire totale ici C'est ça. Mais il existe une
meilleure façon de procéder. Nous pouvons utiliser la fonctionnalité de modèle
littéral d'ECMAScript. Donc, pour ceux qui ne le savent pas, ECMAScript est une spécification
utilisée pour Chaque année, de nouvelles fonctionnalités sont
ajoutées à JavaScript, et elles sont
maintenues par ECMAScript Cette fonctionnalité
littérale du modèle est donc disponible dans les spécifications ES six ou
Abo Et la dernière version d'
ECMAScript est ES 14 ou ES 2023. Laissez-moi vous montrer comment
utiliser le modèle littéral. Donc, enregistrez les points de la console, et au lieu de guillemets simples, nous utiliserons le caractère BTI Vous trouverez le caractère BTI juste en dessous du
bouton d'échappement de votre clavier Ajoutons donc du
texte statique ici, comme Mémoire totale. Et je veux ajouter
quelque chose de manière dynamique. Je vais donc utiliser le signe du dollar
suivi de bretelles bouclées. Et à l'intérieur de cela, il
faut un argument. Dans ce cas, l'
argument est notre variable, qui est la mémoire totale. Ainsi,
vous n'avez pas besoin concaténer la variable
avec le texte statique Je vais donc simplement le copier et changer la
mémoire totale en mémoire re. Ici aussi, je vais changer
la variable en re memory. Maintenant, sauvegardons-le et
vérifions-le rapidement sur le terminal. Avant cela, nous n'avons pas
besoin de cette première console. Je vais donc simplement le
recommander au terminal, et exécutons le code L'application Node nous a contacté. Comme vous pouvez le voir, la
mémoire totale et la mémoire libre de mon système sont affichées ici. Ce qui est intéressant ici,
c'est qu'avant node, nous ne pouvions pas utiliser JavaScript pour trouver ce type
d'informations. Après le nœud, il est
assez simple d'utiliser le module OS et les autres modules
intégrés du nœud. Par exemple, nous pouvons créer un serveur Web qui gérera le
SDTPRQuest sur un port, et je vais vous montrer tout
cela plus loin
8. Manipuler le système de fichiers avec Node.js: Dans cette conférence,
je vais
vous montrer comment travailler
avec des fichiers dans node. Faites défiler la page vers le bas et vous verrez
le module du système de fichiers ici. Cliquez dessus.
Ici, sur cette page, vous verrez un ensemble
complet de méthodes pour travailler avec des fichiers. Cependant, je ne vais pas vous faire perdre votre temps et vous montrer
chacune des méthodes. Je vais plutôt
vous montrer un exemple d' opération particulière
qui consiste à lire le répertoire de différentes manières pour effectuer cette opération. Passons donc au système
de fichiers ici. Nous avons donc deux manières différentes d'utiliser un module de système de fichiers, que nous examinerons sous peu. Avant cela, laissez-moi vous montrer deux syntaxes différentes que nous pouvons utiliser pour charger
le module FS Vous pouvez soit utiliser la fonctionnalité
d'importation des modules ESX, soit simplement utiliser la syntaxe
JavaScript courante, qui utilise la fonction requise où vous devez
fournir l'espace de noms node fs Promises
ou simplement le nœud FS Et tout ce que vous avez à faire est le
stocker dans une
constante appelée FS. Quoi qu'il en soit, vous
allez utiliser ou charger
le module FS,
le module de système de fichiers. Voyons maintenant la différence fondamentale entre les API basées sur
les promesses, les API rappel et les API
synchrones. opérations du système de fichiers peuvent donc être effectuées de manière synchrone
et asynchrone De plus, les
opérations asynchrones peuvent être effectuées à l'aide de l'API de rappel
ou de l'API basée sur les promesses Toutes les opérations
sont accessibles en utilisant à la fois la
syntaxe JavaScript commune et les six modules ES. Maintenant, voyons
la différence fondamentale entre toutes ces API. Les API synchrones exécutent toutes les
opérations de manière synchrone, bloquant la boucle d'événements jusqu'à ce que l'opération soit
terminée ou échoue Donc, comme je vous l'ai déjà dit, il ne s'agit pas d'une opération
mono-thread. Il n'exécute autre demande tant que l' opération en
cours n'est pas
terminée ou n'a pas échoué. Passons aux API de rappel. Ces API exécutent
toutes les opérations manière asynchrone sans
bloquer la boucle d'événements Invoquez ensuite une
fonction de rappel en cas de fin ou d'erreur. Cela signifie que les
opérations asynchrones peuvent être effectuées en utilisant
le thread unique car il n'est pas bloquant. Vous souvenez-vous donc de l'exemple du restaurant
que je vous ai donné ? Un serveur peut prendre la commande et la
rendre à la cuisine Ensuite, prenez la commande d' une autre table et
retournez dans la cuisine. De cette façon, nous pouvons servir le plus
grand nombre de clients possible. Enfin, nous
avons l'API Promises. Cela fournit des méthodes de système de
fichiers asynchrones qui renvoient C'est donc quelque chose qui est
ajouté à la version dix du nœud. Avant cela, toutes les opérations
asynchrones étaient effectuées à l'aide de
l'API de rappel Enfin, comme je vous l'ai déjà dit, les API basées sur le rappel et les API basées sur les
promesses utilisent le pool de
threads de nœuds sous-jacent pour effectuer opérations du système de
fichiers sur
le thread de boucle d'événements Examinons maintenant l'exemple
utilisant l'API promises, l'API rappel et
l'API synchrone. Tout d'abord, laissez-moi vous
montrer un exemple d' opération synchrone utilisant la syntaxe JavaScript courante Nous chargeons donc le module FS en utilisant la
fonction requise comme celle-ci. Une fois la fonction chargée, nous pouvons accéder à la synchronisation du
dir de lecture à partir d'ici. Nous allons maintenant devoir
mentionner le chemin ici, donc barre oblique car nous examinons le répertoire en
cours Maintenant, permettez-moi de l'enregistrer dans
un fichier d'appel constant. Il ne nous reste plus qu'à enregistrer les fichiers sur la console. Donc, les fichiers Dot Log de la console. Ici, l'
opération synchrone sera terminée, mais laissez-moi encapsuler tout le code ici dans
l'instruction trikt Essayez donc d'obtenir les fichiers
ici et de gérer l'erreur, quelque chose comme ceci, erreur de journalisation des
points de la console, erreur C. Cependant, ce n'est pas le moyen
idéal pour gérer une erreur, mais ce sera le cas pour le moment. Nous pouvons également rectifier le
code un peu plus comme ceci pour le fichier const de fichiers J'utilise donc les quatre boucles pour me
connecter à un fichier individuel
des fichiers du tableau. Sauvegardez-le et
emballez-le dans le terminal. Exécutez node app point JS. Vous pouvez donc
voir ici tous les fichiers que nous avons dans le dossier
actuel. Vérifiez cela d'ici : modules
Nord, app point js, logy point js, package lag
point JCN, package point JSN Et là, tout de même. Retour au code ES. Permettez-moi maintenant de vous montrer les exemples
asynchrones utilisant les modules ESX Je vais donc supprimer
tout cela d'ici. Avant cela, laissez-moi vous dire
que pour utiliser les modules ESX, vous devez déclarer leur type
dans le package point JSNFle Vous devez donc vous
rendre sur Packs point Jason et déclarer le type en tant que module. N'oubliez donc pas qu'une fois que vous aurez
déclaré le type en tant que module, vous ne pourrez pas
utiliser la fonction requise. Une fois déclaré, vous ne
pourrez utiliser que les six modes ES. Je vais donc fermer ceci et ne pas oublier de charger
les six modules ES, nous utiliserons Import. Importez astric en tant que FS depuis la colonne de
nœuds FS. C'est ça. Pour utiliser l'
API de rappel, nous utiliserons Fsrddr. Il va falloir inclure
le chemin ici, point final. Et maintenant, le deuxième argument
sera une fonction de rappel. Donc, maintenant, la fonction de rappel
prendra deux paramètres. Tout d'abord, l'erreur et
deuxièmement, les fichiers. J'utilise donc la fonction
flèche ici, ERR pour erreur puis fichiers, et cela passe à un bloc de code. Nous allons utiliser la déclaration
IL ici. Donc, en cas d'erreur ER, vous devrez le
connecter à la console. Donc erreur, colonne ErreLse vous pouvez simplement
enregistrer les fichiers comme ceci Voyons donc ce qui se passe. Sauvegardez-le et
retournez au terminal. Courez un signe de tête à Js. Donc, comme vous pouvez le voir,
le tableau de fichiers, qui inclut le
nom des fichiers. Maintenant, revenons au code VS, nous pouvons également rectifier le
code comme nous l'avons fait précédemment Nous allons donc
réutiliser la boucle à quatre pour le fichier const des fichiers Et au lieu de fichiers, ce devrait être un fichier. Revenez au terminal, node app point js. C, même résultat. Déclenchez ceci et
revenez au code VS, et laissez-moi vous montrer
le dernier
exemple de l'API Promises. Pour utiliser l'API promises, nous devons utiliser slash
Promises ici Désormais, l'API Promises possède les méthodes du système de fichiers
qui renvoient les promesses. Donc, comme vous le savez, si vous connaissez le JavaScript
asynchrone, si vous renvoyez une promesse, vous
devez décorer
la fonction avec await Permettez-moi donc d'
écrire rapidement « wait here ». Dans ce cas, vous n'êtes pas obligé d'utiliser
la fonction Callbek ici. Je vais donc le déplacer
ici et c'est tout. Maintenant, il va falloir le
stocker dans une constante. Je vais donc le stocker dans
des fichiers const files. Ensuite, nous pouvons simplement
prendre ce code d' ici et le déplacer ici. Enfin, nous n'avons pas
besoin de cette fonction, je vais
donc la supprimer. N'oubliez pas qu'il s'agit d'une fonction
synchrone. Cela renverrait également une erreur. Nous devrons donc nous
assurer de gérer cette erreur
à l'aide du bloc de cache tr. Je vais donc encapsuler cela
dans un bloc de tri de cache TryCatch, et je vais déplacer tout ce code dans le bloc tri et pour enregistrer l'erreur, je vais faire quelque chose comme
cette erreur de colonne d'erreur Enregistrez ceci et revenez au
terminal point une fois de plus. Node app point js, et le même résultat.
9. Programmation axée sur les événements dans Node.js: L'un des concepts fondamentaux de node est le concept d'événements. En fait, de nombreuses fonctionnalités de base des nœuds sont basées sur ce concept d'événements. Un événement est essentiellement
un signal qui
indique que quelque chose s'
est passé dans notre application. Par exemple, dans node, nous avons une classe appelée STTB que nous pouvons utiliser
pour créer un serveur Web Nous allons donc écouter sur un pot donné, et chaque fois que nous recevons
une requête sur ce port, cette classe STDP déclenche un événement Notre travail consiste maintenant à
répondre à cet événement, ce qui implique essentiellement de lire cette demande et de renvoyer
la bonne réponse. En parcourant la documentation
du nœud, vous pouvez constater que plusieurs classes nœud déclenchent différents
types d'événements. Et dans votre code, vous pourriez être intéressé à répondre
à ces événements. Dans cette conférence,
je vais donc vous montrer comment
travailler avec le module événements. Maintenant, de retour dans la
documentation de la note, encore une fois, dans la liste des modules, vous pouvez voir ici que nous avons
ce module d'événements. Dans ce module, nous avons une classe qui
s'appelle Event Emitter. C'est l'un des
éléments de base du nœud, et de nombreuses classes sont
basées sur cet émetteur d'événements Voyons comment nous pouvons travailler
avec cet émetteur d'événements. Où dans le code VS ? Tout d'abord, chargeons
le module d'événements. Exigez donc des événements de colonne de nœuds. Maintenant, lorsque nous appelons
la fonction requise, nous obtenons la classe de l'émetteur d'événements Donc, émetteur d'événements constant. Vous pouvez également utiliser les
modules ESX pour importer la classe Evenimter depuis le module d'
événements de cette manière Importez l'émetteur d'événements
à partir des événements du nœud. Assurez-vous de mettre à jour
le package ou le fichier JCNFle pour indiquer le type d'un module comme
lors de la dernière conférence Alors allons-y pour le moment. Notez qu'ici, en
termes de dénomination, la première lettre de
chaque mot est en majuscule Il s'agit d'une convention
qui indique que cet émetteur d'événements est une
classe. Ce n'est pas une fonction. Ce n'est pas une simple
valeur, c'est une classe. Une classe est un type de conteneur pour les propriétés
et les fonctions, que nous appelons méthodes. Donc, dans cette classe d'émetteur d'événements, nous avons ces méthodes que vous voyez ici dans
la documentation Une classe est donc un conteneur ou un ensemble de
méthodes et de propriétés connexes. Maintenant, pour
utiliser cet émetteur d'événements, nous devons d'
abord créer
une instance de cette classe Donc émetteur constant, nous avons réglé
ces deux nouveaux compteurs d'événements. Donc ici, cet émetteur
est un objet. Si vous ne connaissez pas la différence entre
une classe et un objet, laissez-moi vous donner une métaphore Une classe est comme un être humain et un objet est comme une
personne réelle comme vous et moi. Ainsi, une classe définit
les propriétés et les comportements d'un
concept comme un être humain, mais un objet est une
instance réelle de cette classe. D'accord ? Donc, ici, ce premier émetteur
d'événements est une classe. C'est un plan Il définit ce que peut faire un émetteur d'
événements, mais le second émetteur
est un objet réel C'est celui que nous
allons utiliser dans notre application. Ce compteur a donc
un tas de méthodes. Et ce sont toutes
les méthodes que vous avez vues
dans la documentation. Maintenant, même si nous
avons ici plus de dix méthodes, plupart du temps, vous
n'en utilisez que deux. L'un est le MT que nous utilisons
pour organiser un événement. ET signifie essentiellement faire
du bruit ou produire quelque chose. Dans ce cas, nous
faisons du bruit. Dans notre application, nous
signalons qu'un
événement s'est produit. D'accord ? C'est donc
le sens de M. Maintenant, nous passons
un argument qui est le nom de l'événement,
disons le journal des messages. À l'avenir, nous allons
étendre notre module d'enregistrement,
et chaque fois que nous enregistrons un message,
nous allons déclencher et chaque fois que nous enregistrons un message, un
événement appelé journal des messages Maintenant, si vous lancez
cette application, rien ne se
passera. Laisse-moi te montrer. De retour dans le terminal.
Application Node Js. Écoutez, rien ne se passe. Parce que nous avons
évoqué un événement ici, mais nulle part dans notre application, nous avons enregistré un auditeur intéressé par cet événement Un écouteur est une
fonction qui sera appelée lorsque cet événement
sera déclenché, d'accord ? Nous allons donc enregistrer un
écouteur qui sera appelé lorsque l'événement
enregistré par message sera déclenché Vous enregistrez un écouteur,
puis vous écrivez emitter. Regardez, nous avons ici cette
méthode, ajoutez un écouteur. Mais nous avons un alias pour cette méthode que nous utilisons le
plus souvent. C'est activé. Si vous avez déjà travaillé avec jQuery, vous l'avez déjà vu Donc, ou ajoutez un écouteur, ce
sont exactement les mêmes Mais très souvent, nous
utilisons la méthode on. Maintenant, cette méthode
prend deux arguments. Le premier est le
nom de l'événement. Dans ce cas, il s'agit du journal des messages, et le second est
une fonction de rappel ou
l'écouteur lui-même Nous passons donc ici une fonction
et cette fonction sera appelée lorsque cet
événement sera déclenché. C'est bon. Pour l'instant, je veux juste enregistrer
un message sur la console. Donc, console point log. Disons un appel d'un auditeur. Exécutons maintenant cette application. Donc, passez un nœud au Js et nous avons reçu
ce message, un appel d'écouteur. Cela indique donc que
lorsque nous déclenchons cet événement, la fonction de rappel ou
l'écouteur a été Et bien sûr, l'ordre
est important ici. Si nous avions enregistré cet écouteur après avoir appelé la méthode EMT, rien ne se serait passé car lorsque nous appelons
la méthode EMT,
cet émetteur, il lit
tous les auditeurs
enregistrés et les tous les auditeurs
enregistrés après avoir appelé la méthode EMT,
rien ne se serait passé
car lorsque nous appelons
la méthode EMT,
cet émetteur, il lit
tous les auditeurs
enregistrés et les appelle de manière synchrone. C'est donc la base pour déclencher
des événements
et les gérer à l'aide de
la classe Event Emitter
10. Arguments d'événements : approfondir: Très souvent, lorsque nous
voulons organiser un événement, nous voulons également envoyer des
données sur cet événement. Par exemple, dans
notre module Lager, lorsque nous enregistrons un message, notre service
de connexion à distance génère
peut-être un identifiant
pour ce message Vous souhaitez peut-être renvoyer
cet identifiant sur la pièce, ou cela peut nous donner une URL pour
accéder directement à ce
message de journal. Ici, lorsque vous déclenchez un événement, nous pouvons ajouter des arguments supplémentaires que nous appelons arguments d'événement. Nous pouvons donc ajouter un identifiant similaire
et nous pouvons ajouter une URL. Mais comme vous pouvez le constater,
ces valeurs
magiques sont un peu confuses. Si vous souhaitez envoyer plusieurs
valeurs relatives à un événement, il est préférable d'
encapsuler ces valeurs
dans un objet Nous ajoutons donc ici un objet. Nous obtenons quelques
propriétés comme ID. Nous l'avons défini sur l'ID de ce
message qui est verrouillé et sur une autre
URL de propriété comme celle-ci. OK, nous appelons donc cet
objet un argument d'événement. Maintenant, lors de l'enregistrement d'un écouteur cette fonction de rappel, cet écouteur réel peut également recevoir cet Nous ajoutons donc ici un paramètre appelé Rc. Tu peux l'
appeler comme tu veux. Le nom n'a pas d'importance,
mais par convention, nous utilisons souvent arc ou certaines personnes utilisent E pour
désigner l'événement ou l'arc d'événements. Tout ce que tu préfères
est parfait. Nous avons donc R. Maintenant,
enregistrons-le sur la console. C'est très simple.
Exécutons cette application. La note abjso, look, listener called, et
voici notre Et avec cette technique, nous pouvons transmettre des données sur l'
événement qui vient de se produire. Voici maintenant un
exercice simple pour vous. Imaginons que dans
notre module d'enregistrement,
juste avant d'appeler notre
service à distance pour enregistrer le message,
nous allons déclencher juste avant d'appeler notre
service à distance pour enregistrer le message, un
événement appelé journalisation Tout en évoquant cet événement, nous souhaitons également envoyer des données. C'est un message que
nous allons enregistrer. Je veux donc que vous utilisiez ce que vous avez appris
au cours de cette conférence pour évoquer et
gérer cet événement de journalisation. C'est un exercice très simple. Je veux juste que tu t'
habitues à cette syntaxe.
11. Élargir EventEmitter : gestion avancée des événements: Maintenant, dans le monde réel, il est assez rare
que vous travailliez directement
avec cet
objet émetteur d'événements Vous souhaitez plutôt
créer une classe qui possède toutes les fonctionnalités
de l'émetteur d'événements, puis vous utiliserez
cette classe dans votre code Permettez-moi de vous expliquer ce que je
veux dire par là et pourquoi. Ouvrons donc
notre module d'enregistrement. Et dans ce module, nous
exportons une
fonction simple, Milo, non ? Et ici, nous enregistrons ce
message sur la console. Il s'agit maintenant de la syntaxe
Javascript courante. Modifions-le. Comme nous utilisons maintenant
les six modules ES, nous devons écrire
Export Default, Milog Ensuite, nous voulons
organiser un événement, puis plus tard dans le module de l'application, nous écouterons cet
événement et ferons quelque chose. Revenons donc à notre module d'application et copions
du code dans le module d'enregistrement partant du haut, je vais copier ces deux lignes pour intégrer l'émetteur d'événements
dans ce module OK ? Maintenant, de retour dans le module d'application, je vais également déplacer
ces deux lignes pour déclencher
un événement dans le module d'enregistrement car ce code ne
devrait pas être ici Il s'agit d'un module d'enregistrement
qui émet ou signale un événement indiquant que
le message est enregistré Donc voilà, après avoir
enregistré le message, nous lançons un événement comme celui-ci. OK ? Maintenant, de retour dans le module de l'application, nous n'avons pas besoin de cette commande. Ici, nous devons enregistrer
le module logger et appeler le MOGFunction Pour charger le module logger, nous allons donc utiliser la
fonctionnalité d'importation des six modules Donc, importez le journal, je l'ai
renommé en log from slash logger
point Gs. Très facile. Et ici, nous appelons simplement la fonction
journal par un message. OK ? Maintenant, lorsque nous exécutons
cette application, nous ne verrons que
ce message sur la console. En d'autres termes, cet
écouteur d'événements ne sera pas appelé. Vérifions-le, puis je vous expliquerai pourquoi cela se produit. De retour dans le nœud terminal, application Jas, regardez, nous n'avons reçu que
le message sur la console. Notre auditeur d'événements n'a donc pas
été appelé. La raison en
est que nous
travaillons ici avec deux émetteurs d'événements
différents Dans App Js, nous avons cet objet émetteur d'
événements, et dans le module inférieur, nous avons un autre objet
émetteur d'événements heure, je vous ai dit
qu'une classe est comme un plan et qu'un objet
est une instance réelle Comme métaphore, j'ai dit que nous pouvions avoir une classe appelée
humain ou personne, mais que les objets pouvaient être Eric,
Steve, David, Maria, peu importe Mais dans ce cas, nous avons
deux objets différents. Dans le
module logger, nous utilisons cet objet émetteur
pour émettre un événement,
tandis que dans le module app, tandis que dans le module app, nous utilisons un autre
objet entemeter pour Elles sont complètement différentes. Lorsque nous enregistrons
un écouteur ici, celui-ci n'est enregistré qu'avec cet émetteur d'événements, qui est complètement différent de
l'autre C'est pourquoi je vous ai dit
dans vos applications qu'il est très rare que
vous souhaitiez travailler directement avec cet
émetteur d'événements Vous souhaitez plutôt
créer une classe qui possède toutes les fonctionnalités
de cet émetteur d'événements, mais qui possède des
fonctionnalités supplémentaires Dans ce cas, vous souhaitez
créer une classe appelée logger qui possède cette méthode
supplémentaire, log OK ? Donc, la première chose que
nous voulons faire ici
est de définir une classe. Dans ES six, nous avons
cette classe de mots clés, qui est un sucre syntaxique permettant de créer une fonction
constructeur Avec cela, nous pouvons
définir une classe, un logger. Notez que la première lettre de chaque mot d'une classe
doit être en majuscule Il s'agit d'une convention de cas Pascal que nous utilisons pour nommer les classes. Enregistreur de classe, nous
avons un bloc de code, nous devons déplacer
cette fonction de journal
dans cette classe d'enregistreur Alors passez-le ici. Nous avons maintenant une erreur car nous définissons une fonction
dans une classe. Nous n'avons plus besoin de cette
fonction d'erreur à partir de maintenant, nous appelons cette
fonction une méthode. Donc, lorsqu'une fonction se
trouve dans une classe, nous disons que c'est une méthode
de cette classe, d'accord ? Voici donc
ce cours de bière blonde. À la fin, au lieu
d'exporter le Mel of Pointie, nous allons
exporter la plus grande classe OK. Nous voulons maintenant que cette classe inférieure possède toutes les capacités
de cet émetteur d'événements Pour ce faire, nous utilisons
le
mot clé extents qui se trouve dans
ES six, so extends Et ici on ajoute le
nom du parent ou la classe de base,
donc event emitter. Et avec ce simple changement, cette classe inférieure bénéficiera toutes les fonctionnalités définies dans Event Event Meter Donc, ici, lorsque
vous déclenchez cet événement, au lieu d'utiliser
cet objet émetteur, nous allons l'utiliser
afin que dans cette classe, nous puissions directement émettre
ou déclencher des événements. OK ? Maintenant, nous n'avons plus besoin de cet objet émetteur
réel car nous ne l'avons utilisé nulle part
dans ce code. Supprimez donc. Nous en avons terminé avec
le module logger. Maintenant, revenons dans le module d'application, donc ici, lors de
l'importation du module logger,
nous obtenons une classe Je vais donc renommer cet enregistreur avec
L. C'est une classe Maintenant, nous créons un objet, donc un nouvel enregistreur,
puis pour enregistrer un message,
nous appelons logger point log nous appelons logger point Maintenant, à l'instar de la modification
que nous avons apportée au module Lager, nous n'avons plus besoin de cet objet dimètre d'
événements Ici, nous voulons travailler directement
avec cet objet inférieur. Nous allons donc enregistrer cet écouteur sur
cet objet lober OK ? Je vais donc
déplacer ce code. Après avoir créé l'enregistreur, nous disons « Hey logger », lorsque vous déclenchez cet événement de verrouillage du
message, je souhaite exécuter ce code Enfin, vous pouvez voir que nous n'avons plus besoin de cet objet émetteur d'
événements Il n'est utilisé nulle part. Plus tard, lorsque nous
exécuterons cette application, nous verrons ce
message sur la console. Mais aussi parce que nous utilisons
le même log ou le même objet pour enregistrer un écouteur d'événements
et pour déclencher un événement, nous allons voir ce
message sur la console Notez donc l'apparence de l'application Jazz, il s'
agit d'un message
sur la console, et vous voyez que notre écouteur
a été appelé avec succès Récapitulons donc rapidement. Si vous souhaitez déclencher des événements dans votre application pour signaler
que quelque chose s'est produit, vous devez créer une classe
qui étend l'indicateur d'événements Ainsi, cette classe aura toutes les fonctionnalités
définies dans Event Emitter. Mais vous pouvez également ajouter
des fonctionnalités supplémentaires. Dans ce cas, il est
possible d'enregistrer un message. Ensuite, dans cette classe, chaque fois que vous
souhaitez déclencher un événement, vous utilisez ce point rencontré car il fait référence à
la classe logger elle-même, qui étend l'émetteur d'événements Ainsi, toutes les méthodes définies dans Event Emitter
feront également partie de cette classe Enfin, dans le module d'
application, encore une fois, au lieu d'utiliser une
instance d'émetteur d'événements, vous utiliserez une instance de la classe personnalisée que vous avez définie qui étend l'émetteur d'
événements.
12. Traitement des requêtes HTTP : réseaux Node.js: L'un des puissants
éléments de base de node est le module STDP que nous utilisons pour créer des applications
réseau Par exemple, nous pouvons
créer un serveur Web qui écoute StdprQuest
sur Ainsi, nous
pouvons facilement créer un service principal pour
nos applications clientes, comme une application Web créée
avec React ou Angular ou une application mobile
exécutée sur un appareil mobile Donc, encore une fois, dans
la documentation du nœud, la liste des modules, vous
pouvez trouver ce module TDP Dans ce module, vous pouvez voir différentes classes
telles que tt point agent, http point client
request, etc. Chacune de ces classes
possède un ensemble de propriétés, de méthodes et d'événements. Donc, de retour dans le code VS, chargeons le module SGTP Importez donc ASTC en tant que
HTTP à partir du nœud STT. D'accord. Ici, nous pouvons appeler
db point, create server. Il s'agit de l'une des fonctions
définies dans ce module. Et avec cela, nous pouvons
créer un serveur Web. Stockons donc le résultat
dans un objet serveur. Maintenant, ce qui est intéressant, c'est que ce serveur est un émetteur d'événements Il possède donc toutes les
fonctionnalités de l'émetteur d' événements décrites
plus haut dans cette section Donc, regardez, point serveur, nous
avons la méthode on. Ou ajoutez un écouteur ou un M et une chanson. De plus, si vous regardez la
documentation du mode SGTP,
sur cette page, vous pouvez voir la classe de serveur
http point Ici, la documentation
indique que cette classe hérite de net point SAR Il s'agit donc d'une autre classe
définie dans le module net. Allons y jeter un œil. Maintenant,
ici dans la documentation indiqué que le serveur Net point
est un émetteur d'événements Mais c'est pourquoi j'ai parlé
d'un tas de nœuds, fonctionnalités de
base sont
basées sur l'émetteur d'événements Revenons donc à notre objet serveur. Nous pouvons maintenant appeler le point
LISN du serveur et lui attribuer un port. Disons le port 3 000. Ensuite, je
vais ajouter un journal à points sur la console indiquant l'écoute sur le port 3 000. D'accord ? Maintenant, lorsque nous exécutons
cette application, le serveur
écoute sur le port 3 000. Comme je vous l'ai déjà dit, chaque fois qu'il y a une nouvelle
connexion ou une nouvelle demande, le serveur déclenche un événement. Nous pouvons donc utiliser la méthode on
pour gérer cet événement. Donc, avant d'écouter, nous voulons enregistrer un écouteur
ou un gestionnaire serveur sur le
nom de l'événement est donc une connexion que vous pouvez
trouver dans la documentation. Tu n'as pas besoin de mémoriser
tout ça. Et le deuxième argument est une fonction de rappel ou
l'écouteur lui-même Comme vous pouvez le voir dans
l'infobulle ici, cet écouteur est une fonction dont un argument est socket
de type socket class, et il tourne Y. Nous avons
donc ici la syntaxe de la
fonction flèche dans ES six Ajoutons donc une
fonction flèche qui prend un socket et accède
à ce bloc de code. Maintenant, ici, nous pouvons simplement verrouiller quelque chose sur le
nom de la connexion de la console. Maintenant, de retour dans un terminal, lançons cette application. Vous pouvez voir que nous
écoutons sur le port 3 000. De retour dans le navigateur,
dirigeons-nous vers le port hôte local 3 000. Maintenant, si vous regardez dans le terminal, vous pouvez voir que nous avons une
nouvelle connexion ici. Vous pouvez donc voir que cet objet
SR déclenche différents types d'événements
auxquels vous pouvez répondre. Désormais, dans les applications du monde réel, nous n'allons pas répondre
au service HTTP de
facturation des événements de connexion. C'est un niveau très bas. Supprimons donc ceci.
Ce que nous faisons généralement c'est transmettre une fonction de rappel
qui crée une méthode Cette fonction prend deux
paramètres : demande et réponse. Maintenant, dans cette fonction, au lieu
de travailler avec un socket, nous pouvons travailler avec les objets de
requête ou de réponse réels. Nous pouvons donc vérifier si l'URL de la
demande est égale à une barre oblique, puis nous pouvons envoyer
quelque chose au client Par exemple, response stat, write, hello world,
puis nous terminons la réponse. D'accord. Dans le terminal, nous pouvons sortir d'ici en appuyant sur Ctrl C puis en
relançant l'application. Nous sommes toujours en train d'écouter
sur le port 3 000. Actualisons la page. Nous avons donc reçu le bonjour sur la page d'accueil. Maintenant que nous voulons créer
un service principal pour une application Web ou mobile, nous devons gérer
différents itinéraires ici Par exemple, nous pouvons
avoir un autre bloc I si URL de la
demande est égale à
l'API slash courses Peut-être voulons-nous ici renvoyer la liste des cours de la base
de données. Nous ferions donc quelque chose comme
ceci, point de réponse à droite. Nous voulons maintenant renvoyer un
tableau d'objets en utilisant JCN. Nous utilisons donc cn dot stringify et lui donnons un tableau d'objets Maintenant, pour simplifier,
nous n'avons pas à nous
soucier de la base de données
ou des objets complexes. Retournons simplement un tableau de nombres un, deux et trois. Nous le transmettons donc à JCN stringifi qui convertira
ce tableau en chaîne en chaîne Ensuite, nous l'
inscrirons dans la réponse. Maintenant, de retour dans le terminal, nous devons arrêter à
nouveau ce processus et le réexécuter. À l'avenir,
je vais vous montrer comment nous pouvons automatiser cela. Ainsi, chaque fois que nous apportons une simple
modification à notre application, nous n'avons pas besoin de redémarrer. Maintenant, de retour dans le navigateur, si nous allons slash les cours de l'API
, nous obtenons un tableau
de trois chiffres Comme vous le voyez, la création d'un serveur Web avec un
nœud est très simple. Maintenant, dans le monde réel,
nous n'allons pas utiliser ce module SDDP pour créer un service principal
pour notre La raison en est
que, comme vous pouvez le voir ici, fur et à mesure que nous ajoutons de nouvelles sorties, ce code devient plus complexe
car nous
les ajoutons tous de manière linéaire dans
cette fonction de rappel Nous utilisons donc plutôt un
framework appelé Express, qui donne à notre application une structure propre pour
gérer différents itinéraires. En interne, le framework
express est construit au-dessus du module
STDP décrit dans la note