10 Node.js meilleures pratiques: l'illumination des gourous du nœud

Les plats clés

• Utiliser les scripts NPM pour organiser des tâches telles que les builds, les tests et le démarrage de l'application. Cela fournit une seule source de vérité lorsque les développeurs regardent un nouveau projet.
• Utilisez des variables d'environnement, telles que process.env.node_env, à partir des premiers stades d'un projet. Cela n'assure aucune fuite d'informations sensibles et construit correctement le code dès le début.
• Comprendre la boucle d'événement et comment utiliser SetImMediate () ou setTimeout () pour décharger les tâches à forte intensité de processeur au cycle de boucle de l'événement suivant.
• Utiliser l'héritage fonctionnel pour la simplicité et pour éviter les complexités de l'héritage ou des classes prototypales. Il s'agit d'une méthode préférée parmi de nombreux contributeurs de nœuds prolifiques.
• Considérons des alternatives à JavaScript, telles que TypeScript, Flow, Elm, Clojurescript ou CoffeeScript en fonction du niveau de l'expertise et de la nature de l'application. Cela peut potentiellement profiter à l'équipe avec très peu de configuration.

10 Node.js meilleures pratiques: l'illumination des gourous du nœud est de l'auteur invité Azat Mardan. Les articles invités SitePoint visent à vous apporter du contenu engageant des écrivains et des conférenciers éminents de la communauté Web.

Dans mes conseils précédents de l'article 10 pour devenir un meilleur développeur de nœuds en 2017, j'ai introduit 10 conseils, astuces et techniques Node.js que vous pourriez appliquer à votre code aujourd'hui. Ce message se poursuit dans cette veine avec 10 autres meilleures pratiques pour vous aider à faire passer vos compétences au nœud au niveau supérieur. C'est ce que nous allons couvrir:

1. Utilisez des scripts NPM - Arrêtez d'écrire des scripts bash lorsque vous pouvez mieux les organiser avec les scripts NPM et le nœud. Par exemple, NPM Run Build, Start and Tester. Les scripts NPM sont comme la seule source de vérité lorsque les développeurs de nœuds regardent un nouveau projet.
2. Utilisez Env Vars - Utilisez Process.env.node_env en le définissant sur le développement ou la production. Certains frameworks utiliseront également cette variable, alors jouez par la convention.
3. Comprendre la boucle d'événement - SetImMediate () n'est pas immédiat tandis que NextTick () n'est pas suivant. Utilisez SetImMediate () ou SetTimeout () pour décharger les tâches à forte intensité de processeur au cycle de boucle de l'événement suivant.
4. Utiliser l'héritage fonctionnel - Évitez de pénétrer dans les débats insensés et un piège à drainage du cerveau de débogage et de compréhension de l'héritage prototypal ou des classes en utilisant simplement l'héritage fonctionnel comme certains des contributeurs de nœuds les plus prolifiques.
5. Nommez les choses de manière appropriée - donnez des noms significatifs qui serviront de documentation. Aussi, veuillez aucun nom de fichiers en majuscules, utilisez un tableau de bord si nécessaire. Majuscule dans les noms de fichiers non seulement étranges, mais peut provoquer des problèmes multiplateformes.
6. Envisagez de ne pas utiliser JavaScript - ES6 / 7 est un ajout pathétique qui est né de 6 ans de réunions alors que nous avions déjà un meilleur JavaScript appelé CoffeeScript. Utilisez-le si vous voulez le code de navire plus rapidement et arrêtez de perdre du temps à débattre de var / const / let, semi-colons, classe et autres arguments.
7. Fournir du code natif - Lorsque vous utilisez des transpiles, commettez du code JS natif (résultat des builds) afin que vos projets puissent s'exécuter sans les builds
8. Utilisez gzip - duh! NPM I Compression -s et journalisation saine - pas trop à pas peu en fonction de l'environnement. NPM I Morgan -s
9. Évoluer - Commencez à penser au regroupement et à avoir des services sans état dès le premier jour de développement de nœuds. Utilisez le contrôle du cluster PM2 ou Strongloop
10. Demandes de cache - Sortez du jus maximal de vos serveurs de nœuds en les cachant derrière un serveur de fichiers statique tel que Nginx et / ou le cache de niveau de demande comme le cache de vernis et la mise en cache CDN.

Alors, bissectons-nous et jetons un coup d'œil à chacun d'eux individuellement. Allons-nous?

Utilisez des scripts NPM

C'est presque une norme maintenant pour créer des scripts NPM pour les builds, les tests et, surtout, pour démarrer l'application. Il s'agit du premier lieu de nœud que les développeurs regardent lorsqu'ils rencontrent un nouveau projet de nœud. Certaines personnes (1, 2, 3, 4) ont même abandonné le grognement, le gorgée et les autres pour le script NPM plus bas mais plus fiable. Je peux parfaitement comprendre leur argument. Étant donné que les scripts NPM ont des crochets pré et post, vous pouvez atteindre un niveau d'automatisation très sophistiqué:

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Souvent, lors du développement pour le frontal, vous souhaitez exécuter deux processus de montre ou plus pour reconstruire votre code. Par exemple, un pour WebPack et un autre pour Nodemon. Vous pouvez le faire avec && car la première commande ne publiera pas l'invite. Cependant, il existe un module pratique appelé simultanément qui peut engendrer plusieurs processus et les exécuter en même temps.

également, installez des outils de ligne de commande de développement tels que webpack, nodemon, gulp, moka, etc. localement pour éviter les conflits. Vous pouvez pointer vers ./node_modules/.bin/mocha par exemple ou ajouter cette ligne à votre profil bash / zsh (chemin!):

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Utiliser Env Vars

Utiliser les variables d'environnement même pour les premiers stades d'un projet pour vous assurer qu'il n'y a pas de fuite d'informations sensibles, et juste pour construire correctement le code depuis le début. De plus, certaines bibliothèques et frameworks (je sais que Express le fait à coup sûr) tirera des informations comme Node_env pour modifier leur comportement. Réglez-le à la production. Définissez également vos valeurs Mongo_uri et API_KEY. Vous pouvez créer un fichier shell (par exemple start.sh) et l'ajouter à .gitignore:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

NODEMON a également un fichier de configuration où vous pouvez mettre votre Env Vars (exemple):

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

Comprendre la boucle d'événement

La boucle d'événements puissante et intelligente est ce qui rend le nœud si rapide et brillant en utilisant tout le temps qui aurait été gaspillé en attendant que les tâches d'entrée et de sortie se terminent. Ainsi, le nœud est excellent pour optimiser les systèmes liés aux E / S.

Si vous avez besoin d'effectuer quelque chose qui exigeait le processeur (par exemple, le calcul, le hachage des mots de passe ou la compression), alors en plus de reproduire de nouveaux processus pour ces tâches CPU, vous voudrez peut-être explorer le report de la tâche avec SETIMMEDIATIE () ou setTimeout () - Le code de leurs rappels se poursuivra sur le prochain cycle de boucle d'événements. NextTick () fonctionne sur le même cycle contraire au nom. Argh!

Voici un diagramme de Bert Belder qui a travaillé sur la boucle de l'événement. Il sait clairement comment fonctionne la boucle d'événement!

Utiliser l'héritage fonctionnel

JavaScript prend en charge l'héritage prototypal qui est lorsque les objets héritent d'autres objets. L'opérateur de classe a également été ajouté à la langue avec ES6. Cependant, il est ouvertement complexe par rapport à l'héritage fonctionnel. La plupart des gourous de nœuds préfèrent la simplicité de ce dernier. Il est implémenté par un modèle d'usine de fonctions simples et ne nécessite pas l'utilisation de prototype, nouveau ou ceci. Il n'y a pas d'effets implicites lorsque vous mettez à jour le prototype (ce qui fait changer toutes les instances également) car dans l'héritage fonctionnel, chaque objet utilise sa propre copie des méthodes.

Considérons le code de TJ Holowaychuk, le génie prolifique derrière Express, Mocha, Connect, Superagent et des dizaines d'autres modules de nœud. Express utilise l'héritage fonctionnel (code source complet):

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Pour être objectif, les modules de nœud de base utilisent beaucoup l'héritage prototypal. Si vous suivez ce modèle, assurez-vous de savoir comment cela fonctionne. Vous pouvez en savoir plus sur les modèles d'héritage JavaScript ici.

Nommez les choses de manière appropriée

Celui-ci est évident. Les bons noms servent de documentation. Lequel préféreriez-vous?

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Je n'ai aucune idée de ce que Dexter fait quand je ne regarde que App.use (). Que diriez-vous d'un nom plus significatif différent:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

De la même manière, les noms de fichiers doivent refléter correctement le but du code à l'intérieur. Si vous jetez un œil au dossier lib de Node (lien github) qui a tous les modules de base regroupés avec la plate-forme, vous verrez une nomation claire des fichiers / modules (même si vous n'êtes pas très familier avec les modules de base):

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

Les modules internes sont marqués d'un soulignement (_debugger.js, _http_agent.js, _http_client.js) Tout comme les méthodes et la variable dans le code. Cela aide à avertir les développeurs qu'il s'agit d'une interface interne et si vous l'utilisez, vous êtes seul - ne vous plaignez pas s'il est refactorisé ou même supprimé.

Envisagez de ne pas utiliser javascript

hein? L'avez-vous juste lu correctement? Mais qu'est-ce que diable? Oui. C’est correct. Même avec ES6 et les deux fonctionnalités ajoutées par ES2016 / ES7, JavaScript a toujours ses bizarreries. Il existe d'autres options en plus de JavaScript dont vous ou votre équipe pouvez bénéficier avec très peu de configuration. Selon le niveau de l'expertise et la nature de l'application, vous pourriez être mieux avec dactylographie ou flux qui fournit un frappeur fort. À l'autre extrémité du spectre, il y a de l'orme ou de la clochologie qui sont purement fonctionnels. Coffeescript est une autre option formidable et testée au combat. Vous pourriez également jeter un œil à Dart 2.0.

quand tout ce dont vous avez besoin n'est que quelques macros (les macros vous permettent de construire exactement la langue que vous voulez), pas une nouvelle langue, alors considérez Sweet.js qui fera exactement cela - vous permettre Pour écrire du code qui génère du code.

Si vous empruntez la voie non-javascript, veuillez toujours inclure votre code compilé car certains développeurs peuvent ne pas comprendre assez bien votre langue pour le construire correctement. Par exemple, VS Code est l'un des plus grands projets TypeScript, peut-être après Angular 2, et le code utilise TypeScript pour patcher le module de base du nœud avec les types. Dans le VSCODE / SRC / VS / BASE / NODE / de VS Code Repo (lien), vous pouvez voir des noms de modules familiers comme Crypto, Process, etc. Mais avec l'extension TS. Il existe d'autres fichiers TS dans le repo. Cependant, ils ont également inclus VScode / build avec le code JavaScript natif.

Connaître Express Middleware

Express est un cadre génial et très mature. Son brillant vient de permettre aux myriades d'autres modules de configurer son comportement. Ainsi, vous devez connaître les middleware les plus utilisés et vous devez savoir comment l'utiliser . Alors pourquoi ne pas saisir ma feuille de triche express. J'ai les principaux modules de middleware répertoriés là-bas. Par exemple, NPM I Compression -S donnera à réduire la vitesse de téléchargement en dégonflant les réponses. Logger («Tiny») ou Logger («Common») fournira respectivement moins (Dev) ou plus (Prod).

Évoluer

Le nœud

est excellent en asynchronisation en raison de ses E / S non bloquantes et il maintient cette façon asynchrone de coder simple car il n'y a qu'un seul fil. C'est l'occasion de commencer à évoluer dès le début, peut-être même avec les premières lignes de code. Il y a le module de cluster de base qui vous permettra de mettre à l'échelle verticalement sans trop de problèmes. Cependant, une manière encore meilleure serait d'utiliser un outil tel que PM2 ou le contrôle de la cluster de Strongloop.

Par exemple, c'est ainsi que vous pouvez commencer avec PM2:

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Ensuite, vous pouvez démarrer quatre instances du même serveur:

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Pour Docker, PM2 Version 2 a PM2-Docker. Ainsi, votre docker peut ressembler à ceci:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

L'image officielle alpine Linux PM2 est dans le Docker Hub.

Demandes de cache

Il s'agit d'une meilleure pratique DevOps qui vous permettra de retirer plus de jus de vos instances de nœud (vous en obtenez plus d'un avec PM2 ou similaires, voir ci-dessus). La voie à suivre est de permettre aux serveurs de nœuds de faire des trucs d'applications comme la création de demandes, le traitement des données et l'exécution de la logique métier et de décharger le trafic vers des fichiers statiques vers un autre serveur Web tel qu'Apache HTTPD ou NGINX. Encore une fois, vous devriez probablement utiliser Docker pour la configuration:

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

J'aime utiliser Docker Compose pour que plusieurs conteneurs (Nginx, Node, Redis, MongoDB) fonctionnent entre eux. Par exemple:

exports <span>= module.exports = createApplication;
</span><span>// ...
</span><span>function createApplication() {
</span>  <span>var app = function(req<span>, res, next</span>) {
</span>    app<span>.handle(req, res, next);
</span>  <span>};
</span>
  <span>mixin(app, EventEmitter.prototype, false);
</span>  <span>mixin(app, proto, false);
</span>
  app<span>.request = { __proto__: req, app: app };
</span>  app<span>.response = { __proto__: res, app: app };
</span>  app<span>.init();
</span>  <span>return app;
</span><span>}
</span>

Résumé

De nos jours des logiciels open source, il n'y a aucune excuse à ne pas apprendre du code de confiance et testé qui est ouvert. Vous n'avez pas besoin d'être dans le cercle intérieur pour entrer. L'apprentissage ne s'arrête jamais et je suis sûr que bientôt nous aurons différentes meilleures pratiques en fonction des échecs et des succès que nous subirons. Ils sont garantis.

Enfin, je voulais écrire sur la façon dont les logiciels mangent le monde et comment JavaScript mange le logiciel… il y a de grandes choses comme les versions standard annuelles, beaucoup, beaucoup de modules, d'outils et de conférences NPM… mais au lieu de cela, je finirai avec un mot de prudence.

Je vois comment de plus en plus de personnes poursuivent le prochain nouveau cadre ou langue. C’est le syndrome d’objet brillant. Ils apprennent une nouvelle bibliothèque chaque semaine et un nouveau cadre chaque mois. Ils vérifient compulsivement Twitter, Reddit, Hacker News et JS Weekly. Ils utilisent le niveau d'activité écrasant dans le monde JavaScript pour tergiverser. Ils ont des histoires de github publics vides.

Apprendre de nouvelles choses est bien, mais ne le confondez pas pour construire des choses. Ce qui compte et ce qui paie votre salaire, c'est réellement construire des choses. Arrêtez-vous en ingénierie. Vous ne construisez pas le prochain Facebook. Les promesses contre les générateurs vs Async Await est un terrain pour moi, car au moment où quelqu'un a répondu à un fil dans une discussion, j'ai déjà écrit mon rappel (et utilisé CoffeeScript pour le faire 2x plus vite que dans PLAIN ES5 / 6/7! ).

La meilleure pratique finale consiste à utiliser les meilleures pratiques et le meilleur des meilleurs est de maîtriser les fondamentaux. Lisez le code source, essayez de nouvelles choses dans le code et surtout écrire vous-même des tonnes de code. Maintenant, à ce stade, arrêtez de lire et allez expédier du code qui compte!

Et juste au cas où cet article ne serait pas suffisant, voici plus de lecture sur les meilleures pratiques de nœud:

• https://blog.riseingstack.com/nodejs-at-scale--npm-best-practices
• https://devcenter.heroku.com/articles/node-best-practices
• https://blog.riseingstack.com/node-js-best-practices
• https://expressjs.com/en/advanced/best-practice-performance.html
• https://www.codementor.io/nodejs/tutorial/nodejs-best-practices

Questions fréquemment posées (FAQ) sur Node.js meilleures pratiques

Quelles sont les meilleures pratiques les plus importantes pour le développement de Node.js?

Le développement de Node.js implique plusieurs meilleures pratiques qui peuvent améliorer considérablement l'efficacité et l'évolutivité de vos applications. Il s'agit notamment de l'utilisation de la programmation asynchrone, qui permet des opérations non bloquantes et améliore les performances. Il est également crucial de gérer correctement les erreurs pour éviter les plantages d'application. Les autres meilleures pratiques incluent l'utilisation d'un linter pour appliquer la qualité du code, l'utilisation de variables d'environnement pour la configuration et l'écriture de petits modules pour garder votre base de code gérable et compréhensible.

Comment puis-je améliorer les performances de mon application Node.js?

Il existe plusieurs façons d'améliorer les performances de votre application Node.js. L'une des méthodes les plus efficaces consiste à utiliser le module de cluster, qui vous permet de créer des processus enfants qui partagent tous les ports du serveur. Cela peut considérablement améliorer les performances de votre application en lui permettant de traiter simultanément plus de demandes. De plus, vous pouvez utiliser des outils tels que PM2 pour gérer et surveiller vos applications Node.js, qui peuvent vous aider à identifier et à résoudre les problèmes de performances.

Quelles sont les erreurs courantes à éviter lors du développement avec Node.js?

Certaines erreurs courantes à éviter lors du développement avec Node.js incluent le blocage de la boucle d'événement, et non les erreurs de gestion correctement et ne pas utiliser d'outils tels que des liners pour appliquer la qualité du code. Le blocage de la boucle d'événements peut entraîner des problèmes de performances, car il empêche l'exécution d'autres opérations. Ne pas gérer les erreurs correctement peut entraîner des accidents de l'application, alors que le fait de ne pas utiliser de liners peut entraîner une qualité de code incohérente et des bogues potentiels.

Comment puis-je m'assurer que mon application Node.js est sécurisée?

Assurer la sécurité de votre application Node.js implique plusieurs meilleures pratiques. Il s'agit notamment d'utiliser HTTPS pour une communication sécurisée, de valider et de désinfecter les entrées des utilisateurs pour prévenir les attaques d'injection et l'utilisation d'en-têtes de sécurité pour se protéger contre les vulnérabilités Web courantes. Il est également important de maintenir vos dépendances à jour, car les dépendances obsolètes peuvent contenir des vulnérabilités de sécurité connues.

Quelles sont les meilleures pratiques pour tester les applications Node.js?

Le test est une partie cruciale de Développement Node.js, et il existe plusieurs meilleures pratiques à suivre. Il s'agit notamment d'écrire des tests unitaires pour tester les composants individuels de votre application, des tests d'intégration pour tester comment ces composants interagissent et des tests de bout en bout pour tester votre application dans son ensemble. Il est également important d'utiliser un système d'intégration continue (CI) pour exécuter automatiquement vos tests chaque fois que des modifications sont apportées à votre base de code.

Comment puis-je gérer les dépendances dans node.js?

Gérer les dépendances dans Node.js se fait généralement à l'aide de NPM, le gestionnaire de package par défaut pour node.js. Il est important de spécifier des versions exactes de vos dépendances dans votre fichier package.json pour vous assurer que votre application fonctionne comme prévu. Vous devez également mettre à jour régulièrement vos dépendances pour bénéficier des corrections de bogues et des correctifs de sécurité.

Quelles sont les meilleures pratiques de gestion des erreurs dans Node.js?

La gestion des erreurs est une partie cruciale du nœud. Développement JS. Les meilleures pratiques incluent l'utilisation de blocs Try / Catch pour attraper des erreurs synchrones, l'utilisation d'erreurs d'abord pour gérer les erreurs asynchrones et l'utilisation d'un mécanisme de gestion des erreurs centralisé pour gérer toutes les erreurs en un seul endroit. Il est également important de journaliser les erreurs à des fins de débogage et de répondre au client avec des messages d'erreur appropriés.

Comment puis-je assurer la qualité du code dans Node.js?

Assurer la qualité du code dans Node.js implique plusieurs meilleures pratiques. Il s'agit notamment d'utiliser un linter pour appliquer la qualité du code, de suivre un style de codage cohérent et d'écrire des tests pour attraper les bogues tôt. Il est également important d'utiliser le contrôle des versions (comme Git) pour suivre les modifications de votre base de code et pour effectuer des avis de code pour attraper des problèmes potentiels.

Comment puis-je mettre à l'échelle mon application Node.js?

Une application Node.js peut être réalisée de plusieurs manières. Une méthode courante consiste à utiliser le module de cluster pour créer des processus enfants qui partagent des ports de serveur, permettant à votre application de traiter simultanément plus de demandes. Vous pouvez également utiliser l'équilibrage de la charge pour distribuer le trafic réseau entrant sur plusieurs serveurs et l'échelle horizontale (ajoutant plus de machines) ou la mise à l'échelle verticale (ajoutant plus de ressources à une seule machine) en fonction de vos besoins.

Quelles sont les meilleures pratiques pour déployer des applications Node.js?

Le déploiement d'applications Node.js implique plusieurs meilleures pratiques. Il s'agit notamment de l'utilisation de variables d'environnement pour la configuration, de l'utilisation d'un gestionnaire de processus comme PM2 pour gérer votre application et de l'utilisation d'un système d'intégration continue (CI) pour déployer automatiquement votre application lorsque des modifications sont apportées à votre base de code. Il est également important de surveiller votre application pour identifier et résoudre les problèmes de performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!