C'est l'une des premières bonnes habitudes à prendre, et elle repose sur des différences réelles de comportement qui affectent la fiabilité de votre code. La règle moderne, simple et à appliquer systématiquement : const par défaut, let si vous devez réassigner, jamais var. Détaillons. const déclare une variable qu'on ne réassignera pas (dont la référence ne changera pas). Utilisez-le par défaut, car : (1) la plupart des variables ne sont jamais réassignées (une valeur calculée, un objet configuré, un résultat) — const exprime cette intention ; (2) const PROTÈGE contre les réassignations accidentelles (si vous essayez de réassigner une const, JavaScript lève une erreur — un bug attrapé tôt) ; (3) il rend le code plus LISIBLE (en voyant const, on sait que cette variable ne changera pas de valeur — moins de charge mentale). Nuance importante : const empêche la RÉASSIGNATION de la variable, mais si c'est un objet ou un tableau, son CONTENU reste modifiable (const arr = []; arr.push(1); fonctionne — on ne réassigne pas arr, on modifie son contenu). const protège la « boîte », pas forcément ce qu'il y a dedans. let déclare une variable qu'on VA réassigner : un compteur (let i = 0; i++;), un accumulateur, une valeur qui évolue au fil du code. Utilisez let UNIQUEMENT quand la réassignation est nécessaire. var est l'ancienne façon de déclarer (avant ES6), à ÉVITER pour plusieurs raisons de fiabilité : (1) Portée déroutante : var a une portée de FONCTION (pas de bloc), ce qui produit des comportements contre-intuitifs — une var déclarée dans un if ou une boucle « fuit » en dehors du bloc, source de bugs. const et let ont une portée de BLOC (limitée aux accolades), bien plus prévisible et sûre. (2) Hoisting piégeux : var est « remontée » en haut de sa portée avec la valeur undefined, permettant d'utiliser une variable AVANT sa déclaration (comportement confus). const/let ont une « zone morte temporelle » qui interdit cela (erreur claire si on les utilise avant déclaration). (3) Pas de protection : var permet la redéclaration et la réassignation sans garde-fou. En clair, var favorise des bugs subtils que const/let éliminent par une portée et un comportement plus stricts et prévisibles. Pourquoi cette règle est importante en Node : le code asynchrone (callbacks, boucles) est particulièrement sensible aux problèmes de portée — utiliser const/let (portée de bloc) évite des bugs classiques (la fameuse « boucle qui capture toujours la dernière valeur » avec var). Un exemple célèbre : une boucle for avec var dans des callbacks capture la MÊME variable partagée (bug) ; avec let, chaque itération a sa propre variable (correct). Adoptez donc le réflexe dès maintenant : (1) écrivez const par défaut ; (2) si votre éditeur/linter signale que vous réassignez, changez en let ; (3) n'écrivez JAMAIS var (les linters modernes comme ESLint le signalent d'ailleurs). Cette discipline, adoptée tôt, rend votre code plus sûr, plus lisible, et vous évite toute une catégorie de bugs de portée. C'est un des marqueurs du JavaScript moderne bien écrit — et une habitude qui ne coûte rien une fois prise.

Les boucles for « fonctionnent » et vous pouvez tout faire avec elles, mais map/filter/reduce sont le style MODERNE et idiomatique de traitement des collections en JavaScript — les maîtriser rend votre code plus lisible, plus expressif, et vous êtes de toute façon obligé de les COMPRENDRE car elles sont partout dans le code Node réel. Voyons pourquoi elles valent l'investissement. Ce qu'elles font (chacune exprime une INTENTION claire) : (1) map : TRANSFORME chaque élément d'un tableau en un nouveau, produisant un nouveau tableau de même taille. « Transforme cette liste de nombres en leurs carrés », « transforme ces objets utilisateurs en leurs noms ». [1,2,3].map(n => n * 2) → [2,4,6]. (2) filter : GARDE les éléments qui satisfont une condition, produisant un tableau plus petit. « Garde les utilisateurs actifs », « garde les nombres pairs ». [1,2,3,4].filter(n => n % 2 === 0) → [2,4]. (3) reduce : AGRÈGE tous les éléments en UNE valeur (une somme, un objet, une concaténation). « Additionne tous les prix », « regroupe ces éléments par catégorie ». [1,2,3].reduce((total, n) => total + n, 0) → 6. (4) forEach : exécute une action pour chaque élément (sans produire de nouveau tableau) — pour des effets de bord (afficher, envoyer). Pourquoi elles sont supérieures aux boucles for pour ces usages : (1) Expressivité / lisibilité : users.filter(u => u.active).map(u => u.name) se lit presque comme une phrase (« garde les actifs, prends leurs noms ») — l'INTENTION est claire d'un coup d'œil. La boucle for équivalente (créer un tableau, itérer, tester, pousser) est plus verbeuse et l'intention se devine moins vite. (2) Moins d'erreurs : pas d'index à gérer manuellement (i, i++, les conditions de fin), pas de tableau à initialiser et remplir à la main — moins d'occasions de se tromper (erreur d'index, oubli d'incrémentation). (3) Chaînage : on enchaîne ces méthodes (.filter().map().reduce()) pour exprimer un pipeline de traitement de données de façon fluide et lisible. (4) Immutabilité : map/filter créent de NOUVEAUX tableaux sans modifier l'original — un style qui évite des bugs (modifier un tableau pendant qu'on l'itère est piégeux). (5) Standard du métier : le code JavaScript/Node moderne (bibliothèques, projets, exemples) utilise massivement ces méthodes — vous DEVEZ les comprendre pour lire et travailler avec du code réel, que vous les préfériez ou non. Faut-il abandonner les boucles for ? Non, elles gardent leur place : (1) quand vous avez besoin d'un contrôle fin (sortir de la boucle avec break, sauter avec continue — que map/filter ne permettent pas) ; (2) pour des boucles qui ne traitent pas une collection (répéter N fois) ; (3) parfois pour la performance sur de très gros volumes (les for peuvent être plus rapides, mais rarement significatif). Il existe aussi for...of (une boucle moderne et lisible pour itérer sur une collection) qui combine simplicité et contrôle. La bonne approche : (1) pour TRANSFORMER, FILTRER, AGRÉGER une collection → map/filter/reduce (expressif, idiomatique) ; (2) pour du contrôle de flux fin ou des répétitions → boucles (for, for...of, while). En pratique, dans le code Node moderne, map/filter/reduce sont omniprésents (traiter des résultats de base de données, transformer des données d'API, etc.). Ne les fuyez pas par habitude des boucles : investissez pour les maîtriser (elles sont simples une fois comprises), et votre code gagnera en clarté et en modernité. Et surtout, vous saurez LIRE le code des autres, qui les utilise partout. C'est un pilier du JavaScript moderne, indispensable en pratique.