Guide Node.js, partie 2: JavaScript, V8, quelques astuces de développement

En publiant la première partie de la traduction de ce guide sur Node.js, nous avons décidé de connaître l'opinion du public sur l'opportunité de continuer à travailler sur le projet et avons mené une petite enquête. Il s'est avéré qu'environ 94% de ceux qui ont voté ont appuyé notre initiative. Alors rencontrez la deuxième partie du tutoriel Node.js.



Aujourd'hui, nous allons parler du type de connaissances JS dont vous avez besoin pour développer efficacement des applications pour la plate-forme Node.js, discuter des différences entre le navigateur et le code JavaScript côté serveur, et parler des moteurs JS et de certaines techniques de développement Node.js.

De quel type de connaissances JS ai-je besoin pour le développement de Node.js?

Supposons que vous venez de commencer la programmation. À quelle profondeur avez-vous besoin d'apprendre JavaScript pour réussir à maîtriser Node.js? Il est difficile pour un débutant d'atteindre un tel niveau lorsqu'il acquiert une confiance suffisante dans ses compétences professionnelles. En outre, lorsque vous étudiez la programmation, vous pouvez penser que vous ne comprenez pas exactement où se termine JavaScript du navigateur et le développement de Node.js.

Si vous êtes au tout début du chemin d'un programmeur JavaScript, je vous conseillerais, avant d'écrire pour Node.js, de bien maîtriser les concepts de langage suivants:

• Constructions lexicales.
• Expressions.
• Types.
• Variables
• Les fonctions
• Ce mot-clé.
• Fonctions fléchées
• Cycles
• Portées.
• Tableaux
• Chaînes de modèle.
• Appliquez un point-virgule.
• Travaillez en mode strict.

En fait, cette liste continue, mais si vous maîtrisez tout cela, cela signifie que vous jetterez une bonne base pour un développement productif des clients et des serveurs en JavaScript.
Les concepts de langage suivants sont également très importants pour comprendre les idées de programmation asynchrone, qui sont l'une des parties de base de Node.js. En particulier, nous parlons de ce qui suit:

• Fonctions de programmation et de rappel asynchrones.
• Minuteries.
• Des promesses.
• Construction asynchrone / wait.
• Court-circuits.
• Cycle d'événements.

Il existe de nombreux supports JavaScript qui permettent aux débutants d'apprendre la langue. Par exemple, voici le cours de formation de l'auteur pour ce guide, voici une section très utile de MDN, voici le tutoriel pour javascript.ru. Vous pouvez apprendre les mécanismes JavaScript de base sur freecodecamp.com .

Ci-dessus, nous avons parlé de la façon dont les débutants peuvent être préoccupés par la question de savoir où se situe la frontière entre le développement JavaScript du serveur et du client. Parlons-en.

Différences entre la plateforme Node.js et le navigateur

En quoi le développement JS pour Node.js est-il différent de la programmation par navigateur? La similitude entre ces environnements est que le même langage est utilisé à la fois là et là. Mais le développement d'applications conçues pour s'exécuter dans un navigateur est très différent du développement d'applications serveur. Malgré l'utilisation du même langage, il existe certaines différences clés qui transforment ces deux types de développement en activités complètement différentes.

Il convient de noter que si quelqu'un qui avait l'habitude de faire l'apprentissage frontal pour démarrer Node.js, il a une occasion très sérieuse de maîtriser rapidement tout ce qui est nécessaire car il écrira dans une langue qu'il connaît déjà. Si le besoin d'apprendre un nouvel environnement est ajouté et le besoin d'apprendre une nouvelle langue, la tâche est beaucoup plus compliquée.
Ainsi, la principale différence entre le client et le serveur est l'environnement pour lequel vous devez programmer, dans les écosystèmes de ces environnements.

Dans le navigateur, la majeure partie du travail concerne diverses opérations avec des documents Web via le DOM, ainsi que l'utilisation d'autres API de plate-forme Web, telles que, par exemple, des mécanismes pour travailler avec des cookies. Node.js, bien sûr, a tout cela. Il n'y a aucun objet document , aucun objet window , ainsi que d'autres objets fournis par le navigateur.

Le navigateur, quant à lui, ne dispose pas des mécanismes logiciels disponibles dans l'environnement Node.js et existe sous la forme de modules pouvant être connectés à l'application. Par exemple, il s'agit d'une API pour accéder au système de fichiers.

Une autre différence entre le développement client et serveur dans JS est que lorsque vous travaillez dans un environnement Node.js, le développeur a un contrôle total sur l'environnement. Sauf si vous développez une application open source qui peut être exécutée n'importe où, vous savez exactement, par exemple, sur quelle version de Node.js votre projet fonctionnera. C'est très pratique par rapport à l'environnement client où votre code doit fonctionner dans le navigateur de l'utilisateur. De plus, cela signifie que vous pouvez, sans crainte de problèmes, utiliser les dernières fonctionnalités de la langue.

Étant donné que JavaScript se développe extrêmement rapidement, les navigateurs n'ont tout simplement pas assez de temps pour mettre en œuvre rapidement toutes ses innovations. De plus, tous les utilisateurs ne travaillent pas sur les dernières versions des navigateurs. En conséquence, les développeurs qui souhaitent utiliser quelque chose de nouveau dans leurs programmes sont obligés d'en tenir compte, de veiller à la compatibilité de leurs applications avec les navigateurs qu'ils utilisent, ce qui peut entraîner la nécessité d'abandonner les fonctionnalités JavaScript modernes. Vous pouvez bien sûr utiliser le transporteur Babel pour convertir le code dans un format compatible avec la norme EcmaScript 5, qui est pris en charge par tous les navigateurs, mais vous n'en aurez pas besoin lorsque vous travaillerez avec Node.js.

Une autre différence entre Node.js et les navigateurs est que Node.js utilise le système de modules CommonJS , tandis que dans les navigateurs, vous pouvez voir le début de la mise en œuvre de la norme ES Modules. En pratique, cela signifie qu'actuellement dans Node.js, la construction require() est utilisée pour connecter le code externe et l' import dans le code du navigateur.

V8 et autres moteurs JavaScript

V8 est le nom du moteur JavaScript utilisé dans le navigateur Google Chrome. C'est lui qui est responsable de l'exécution du code JavaScript, qui pénètre dans le navigateur lorsque l'on travaille sur Internet. V8 fournit un runtime pour JavaScript. DOM et autres API de plate-forme Web sont fournis par le navigateur.

Le moteur JS est indépendant du navigateur dans lequel il s'exécute. C'est ce fait qui a permis l'émergence et le développement de la plateforme Node.js. Le V8 a été choisi comme moteur pour Node.js en 2009. En raison de la croissance explosive de la popularité, Node.js V8 s'est avéré être un moteur qui est maintenant responsable de l'exécution d'une énorme quantité de code JS côté serveur.

L'écosystème de Node.js est immense. Grâce à cela, le V8 est également utilisé, à travers des projets comme Electron , pour développer des applications bureautiques.

Il convient de noter qu'en plus du V8, il existe d'autres moteurs:

• Firefox utilise le moteur SpiderMonkey .
• Safari utilise JavaScriptCore (également appelé Nitro).
• Edge utilise le moteur Chakra .

La liste des moteurs JS ne se limite pas à cela.

Ces moteurs implémentent la spécification ECMA-262, également appelée ECMAScript. C'est cette spécification qui standardise JavaScript. La dernière version de la norme est disponible ici .

Développement du moteur JS et aspiration aux performances

Le moteur V8 est écrit en C ++, il est constamment amélioré. Il peut fonctionner sur de nombreux systèmes, en particulier Mac, Windows et Linux. Ici, nous ne parlerons pas des détails de la mise en œuvre de la V8. Des informations à leur sujet peuvent être trouvées dans d'autres publications, y compris sur le site officiel de V8 . Ils changent avec le temps, parfois très sérieusement.

Le V8 évolue constamment, on peut en dire autant des autres moteurs. Cela conduit notamment à une augmentation des performances des navigateurs Web et de la plateforme Node.js. Les fabricants de moteurs de navigation sont constamment en concurrence, luttant pour la vitesse d'exécution du code, cela dure depuis de nombreuses années. Tout cela profite aux utilisateurs et aux programmeurs.

▍ Interprétation et compilation

JavaScript est considéré comme un langage interprété, mais les moteurs modernes sont loin de n'interpréter que du code JS. Ils le compilent. Cette tendance peut être observée depuis 2009, lorsque le compilateur JavaScript a été ajouté dans Firefox 3.5, après quoi d'autres fabricants de moteurs et de navigateurs ont adopté cette idée.

V8 compile JavaScript pour améliorer les performances du code. Depuis l'avènement de Google Maps en 2004, JavaScript a évolué, évolué d'une langue dans laquelle, pour implémenter les fonctionnalités interactives des applications Web, ils écrivaient généralement quelques dizaines de lignes, dans une langue dans laquelle des applications de navigateur composées de milliers voire de centaines sont écrites. mille lignes de code. De telles applications peuvent fonctionner pendant des heures dans le navigateur, ce qui est très différent des anciens scénarios d'utilisation de JS, le code sur lequel, par exemple, ne pouvait être utilisé que pour vérifier l'exactitude des données saisies dans les formulaires. Dans les conditions modernes, la compilation du code a beaucoup de sens, car bien que l'exécution de cette étape puisse retarder le moment où le code est lancé, après la compilation, le code est beaucoup plus productif que celui qui serait traité exclusivement par l'interpréteur et s'exécuterait plus rapidement, mais fonctionnerait plus lentement.

Maintenant, après avoir discuté de certaines dispositions concernant les moteurs JS, l'interprétation et la compilation du code, passons à la pratique. À savoir, parlons de la façon de fermer les applications Node.js.

Quitter l'application Node.js

Il existe plusieurs façons de fermer les applications Node.js.

Ainsi, lorsque vous exécutez un programme dans la console, vous pouvez terminer son travail en utilisant le raccourci clavier ctrl+c . Mais nous nous intéressons davantage aux méthodes logicielles de fermeture des applications. Et nous allons peut-être commencer par la commande la plus grossière pour quitter le programme, qui, comme vous le comprendrez maintenant, vaut mieux ne pas l'utiliser.

Le module de process noyau fournit une méthode pratique qui vous permet de quitter par programme une application Node.js. Cela ressemble à ceci:

 process.exit() 

Lorsque Node.js rencontre une telle commande dans le code, cela conduit au fait que son processus se termine instantanément. Cela signifie qu'absolument tout ce que le programme a fait sera plutôt grossier et interrompu inconditionnellement. Nous parlons de rappels non invités, de requêtes réseau en cours d'exécution au moment de la publication, d'actions avec des fichiers, d'opérations d'écriture dans stdout ou stderr .

Si cette situation vous convient, vous pouvez utiliser cette méthode. Lorsque vous l'appelez, vous pouvez lui transmettre un entier qui sera perçu par le système d'exploitation comme le code de sortie du programme.

 process.exit(1) 

Par défaut, ce code est défini sur 0, ce qui signifie une réussite. D'autres codes de sortie ont des significations différentes, ce qui peut être utile pour les utiliser dans votre propre système afin d'établir l'interaction de certains programmes avec d'autres.
Des détails sur les codes d'arrêt du programme peuvent être trouvés ici .

Vous pouvez également affecter un code de sortie à la propriété process.exitCode . Cela ressemble à ceci:

 process.exitCode = 1 

Une fois le programme terminé, Node.js renverra ce code au système.

Il convient de noter que le travail du programme se terminera naturellement de lui-même après avoir exécuté toutes les actions qui y sont spécifiées. Cependant, dans le cas de Node.js, il existe souvent des programmes qui, dans des conditions idéales, sont conçus pour fonctionner pendant une durée indéterminée. Nous parlons, par exemple, de serveurs HTTP comme celui-ci:

 const express = require('express') const app = express() app.get('/', (req, res) => { res.send('Hi!') }) app.listen(3000, () => console.log('Server ready')) 

Un tel programme, si rien ne se passe, en théorie, peut fonctionner pour toujours. Dans ce cas, si vous appelez process.exit() , les opérations effectuées par celui-ci au moment de l'appel de cette commande seront interrompues. Et c'est mauvais.

Pour terminer le travail de ces programmes, vous devez utiliser le signal SIGTERM et effectuer les actions nécessaires à l'aide du gestionnaire approprié.

Veuillez noter que pour utiliser l'objet de process , vous n'avez pas besoin de connecter quoi que ce soit à l'aide de require , car cet objet est disponible par défaut pour les applications Node.js.

Prenons l'exemple suivant:

 const express = require('express') const app = express() app.get('/', (req, res) => { res.send('Hi!') }) app.listen(3000, () => console.log('Server ready')) process.on('SIGTERM', () => { app.close(() => {   console.log('Process terminated') }) }) 

Quels sont les signaux? Les signaux sont un moyen d'interaction entre les processus dans la norme POSIX (Portable Operating System Interface). Ce sont des notifications envoyées au processus afin de l'informer de certains événements.

Par exemple, un signal SIGKILL indique à un processus qu'il doit s'arrêter immédiatement. Cela fonctionne idéalement comme process.exit() .

Le signal SIGTERM indique au processus qu'il doit effectuer une procédure d'arrêt normale. Ces signaux sont envoyés par les gestionnaires de processus, tels que les upstart ou les supervisord , et par de nombreux autres.

Vous pouvez envoyer un tel signal à partir du programme lui-même, en utilisant la commande suivante:

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

Pour mener à bien une telle commande, vous devez connaître le PID processus que vous prévoyez de terminer.

Lecture des variables d'environnement à partir de Node.js

Le module de noyau de process a la propriété env , qui donne accès à toutes les variables d'environnement qui ont été définies au moment du démarrage du processus.

Voici un exemple de travail avec la variable d'environnement NODE_ENV , qui, par défaut, est définie sur development :

 process.env.NODE_ENV // "development" 

Si, avant d'exécuter le script, définissez-le sur production , cela indiquera à Node.js que le programme s'exécute dans un environnement de production.

De même, vous pouvez travailler avec d'autres variables d'environnement, par exemple celles que vous définissez vous-même.

Résumé

Aujourd'hui, nous avons abordé la programmation basée sur navigateur et côté serveur en JavaScript, parlé des moteurs JS, comment fermer les applications serveur et comment lire les variables d'environnement à partir des programmes Node.js. La prochaine fois, nous parlerons de l'hébergement des applications Node.js, comment utiliser Node.js en mode REPL, comment travailler avec des arguments qui peuvent être passés aux scripts lorsqu'ils sont appelés, comment interagir avec la console et comment concevoir le code dans le formulaire modules.

Chers lecteurs! Quels tutoriels JavaScript recommanderiez-vous aux débutants?