1. Expliquez l'event loop de Node.js et ses differentes phases.
L'event loop est le coeur de Node.js, permettant les operations asynchrones non-bloquantes sur un seul thread. Il comporte six phases : Timers (execution des callbacks setTimeout/setInterval), Pending callbacks (callbacks d'I/O reportes), Idle/Prepare (usage interne), Poll (recuperation des evenements I/O, execution des callbacks), Check (execution des callbacks setImmediate), Close (callbacks de fermeture comme socket.on close). Chaque phase a une file FIFO de callbacks. Entre chaque phase, Node execute les microtasks (process.nextTick, Promises resolues). process.nextTick a priorite sur les Promises.
2. Quelle est la difference entre require() et import en Node.js ?
require() est le systeme CommonJS (CJS) historique de Node. Il est synchrone, charge les modules au runtime, et les met en cache. import/export est le systeme ECMAScript Modules (ESM), standardise. Il est asynchrone, permet le tree-shaking, et supporte les imports nommes. Pour utiliser ESM : ajouter "type": "module" dans package.json ou utiliser l'extension .mjs. CJS utilise .cjs. Les deux systemes ne sont pas directement interchangeables : on peut importer du CJS depuis ESM, mais pas l'inverse sans import() dynamique. La tendance est vers ESM pour les nouveaux projets.
3. Comment gerer les erreurs dans une application Node.js ?
Strategie multi-niveaux : try/catch pour le code synchrone et async/await. Callbacks avec le pattern error-first (premier argument est l'erreur). Promises avec .catch() ou try/catch autour d'await. Event emitters avec l'evenement error. Erreurs non capturees : process.on('uncaughtException') et process.on('unhandledRejection') comme filet de securite, mais il faut redemarrer le processus apres. Utiliser des classes d'erreurs personnalisees pour categoriser (ValidationError, NotFoundError, AuthError). En Express, utiliser un middleware d'erreur centralise (4 parametres : err, req, res, next). Logger toutes les erreurs avec un outil structure.
4. Expliquez le concept de streams en Node.js.
Les streams permettent de traiter des donnees par morceaux (chunks) plutot que de tout charger en memoire. Quatre types : Readable (lecture, ex: fs.createReadStream), Writable (ecriture, ex: fs.createWriteStream), Duplex (lecture et ecriture, ex: TCP socket), Transform (modification des donnees en transit, ex: zlib compression). Les streams implementent le pattern backpressure : si le consommateur est plus lent que le producteur, le flux est mis en pause automatiquement. On peut chainer les streams avec pipe(). Essentiels pour traiter de gros fichiers, des flux reseau ou des transformations de donnees sans exploser la memoire.
5. Comment fonctionne le clustering en Node.js ?
Le module cluster permet de creer des processus worker qui partagent le meme port serveur. Le processus master fork des workers (generalement un par coeur CPU). Deux modes de distribution : round-robin (par defaut sur Linux/Mac) ou via le systeme d'exploitation. Chaque worker est un processus Node independant avec sa propre memoire et event loop. La communication inter-processus se fait par IPC (process.send/process.on message). En production, privilegier PM2 qui gere le clustering, le redemarrage automatique, le zero-downtime reload, et le monitoring. Alternative moderne : les worker threads pour le parallelisme CPU-intensif dans un meme processus.
6. Qu'est-ce que le middleware pattern dans Express.js ?
Un middleware Express est une fonction avec acces a la requete (req), la reponse (res) et la fonction next(). Les middleware s'executent dans l'ordre d'enregistrement et peuvent : modifier req/res, executer du code, terminer le cycle requete-reponse, ou appeler next() pour passer au middleware suivant. Types : middleware d'application (app.use), de routeur (router.use), d'erreur (4 params), tiers (cors, helmet, morgan). Le pattern permet de decomposer le traitement en couches : logging, authentification, validation, parsing du body, gestion des erreurs. L'ordre est crucial : authentification avant les routes protegees, erreurs en dernier.
7. Comment optimiser les performances d'une application Node.js ?
Optimisations cles : profiling avec clinic.js ou le profiler V8 integre pour identifier les bottlenecks. Caching avec Redis pour les donnees frequemment accedees. Connection pooling pour les bases de donnees. Eviter les operations synchrones (fs.readFileSync) en production. Utiliser les streams pour les gros volumes de donnees. Compression gzip/brotli des reponses. Load balancing avec cluster ou un reverse proxy (Nginx). Eviter les memory leaks (closures, event listeners non supprimes, caches sans limite). Utiliser les worker threads pour les taches CPU-intensives. Monitorer avec les metriques process (memory, CPU, event loop lag).
8. Expliquez la difference entre process.nextTick() et setImmediate().
process.nextTick() place le callback dans la file nextTick, executee apres l'operation en cours et avant que l'event loop ne continue a la phase suivante. setImmediate() place le callback dans la phase Check de l'event loop. process.nextTick est donc execute en priorite. Attention : un usage excessif de process.nextTick peut bloquer l'event loop (I/O starvation) car les callbacks nextTick sont traites recursivement avant de passer a la phase suivante. setImmediate est generalement prefere pour le code asynchrone car il laisse l'event loop respirer. Les Promises resolues (.then) s'executent dans la file microtask, apres nextTick.
9. Comment securiser une API Node.js/Express ?
Securite en couches : helmet pour les en-tetes de securite HTTP. Rate limiting avec express-rate-limit contre les attaques brute force. Validation des entrees avec Joi ou Zod (ne jamais faire confiance aux donnees client). Authentification avec JWT ou sessions securisees. CORS configure strictement. Protection CSRF pour les formulaires. Parametres de requete sanitises contre l'injection NoSQL. HTTPS obligatoire en production. Dependencies verifiees avec npm audit. Eviter d'exposer les stack traces en production (NODE_ENV=production). Logger les acces suspects. Utiliser des Content Security Policies strictes.
10. Comment gerer la scalabilite d'une application Node.js ?
Scalabilite horizontale et verticale : horizontale avec un load balancer (Nginx, HAProxy, ALB) distribuant le trafic entre plusieurs instances. Verticale avec le module cluster pour exploiter tous les coeurs CPU. Architecture microservices pour decouple les composants et les scaler independamment. Message queues (RabbitMQ, Redis, SQS) pour les taches asynchrones et le decouplage. CDN pour les assets statiques. Base de donnees : read replicas, sharding, caching Redis. Containerisation avec Docker et orchestration Kubernetes pour le deploiement et l'auto-scaling. Serverless (Lambda, Cloud Functions) pour les charges variables. Monitorer les metriques pour anticiper les besoins de scaling.