Commandes de base Node.js avec exemples pratiques : guide d'implémentation

Intro

Node.js s'accompagne d'un petit ensemble de commandes qui couvrent l'essentiel du quotidien : exécuter du code, installer des packages, lancer des scripts et déboguer. Ce guide présente les Node.js basic commands vraiment utiles, quand les utiliser, et des Node.js examples sûrs à copier‑coller sous macOS, Linux ou Windows.

Pour qui :

• Développeurs qui livrent des services et des CLIs
• Consultants DevOps qui standardisent les workflows
• Équipes startup qui construisent des APIs avec Express, des couches de données avec MongoDB ou Redis, et automatisent avec Docker et GitLab CI/CD

Ce que vous obtiendrez :

• Un flux minimal du setup 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

Utilisez cette séquence pour garder un travail prévisible et à faible risque.

1. Vérifier les versions

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

Pourquoi : confirme votre chaîne d'outils et facilite la reproduction entre machines.

1. Initialiser un projet

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

Pourquoi : crée package.json pour suivre scripts et dépendances.

1. Essayer des one-liners

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

Pourquoi : valider des fonctionnalités du runtime ou reproduire vite un bug sans fichier.

1. Ajouter des dépendances

npm install express
npm install --save-dev nodemon

Pourquoi : séparer les dépendances runtime des outils réservés au dev.

1. Câbler des scripts npm (package.json)

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

Pourquoi : des points d'entrée standard rendent l'exécution locale et l'automatisation cohérentes.

1. Exécuter et déboguer

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

Pourquoi : inspecter les variables et pas‑à‑pas au démarrage quand nécessaire.

1. Maintenir l'installation

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

Pourquoi : garder l'arbre propre et l'état des dépendances prévisible.

1. Installations reproductibles pour l'automatisation

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

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

---

Commandes clés 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 diagnostic

• Inspection avec port de debug

node --inspect index.js
node --inspect-brk index.js  # point d'arrêt à la première ligne

• Tracer l'origine des avertissements

node --trace-warnings index.js

Astuce : n'utilisez ces drapeaux que pour investiguer ; retirez-les pour les exécutions normales.

Initialiser et gérer les packages

• Créer rapidement un package.json

npm init -y

• Installer des dépendances runtime et dev

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

• Supprimer et nettoyer

npm uninstall express
npm prune

• Lister les packages top‑niveau

npm list --depth=0

• Mettre à jour dans les marges semver

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 et exécuter

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

Utiliser npx pour exécuter les binaires du projet

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

• Préférez les outils de dev locaux pour garder des versions cohérentes :

# Après avoir installé eslint en dev
npm install --save-dev eslint
npx eslint .

• Lancer un nodemon local sans installation globale :

npx nodemon index.js

Conseils d'environnement pour les opérations quotidiennes

• Définir le port en code, plus robuste inter‑plateformes :

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

• En Docker ou CI, préférez :

npm ci --omit=dev    # installation production uniquement

• Pour des monorepos ou plusieurs services, exécutez les scripts depuis la racine de chaque package pour garder un contexte clair.

---

Plan pilote local

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

1. Pré‑checks

node --version
npm --version

Critères de succès : Node et npm répondent par des versions.

1. Initialiser et installer

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

1. 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}`)
})

1. Ajouter des scripts

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

1. Exécuter en local

npm run start
# ou rechargement à chaud en dev
npm run dev

1. Valider le comportement

# Dans un terminal séparé
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 timestamp ISO

1. Diagnostics optionnels

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

1. Nettoyage

Ctrl+C pour arrêter
npm prune

Notes :

• Étendez le pilote en ajoutant une route POST et un petit store en mémoire avant d'introduire MongoDB ou Redis.
• En conteneurisation, remplacez npm install par npm ci pour des builds cohérents.

---

Conclusion

Vous disposez maintenant d'un ensemble compact de Node.js commands, d'un flux clair et d'un pilote local exécutable dès aujourd'hui. Appliquez ces habitudes à des services sous Express, connectés à MongoDB ou Redis, et exécutés dans Docker ou GitLab CI/CD. Prochaines étapes :

• Standardisez les scripts : start, dev, test, lint
• Utilisez npm ci dans les conteneurs et l'automatisation pour des installations reproductibles
• Gardez les drapeaux de débogage à portée pour un diagnostic rapide, mais désactivés en exécution normale

Avec ces patterns et ce Node.js cheat sheet, votre équipe ira plus vite avec moins de surprises, tout en conservant des Node.js operations sûres et prévisibles.