TOC

Comment écrire et exécuter votre premier programme dans Node.js

L’auteur a sélectionné le Open Internet / Free Speech Fund pour recevoir un don dans le cadre du https://do.co/w4do-cta Programme [Write for DOnations] .

introduction

Node.js est un environnement d’exécution open source populaire pouvant exécuter JavaScript en dehors du navigateur à l’aide du moteur JavaScript V8, qui est identique à celui utilisé pour exécuter l’exécution de JavaScript par le navigateur Web Google Chrome. L’exécution du noeud est généralement utilisée pour créer des outils de ligne de commande et des serveurs Web.

Learning Node.js vous permettra d’écrire votre code frontal et votre code back-end dans la même langue. L’utilisation de JavaScript dans l’ensemble de votre pile peut aider à réduire le temps nécessaire à la commutation de contexte. Les bibliothèques sont plus facilement partagées entre votre serveur principal et vos projets frontaux.

De plus, grâce à sa prise en charge de l’exécution asynchrone, Node.js excelle dans les tâches intensives en E / S, ce qui le rend si bien adapté au Web. Les applications en temps réel, telles que le streaming vidéo, ou les applications qui envoient et reçoivent des données en continu, peuvent s’exécuter plus efficacement lorsqu’elles sont écrites dans Node.js.

Dans ce tutoriel, vous allez créer votre premier programme avec le moteur d’exécution Node.js. Quelques concepts spécifiques aux nœuds vous seront présentés et vous pourrez créer un programme qui aide les utilisateurs à inspecter les variables d’environnement sur leur système. Pour ce faire, vous apprendrez à exporter des chaînes sur la console, à recevoir les entrées de l’utilisateur et à accéder aux variables d’environnement.

Conditions préalables

Pour compléter ce tutoriel, vous aurez besoin de:

Étape 1 - Sortie sur la console

Pour écrire un programme “Hello, World!”, Ouvrez un éditeur de texte en ligne de commande tel que + nano + et créez un nouveau fichier:

nano hello.js

Avec l’éditeur de texte ouvert, entrez le code suivant:

bonjour.js

console.log("Hello World");

L’objet + console + dans Node.js fournit des méthodes simples pour écrire dans + stdout +, + stderr + ou dans tout autre flux de Node.js, qui dans la plupart des cas est la ligne de commande. La méthode + log est imprimée dans le flux` + stdout`, afin que vous puissiez le voir dans votre console.

Dans le contexte de Node.js, streams sont des objets pouvant recevoir des données, comme le flux + stdout +, ou des objets pouvant générer des données, comme un socket réseau ou un fichier. Dans le cas des flux + stdout + et + + stderr +, toutes les données qui leur sont envoyées seront alors affichées dans la console. L’un des avantages des flux est qu’ils sont facilement redirigés. Dans ce cas, vous pouvez rediriger la sortie de votre programme vers un fichier, par exemple.

Sauvegardez et quittez + nano + en appuyant sur + CTRL + X +, lorsque vous êtes invité à enregistrer le fichier, appuyez sur + Y +. Votre programme est maintenant prêt à fonctionner.

Étape 2 - Exécution du programme

Pour exécuter ce programme, utilisez la commande + node + comme suit:

node hello.js

Le programme + hello.js + sera exécuté et affichera la sortie suivante:

Output Hello World

L’interpréteur Node.js a lu le fichier et a exécuté + console.log (" Hello World "); + en appelant la méthode + log + de l’objet global + console +. La chaîne " Hello World " a été transmise en tant qu’argument à la fonction + log +.

Bien que des guillemets soient nécessaires dans le code pour indiquer que le texte est une chaîne, ils ne sont pas imprimés à l’écran.

Une fois que le programme fonctionne, rendons-le plus interactif.

Étape 3 - Réception d’une entrée utilisateur via des arguments de ligne de commande

Chaque fois que vous exécutez le programme «Hello, World!» De Node.js, il produit le même résultat. Pour rendre le programme plus dynamique, obtenons l’information de l’utilisateur et affichons-la à l’écran.

Les outils de ligne de commande acceptent souvent divers arguments qui modifient leur comportement. Par exemple, si vous exécutez + node + avec l’argument + - version +, vous imprimez la version installée au lieu d’exécuter l’interpréteur. Dans cette étape, vous ferez en sorte que votre code accepte les entrées utilisateur via des arguments de ligne de commande.

Créez un nouveau fichier + arguments.js + avec nano:

nano arguments.js

Entrez le code suivant:

arguments.js

console.log(process.argv);

L’objet + process + est un objet global Node.js qui contient des fonctions et des données, toutes liées au processus Node.js en cours d’exécution. La propriété + argv + est un tableau de chaînes contenant tous les arguments de ligne de commande donnés à un programme.

Sauvegardez et quittez + nano + en tapant + CTRL + X +, lorsque vous êtes invité à enregistrer le fichier, appuyez sur + Y +.

Maintenant, lorsque vous exécutez ce programme, vous fournissez un argument de ligne de commande comme celui-ci:

node arguments.js hello world

La sortie ressemble à ceci:

Output [ '/usr/bin/node',
 '/home//first-program/arguments.js',
 'hello',
 'world' ]

Le premier argument du tableau + process.argv + est toujours l’emplacement du binaire Node.js qui exécute le programme. Le deuxième argument est toujours l’emplacement du fichier en cours d’exécution. Les arguments restants sont ceux que l’utilisateur a entrés, dans ce cas: + hello + et + world +.

Nous nous intéressons principalement aux arguments entrés par l’utilisateur, et non à ceux fournis par défaut par Node.js. Ouvrez le fichier + arguments.js pour le modifier:

nano arguments.js

Changez + console.log (process.arg); + comme suit:

arguments.js

console.log(process.argv.);

Comme + argv + est un tableau, vous pouvez utiliser la méthode + slice + intégrée de JavaScript qui renvoie une sélection d’éléments. Lorsque vous fournissez la fonction + slice + avec l’argument + 2 +, vous obtenez tous les éléments de + argv + qui viennent after, son deuxième élément; c’est-à-dire les arguments entrés par l’utilisateur.

Relancez le programme avec la commande + node + et les mêmes arguments que la dernière fois:

node arguments.js hello world

Maintenant, la sortie ressemble à ceci:

Output [ 'hello', 'world' ]

Maintenant que vous pouvez collecter les informations de l’utilisateur, collectons les informations de l’environnement du programme.

Étape 4 - Accès aux variables d’environnement

Les variables d’environnement sont des données de valeur clé stockées en dehors d’un programme et fournies par le système d’exploitation. Ils sont généralement définis par le système ou l’utilisateur et sont disponibles pour tous les processus en cours d’exécution à des fins de configuration ou d’état. Vous pouvez utiliser l’objet Node + process pour y accéder.

Utilisez + nano + pour créer un nouveau fichier + environment.js +:

nano environment.js

Ajoutez le code suivant:

environment.js

console.log(process.env);

L’objet + env + stocke all les variables d’environnement disponibles lorsque Node.js exécute le programme.

Sauvegardez et quittez comme avant, et exécutez le fichier + environment.js avec la commande` + node n`.

node environment.js

Lors de l’exécution du programme, vous devriez voir une sortie semblable à celle-ci:

Output{ SHELL: '/bin/bash',
 SESSION_MANAGER:
  'local/digitalocean:@/tmp/.ICE-unix/1003,unix/digitalocean:/tmp/.ICE-unix/1003',
 COLORTERM: 'truecolor',
 SSH_AUTH_SOCK: '/run/user/1000/keyring/ssh',
 XMODIFIERS: '@im=ibus',
 DESKTOP_SESSION: 'ubuntu',
 SSH_AGENT_PID: '1150',
 PWD: '/home/sammy/first-program',
 LOGNAME: 'sammy',
 GPG_AGENT_INFO: '/run/user/1000/gnupg/S.gpg-agent:0:1',
 GJS_DEBUG_TOPICS: 'JS ERROR;JS LOG',
 WINDOWPATH: '2',
 HOME: '/home/sammy',
 USERNAME: 'sammy',
 IM_CONFIG_PHASE: '2',
 LANG: 'en_US.UTF-8',
 VTE_VERSION: '5601',
 CLUTTER_IM_MODULE: 'xim',
 GJS_DEBUG_OUTPUT: 'stderr',
 LESSCLOSE: '/usr/bin/lesspipe %s %s',
 TERM: 'xterm-256color',
 LESSOPEN: '| /usr/bin/lesspipe %s',
 USER: 'sammy',
 DISPLAY: ':0',
 SHLVL: '1',
 PATH:
  '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin',
 DBUS_SESSION_BUS_ADDRESS: 'unix:path=/run/user/1000/bus',
 _: '/usr/bin/node',
 OLDPWD: '/home/sammy' }

Gardez à l’esprit que beaucoup de variables d’environnement que vous voyez dépendent de la configuration et des paramètres de votre système, et que votre sortie peut avoir une apparence très différente de celle que vous voyez ici. Plutôt que d’afficher une longue liste de variables d’environnement, vous souhaiterez peut-être en récupérer une spécifique.

Étape 5 - Accéder à une variable d’environnement spécifiée

Dans cette étape, vous allez visualiser les variables d’environnement et leurs valeurs à l’aide de l’objet global + process.env + et les imprimer sur la console.

L’objet + process.env + est un simple mappage entre les noms de variables d’environnement et leurs valeurs stockées sous forme de chaînes. Comme tous les objets en JavaScript, vous accédez à une propriété individuelle en référant son nom entre crochets.

Ouvrez le fichier + environment.js pour le modifier:

nano environment.js

Remplacez + console.log (process.env); + par:

environment.js

console.log(process.env);

Enregistrez le fichier et quittez. Maintenant, lancez le programme + environment.js +:

node environment.js

La sortie ressemble maintenant à ceci:

Output /home/

Au lieu d’imprimer l’intégralité de l’objet, vous n’imprimez maintenant que la propriété + HOME + de + process.env +, qui stocke la valeur de la variable d’environnement + $ HOME +.

Encore une fois, gardez à l’esprit que la sortie de ce code sera probablement différente de ce que vous voyez ici car elle est spécifique à votre système. Maintenant que vous pouvez spécifier la variable d’environnement à récupérer, vous pouvez améliorer votre programme en demandant à l’utilisateur la variable qu’il souhaite voir.

Étape 6 - Récupération d’un argument en réponse à une entrée utilisateur

Vous utiliserez ensuite la possibilité de lire des arguments de ligne de commande et des variables d’environnement pour créer un utilitaire de ligne de commande qui affiche la valeur d’une variable d’environnement à l’écran.

Utilisez + nano + pour créer un nouveau fichier + echo.js +:

nano echo.js

Ajoutez le code suivant:

echo.js

const args = process.argv.slice(2);
console.log(process.env[args[0]]);

La première ligne de + echo.js + stocke tous les arguments de ligne de commande fournis par l’utilisateur dans une variable constante appelée + args +. La deuxième ligne affiche la variable d’environnement stockée dans le premier élément de + args +; c’est-à-dire le premier argument de ligne de commande fourni par l’utilisateur.

Enregistrez et quittez + nano +, puis exécutez le programme comme suit:

node echo.js HOME

Maintenant, le résultat serait:

Output /home/

L’argument + HOME + a été enregistré dans le tableau + args +, qui a ensuite été utilisé pour trouver sa valeur dans l’environnement via l’objet + process.env +.

À ce stade, vous pouvez maintenant accéder à la valeur de toute variable d’environnement de votre système. Pour vérifier cela, essayez d’afficher les variables suivantes: + PWD,` + USER`, + PATH.

Récupérer des variables uniques est une bonne chose, mais laisser l’utilisateur spécifier le nombre de variables qu’il souhaite mieux.

Étape 7 - Affichage de plusieurs variables d’environnement

Actuellement, l’application ne peut inspecter qu’une seule variable d’environnement à la fois. Il serait utile de pouvoir accepter plusieurs arguments de ligne de commande et d’obtenir la valeur correspondante dans l’environnement. Utilisez + nano + pour éditer + echo.js +:

nano echo.js

Editez le fichier pour qu’il contienne le code suivant:

echo.js

const args = process.argv.slice(2);

La méthode + forEach + est une méthode JavaScript standard sur tous les objets tableau. Il accepte une fonction de rappel utilisée car il itère sur chaque élément du tableau. Vous utilisez + forEach + sur le tableau + args +, en lui fournissant une fonction de rappel qui affiche la valeur de l’argument actuel dans l’environnement.

Enregistrez et quittez le fichier. Maintenant, relancez le programme avec deux arguments:

node echo.js HOME PWD

Vous verriez la sortie suivante:

Output /home/
/home//first-program

La fonction + forEach + garantit que tous les arguments de la ligne de commande du tableau + args + sont imprimés.

Vous avez maintenant un moyen de récupérer les variables demandées par l’utilisateur, mais nous devons tout de même gérer le cas où l’utilisateur entre des données incorrectes.

Étape 8 - Gestion des entrées non définies

Pour voir ce qui se passe si vous donnez au programme un argument qui n’est pas une variable d’environnement valide, exécutez la procédure suivante:

node echo.js HOME PWD NOT_DEFINED

La sortie ressemblera à ce qui suit:

Output /home/
/home//first-program
undefined

Les deux premières lignes sont imprimées comme prévu et la dernière ne contient que + undefined. En JavaScript, une valeur + undefined + signifie qu’une valeur ou une variable n’a pas été affectée. Étant donné que + NOT_DEFINED + n’est pas une variable d’environnement valide, il est indiqué par + undefined +.

Il serait plus utile pour un utilisateur de voir un message d’erreur si son argument de ligne de commande n’a pas été trouvé dans l’environnement.

Ouvrez + echo.js + pour l’édition:

nano echo.js

Éditez + echo.js + pour qu’il ait le code suivant:

echo.js

const args = process.argv.slice(2);

args.forEach(arg => {
 let envVar = process.env[arg];





});

Ici, vous avez modifié la fonction de rappel fournie à + ​​forEach + pour effectuer les opérations suivantes:

  1. Obtenez la valeur des arguments de ligne de commande dans l’environnement et stockez-la dans une variable + env Var.

  2. Vérifiez si la valeur de + env Var est` + undefined`.

  3. Si + envVar + est + undefined +, nous imprimons un message utile indiquant qu’il est introuvable.

  4. Si une variable d’environnement a été trouvée, nous imprimons sa valeur.

Maintenant, exécutez la commande suivante une fois de plus:

node echo.js HOME PWD NOT_DEFINED

Cette fois la sortie sera:

Output /home/
/home//first-program
Could not find "NOT_DEFINED" in environment

Désormais, lorsque vous fournissez un argument de ligne de commande qui n’est pas une variable d’environnement, vous obtenez un message d’erreur clair l’affirmant.

Conclusion

Votre premier programme a affiché «Hello World» à l’écran et vous venez d’écrire un utilitaire de ligne de commande Node.js qui lit les arguments de l’utilisateur pour afficher les variables d’environnement.

Si vous voulez aller plus loin, vous pouvez changer encore plus le comportement de ce programme. Par exemple, vous souhaiterez peut-être valider les arguments de la ligne de commande avant d’imprimer. Si un argument n’est pas défini, vous pouvez renvoyer une erreur. L’utilisateur ne pourra obtenir une sortie que si tous les arguments sont des variables d’environnement valides.

Related