Commandes Node.js de base avec exemples pratiques : guide pratique

Introduction

Node.js fournit un petit ensemble de commandes qui couvrent la majorité du travail quotidien : exécuter du code, installer des packages, lancer des scripts et déboguer. Ce guide présente les commandes indispensables, quand les utiliser et des exemples sûrs, copiables‑collables, que vous pouvez lancer sur macOS, Linux ou Windows.

Public cible :

Développeurs qui livrent des services et des CLI
Consultants DevOps qui standardisent les flux de travail
Équipes de startups construisant des API avec Express, des couches de données avec MongoDB ou Redis, et automatisant les builds avec Docker et GitLab CI/CD

Ce que vous obtiendrez :

Un flux de travail minimal, de la configuration du projet au débogage
Des exemples pratiques de node, npm et npx
Un petit pilote local réalisable en moins de 20 minutes

---

Aperçu du flux de travail

Suivez cette séquence pour garder votre travail prévisible et à faible risque.

Vérifier les versions

   node --version
   npm --version
   npx --version

Pourquoi : Confirme votre chaîne d’outils et aide à reproduire les problèmes sur d’autres machines.

Initialiser un projet

   mkdir mon-app && cd mon-app
   npm init -y

Pourquoi : Crée package.json afin de suivre les scripts et les dépendances.

Tester rapidement des one‑liners

   node -e "console.log('hello world')"
   node -p "1 + 2"

Pourquoi : Valide les fonctionnalités du runtime ou reproduit un bogue rapidement sans créer de fichiers.

Ajouter des dépendances

   npm install express
   npm install --save-dev nodemon

Pourquoi : Sépare les dépendances d’exécution des outils de développement.

Configurer les scripts npm (package.json)

   {
     "scripts": {
       "start": "node index.js",
       "dev": "npx nodemon index.js",
       "test": "node test.js"
     }
   }

Pourquoi : Des points d’entrée standardisés rendent les exécutions locales et l’automatisation cohérentes.

Exécuter et déboguer

   npm run start
   node --inspect index.js
   node --inspect-brk index.js

Pourquoi : Inspecter les variables et parcourir le code au démarrage quand c’est nécessaire.

Maintenir l’installation

   npm list --depth=0
   npm uninstall <pkg>
   npm prune
   npm cache verify

Pourquoi : Garde l’arbre de dépendances propre et l’état prévisible.

Installations reproductibles pour l’automatisation

   # À utiliser quand un lockfile (package-lock.json) existe
   npm ci

Pourquoi : Installation plus rapide et propre qui correspond exactement au lockfile.

---

Commandes de base avec exemples

Voici les commandes que vous utiliserez au quotidien, regroupées par tâche.

Vérifier et explorer le runtime

Versions

  node -v
  npm -v

REPL (shell interactif)

  node
  > 2 + 2
  4
  > .exit

One‑liners

  node -e "console.log(process.platform)"
  node -p "[1,2,3].map(x=>x*2)"

Exécuter un fichier

  node index.js

Débogage et diagnostics

Inspecter via un port de débogage

  node --inspect index.js
  node --inspect-brk index.js # pause à la première ligne

Tracer les avertissements jusqu’à la source

  node --trace-warnings index.js

Astuce : Utilisez ces drapeaux seulement lors d’investigations ; retirez‑les pour les exécutions normales.

Initialiser et gérer les packages

Créer rapidement package.json

  npm init -y

Installer les dépendances d’exécution et de développement

  npm install express
  npm install --save-dev nodemon eslint

Supprimer des dépendances et nettoyer les extras

  npm uninstall express
  npm prune

Lister les packages de premier niveau

  npm list --depth=0

Mettre à jour dans les plages semver autorisées

  npm update

Installation propre et reproductible (CI, conteneurs)

  npm ci

Note : npm ci supprime node_modules et installe exactement selon package-lock.json.

Exécuter les scripts du projet

Ajouter des scripts (exemple)

  {
    "scripts": {
      "start": "node index.js",
      "dev": "npx nodemon index.js",
      "lint": "npx eslint .",
      "test": "node test.js"
    }
  }

Lister les scripts disponibles et les lancer

  npm run          # liste les scripts
  npm run dev
  npm run lint
  npm test         # alias pour npm run test

Utiliser npx pour exécuter des binaires du projet

npx cherche les exécutables dans votre projet ou les télécharge si nécessaire.

Préférer les outils de développement locaux pour garder les versions cohérentes :

  # Après avoir installé eslint comme dépendance de développement
  npm install --save-dev eslint
  npx eslint .

Lancer un nodemon installé localement sans installation globale :

  npx nodemon index.js

Astuces d’environnement pour les opérations quotidiennes

Définir le port dans le code est plus sûr que dans le shell :

  // index.js
  const port = process.env.PORT || 3000

Dans Docker ou CI, privilégiez :

  npm ci --omit=dev   # installation uniquement production

Pour les monorepos ou plusieurs services, lancez les scripts depuis la racine de chaque package afin de conserver un contexte clair.

---

Plan de pilote local

Construisez une petite API Express locale. Ce pilote est ciblé, mesurable et facile à inspecter.

Pré‑vérifications

   node --version
   npm --version

Critères de réussite : Node et npm répondent avec leurs versions.

Initialiser et installer

   mkdir node-pilot && cd node-pilot
   npm init -y
   npm install express
   npm install --save-dev nodemon

Créer une API minimale

   // index.js
   const express = require('express')
   const app = express()
   const port = process.env.PORT || 3000

   app.get('/health', (req, res) => {
     res.json({ status: 'ok' })
   })

   app.get('/time', (req, res) => {
     res.json({ now: new Date().toISOString() })
   })

   app.listen(port, () => {
     console.log(`API listening on http://localhost:${port}`)
   })

Ajouter les scripts

   {
     "scripts": {
       "start": "node index.js",
       "dev": "npx nodemon index.js",
       "test": "node test.js"
     }
   }

Exécuter localement

   npm run start
   # ou rechargement à chaud pendant le développement
   npm run dev

Valider le comportement

   # Dans un autre terminal
   curl -s http://localhost:3000/health | jq .
   curl -s http://localhost:3000/time | jq .

Critères de passage :

/health renvoie {"status":"ok"}
/time renvoie un horodatage ISO

Diagnostics optionnels

   node --inspect index.js
   node --trace-warnings index.js

Nettoyage

Appuyez sur Ctrl+C pour arrêter le serveur, puis :

   npm prune

Notes :

Étendez le pilote en ajoutant une route POST et un magasin en mémoire simple avant d’introduire MongoDB ou Redis.
Lors de la conteneurisation, remplacez npm install par npm ci pour des builds cohérents.

---

Conclusion

Vous disposez maintenant d’un ensemble compact de commandes Node.js, d’un flux de travail clair et d’un pilote local que vous pouvez lancer dès aujourd’hui. Appliquez ces habitudes aux services qui utilisent Express, se connectent à MongoDB ou Redis, et s’exécutent dans Docker ou GitLab CI/CD. Prochaines étapes :

Standardiser les scripts : start, dev, test, lint
Utiliser npm ci dans les conteneurs et l’automatisation pour des installations reproductibles
Garder les drapeaux de débogage à portée de main pour un diagnostic rapide, mais les désactiver en exploitation normale

Avec ces commandes et ces patterns, votre équipe avancera plus vite avec moins de surprises.