Trucs, astuces et outils –

Le développement logiciel est complexe et, à un moment donné, votre application Node.js échouera. Si vous avez de la chance votre code se bloquera avec un message d'erreur évident. Si vous n’avez pas de chance, votre candidature continuera malgré tout mais ne générera pas les résultats escomptés. Si vous n’avez vraiment pas de chance, tout fonctionnera bien jusqu’à ce que le premier utilisateur découvre un bug catastrophique d’effacement de disque.

Qu'est-ce que le débogage?

Le débogage est l'art noir de corriger les défauts logiciels. Il est souvent facile de corriger un bogue – un caractère corrigé ou une ligne de code supplémentaire résout le problème. Trouver ce bogue est une autre affaire, et les développeurs peuvent passer de nombreuses heures malheureuses à essayer de localiser la source d'un problème. Heureusement, Node.js dispose d'excellents outils pour aider à tracer les erreurs.

Terminologie

Le débogage a sa propre sélection de jargon obscur, y compris ce qui suit:

Comment éviter les bogues

Les bogues peuvent souvent être évité avant de tester votre application…

Utilisez un bon éditeur de code

Un bon éditeur de code offrira de nombreuses fonctionnalités, notamment la numérotation des lignes, la saisie semi-automatique, le codage couleur, la correspondance des crochets, la mise en forme, l'indentation automatique, le changement de nom des variables, fragment réutilisation, inspection des objets, navigation dans les fonctions, invites de paramètres, refactorisation, détection de code inaccessible, suggestions, vérification de type, etc.

Les développeurs Node.js ont l'embarras du choix avec des éditeurs gratuits tels que VS Code Atom et Brackets ainsi que de nombreuses alternatives commerciales.

Utilisez un code Linter

Un linter peut signaler des erreurs de code telles que des erreurs de syntaxe, une mauvaise indentation, des déclarations non déclarées les variables et les parenthèses incompatibles avant d'enregistrer et de tester votre code. Les options populaires pour JavaScript et Node.js incluent ESLint JSLint et JSHint .

Ceux-ci sont souvent installés en tant que modules globaux Node.js afin que vous peut exécuter des vérifications à partir de la ligne de commande:

 eslint myfile.js

Cependant, la plupart des linters ont des plugins d'éditeur de code, tels que ESLint pour VS Code et linter-eslint pour Atom qui vérifient votre code lors de la frappe:

Utiliser le contrôle de source

Un système de contrôle de source tel que Git peut aider à protéger votre code et à gérer les révisions. Il devient plus facile de découvrir où et quand un bug a été introduit et qui devrait être blâmé! Les référentiels en ligne tels que GitHub et Bitbucket offrent de l'espace libre et des outils de gestion.

Adoptez un système de suivi des problèmes

Existe-t-il un bug si personne ne connaît Un système de suivi des problèmes est utilisé pour signaler les bogues, trouver des doublons, documenter les étapes de reproduction, déterminer la gravité, calculer les priorités, affecter des développeurs, enregistrer les discussions et suivre la progression de tout correctif.

Les référentiels source en ligne offrent souvent suivi des problèmes de base, mais des solutions dédiées peuvent être appropriées pour des équipes et des projets plus importants.

Utiliser le développement piloté par les tests

Le développement piloté par les tests (TDD) est un processus de développement qui encourage les développeurs à écrire du code qui teste le fonctionnement d'une fonction avant qu'elle ne soit écrite – par exemple, est renvoyé X lorsque la fonction Y passe l'entrée Z .

Les tests peuvent être exécutés au fur et à mesure que le code est développé pour prouver qu'une fonction fonctionne et repérez les problèmes à mesure que de nouveaux changements sont apportés. Cela dit, vos tests pourraient aussi avoir des bugs…

Step Away

Il est tentant de rester éveillé toute la nuit dans une tentative futile de localiser la source d'un bogue méchant. Non. Éloignez-vous et faites autre chose. Votre cerveau travaillera inconsciemment sur le problème et vous réveillera à 4 heures du matin avec une solution. Même si cela ne se produit pas, de nouveaux yeux repéreront ce point-virgule manquant évident.

Débogage de Node.js: variables d'environnement

Les variables d'environnement définies dans le système d'exploitation hôte peuvent être utilisées pour contrôler les paramètres de l'application Node.js. La plus courante est NODE_ENV qui est généralement définie sur développement lors du débogage.

Les variables d'environnement peuvent être définies sur Linux / macOS:

 NODE_ENV = développement

Windows cmd :

 set NODE_ENV = development

Ou Windows Powershell:

 $ env: NODE_ENV = "development"

En interne, une application permettra de nouvelles fonctionnalités de débogage et des messages. Par exemple:

 // NODE_ENV est-il réglé sur "développement"?
const DEVMODE = (process.env.NODE_ENV === 'développement');

si (DEVMODE) {
  console.log ('application démarrée en mode développement sur le port $ {PORT}');
}

NODE_DEBUG permet de déboguer des messages à l'aide de Node.js util.debuglog (voir ci-dessous), mais consultez également la documentation de vos principaux modules et frameworks pour découvrir d'autres options. [19659060] Notez que les variables d'environnement peuvent également être enregistrées dans un fichier .env . Par exemple:

 NODE_ENV = développement
NODE_LOG =. / Log / debug.log
SERVER_PORT = 3000
DB_HOST = localhost
DB_NAME = ma base de données

Puis chargé à l'aide du module dotenv :

 require ('dotenv'). Config ();

Débogage de Node.js: options de ligne de commande

Diverses options de ligne de commande peuvent être transmises au runtime du nœud lors du lancement d'une application. L'une des plus utiles est - trace-warnings qui génère des traces de pile pour les avertissements de processus (y compris les dépréciations).

Un certain nombre d'options peuvent être définies, notamment:

• - enable- cartes sources : activer les cartes sources (expérimentales)
• - throw-deprecation : lancer des erreurs lorsque des fonctionnalités obsolètes sont utilisées
• - inspect : activer l'inspecteur V8 (voir ci-dessous)

À titre d'exemple, essayons de consigner la propriété DEFAULT_ENCODING du module de chiffrement qui était obsolète dans le nœud v10:

 const crypto = require ('crypto') ;

barre de fonctions () {
  console.log (crypto.DEFAULT_ENCODING);
}

fonction foo () {
  bar();
}

foo ();

Exécutez maintenant ceci avec ce qui suit:

 node index.js

On verra alors ceci:

 tampon
(nœud: 7405) [DEP0091] DeprecationWarning: crypto.DEFAULT_ENCODING est obsolète.

Cependant, nous pouvons aussi faire ceci:

 node --trace-warnings index.js

Cela produit ce qui suit:

 tampon
(nœud: 7502) [DEP0091] DeprecationWarning: crypto.DEFAULT_ENCODING est déconseillé.
    au bar (/home/Desktop/index.js:4:22)
    à foo (/home/Desktop/index.js:8:3)
    chez Object.  (/home/Desktop/index.js:11:1)
    à Module._compile (interne / modules / cjs / loader.js: 1151: 30)
    sur Object.Module._extensions..js (internal / modules / cjs / loader.js: 1171: 10)
    à Module.load (interne / modules / cjs / loader.js: 1000: 32)
    à Function.Module._load (interne / modules / cjs / loader.js: 899: 14)
    sur Function.executeUserEntryPoint [as runMain] (internal / modules / run_main.js: 71: 12)
    sur internal / main / run_main_module.js: 17: 47

Cela nous indique que l'avertissement de dépréciation provient du code de la ligne 4 (l'instruction console.log ), qui a été exécuté lors de l'exécution de la fonction de barre . La fonction bar a été appelée par la fonction foo sur la ligne 8 et la fonction foo a été appelée sur la ligne 11 de notre script.

Notez que la même chose les options peuvent également être passées à nodemon .

Débogage de la console

L'une des façons les plus simples de déboguer une application consiste à afficher des valeurs sur la console pendant l'exécution:

 console.log (myVariable) ;

Peu de développeurs vont au-delà de cette humble commande de débogage, mais ils manquent de nombreuses autres possibilités notamment:

console.log () accepte une liste de valeurs séparées par des virgules. Par exemple:

 let x = 123;
console.log ('x:', x);
// x: 123

Cependant, La déstructuration ES6 peut offrir une sortie similaire avec moins d'effort de frappe:

 console.log ({x});
// {x: 123}

Des objets plus gros peuvent être sortis sous forme de chaîne condensée en utilisant ceci:

 console.log (JSON.stringify (obj));

util.inspect formatera les objets pour une lecture plus facile, mais console.dir () fait le travail pour vous.

Node.js util.debuglog

Le module Node.js util propose une méthode intégrée debuglog qui écrit de manière conditionnelle des messages dans STDERR :

 const util = require ('util');
const debuglog = util.debuglog ('myapp');

debuglog ('message de débogage myapp [%d]', 123);

Lorsque la variable d'environnement NODE_DEBUG est définie sur myapp (ou un caractère générique tel que * ou my * ), les messages sont affiché dans la console:

 NODE_DEBUG = myapp node index.js
MYAPP 9876: message de débogage myapp [123]

Ici, 9876 est l'ID de processus Node.js.

Par défaut, util.debuglog est silencieux. Si vous deviez exécuter le script ci-dessus sans définir une variable NODE_DEBUG rien ne serait sorti sur la console. Cela vous permet de laisser une journalisation de débogage utile dans votre code sans encombrer la console pour une utilisation régulière.

Débogage avec des modules de journalisation

Des modules de journalisation tiers sont disponibles si vous avez besoin d'options plus sophistiquées pour les niveaux de messagerie, la verbosité, le tri, sortie de fichiers, profilage, etc. Les options populaires incluent:

Inspecteur Node.js V8

Dans les sections suivantes, le projet pagehit développé en d'autres didacticiels est utilisé pour illustrer les concepts de débogage. Vous pouvez le télécharger avec:

 git clone https://github.com/sitepoint-editors/pagehit-ram

Ou vous pouvez utiliser n'importe lequel de vos propres codes.

Node.js est un wrapper autour du moteur JavaScript V8 qui comprend son propre inspecteur et son propre client de débogage . Pour commencer, utilisez l'argument inspect (à ne pas confondre avec - inspect ) pour démarrer une application:

 node inspect ./index.js

Le débogueur marque une pause à la première ligne et affiche une invite de débogage> :

 <Écoute du débogueur sur ws: //127.0.0.1: 9229 / 6f38abc1-8568-4035-a5d2-dee6cbbf7e44
<Pour obtenir de l'aide, voir: https://nodejs.org/en/docs/inspector
 7 ports = 3000,
  8
  9 // Modules Node.js
déboguer>

Vous pouvez parcourir l'application en entrant:

• cont ou c : poursuivre l'exécution
• suivant ou n : exécuter la commande suivante
• étape ou s : entrée dans une fonction appelée
• out ou o : sortie d'une fonction et retour à la commande appelante [19659097] pause : pause en cours d'exécution du code

Les autres options incluent:

• observation de valeurs variables avec watch ('myvar')
• définition de points d'arrêt avec le setBreakpoint () / sb () commande (il est généralement plus facile d'insérer un débogueur ; instruction dans votre code)
• redémarrez un script
• .exit ] le débogueur (l'initiale . est requise)

Si cela semble horriblement maladroit, c'est . N'utilisez le client de débogage intégré que lorsqu'il n'y a absolument aucune autre option, vous vous sentez particulièrement masochiste et vous n'utilisez pas Windows (c'est souvent problématique).

Node.js Debugging with Chrome

The Node. js inspector (sans le client du débogueur) est démarré avec l'indicateur - inspect : noeud

 --inspect ./index.js

Remarque: nodemon peut être utilisé à la place du noeud si nécessaire.

Ceci démarre l'écoute du débogueur le 127.0.0.1.199229 auquel tout client de débogage local peut s'attacher:

 Débogueur écoutant sur ws: //127.0.0.1: 9229 / 20ac75ae-90c5-4db6-af6b-d9d74592572f

Si vous exécutez l'application Node.js sur un autre appareil ou conteneur Docker, assurez-vous que le port 9229 est accessible et accordez l'accès à distance en utilisant ceci:

 node --inspect = 0.0.0.0: 9229 ./index.js

Alternativement, vous pouvez utiliser - inspect-brk pour définir un point d'arrêt sur la première instruction afin que l'application soit suspendue immédiatement.

Ouvrez Chrome et entrez chrome: // inspect dans la barre d'adresse.

Remarque: si l'application Node.js n'apparaît pas en tant que cible distante assurez-vous que ] La découverte des cibles réseau est cochée, puis cliquez sur Configurer pour ajouter l'adresse IP et le port du périphérique sur lequel l'application s'exécute.

Cliquez sur l'inspection de la cible ] lien pour lancer DevTools. Il sera immédiatement familier à toute personne ayant une expérience de débogage de navigateur.

Le lien + Ajouter un dossier à l'espace de travail vous permet de sélectionner l'emplacement des fichiers Node.js situé sur votre système, il devient donc plus facile de charger d'autres modules et d'effectuer des modifications.

Cliquer sur n'importe quel numéro de ligne définit un point d'arrêt, indiqué par un marqueur vert, qui arrête l'exécution lorsque ce code est atteint:

Des variables peuvent être ajoutées au volet Watch à droite en cliquant sur l'icône + et en saisissant leur nom. Leur valeur est affichée chaque fois que l'exécution est suspendue.

Le volet Pile d'appels affiche les fonctions qui ont été appelées pour atteindre ce point.

Le volet Étendue affiche l'état de tous les éléments disponibles variables locales et globales.

Le volet Points d'arrêt affiche une liste de tous les points d'arrêt et permet leur activation ou leur désactivation.

Les icônes au-dessus du message Débogueur en pause peuvent être affichées utilisé pour reprendre l'exécution, passer au-dessus, entrer dans, sortir, passer à travers, désactiver tous les points d'arrêt et mettre en pause les exceptions.

Débogage Node.js avec VS Code

VS Code Le débogage Node.js peut être lancé sans aucune configuration lorsque vous exécutez une application Node.js sur votre système local. Ouvrez le fichier de démarrage (généralement index.js ), activez le volet Exécuter et déboguer puis cliquez sur le bouton Exécuter et déboguer Node.js (F5) .

L'écran de débogage est similaire à Chrome DevTools avec une Variables Montre Pile d'appels Scripts chargés et Liste des points d'arrêt .

Un point d'arrêt peut être défini en cliquant sur la gouttière à côté du numéro de ligne. Vous pouvez également cliquer avec le bouton droit.

Avec ce clic droit, vous pouvez définir les paramètres suivants:

1. Un point d'arrêt standard.

2. Un point d'arrêt conditionnel qui s'arrête lorsque les critères sont remplis – par exemple, compte> 3 .

3. Un point de connexion, qui est en fait console.log () sans code! Toute chaîne peut être entrée avec des expressions entre accolades – par exemple, {count} pour afficher la valeur de la variable count .

   Débogage dans Visual Studio Code .

   Configuration de débogage avancée

   la configuration est requise lorsque vous déboguez un service distant ou devez utiliser différentes options de lancement. VS Code stocke les configurations de lancement dans un fichier launch.json généré dans le dossier .vscode de votre projet. Pour générer ou modifier le fichier, cliquez sur l'icône en forme de rouage en haut à droite du volet Exécuter et déboguer .

   

   Un nombre illimité de paramètres de configuration peut être être ajouté au tableau de configurations . Cliquez sur le bouton Ajouter une configuration pour choisir une option. VS Code peut soit:

   1. lancer un processus utilisant Node.js lui-même, soit
   2. attacher à un processus d'inspection Node.js, peut-être exécuté sur une machine distante ou un conteneur Docker

   Dans le Dans l'exemple ci-dessus, une seule configuration de lancement de Nodemon a été définie. Enregistrez launch.json sélectionnez nodemon dans la liste déroulante en haut du volet Exécuter et déboguer puis cliquez sur l'icône de démarrage verte. [19659060]

   Pour plus d'informations, voir Configurations de lancement du code VS .

   Le Node.js Debugging Guide fournit des conseils pour d'autres IDE et éditeurs dont Visual Studio, JetBrains, WebStorm, Gitpod et Eclipse. Atom a également une extension de noeud-débogage .

   ndb offre une expérience de débogage améliorée avec des fonctionnalités puissantes telles que l'attachement aux processus enfants et le blackboxing de script, donc uniquement le code dans des dossiers spécifiques est affiché.

   Le rapport IBM-toolkit pour Node.js fonctionne en analysant la sortie de données lorsque le noeud est exécuté avec le - experimental-report option.

   Enfin, des services commerciaux tels que LogRocket et Sentry.io s'intègrent à votre application Web en direct dans le client et le serveur pour enregistrer les erreurs au fur et à mesure qu'ils "

   Obtenez le débogage!

   Node.js dispose d'une gamme d'excellents outils de débogage et d'analyseurs de code qui peuvent améliorer la vitesse et la fiabilité de votre application. Qu'ils puissent ou non vous éloigner de console.log () est une autre affaire!

   
   

   Craig est un consultant web britannique indépendant qui a construit sa première page pour IE2.0 en 1995. Depuis, il est préconise les normes, l'accessibilité et les meilleures pratiques HTML5. Il a créé des spécifications d'entreprise, des sites Web et des applications en ligne pour des entreprises et des organisations, notamment le Parlement britannique, le Parlement européen, le Département de l'énergie et du changement climatique, Microsoft, etc. Il a écrit plus de 1 000 articles pour SitePoint et vous pouvez le trouver @craigbuckler .