Clever Geek Handbook

Tutoriel Node.js pour les débutants. Partie 2





Bonjour mes amis!



Je continue à poster une traduction de ce tutoriel Node.js .



Autres parties:



Partie 1

Partie 2

Partie 3

Partie 4



Moteur JavaScript V8

V8 est le nom du moteur JavaScript pris en charge par Google Chrome. C'est ce qui prend votre code JavaScript et l'exécute dans le navigateur.



En d'autres termes, V8 est un runtime JavaScript. DOM et d'autres API Web sont également exposés par le navigateur.



Le moteur JavaScript est indépendant du navigateur. C'est ce qui a donné naissance à Node.js. V8 a été choisi comme moteur pour Node.js en 2009, et avec la popularité croissante de Node.js, V8 est devenu la base de beaucoup de JavaScript côté serveur.



L'écosystème Node.js est immense et grâce à la V8, nous pouvons créer des applications de bureau en utilisant Electron par exemple.



Autres moteurs JS

D'autres navigateurs ont leurs propres moteurs JavaScript:





etc.



Tous ces moteurs implémentent la norme ECMA ES-262 (ECMAScript) , la norme utilisée par JavaScript.



À propos des performances

La V8 est écrite en C ++ et continue d'évoluer. Cela fonctionne sur tous les systèmes d'exploitation.



Nous n'aborderons pas les spécificités de l'implémentation du V8: vous pouvez les retrouver ici , elles changent de temps en temps, souvent radicalement.



Le V8 est en constante évolution, comme les autres moteurs JavaScript, pour améliorer la vitesse du Web et de l'écosystème Node.js.



Il y a une compétition de performance sur le Web qui dure depuis des années, et nous (en tant qu'utilisateurs et développeurs) tirons beaucoup de profit de cette concurrence car nous obtenons des outils plus rapides et plus optimisés chaque année.



Compilation

JavaScript est généralement commercialisé comme un langage interprété, mais les moteurs modernes ne se contentent pas d'interpréter JavaScript, ils le compilent.



Cela se produit depuis 2009, lorsque le compilateur JavaScript SpiderMonkey a été ajouté dans Firefox 3.5.



JavaScript compile V8 à la volée (juste à temps, JIT, compilation dynamique) pour l'accélérer.



Cela peut sembler contre-intuitif, mais avec l'avènement de Google Maps en 2004, JavaScript est passé d'un langage dans lequel de petits blocs de code sont écrits à un langage dans lequel des applications à part entière sont créées, constituées de centaines ou de milliers de lignes de code exécutées dans le navigateur.



Aujourd'hui, nos applications basées sur navigateur peuvent fonctionner pendant des heures, ce ne sont plus de simples outils pour résoudre des tâches primitives, comme la validation de formulaire.



Dans le monde d'aujourd'hui, la compilation de JavaScript a du sens: bien que la préparation du code prenne plus de temps, ses performances dépassent largement les performances du code interprété.



Exécution de scripts Node.js à partir de la ligne de commande

La manière standard d'exécuter les programmes Node.js consiste à exécuter une commande globale nodeet à transmettre le nom de l'exécutable.



Si le fichier principal de votre application Node.js est nommé app.js, vous pouvez l'appeler comme ceci: 



node app.js


Lors de l'exécution de la commande spécifiée, assurez-vous que vous vous trouvez dans le répertoire contenant le fichier app.js.



Comment quitter Node.js?

Il existe différentes manières d'arrêter une application Node.js.



Lorsque vous exécutez un programme via le terminal, vous pouvez le fermer avec ctrl-C, cependant, discutons des méthodes programmatiques.



Commençons par le plus radical et expliquons pourquoi il ne devrait pas être utilisé.



Le module principal (global, module du noyau) processfournit une méthode simple pour sortir de l'application logicielle Node.js: process.exit().



Lorsque Node.js atteint cette ligne de code, le processus d'exécution du programme se termine immédiatement.



Cela signifie que tous les rappels en cours, les demandes soumises (en attente), l'accès ouvert au système de fichiers, les écritures sur stdoutou stderr- tous seront définitivement abandonnés.



Si cela vous convient, vous pouvez passer exit()un entier à la méthode - un signal pour terminer l'exécution du code: 



process.exit(1)


Le code de sortie par défaut est 0, indiquant la réussite. Différents codes de sortie ont des significations différentes, vous pouvez les utiliser pour vous assurer que certains programmes interagissent avec d'autres.



Vous pouvez en savoir plus sur les codes de sortie ici .



Vous pouvez également attribuer une valeur appropriée à la propriété exitCode: 



process.exitCode = 1


et une fois le programme terminé, Node.js renverra ce code.



L'exécution du programme se terminera en douceur lorsque tous les processus seront terminés.



Dans Node.js, nous démarrons souvent le serveur: 



const express = require('express')
const app = express()

app.get('/', (req, res) => {
    res.send('Hi!')
})

app.listen(3000, () => console.log('Server ready'))


Ce programme ne se terminera jamais. Si vous appelez process.exit(), toutes les demandes en cours ou en cours seront abandonnées. N'est pas cool.



Dans ce cas, il est nécessaire d'envoyer une commande de signal SIGTERMet de la traiter à l'aide d'un gestionnaire de signaux de processeur ( processvous n'avez pas besoin de le connecter, il est disponible par défaut): 



const express = require('express')

const app = express()

app.get('/', (req, res) => {
    res.send('Hi!')
})

const server = app.listen(3000, () => console.log('Server ready'))

process.on('SIGTERM', () => {
    server.close(() => {
        console.log('Process terminated')
    })
})


Que sont les signaux? Les signaux sont un système de communication POSIX: notifiant à un processus qu'un événement s'est produit.



SIGKILL- signal de l'achèvement immédiat du processus, similaire process.exit().



SIGTERM- signal de la fin douce du processus. Ce signal peut être envoyé par un système de contrôle de processus tel que upstart, supervisordetc.



Vous pouvez envoyer ce signal dans le programme via une autre fonction: 



process.kill(process.id, 'SIGTERM')


Ou à partir d'un autre programme Node.js ou de toute autre application exécutée sur le système, à condition qu'ils connaissent le PID du processus que vous souhaitez terminer.



Comment lire les variables d'environnement dans Node.js?

Le module principal Node.js processa une propriété envcontenant toutes les variables d'environnement définies au démarrage du processus.



Voici un exemple d'accès à la variable d'environnement par défaut NODE_ENV development: 



process.env.NODE_ENV // development


Définir une valeur en production avant d'exécuter le script indiquera à Node.js qu'il a un environnement de production devant lui.



De la même manière, vous pouvez accéder à n'importe quelle variable d'environnement définie.



Comment utiliser le REPL Node.js

La commande est nodeutilisée pour exécuter les scripts Node.js: 



node script.js


Si nous omettons le nom du fichier, nous passerons en mode REPL: 



node


Le REPL (Run Evaluate Print Loop) est un environnement d'exécution de code (généralement une fenêtre de terminal) qui prend une expression saisie par l'utilisateur et renvoie le résultat de l'évaluation de cette expression.



Si vous entrez nodedans le terminal, ce qui suit se produit: 



>


Le terminal passera en mode veille.



Pour être plus précis, le terminal dans ce cas attend qu'un code JavaScript soit entré.



Introduisons ce qui suit: 



> console.log('test')
test 
undefined 
>


La première valeur testest ce que nous avons dit de sortir vers la console, puis nous obtenons la undefinedvaleur renvoyée par l'exécution, console.log()



après quoi nous pouvons entrer autre chose.



Utiliser tabpour l'auto-complétion

Le REPL est interactif.



Si vous appuyez tabdessus pendant l'écriture de code, le REPL tentera de terminer ce qu'il a écrit en choisissant parmi des variables précédemment définies ou prédéfinies.



Objets JavaScript

Essayez de taper le nom de la classe JavaScript, par exemple Numberajoutez un point et cliquez sur tab.



Le REPL affichera toutes les propriétés et méthodes de cette classe:







Objets globaux

Vous pouvez obtenir une liste d'objets globaux en tapant global.et en appuyant sur tab:







Variable spéciale _

Si vous tapez à la fin du code _, le résultat de la dernière opération sera affiché.



Commandes après le point

Le REPL contient des commandes spéciales commençant par un point. Les voici:



  • .help - affiche une liste des commandes disponibles
  • .editor- active le mode d'édition pour l'écriture de code JavaScript multiligne. Pour exécuter le code dans ce mode, appuyez surctrl-D
  • .break- arrête de saisir le code multiligne. Similaire au pressagectrl-C
  • .clear - réinitialise le contexte REPL à un objet vide, supprime tout le code entré
  • .load - charge un fichier JavaScript situé dans le répertoire courant (de travail)
  • .save - enregistre la session REPL dans un fichier avec le nom spécifié
  • .exit- quitter REPL. Comme double tapctrl-C


Le REPL comprend que vous entrez un code multiligne sans appeler .editor.



Par exemple, si vous avez commencé à implémenter l'itération: 



[1, 2, 3].forEach(num => {


et cliqué enter, REPL ira sur une nouvelle ligne avec trois points au début, indiquant que vous pouvez continuer à travailler avec le bloc de code: 



... console.log(num)
... })


Si vous entrez .breakà la fin, le mode de code multiligne s'arrêtera et l'expression ne sera pas exécutée.



Passer des arguments à l'aide de la ligne de commande

Lors du lancement d'une application Node.js, vous pouvez lui transmettre un nombre quelconque d'arguments.



Les arguments peuvent être autonomes ou clé et valeur.



Par exemple: 



node app.js joe


ou 



node app.js name=joe


La manière dont vous récupérez la valeur dans le code Node.js en dépend.



Un objet intégré est utilisé pour récupérer les valeurs process.



La propriété de argvcet objet contient un tableau d'arguments transmis via la ligne de commande.



Le premier argument est le chemin complet de la commande node.



Le second est le chemin complet du fichier exécutable.



Les arguments qui nous intéressent commencent à la troisième position (index du tableau).



Vous pouvez parcourir les arguments (y compris le chemin du nœud et le chemin du fichier) avec une boucle: 



process.argv.forEach((val, index) => {
    console.log(`${index}: ${val}`)
})


Les arguments passés peuvent être obtenus en créant un nouveau tableau sans les deux premiers paramètres: 



const args = process.argv.slice(2)


Si nous avons un argument sans index (clé): 



node app.js joe


nous pouvons l'obtenir comme ceci: 



const args = process.argv.slice(2)
args[0]


Dans ce cas: 



node app.js name=joe


args[0]- name=joec'est pourquoi nous devons l'analyser. La meilleure façon de faire est d'utiliser la bibliothèque minimist pour traiter les arguments: 



const args = require('minimist')(process.argv.slice(2))
args['name'] // joe


Ici, vous devez utiliser un double tiret avant chaque argument: 



node app.js --name=joe


Sortie des résultats sur la ligne de commande à l'aide de Node.js

Sortie standard via module console

Node.js fournit un module de console qui contient de nombreuses façons très utiles d'interagir avec la ligne de commande.



Cela ressemble à un objet de consolenavigateur.



L'une des principales méthodes de ce module est console.log(), qui imprime la chaîne transmise à la console.



Si vous passez un objet, il sera converti en chaîne.



On peut passer console.logplusieurs variables: 



const x = 'x'
const y = 'y'
console.log(x, y)


et Node.js affichera les deux.



Nous pouvons également formater la chaîne à l'aide de spécificateurs:



Par exemple: 



console.log('My %s has %d years', 'cat', 2)


  • %s - met en forme la variable sous forme de chaîne
  • %d - formate la variable sous forme de nombre
  • %i - convertit une variable en entier
  • %o - met en forme une variable comme un objet


Par exemple: 



console.log('%o', Number)


Nettoyer la console

console.clear() efface la console (le comportement dépend de la console utilisée).



Comptage des éléments

console.count()Est une méthode pratique.



Examinez ce code: 



const x = 1 
const y = 2 
const z = 3
console.count(
    'The value of x is ' + x +
    ' and has been checked .. how many times?'
)
console.count(
    'The value of x is ' + x +
    ' and has been checked .. how many times?'
)
console.count(
    'The value of y is ' + y +
    ' and has been checked .. how many times?'
)


Le compteur compte le nombre de lignes affichées et affiche ce nombre. 



The value of x is 1 and has been checked .. how many times?: 1
The value of x is 1 and has been checked .. how many times?: 2
The value of y is 2 and has been checked .. how many times?: 1


Vous pouvez donc compter le nombre de pommes et d'oranges: 



const oranges = ['orange', 'orange']
const apples = ['just one apple']
oranges.forEach(fruit => console.count(fruit))
apples.forEach(fruit => console.count(fruit))


Affichage de trace de pile

Il y a des situations où vous devez afficher la trace de pile d'une fonction, par exemple, afin de répondre à la question "Comment avons-nous atteint ce morceau de code?"



Vous pouvez le faire avec console.trace(): 



const function2 = () => console.trace()
const function1 = () => function2()
function1()


Cela imprimera la trace de la pile sur la console. C'est ce que nous voyons sur la ligne de commande si nous exécutons le code ci-dessus dans le REPL Node.js: 



Trace
    at function2 (repl:1:33)
    at function1 (repl:1:25)
    at repl:1:1
    at ContextifyScript.Script.runInThisContext (vm.js:44:33)
    at REPLServer.defaultEval (repl.js:239:29)
    at bound (domain.js:301:14)
    at REPLServer.runBound [as eval] (domain.js:314:12)
    at REPLServer.onLine (repl.js:440:10)
    at emitOne (events.js:120:20)
    at REPLServer.emit (events.js:210:7)


Comptage du temps d'exécution du code

Vous pouvez facilement calculer la durée d'exécution d'une fonction à l'aide de time()et timeEnd(): 



const doSomething = () => console.log('test')
const measureDoingSomething = () => {
    console.time('doSomething()')
    //  -      
    doSomething()
    console.timeEnd('doSomething()')
}
measureDoingSomething()


stdout et stderr

Comme nous le savons, console.log est idéal pour imprimer des messages sur la console. C'est ce qu'on appelle la sortie standard ou stdout.



console.erroraffiche le flux stderr.



Ce flux n'est pas sorti sur la console, mais écrit dans le journal des erreurs.



Styliser la sortie

Vous pouvez coloriser la sortie de texte sur la console à l'aide de séquences d'échappement . Ces séquences sont un ensemble de symboles qui identifient une couleur.



Par exemple: 



console.log('\x1b[33m%s\x1b[0m', 'hi!')


Si vous tapez le code ci-dessus dans le Node.js REPL, il hi!sera jaune.



La méthode envisagée est assez laborieuse. Le moyen le plus simple de coloriser la sortie de la console consiste à utiliser une bibliothèque. L'une de ces bibliothèques est Chalk , qui, en plus de définir la couleur, vous permet de rendre le texte en gras, oblique ou souligné.



Installez la bibliothèque à l'aide npm install chalket utilisez-la comme suit: 



const chalk = require('chalk')
console.log(chalk.yellow('hi!'))


L'utilisation est chalk.yellowbeaucoup plus facile que la mémorisation de séquences complexes. Cela rend également le code plus lisible.



Création d'une barre de progression

Progress est une excellente bibliothèque pour créer des barres de progression dans le terminal. Installez-le avec npm install progress.



Cet extrait crée une barre de progression en 10 étapes. Une étape est effectuée toutes les 100 ms. Lors du remplissage de l'indicateur, nous désactivons le compteur: 



const ProgressBar = require('progress')

const bar = new ProgressBar(':bar', { total: 10 })
const timer = setInterval(() => {
    bar.tick()
    if (bar.complete) clearInterval(timer)
}, 100)


Merci de votre attention, mes amis. Si vous trouvez des erreurs et des fautes de frappe, n'hésitez pas à écrire en PM, je vous en serai reconnaissant.



À suivre…


More articles:


All Articles