...
Pregătire interviuri

100 de întrebări de interviu Node.js, cu răspunsuri

Întrebările despre Node.js care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Node.js: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 48junior
  • 38mid
  • 14senior
  • 152 minde citit
Întrebări de interviu Node.js cu răspunsuri

La un interviu pentru un rol în care se lucrează cu Node.js, întrebările despre runtime vin de obicei după cele de JavaScript: cum funcționează event loop-ul și thread pool-ul libuv, ce diferă între CommonJS și modulele ES, cum lucrezi cu fișiere, stream-uri și Buffer-e, ce face de fapt Express peste modulul http. Pe lângă teorie, apar des fragmente de cod de tipul „ce afișează” sau „unde e bug-ul”, exerciții scrise live (un middleware, un Transform stream, citirea corpului unei cereri) și, uneori, o temă de casă cu un mic API.

Pentru un post de junior se verifică mai ales înțelegerea corectă a modelului asincron, a modulelor și a API-urilor de bază, plus obiceiuri sănătoase: fără operații sincrone în handlere, erori tratate, căi construite corect. La nivel mid și senior discuția se mută spre comportamentul în producție: backpressure, memorie și profilare, workeri și cluster, timeout-uri în spatele unui load balancer, securitate și testare, precum și felul în care planifici o migrare sau un upgrade de versiune.

Întrebările sunt grupate pe teme și ordonate de la junior la senior. Citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară cu răspunsul detaliat. Rulează exemplele de cod pe o versiune LTS actuală de Node: acolo unde un detaliu depinde de versiune, este menționat explicit. Întrebările generale despre limbajul JavaScript, REST, baze de date și arhitectură au pagini separate.

Runtime, event loop și libuv

1 Junior

Ce rol au V8 și libuv în Node.js? Ce face fiecare?

Răspuns scurt: V8 este motorul care compilează și execută codul JavaScript și gestionează heap-ul cu garbage collector. libuv este biblioteca C care oferă event loop-ul, I/O asincron (fișiere, rețea, timere) și thread pool-ul.

Node.js este un runtime: lipește la un loc un motor JavaScript și o bibliotecă de sistem, plus un set de module scrise în C++ și JavaScript (fs, http, crypto).

  • V8 (motorul din Chrome) parsează codul, îl compilează JIT (just-in-time, adică în cod mașină în timpul rulării) și administrează memoria: heap-ul, obiectele, garbage collector-ul. V8 nu știe nimic despre fișiere sau socket-uri.
  • libuv oferă event loop-ul, abstracția peste mecanismele de I/O ale sistemului de operare (epoll pe Linux, kqueue pe macOS, IOCP pe Windows), timerele și un thread pool pentru operațiile care nu au variantă asincronă nativă.

Când scrii fs.readFile('a.txt', cb), funcția JavaScript ajunge într-un binding C++, care cere libuv să citească fișierul pe un thread din pool. Când citirea se termină, libuv pune callback-ul în coada potrivită, iar event loop-ul îl dă înapoi lui V8 să-l execute pe thread-ul principal.

De aici vine ideea că „JavaScript-ul tău rulează pe un singur thread”, dar Node în ansamblu folosește mai multe: thread pool-ul libuv, thread-urile V8 pentru garbage collection și compilare. Un candidat bun știe să spună ce componentă e responsabilă când ceva e lent: cod JavaScript (V8, CPU) sau așteptare de I/O (libuv).

Ce urmărește intervievatorul: Verifică dacă înțelegi Node ca runtime compus, nu ca „JavaScript pe server”. Greșeala tipică este să spui că V8 face și I/O-ul sau că libuv execută cod JavaScript.

2 Junior

Unde e problema în acest handler HTTP și cum o repari?

JavaScript
const http = require('node:http');
const fs = require('node:fs');

http.createServer((req, res) => {
  const data = fs.readFileSync('./raport-mare.json');
  res.setHeader('Content-Type', 'application/json');
  res.end(data);
}).listen(3000);

Răspuns scurt: readFileSync blochează thread-ul principal cât durează citirea, deci serverul nu poate servi nicio altă cerere în acel timp. Folosește fs.promises.readFile sau, pentru fișiere mari, un stream trimis direct în răspuns.

Toate cererile unui proces Node sunt servite de același thread JavaScript. Funcțiile *Sync din fs fac apelul de sistem direct pe acest thread și nu se întorc până nu termină. Dacă fișierul are zeci de megaocteți sau discul e lent, fiecare cerere nouă așteaptă la coadă, iar latența crește pentru toți utilizatorii, nu doar pentru cel care a cerut raportul.

Variantele corecte:

JavaScript
const { createReadStream } = require('node:fs');
const { pipeline } = require('node:stream');

http.createServer((req, res) => {
  res.setHeader('Content-Type', 'application/json');
  pipeline(createReadStream('./raport-mare.json'), res, (err) => {
    if (err) console.error('trimitere eșuată', err);
  });
}).listen(3000);

Stream-ul trimite fișierul în bucăți, fără să-l țină întreg în memorie, iar pipeline închide corect ambele capete la eroare. Pentru fișiere mici, await fs.promises.readFile(...) e suficient.

Funcțiile sincrone nu sunt interzise: sunt potrivite la pornirea aplicației (citirea configurației), în scripturi CLI sau în teste. Regula este să nu le folosești în codul care rulează la fiecare cerere.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că legi „single thread” de consecința practică: o operație blocantă afectează toate cererile. Mulți candidați spun doar „e sincron” fără să explice impactul asupra celorlalți utilizatori.

3 Junior

Ce afișează acest script rulat ca fișier CommonJS (node app.js, fără "type": "module")?

JavaScript
Promise.resolve().then(() => console.log('promise 1'));
process.nextTick(() => console.log('tick 1'));
console.log('sync');
Promise.resolve().then(() => {
  console.log('promise 2');
  process.nextTick(() => console.log('tick 2'));
});
process.nextTick(() => console.log('tick 3'));

Răspuns scurt: Afișează: sync, tick 1, tick 3, promise 1, promise 2, tick 2. Coada nextTick se golește înaintea cozii de microtask-uri ale promisiunilor, iar un tick programat dintr-o promisiune rulează după ce se termină microtask-urile curente.

Node are două cozi care se golesc imediat după fiecare bucată de cod sincron, înainte ca event loop-ul să treacă la următoarea fază:

  • coada process.nextTick, specifică Node;
  • coada de microtask-uri a V8, unde ajung callback-urile then, catch, finally și queueMicrotask.

Ordinea pașilor aici:

  • se rulează codul sincron: apare sync;
  • se golește întâi coada nextTick: tick 1, tick 3;
  • se golește coada de microtask-uri: promise 1, promise 2. Callback-ul lui promise 2 adaugă tick 2 în coada nextTick;
  • după ce microtask-urile s-au terminat, Node verifică iar coada nextTick și rulează tick 2.

Detaliu important: într-un modul ES (.mjs sau "type": "module"), codul de nivel superior rulează deja ca parte a evaluării asincrone a modulului, așa că în același cod promise 1 poate apărea înaintea lui tick 1. De aceea ordinea exactă nextTick vs promisiune nu e bine să fie o presupunere de care depinde logica aplicației.

Practic, process.nextTick e folosit rar în cod de aplicație; îl vezi în biblioteci care vor să emită un eveniment după ce apelantul a apucat să atașeze listener-ele.

Ce urmărește intervievatorul: Se verifică dacă știi că există două cozi distincte și ordinea lor. Greșeala frecventă e să pui nextTick și promisiunile în aceeași coadă sau să crezi că tick 2 rulează înaintea lui promise 2.

4 Junior

Ce afișează acest cod rulat direct ca node index.js și de ce rezultatul poate varia între rulări?

JavaScript
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));

Răspuns scurt: Ordinea nu e garantată: uneori apare întâi timeout, alteori immediate. În modulul principal depinde dacă pragul minim al timer-ului (1 ms) a trecut deja când event loop-ul intră în faza de timere.

setTimeout(fn, 0) este de fapt setTimeout(fn, 1): Node transformă orice întârziere sub 1 ms în 1 ms. setImmediate pune callback-ul în faza check, care vine după faza poll din fiecare iterație a event loop-ului.

Când pornește event loop-ul pentru prima dată, intră în faza de timere. Dacă pregătirea procesului a durat mai mult de 1 ms de la programarea timer-ului, timer-ul e expirat și rulează primul: apare timeout, apoi immediate. Dacă a durat mai puțin, faza de timere nu găsește nimic expirat, loop-ul trece prin poll, ajunge la check și afișează întâi immediate. Timpul depinde de încărcarea mașinii, deci rezultatul variază.

Situația se schimbă complet într-un callback de I/O:

JavaScript
const fs = require('node:fs');
fs.readFile(__filename, () => {
  setTimeout(() => console.log('timeout'), 0);
  setImmediate(() => console.log('immediate'));
});

Aici callback-ul rulează în faza poll, după care urmează check, deci immediate apare mereu primul. Concluzia practică: dacă vrei „rulează după I/O-ul curent, cât mai curând”, folosește setImmediate, nu setTimeout(fn, 0).

Ce urmărește intervievatorul: Intervievatorul caută răspunsul „depinde” cu explicația corectă, nu o ordine inventată. Candidații care au învățat pe de rost „setTimeout e primul” sau „setImmediate e primul” pică aici.

5 Junior

După câte milisecunde se afișează mesajul, aproximativ?

JavaScript
const start = Date.now();
setTimeout(() => {
  console.log('a trecut', Date.now() - start, 'ms');
}, 100);

while (Date.now() - start < 500) {
  // calcul sincron de 500 ms
}

Răspuns scurt: După aproximativ 500 ms, nu 100. Întârzierea din setTimeout este un minim: callback-ul poate rula doar când stiva de apeluri e goală și event loop-ul ajunge în faza de timere.

setTimeout nu programează o întrerupere la momentul exact. El spune doar: „după cel puțin 100 ms, pune callback-ul în rând pentru execuție”. Timer-ul expiră la 100 ms, dar thread-ul principal este ocupat cu bucla while. JavaScript nu poate opri o funcție în mijlocul execuției ca să ruleze alta, deci callback-ul așteaptă până se termină bucla, iar apoi event loop-ul intră în faza de timere și îl rulează. Mesajul afișează ceva în jur de 500 ms, plus câteva milisecunde.

Consecințe practice:

  • Timerele nu sunt potrivite pentru măsurători precise sau pentru „rulează exact la ora X”.
  • Orice cod CPU-intensiv (parsare de JSON uriaș, sortarea unei liste foarte mari, o expresie regulată proastă) întârzie toate timerele, toate răspunsurile HTTP și toate callback-urile de I/O din proces.
  • setInterval(fn, 1000) nu garantează 1000 ms între rulări; dacă fn durează mult, intervalele se înghesuie sau se decalează.

Dacă ai nevoie de măsurători, folosește performance.now() din node:perf_hooks (sau global), care are rezoluție mai bună decât Date.now().

Ce urmărește intervievatorul: Verifică înțelegerea modelului „run-to-completion”: o funcție sincronă nu poate fi întreruptă. Greșeala tipică este răspunsul „100 ms, pentru că timerul rulează în paralel”.

6 Junior

Care e diferența dintre process.nextTick, queueMicrotask și setImmediate? Când ai folosi fiecare?

Răspuns scurt: process.nextTick rulează înaintea tuturor microtask-urilor, queueMicrotask rulează alături de callback-urile promisiunilor, iar setImmediate rulează abia în faza check a următoarei iterații, după I/O. Pentru a „ceda” event loop-ul, folosești setImmediate.

Toate trei amână un callback, dar la momente diferite:

  • process.nextTick(fn): imediat după operația curentă, înaintea promisiunilor și a oricărei faze a event loop-ului. E specific Node.
  • queueMicrotask(fn): în coada de microtask-uri a V8, aceeași în care ajung callback-urile then. Funcționează identic în browser și în Node, deci e alegerea pentru cod portabil.
  • setImmediate(fn): în faza check, după ce event loop-ul a procesat I/O-ul pregătit. Între timp pot rula alte callback-uri de rețea sau de fișiere.

Primele două nu lasă event loop-ul să avanseze: dacă un callback programează mereu altul în aceeași coadă, I/O-ul nu mai ajunge să ruleze. setImmediate e „politicos”: dă voie celorlalte operații să-și facă treaba.

Când le folosești:

  • nextTick: într-o bibliotecă, ca să emiți un eveniment sau o eroare după ce apelantul a terminat codul sincron și a apucat să atașeze listener-ele (de exemplu, un constructor care validează opțiunile și vrea să emită error).
  • queueMicrotask: când vrei semantica unei promisiuni fără să creezi una, de pildă pentru a grupa mai multe actualizări de stare într-una singură.
  • setImmediate: când împarți o muncă lungă în bucăți sau vrei să rulezi ceva după I/O-ul curent.

Numele sunt înșelătoare: nextTick rulează mai devreme decât setImmediate, deși „immediate” sugerează opusul. Documentația Node recunoaște asta.

Ce urmărește intervievatorul: Se verifică dacă știi locul fiecăreia față de event loop, nu doar definițiile. Răspunsul slab le tratează ca sinonime sau recomandă nextTick pentru a ceda controlul.

7 Junior

Ce operații din Node.js folosesc thread pool-ul libuv și care nu?

Răspuns scurt: Folosesc thread pool-ul: majoritatea operațiilor fs, dns.lookup, funcțiile asincrone grele din crypto (pbkdf2, scrypt, randomBytes) și zlib. Nu îl folosesc: socket-urile TCP/UDP, deci HTTP, și dns.resolve*, care merg prin mecanismele asincrone ale sistemului de operare.

libuv preferă mecanismele native de I/O neblocant ale sistemului de operare (epoll, kqueue, IOCP). Pentru rețea ele există: un socket poate fi pus în modul neblocant, iar kernel-ul anunță când are date. De aceea un server Node poate ține deschise zeci de mii de conexiuni cu un singur thread, fără thread pool.

Pentru alte operații, sistemele de operare nu oferă o variantă asincronă portabilă, așa că libuv le rulează pe un thread separat din pool și anunță event loop-ul la final:

  • fs: citire, scriere, stat, readdir (aproape tot modulul);
  • dns.lookup: folosește getaddrinfo din sistem, care e blocant; e funcția apelată implicit de http.get('http://exemplu.ro');
  • crypto: pbkdf2, scrypt, randomBytes, randomFill, generarea de chei;
  • zlib: compresie și decompresie asincronă.

Nu folosesc pool-ul: net, http, https la nivel de socket, dns.resolve4 și celelalte resolve* (folosesc biblioteca c-ares), timerele, pipe-urile și semnalele.

Consecința practică: pool-ul are implicit doar 4 thread-uri. Dacă aplicația face multe hash-uri de parole, compresie și citiri de fișiere în același timp, acestea se așteaptă unele pe altele, chiar dacă CPU-ul nu e plin. Un fs.readFile poate deveni lent pentru că pool-ul e ocupat cu scrypt.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi că „asincron” nu înseamnă automat thread pool. Greșeala tipică este afirmația că fiecare cerere HTTP primește un thread din pool.

8 Mid

Ce observi când rulezi codul de mai jos pe o mașină cu 8 nuclee? Cum ai schimba comportamentul?

JavaScript
const crypto = require('node:crypto');
const start = Date.now();
for (let i = 1; i <= 6; i++) {
  crypto.pbkdf2('parola', 'sare', 300000, 64, 'sha512', () => {
    console.log(i, Date.now() - start, 'ms');
  });
}

Răspuns scurt: Primele 4 apeluri se termină aproape simultan, iar ultimele 2 durează cam dublu, pentru că thread pool-ul libuv are implicit 4 thread-uri. Poți mări pool-ul cu variabila de mediu UV_THREADPOOL_SIZE, setată înainte de pornirea procesului.

pbkdf2 asincron rulează pe thread pool-ul libuv. Cu valoarea implicită de 4 thread-uri, primele 4 calcule pornesc în paralel pe 4 nuclee și se termină în jurul aceluiași moment, să zicem T. Apelurile 5 și 6 stau la coadă și pornesc doar când se eliberează un thread, deci se termină în jur de 2T. Restul de 4 nuclee stau nefolosite.

Pool-ul se configurează prin variabila de mediu:

BASH
UV_THREADPOOL_SIZE=8 node hash.js

Valoarea maximă este 1024. Contează momentul: pool-ul se creează la prima utilizare, așa că setarea process.env.UV_THREADPOOL_SIZE în cod funcționează doar dacă se face înainte de orice operație care îl folosește. Pe Windows, ea trebuie dată din exterior. Cel mai sigur o pui în comanda de pornire sau în Dockerfile.

Nu mări valoarea orbește:

  • mai multe thread-uri decât nuclee pentru muncă de CPU nu aduc viteză, doar comutări de context;
  • pentru operații de fișiere pe disc lent, un pool mai mare poate ajuta, pentru că thread-urile mai mult așteaptă decât calculează.

Dacă problema reală este CPU (hash-uri de parole la login, sub trafic mare), soluțiile sunt măsurarea, limitarea concurenței la endpoint-ul respectiv, worker_threads pentru calcule proprii sau mai multe instanțe ale aplicației.

Ce urmărește intervievatorul: Se verifică dacă știi dimensiunea implicită a pool-ului și efectul ei măsurabil. Candidații greșesc spunând că toate cele 6 apeluri rulează în paralel sau că pool-ul se poate mări oricând din cod.

9 Mid

Ce se întâmplă cu serverul când rulează această funcție și de ce setImmediate nu ar avea aceeași problemă?

JavaScript
function proceseaza(coada) {
  if (coada.length === 0) return;
  lucreaza(coada.shift());
  process.nextTick(() => proceseaza(coada));
}

Răspuns scurt: Cât timp coada are elemente, event loop-ul nu avansează: nextTick rulează înaintea oricărei faze, deci I/O-ul, timerele și cererile noi sunt înfometate (starvation). Cu setImmediate, fiecare pas rulează în faza check și lasă loc I/O-ului între pași.

Coada process.nextTick se golește complet înainte ca Node să treacă mai departe, iar orice tick adăugat în timpul golirii se adaugă la aceeași coadă. Funcția de mai sus programează mereu încă un tick, deci, pentru Node, coada nu se termină până nu se golește lista. Dacă lista are un milion de elemente, timp de câteva secunde serverul nu acceptă conexiuni, nu citește socket-uri și nu rulează timere, deși codul pare „asincron”.

Același lucru se întâmplă cu o buclă de promisiuni care se rezolvă imediat, de exemplu await pe valori care nu sunt I/O real într-un for uriaș: microtask-urile se golesc și ele complet.

Versiunea care cedează controlul:

JavaScript
function proceseaza(coada) {
  if (coada.length === 0) return;
  const limita = Date.now() + 10;
  while (coada.length && Date.now() < limita) {
    lucreaza(coada.shift());
  }
  setImmediate(() => proceseaza(coada));
}

Lucrează în bucăți de cel mult 10 ms, apoi lasă event loop-ul să parcurgă fazele de poll și timere înainte de bucata următoare. Gruparea e importantă: un setImmediate pe fiecare element ar adăuga overhead inutil.

Dacă munca e pur CPU și durează mult în total, mutarea ei într-un worker_thread e de obicei soluția mai bună, pentru că nu mai concurează deloc cu cererile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi starvation-ul produs de cozile care se golesc complet. Greșeala tipică este să crezi că orice cod amânat cu nextTick sau promisiuni lasă automat loc I/O-ului.

10 Mid

De ce un proces Node se oprește singur după un script, dar rămâne pornit după server.listen()? Ce fac ref() și unref()?

Răspuns scurt: Event loop-ul rulează cât timp există handle-uri active cu referință (servere, timere, socket-uri) sau cereri în curs. unref() spune că un handle nu trebuie să țină procesul în viață, iar ref() anulează acest lucru.

La fiecare iterație, libuv verifică dacă mai are motive să continue: un server care ascultă, un socket deschis, un timer programat, o operație de fișier în curs, un proces copil. Dacă nu există niciunul, loop-ul se termină și procesul iese cu codul din process.exitCode (implicit 0). De aceea un script care citește un fișier și afișează rezultatul se oprește singur, iar un server HTTP rămâne pornit la nesfârșit.

Fiecare handle are o „referință”. Cu unref() îi spui lui Node că handle-ul poate exista, dar nu trebuie să împiedice oprirea:

JavaScript
// raportare periodică ce nu trebuie să țină procesul pornit
const t = setInterval(trimiteMetrici, 10000);
t.unref();

// timeout de siguranță la oprire
setTimeout(() => process.exit(1), 5000).unref();

Al doilea exemplu e frecvent la graceful shutdown: dacă închiderea se termină normal, timer-ul unref nu ține procesul pornit cele 5 secunde; dacă ceva rămâne agățat, forțează ieșirea.

unref există pe timere, servere (server.unref()), socket-uri, procese copil și workeri. ref() reface legătura. timer.hasRef() îți spune starea curentă.

Situația inversă e un bug frecvent: testele care „nu se termină” pentru că o conexiune la bază de date sau un setInterval a rămas deschis. Soluția corectă e închiderea resurselor în after, nu process.exit() forțat.

Ce urmărește intervievatorul: Se verifică dacă înțelegi condiția de oprire a event loop-ului. Mulți candidați nu știu de unref și rezolvă procesele agățate cu process.exit(), ascunzând resurse rămase deschise.

11 Mid

Ce problemă are funcția de mai jos și cum o repari?

JavaScript
const cache = new Map();

function citesteConfig(nume, callback) {
  if (cache.has(nume)) {
    return callback(null, cache.get(nume));
  }
  fs.readFile(nume, 'utf8', (err, text) => {
    if (err) return callback(err);
    cache.set(nume, text);
    callback(null, text);
  });
}

Răspuns scurt: Funcția apelează callback-ul uneori sincron (din cache) și alteori asincron (după citire). Codul apelantului se comportă diferit în cele două cazuri; repari apelând callback-ul mereu asincron, de exemplu cu process.nextTick, sau trecând la o funcție async.

Problema e cunoscută în comunitatea Node ca „eliberarea lui Zalgo”: un API care e uneori sincron și alteori asincron. Uită-te la apelant:

JavaScript
let gata = false;
citesteConfig('app.json', () => {
  console.log('gata =', gata);
});
gata = true;

La primul apel afișează gata = true (callback-ul vine după citire). La al doilea, din cache, afișează gata = false, pentru că rulează înainte de linia următoare. Bug-urile de acest tip apar intermitent, depind de starea cache-ului și sunt greu de reprodus. Mai rău, o excepție aruncată de callback-ul apelantului în varianta sincronă urcă prin citesteConfig și poate fi prinsă de un try/catch care nu era pentru ea.

Reparația:

JavaScript
if (cache.has(nume)) {
  const valoare = cache.get(nume);
  return process.nextTick(callback, null, valoare);
}

process.nextTick acceptă argumentele după funcție. Acum callback-ul rulează mereu după ce apelantul a terminat codul sincron.

Varianta modernă evită complet problema:

JavaScript
async function citesteConfig(nume) {
  if (!cache.has(nume)) cache.set(nume, await fs.promises.readFile(nume, 'utf8'));
  return cache.get(nume);
}

O promisiune rezolvă mereu asincron, chiar dacă valoarea e deja disponibilă. Bonus: dacă pui în cache promisiunea, nu textul, două apeluri simultane nu citesc fișierul de două ori.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că recunoști contractul „mereu asincron” al API-urilor Node. Greșeala tipică este să consideri apelul sincron din cache o optimizare inofensivă.

12 Mid

Ai un endpoint care calculează un raport sortând și agregând 2 milioane de rânduri deja aflate în memorie, ceea ce durează 3 secunde. Scrie o variantă care nu blochează celelalte cereri, fără worker_threads.

Răspuns scurt: Împarți munca în bucăți mici și cedezi event loop-ul între ele cu setImmediate (sau await pe setImmediate din node:timers/promises). Latența celorlalte cereri rămâne mică, deși raportul în sine durează puțin mai mult.

Ideea este „cooperative multitasking”: codul tău ia o pauză voluntară, din când în când, ca event loop-ul să poată servi alte cereri.

JavaScript
const { setImmediate: pauza } = require('node:timers/promises');

async function agregaPeClient(randuri, felie = 20000) {
  const totaluri = new Map();
  for (let i = 0; i < randuri.length; i += felie) {
    const sfarsit = Math.min(i + felie, randuri.length);
    for (let j = i; j < sfarsit; j++) {
      const r = randuri[j];
      totaluri.set(r.client, (totaluri.get(r.client) || 0) + r.suma);
    }
    await pauza(); // lasă I/O-ul și alte cereri să ruleze
  }
  return [...totaluri].sort((a, b) => b[1] - a[1]);
}

Observații:

  • await pauza() rezolvă în faza check, după I/O, spre deosebire de await Promise.resolve(), care nu ar ceda nimic.
  • Dimensiunea feliei se alege măsurând: o felie ar trebui să dureze câteva milisecunde. Prea mică, adaugi overhead; prea mare, revii la blocare.
  • Sortarea finală nu poate fi împărțită ușor. Dacă ea e partea grea, o reduci: sortezi doar totalurile pe client, nu rândurile brute.
  • Cât timp rulează, raportul ocupă memoria; două rapoarte simultane dublează consumul, deci limitezi câte rapoarte rulează în același timp.

Soluția scalează până la un punct. Dacă munca CPU devine dominantă, un worker sau un job separat (o coadă cu procesare în fundal) sunt variantele corecte. Și cel mai bun câștig rămâne de multe ori mutarea agregării în baza de date.

Ce urmărește intervievatorul: Se verifică dacă știi să cedezi controlul corect și dacă înțelegi compromisul latență vs. durată totală. Greșeala tipică este să crezi că a pune codul într-o funcție async îl face neblocant.

13 Senior

Cum ai atașa un ID de cerere la fiecare linie de log, inclusiv în funcțiile apelate adânc, fără să transmiți ID-ul ca parametru peste tot?

Răspuns scurt: Folosești AsyncLocalStorage din node:async_hooks: rulezi handler-ul cererii în als.run(context, ...), iar orice cod asincron pornit din el poate citi contextul cu als.getStore(). Logger-ul citește de acolo ID-ul.

AsyncLocalStorage păstrează o valoare legată de „lanțul asincron” curent: tot ce pornește din run() (callback-uri, promisiuni, timere, I/O) vede aceeași valoare, chiar dacă între timp au rulat alte cereri pe același thread. E echivalentul thread-local storage din alte limbaje, adaptat modelului cu event loop.

JavaScript
const { AsyncLocalStorage } = require('node:async_hooks');
const { randomUUID } = require('node:crypto');

const context = new AsyncLocalStorage();

function log(mesaj, date = {}) {
  const store = context.getStore();
  console.log(JSON.stringify({ requestId: store?.requestId, mesaj, ...date }));
}

app.use((req, res, next) => {
  const requestId = req.get('x-request-id') || randomUUID();
  res.set('x-request-id', requestId);
  context.run({ requestId }, next);
});

async function salveazaComanda(c) {
  log('salvez comanda', { id: c.id }); // are requestId fără parametru
}

Ce trebuie să știi ca senior:

  • API-ul e stabil în Node 16+; e folosit de bibliotecile de tracing (OpenTelemetry) și de framework-uri.
  • Contextul se poate pierde când codul trece prin biblioteci care își gestionează singure cozile de callback-uri (unele pool-uri vechi de conexiuni). Soluția e AsyncResource.bind sau AsyncLocalStorage.bind pe callback.
  • Store-ul trebuie să fie un obiect mic; nu pui acolo req întreg, ca să nu ții în memorie cereri terminate.
  • Are un cost mic de performanță, de obicei acceptabil; se măsoară pe căile foarte fierbinți.
  • Nu înlocuiește parametrii pentru logica de business: e bun pentru date transversale (ID de cerere, utilizator pentru audit, tranzacția curentă), nu pentru date pe care se bazează rezultatul funcției.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi soluția nativă pentru context propagat și limitele ei. Răspunsurile slabe propun variabile globale, care se amestecă între cereri concurente.

14 Senior

Sub încărcare mare, cererile HTTP către un API extern devin lente, deși API-ul răspunde repede și CPU-ul e liber. În același timp, citirile de fișiere încetinesc și ele. Ce ai suspecta?

Răspuns scurt: Thread pool-ul libuv saturat: dns.lookup, folosit implicit de http.request, rulează în pool, alături de fs, crypto și zlib. Câteva operații lente ocupă cele 4 thread-uri și blochează tot restul. Verifici cu măsurători, apoi refolosești conexiunile, cache-uiești DNS-ul sau mărești pool-ul.

Indiciile sunt simptomele combinate: rețea și disc lente simultan, CPU liber, serviciul extern rapid. Ce au în comun este thread pool-ul de 4 thread-uri.

Mecanismul: fiecare conexiune nouă către api.exemplu.ro apelează întâi dns.lookup, care folosește getaddrinfo blocant din sistem, rulat în pool. Dacă rezolvarea DNS durează (server DNS lent, timeout-uri), câteva lookup-uri ocupă tot pool-ul. Între timp, fs.readFile, crypto.scrypt sau compresia zlib stau la coadă. Invers, o rafală de hash-uri de parole poate întârzia DNS-ul și deci cererile HTTP ieșite.

Cum confirmi:

  • măsori separat timpul de DNS, de conectare și de răspuns (de exemplu cu diagnostics_channel pe undici sau cu tracing);
  • compari cu UV_THREADPOOL_SIZE mărit într-un test de încărcare: dacă problema dispare, ai găsit cauza;
  • te uiți la câte conexiuni noi se deschid pe secundă.

Remedii, în ordinea preferinței:

  • Refolosirea conexiunilor: un http.Agent({ keepAlive: true }) sau dispatcher-ul undici reutilizează socket-urile, deci nu mai faci DNS la fiecare cerere. Agentul global are keep-alive activ implicit din Node 19.
  • Cache DNS în aplicație sau un resolver local; alternativ, opțiunea lookup a agentului cu o funcție bazată pe dns.resolve4, care nu folosește pool-ul.
  • Mărirea UV_THREADPOOL_SIZE, ca atenuare.
  • Mutarea muncii grele de crypto/zlib (de exemplu compresia răspunsurilor) la reverse proxy sau în workeri.

Ce urmărește intervievatorul: Se verifică dacă poți lega simptome aparent fără legătură de o resursă comună. Candidații tind să dea vina pe API-ul extern sau pe rețea fără să se gândească la DNS și la pool.

Module: CommonJS și ESM

15 Junior

De ce index.js primește un obiect gol și cum repari util.js?

JavaScript
// util.js
exports = {
  aduna: (a, b) => a + b,
};

// index.js
const util = require('./util');
console.log(util); // {}

Răspuns scurt: exports este doar o variabilă care pornește ca referință la module.exports. Reatribuirea ei rupe legătura, iar require întoarce mereu module.exports, care a rămas {}. Scrii module.exports = { aduna } sau adaugi proprietăți: exports.aduna = ....

Înainte să ruleze un fișier CommonJS, Node îl învelește într-o funcție și îi dă ca parametri exports, require, module, __filename și __dirname. La început, exports === module.exports, ambele indicând același obiect gol.

Ce returnează require este valoarea lui module.exports la finalul execuției modulului. Așa că:

  • exports.aduna = fn modifică obiectul comun, deci funcționează;
  • module.exports = { aduna } înlocuiește valoarea exportată, deci funcționează;
  • exports = { aduna } schimbă doar variabila locală exports; module.exports rămâne obiectul gol inițial.

Reparația cea mai clară:

JavaScript
// util.js
const aduna = (a, b) => a + b;
module.exports = { aduna };

O capcană înrudită: amestecul celor două stiluri.

JavaScript
exports.a = 1;
module.exports = { b: 2 };
// require întoarce { b: 2 }; proprietatea a s-a pierdut

Multe echipe aleg o regulă simplă: folosesc doar module.exports, ca să nu existe dubii. Dacă exportul e o singură funcție sau clasă, module.exports = ClasaMea este singura variantă posibilă, pentru că exports nu poate fi reatribuit util.

Ce urmărește intervievatorul: Verifică dacă înțelegi mecanismul (referințe, wrapper-ul modulului), nu doar regula. Mulți candidați știu că „nu merge” fără să poată explica de ce.

Eroarea, în practică:calcule.totalCos is not a function (exports)module is not defined in ES module scope

16 Junior

Cum găsește Node fișierul când scrii require('./config') și când scrii require('lodash')?

Răspuns scurt: Pentru căi relative încearcă fișierul exact, apoi cu extensiile .js, .json, .node, apoi ca dosar (câmpul main din package.json sau index.js). Pentru nume simple caută întâi modulele incluse, apoi în node_modules din dosarul curent și din fiecare dosar părinte.

Algoritmul de rezoluție CommonJS, simplificat:

  • Module incluse (fs, http, path): dacă numele corespunde unui modul din Node, acesta are prioritate. Cu prefixul node: nu mai există nicio ambiguitate.
  • Căi relative sau absolute (./, ../, /): calea se rezolvă față de dosarul fișierului care face require, nu față de dosarul curent al procesului. Pentru ./config se încearcă pe rând config, config.js, config.json, config.node. Dacă config e dosar, se citește config/package.json și se folosește main (sau exports), altfel config/index.js.
  • Nume simple (lodash, @scope/pachet): se caută node_modules/lodash în dosarul fișierului, apoi în părinte, și tot așa până la rădăcina discului. În pachet, intrarea e dată de exports sau main din package.json.

Poți vedea rezultatul fără să încarci modulul:

JavaScript
console.log(require.resolve('lodash'));
console.log(require.resolve.paths('lodash')); // dosarele în care caută

Consecințe practice: un node_modules dintr-un dosar părinte poate fi găsit accidental și încărcat (surprize în monorepo-uri); require('./Config') merge pe macOS, unde sistemul de fișiere nu face diferența între majuscule, dar pică pe Linux în producție.

În ESM regulile sunt mai stricte: căile relative trebuie să includă extensia (./config.js), iar importul unui dosar nu caută automat index.js.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți depana un „Cannot find module”. Greșeala tipică e să spui că o cale relativă se rezolvă față de dosarul din care pornești node.

Eroarea, în practică:Cannot find module './calcul'Cannot find module 'lodash' (pachet npm)

17 Junior

Ce afișează index.js?

JavaScript
// contor.js
let valoare = 0;
console.log('incarc contor.js');
module.exports = { creste: () => ++valoare };

// index.js
const a = require('./contor');
const b = require('./contor');
console.log(a.creste(), b.creste(), a === b);

Răspuns scurt: Afișează incarc contor.js o singură dată, apoi 1 2 true. După primul require, modulul e pus în cache, iar următoarele apeluri primesc același obiect, cu aceeași stare internă.

Un modul CommonJS se execută o singură dată per proces. Rezultatul (module.exports) se păstrează în require.cache, indexat după calea absolută a fișierului. Al doilea require('./contor') nu mai citește și nu mai rulează fișierul; întoarce direct obiectul din cache. De aceea a și b sunt același obiect și împart variabila valoare.

Comportamentul e util și e folosit intenționat:

  • un modul care creează o conexiune la baza de date sau un logger funcționează ca un singleton natural: toată aplicația primește aceeași instanță;
  • costul inițializării se plătește o singură dată.

Capcane:

  • Cache-ul e pe cale absolută. Dacă același pachet e instalat în două locuri din node_modules, ai două instanțe separate (frecvent la pachete cu stare globală, cum ar fi unele biblioteci de UI sau de ORM).
  • Starea modulului se păstrează între teste dacă rulează în același proces; de aceea Jest izolează modulele per fișier de test.
  • Poți șterge o intrare cu delete require.cache[require.resolve('./contor')], dar e o tehnică pentru unelte (hot reload), nu pentru cod de aplicație.

Modulele ES au și ele cache (un modul se evaluează o singură dată), dar acesta nu e expus ca obiect modificabil, deci nu poți „reîncărca” un modul ES pe aceeași cale.

Ce urmărește intervievatorul: Se verifică înțelegerea cache-ului și a singleton-ului rezultat. Candidații greșesc afișând mesajul de două ori sau 1 1 false.

18 Junior

De unde vin __dirname și require într-un fișier CommonJS și cum obții echivalentele într-un modul ES?

Răspuns scurt: În CommonJS sunt parametri ai funcției-wrapper în care Node învelește fiecare fișier. În ESM nu există; folosești import.meta.dirname și import.meta.filename (Node 20.11+), import.meta.url cu fileURLToPath pe versiuni mai vechi și createRequire dacă ai nevoie de require.

Node rulează fiecare fișier CommonJS ca și cum ar fi scris așa:

JavaScript
(function (exports, require, module, __filename, __dirname) {
  // codul tău
});

De aici: variabilele de nivel superior sunt locale modulului (nu devin globale), iar require, module, __dirname par globale, dar sunt parametri. Poți verifica: console.log(arguments.length) la nivelul de sus al unui fișier CJS afișează 5.

Modulele ES nu au wrapper, deci în ele __dirname dă ReferenceError. Echivalentele:

JavaScript
// Node 20.11+ și 22
const dosar = import.meta.dirname;
const fisier = import.meta.filename;

// orice versiune cu ESM
import { fileURLToPath } from 'node:url';
import path from 'node:path';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// dacă ai nevoie de require (de pildă pentru un JSON sau un pachet doar CJS)
import { createRequire } from 'node:module';
const require = createRequire(import.meta.url);
const pachet = require('./package.json');

import.meta.url este un URL file:///..., nu o cale; trebuie convertit cu fileURLToPath, altfel pe Windows și la căi cu spații obții erori greu de înțeles.

În ESM poți importa JSON și direct, cu import date from './date.json' with { type: 'json' } (import attributes, disponibile în Node 22).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce e module wrapper-ul și dacă ai lucrat efectiv cu ESM. Greșeala tipică e să construiești căi relative la process.cwd() în loc de dosarul fișierului.

Eroarea, în practică:require is not defined in ES module scope__dirname is not defined in ES module scope

19 Junior

Cum decide Node dacă un fișier .js este CommonJS sau modul ES?

Răspuns scurt: După extensie și după cel mai apropiat package.json: .mjs e mereu ESM, .cjs e mereu CommonJS, iar .js e ESM doar dacă package.json are "type": "module". În Node 22.7+ și 20.19+, un .js fără type care conține sintaxă ESM este detectat automat.

Regulile, în ordine:

  • .mjs este tratat ca modul ES, .cjs ca CommonJS, indiferent de configurare.
  • Pentru .js, Node caută cel mai apropiat package.json urcând din dosarul fișierului. Dacă are "type": "module", fișierul e ESM; dacă are "type": "commonjs" sau nu are câmpul, e CommonJS.
  • Fără câmpul type, versiunile recente (22.7+, 20.19+) încearcă detectarea: dacă fișierul conține import/export și nu poate fi CommonJS, e reîncărcat ca ESM. E o plasă de siguranță pentru scripturi, nu ceva pe care să te bazezi într-un proiect: costă o parsare în plus și poate emite avertismente.
  • Flag-ul --input-type=module se aplică doar codului dat cu --eval sau prin stdin.

Pentru că regula se aplică per package.json, un proiect poate avea un package.json minimal într-un subdosar, doar cu {"type": "commonjs"}, ca să păstreze fișierele vechi CJS în timp ce restul proiectului e ESM.

Recomandarea pentru un proiect nou: setezi explicit "type" (de obicei "module") și folosești .cjs pentru puținele fișiere de configurare care trebuie să rămână CommonJS. Mesajul SyntaxError: Cannot use import statement outside a module aproape întotdeauna înseamnă că un fișier cu import e interpretat ca CommonJS.

Ce urmărește intervievatorul: Se verifică dacă știi mecanismul concret de selecție, care e sursa multor erori de configurare. Candidații spun adesea doar „depinde de sintaxă”, ignorând package.json.

Eroarea, în practică:Cannot use import statement outside a modulerequire is not defined in ES module scope

20 Junior

De ce se recomandă import fs from 'node:fs' în loc de import fs from 'fs'?

Răspuns scurt: Prefixul node: arată clar că e un modul inclus în Node, nu poate fi confundat cu un pachet din node_modules cu același nume și ocolește căutarea pe disc. Unele module noi, ca node:test sau node:sqlite, există doar cu prefix.

Ambele forme încarcă același modul pentru numele clasice, dar node: aduce câteva avantaje reale:

  • Lipsă de ambiguitate: cine citește codul vede imediat că node:events e din runtime, nu pachetul npm events (care există și e un polyfill pentru browser). La fel pentru buffer, util, process, punycode.
  • Siguranță: un pachet malițios sau instalat greșit cu un nume de modul inclus nu poate „umbri” importul, pentru că node: nu caută niciodată în node_modules.
  • Module disponibile doar cu prefix: node:test, node:sqlite (Node 22.5+), node:sea. import test from 'test' ar căuta un pachet npm numit test.
  • Unelte: bundler-ele și ESLint (regula unicorn/prefer-node-protocol, de exemplu) recunosc ușor dependențele de runtime și nu încearcă să le includă în bundle.

Prefixul funcționează și în CommonJS: require('node:fs'), din Node 14.18/16. Pe versiunile actuale LTS e sigur să-l folosești peste tot.

Un detaliu util: în ESM, modulele incluse se pot importa și cu nume: import { readFile } from 'node:fs/promises', ceea ce face clar ce funcții folosește fișierul.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că urmărești practicile actuale și înțelegi motivul, nu doar convenția. Un răspuns slab e „așa e scris în documentație”.

Eroarea, în practică:No such built-in module: node:...

21 Mid

Ce afișează a.js când rulezi node a.js?

JavaScript
// a.js
exports.gata = false;
const b = require('./b');
console.log('în a, b.gata =', b.gata);
exports.gata = true;

// b.js
const a = require('./a');
console.log('în b, a.gata =', a.gata);
exports.gata = true;

Răspuns scurt: Afișează în b, a.gata = false, apoi în a, b.gata = true. Când b.js cere a.js, care e încă în execuție, primește din cache exporturile parțiale ale lui a de la acel moment, nu o eroare și nu o buclă infinită.

Cum rulează pașii:

  • Node începe a.js, îl pune imediat în cache și execută exports.gata = false.
  • a.js cere b.js; Node începe b.js.
  • b.js cere a.js. a.js există deja în cache (deși nu s-a terminat), așa că require întoarce obiectul lui de exporturi așa cum e acum: { gata: false }. Se afișează în b, a.gata = false.
  • b.js se termină cu gata = true; controlul revine în a.js, care afișează în a, b.gata = true.

Dependențele circulare nu dau eroare în CommonJS, dar dau rezultate parțiale. Bug-ul clasic: const { functie } = require('./a') în b.js destructurează o proprietate care încă nu există, deci functie e undefined pentru totdeauna, chiar dacă mai târziu a.js o adaugă. Cu module.exports = {...} la finalul lui a.js e și mai rău: b ține referința la obiectul vechi, gol.

În ESM, ciclurile se comportă diferit: legăturile sunt „live”, dar accesarea unui export let/const/class încă neinițializat aruncă ReferenceError.

Soluții: extragi codul comun într-un al treilea modul pe care îl cer amândouă; ceri dependența în interiorul funcției care o folosește, nu la începutul fișierului; injectezi dependența ca parametru. Unelte precum madge detectează ciclurile automat.

Ce urmărește intervievatorul: Se verifică dacă știi ce se întâmplă de fapt la un ciclu și poți explica bug-urile cu undefined care rezultă. Candidații spun adesea că Node aruncă eroare sau intră în buclă.

Eroarea, în practică:non-existent property ... circular dependency

22 Mid

Ai un proiect CommonJS și vrei să folosești un pachet publicat doar ca ESM. require('pachet') dă eroare. Ce opțiuni ai?

Răspuns scurt: Pe Node 22.12+ și 20.19+, require() poate încărca sincron un modul ES fără top-level await. Pe versiuni mai vechi, sau dacă pachetul folosește top-level await, imporți dinamic cu await import('pachet'). Alternativ, migrezi fișierul respectiv sau proiectul la ESM.

Timp de ani, eroarea ERR_REQUIRE_ESM a fost un obstacol: CommonJS e sincron, iar încărcarea ESM era tratată ca asincronă. Situația s-a schimbat:

  • require(esm): din Node 22.12 și 20.19, require() poate încărca un graf de module ES dacă niciunul nu folosește top-level await. Rezultatul este obiectul namespace al modulului; exportul implicit e la .default. Dacă graful are top-level await, primești ERR_REQUIRE_ASYNC_MODULE.
JavaScript
const { formateaza } = require('pachet-esm'); // Node 22.12+
const Clasa = require('alt-pachet-esm').default;
  • import() dinamic: funcționează în CommonJS pe orice versiune modernă și întoarce o promisiune:
JavaScript
async function main() {
  const { formateaza } = await import('pachet-esm');
  console.log(formateaza(new Date()));
}
main();

Dezavantajul e că devine asincron tot codul care depinde de modul; de obicei imporți o dată la pornire și păstrezi referința.

  • Migrarea la ESM: pe termen lung, cea mai curată soluție, dar presupune extensii explicite la importuri, înlocuirea __dirname și verificarea uneltelor (Jest, de exemplu, are încă suport ESM experimental).
  • O versiune mai veche a pachetului, care încă publica CommonJS: rezolvă urgent, dar te lasă fără actualizări de securitate.

TypeScript compilat în CommonJS transformă uneori import() în require(); cu "module": "nodenext" în tsconfig comportamentul e corect.

Ce urmărește intervievatorul: Intervievatorul verifică dacă cunoști situația actuală din Node, nu doar cea din 2021. Mulți candidați nu știu de require(esm) sau, invers, nu știu de limitarea cu top-level await.

Eroarea, în practică:ERR_REQUIRE_ESM: require() of ES Module

23 Mid

Ce afișează cele două variante și de ce diferă?

JavaScript
// varianta ESM
// contor.mjs
export let valoare = 0;
export function creste() { valoare++; }
// main.mjs
import { valoare, creste } from './contor.mjs';
creste();
console.log(valoare);

// varianta CommonJS
// contor.cjs
let valoare = 0;
module.exports = { valoare, creste() { valoare++; } };
// main.cjs
const { valoare, creste } = require('./contor.cjs');
creste();
console.log(valoare);

Răspuns scurt: Varianta ESM afișează 1, cea CommonJS afișează 0. Importurile ES sunt legături „live” către variabila din modul, iar în CommonJS primești o copie a valorii din momentul exportului, apoi o copie și la destructurare.

În ESM, import { valoare } nu copiază nimic: creează o legătură live (live binding) către variabila valoare din contor.mjs. Când creste() modifică variabila, importul vede noua valoare. Legătura e doar pentru citire: valoare = 5 în main.mjs dă TypeError: Assignment to constant variable.

În CommonJS, module.exports = { valoare } pune în obiect valoarea primitivă 0 de la momentul respectiv. creste() modifică variabila locală din modul, nu proprietatea obiectului. Destructurarea din main.cjs mai face o copie. Rezultat: 0.

Cum ai obține comportamentul dorit în CommonJS:

JavaScript
let valoare = 0;
module.exports = {
  get valoare() { return valoare; },
  creste() { valoare++; },
};
// și în main: const contor = require('./contor.cjs'); contor.valoare

De ce contează în practică:

  • La migrarea CJS → ESM, codul care se baza pe copii poate începe să vadă valori modificate.
  • Legăturile live sunt motivul pentru care dependențele circulare în ESM funcționează mai bine (când ordinea de inițializare permite).
  • Bundler-ele fac tree-shaking pe ESM tocmai pentru că importurile și exporturile sunt statice și analizabile fără rulare.

Un alt aspect diferit: în ESM, structura importurilor se cunoaște înainte de execuție (importurile sunt hoisted), iar import nu poate apărea în if; pentru încărcare condiționată există import().

Ce urmărește intervievatorul: Se verifică înțelegerea unei diferențe semantice reale între sistemele de module, dincolo de sintaxă. Greșeala tipică e să răspunzi 1 în ambele cazuri sau 0 în ambele.

Eroarea, în practică:read only property of object '[object Module]'

24 Mid

Ce este top-level await în modulele ES și ce efect are asupra modulelor care îl importă?

Răspuns scurt: Permite await direct la nivelul de sus al unui modul ES, fără funcție async. Modulele care îl importă așteaptă ca promisiunea să se rezolve înainte să-și ruleze propriul cod, deci un top-level await lent întârzie pornirea întregii aplicații.

În ESM poți scrie:

JavaScript
// config.mjs
import { readFile } from 'node:fs/promises';
export const config = JSON.parse(await readFile(new URL('./config.json', import.meta.url), 'utf8'));

// server.mjs
import { config } from './config.mjs';
console.log(config.port); // config e garantat încărcat aici

Modulul care folosește top-level await devine asincron. Orice modul care îl importă, direct sau indirect, își amână evaluarea până când promisiunea se rezolvă. Modulele „frați” care nu depind de el pot fi evaluate între timp.

Utilizări bune: încărcarea configurației, inițializarea unui pachet WebAssembly, alegerea unei implementări cu await import() condiționat, scripturi și unelte CLI.

Capcane:

  • Pornire lentă sau blocată: un await conectareLaBaza() la nivel de modul care nu se termină blochează pentru totdeauna tot ce depinde de modul, fără un mesaj clar. Pune timeout-uri.
  • Eroare la import: dacă promisiunea e respinsă, importul eșuează și aplicația nu pornește; uneori e ce vrei (fail fast), alteori nu.
  • Dependențe circulare cu top-level await pot produce blocaje.
  • Incompatibil cu require(esm): un modul cu top-level await nu poate fi încărcat cu require() (eroare ERR_REQUIRE_ASYNC_MODULE), deci o bibliotecă publicată nu ar trebui să-l folosească.
  • Nu există în CommonJS.

Pentru aplicații, o funcție explicită async function main() apelată din punctul de intrare dă de obicei mai mult control asupra ordinii și a erorilor.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi și costurile funcționalității, nu doar sintaxa. Răspunsul slab îl prezintă ca pe un simplu zahăr sintactic, fără efect asupra grafului de module.

Eroarea, în practică:Detected unsettled top-level awaitCannot determine intended module format

25 Senior

Publici o bibliotecă ce trebuie să funcționeze atât cu require, cât și cu import. Cum configurezi package.json și ce este „dual package hazard”?

Răspuns scurt: Folosești câmpul exports cu condiții (import, require, types) care indică build-urile ESM și CJS. Riscul dual package hazard apare când aceeași aplicație încarcă ambele variante: obții două copii ale modulului, cu stare și clase diferite, deci instanceof și singleton-urile se strică.

Configurație tipică pentru un pachet dual:

JSON
{
  "name": "biblioteca-mea",
  "type": "module",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "import": "./dist/index.js",
      "require": "./dist/index.cjs"
    },
    "./package.json": "./package.json"
  },
  "files": ["dist"]
}

Câmpul exports:

  • încapsulează pachetul: doar căile listate pot fi importate; require('biblioteca-mea/dist/intern.js') dă ERR_PACKAGE_PATH_NOT_EXPORTED. Adăugarea lui exports într-un pachet existent este deci o schimbare care poate strica utilizatori, adică versiune majoră;
  • are prioritate față de main;
  • condițiile se evaluează în ordine, prima potrivită câștigă; types trebuie pus primul pentru TypeScript, iar default se pune ultimul ca rezervă.

Dual package hazard: dacă o parte a aplicației face import și alta (sau o dependență) face require, Node încarcă două fișiere diferite, deci două instanțe ale modulului. O clasă ValidationError din varianta ESM nu e instanceof aceeași clasă din varianta CJS; un registru intern sau o conexiune partajată există de două ori.

Strategii:

  • variantă CJS subțire care re-exportă implementarea, sau stare ținută într-un singur loc;
  • publicare doar ESM, acum că require(esm) funcționează în Node 20.19+ și 22.12+, cu condiția să nu folosești top-level await; aceasta e direcția recomandată pentru biblioteci noi care țintesc doar versiuni actuale;
  • testarea pachetului împachetat (npm pack) atât cu require, cât și cu import, plus unelte ca publint sau „Are the Types Wrong?”.

Ce urmărește intervievatorul: Se verifică experiența reală cu publicarea de pachete și înțelegerea unei probleme subtile. Candidații de nivel mediu știu de main și module, dar nu de încapsularea prin exports și nici de instanțele duble.

Eroarea, în practică:ERR_PACKAGE_PATH_NOT_EXPORTED

26 Senior

Echipa vrea să migreze o aplicație Node mare, scrisă în CommonJS, la modulele ES. Cum ai planifica migrarea?

Răspuns scurt: Aș stabili întâi motivul și criteriile de succes, aș inventaria blocajele (unelte, dependențe, __dirname, require dinamic), apoi aș migra incremental, de la frunze spre punctul de intrare, cu teste și CI verzi la fiecare pas, nu printr-un singur PR uriaș.

Model de răspuns structurat:

  • De ce: migrarea costă. Motive valide: dependențe importante doar ESM, unificarea cu codul de frontend, top-level await, tree-shaking. Dacă singurul motiv e „e mai modern”, cu require(esm) disponibil în Node 22.12+ s-ar putea să nu merite acum.
  • Inventar: căutăm require dinamic (require(variabila)), require.cache, __dirname/__filename, module.exports reatribuit condiționat, require pentru JSON, mock-uri de module în teste, fișiere de configurare citite de unelte (ESLint, Jest, Babel), versiunea Node din toate mediile.
  • Unelte: verificăm că runner-ul de teste suportă ESM (Jest are suport experimental; node:test sau Vitest îl au nativ), că TypeScript are "module": "nodenext", că instrumentele de APM se încarcă corect cu --import.
  • Pași incrementali: modulele ES pot importa CJS, deci convertim de la frunze (utilitare fără dependențe interne) spre rădăcină. Fișierele noi pot fi .mjs sau într-un subdosar cu "type": "module". Un codemod (de exemplu cjs-to-esm) face partea mecanică; adăugarea extensiilor la importuri e cea mai mare sursă de diferențe.
  • Comutarea finală: "type": "module" în rădăcină, fișierele rămase CJS redenumite .cjs.
  • Verificare: testele rulează în CI la fiecare pas; un deploy pe staging măsoară timpul de pornire și erorile; avem plan de revenire.
  • Comunicare: un document scurt pentru echipă cu regulile noi (extensii, import.meta.dirname, interzicerea importurilor fără extensie prin ESLint), ca să nu reintroducem cod CJS.

Ce urmărește intervievatorul: Intervievatorul evaluează planificarea și gestionarea riscului, nu doar cunoștințele de sintaxă. Răspunsul slab propune „rulez un codemod și repar ce pică”.

npm și package.json

Exersează capitolul cu exerciții reale: Curs Node.js pentru începători →
27 Junior

Care e diferența dintre npm install și npm ci? Pe care îl folosești în CI și în Dockerfile?

Răspuns scurt: npm install rezolvă dependențele, poate actualiza package-lock.json și păstrează ce există în node_modules. npm ci șterge node_modules, instalează exact ce scrie în lockfile și eșuează dacă acesta nu se potrivește cu package.json. În CI și Docker folosești npm ci.

npm install este comanda de dezvoltare: adaugă pachete noi, actualizează lockfile-ul când package.json s-a schimbat și încearcă să refolosească ce e deja instalat. Rezultatul poate depinde de starea locală a dosarului node_modules.

npm ci (clean install) e făcut pentru build-uri reproductibile:

  • cere un package-lock.json (sau npm-shrinkwrap.json);
  • dacă lockfile-ul nu corespunde cu package.json (de exemplu cineva a adăugat o dependență fără să facă commit la lockfile), se oprește cu eroare în loc să „repare” singur;
  • șterge node_modules și instalează de la zero exact versiunile blocate;
  • nu modifică niciodată package.json sau lockfile-ul.

Într-un Dockerfile, combinat cu cache-ul de straturi:

BASH
COPY package.json package-lock.json ./
RUN npm ci --omit=dev
COPY . .

Copiind întâi doar fișierele de pachete, stratul cu dependențele se refolosește cât timp ele nu se schimbă. --omit=dev exclude devDependencies în imaginea de producție (dacă build-ul are nevoie de ele, faci build într-o etapă separată).

Greșeli frecvente: npm install în CI, care face ca build-ul să instaleze alte versiuni decât cele testate local; lockfile-ul pus în .gitignore; lockfile-uri generate cu versiuni foarte diferite de npm în echipă, care produc diferențe mari la fiecare commit.

Ce urmărește intervievatorul: Se verifică dacă știi cum obții instalări reproductibile. Greșeala tipică e să crezi că cele două comenzi sunt echivalente sau că npm ci e doar „mai rapid”.

Eroarea, în practică:Cannot find module 'lodash' (pachet npm)

28 Junior

Cum funcționează scripturile din package.json? De ce "test": "jest" merge cu npm test, dar jest scris direct în terminal dă „command not found”?

Răspuns scurt: npm run <nume> rulează comanda din scripts într-un shell în care node_modules/.bin e adăugat la PATH, deci executabilele pachetelor locale sunt găsite. În terminal, jest nu e în PATH; îl rulezi cu npx jest sau prin script.

Când rulezi npm run build, npm:

  • caută build în câmpul scripts;
  • pornește un shell (sh pe Linux și macOS, cmd pe Windows implicit);
  • adaugă la începutul PATH dosarul node_modules/.bin, unde pachetele își pun executabilele (câmpul bin din package.json-ul lor);
  • setează variabile de mediu utile, de exemplu npm_package_version.

Câteva scripturi au scurtături: npm test, npm start, npm stop, npm restart. Restul cer npm run. Argumentele se transmit după --:

BASH
npm test -- --watch
npm run lint -- --fix

Scripturile pot avea cârlige pre și post: dacă există prebuild, rulează automat înainte de build. Sunt comode, dar ascund pași, deci multe echipe preferă o comandă explicită: "build": "npm run clean && tsc".

npx jest rulează executabilul din node_modules/.bin dacă există; dacă nu, îl descarcă temporar din registru, ceea ce poate fi un risc de securitate la un nume scris greșit. npm exec este forma nouă a aceleiași funcționalități.

Pentru portabilitate între sisteme de operare, evită în scripturi comenzi specifice shell-ului (rm -rf, VAR=1 cmd); folosește node --run (Node 22, rulează scripturi fără overhead-ul npm, dar fără cârlige pre/post), unelte ca rimraf sau scripturi scrise în Node.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul din spatele scripturilor, nu doar că le folosești. Mulți candidați instalează global unelte ca să scape de eroare, ceea ce produce versiuni diferite între colegi.

29 Junior

Ce face npm install -g și de ce se recomandă să eviți instalarea globală a uneltelor de proiect, cum ar fi typescript sau eslint?

Răspuns scurt: Instalarea globală pune pachetul într-un dosar comun al sistemului și executabilul în PATH, independent de proiecte. Pentru uneltele de proiect, versiunea globală diferă între colegi și față de CI, deci le instalezi ca devDependencies și le rulezi prin scripturi sau npx.

Diferența între tipurile de instalare:

  • npm install pachet adaugă în dependencies, adică necesar la rulare;
  • npm install -D pachet (--save-dev) adaugă în devDependencies, adică necesar doar pentru dezvoltare, testare, build;
  • npm install -g pachet instalează în prefixul global (vezi npm prefix -g), fără să atingă package.json-ul vreunui proiect.

Problemele instalării globale pentru unelte de proiect:

  • Versiuni diferite: tu ai typescript 5.6 global, colegul are 5.3, CI-ul instalează altceva. Același cod compilează la unul și pică la altul.
  • Proiecte diferite pe aceeași mașină pot cere versiuni majore diferite ale aceleiași unelte.
  • Dependența nu e documentată: cineva care clonează repo-ul nu află din package.json că are nevoie de unealtă.
  • Permisiuni: pe Linux, instalarea globală cu Node din pachetele sistemului cere uneori sudo, ceea ce dă unor scripturi de instalare drepturi de administrator. Un manager de versiuni (nvm, fnm, Volta) evită problema.

Cum faci corect:

BASH
npm install -D typescript eslint
npx tsc --noEmit

Instalarea globală are sens pentru unelte personale, care nu țin de un proiect: un manager de versiuni Node, un generator pe care îl rulezi o dată (deși npx create-... acoperă și asta), unelte CLI de administrare.

Pentru managerul de pachete în sine (npm, pnpm, Yarn), câmpul packageManager din package.json împreună cu Corepack fixează versiunea pentru toată echipa.

Ce urmărește intervievatorul: Se verifică disciplina de proiect: reproductibilitate între oameni și medii. Răspunsul slab e „global e mai comod, îl instalezi o dată”.

30 Junior

Cum te asiguri că toată echipa și serverul de producție folosesc aceeași versiune de Node.js pentru un proiect? Ce înseamnă LTS?

Răspuns scurt: Fixezi versiunea în .nvmrc sau .node-version (citite de nvm, fnm, Volta), în câmpul engines din package.json și în imaginea Docker sau configurația CI. LTS (Long Term Support) sunt versiunile pare, care primesc remedieri și patch-uri de securitate pe termen lung; pe ele rulezi producția.

Mecanismele, de obicei folosite împreună:

  • .nvmrc / .node-version în rădăcina proiectului, cu o linie precum 22. Cu nvm rulezi nvm use; fnm și Volta pot comuta automat când intri în dosar.
  • engines în package.json:
JSON
{ "engines": { "node": ">=22.12 <23" } }

Atenție: npm doar afișează un avertisment dacă versiunea nu se potrivește. Ca să devină eroare, pui engine-strict=true în .npmrc. Pachetele publicate folosesc engines ca să anunțe ce versiuni suportă.

  • Docker și CI: FROM node:22-alpine (sau o versiune exactă, node:22.12.0, pentru build-uri complet reproductibile) și aceeași versiune în configurația CI (de exemplu node-version-file: .nvmrc în GitHub Actions).

Despre versiuni: Node scoate o versiune majoră nouă de două ori pe an. Versiunile pare (20, 22, 24) devin LTS după aproximativ șase luni: trec prin „Active LTS”, apoi „Maintenance”, cu suport total în jur de trei ani. Versiunile impare (21, 23) au viață scurtă și nu sunt pentru producție. Calendarul exact e publicat pe nodejs.org și pe GitHub, în repo-ul nodejs/Release.

De ce contează: o versiune ieșită din suport nu mai primește patch-uri de securitate, iar diferențele între versiuni (de exemplu fetch global, require(esm), node --run) pot face ca un cod să meargă local și să pice pe server.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai lucrat într-o echipă cu medii consistente. Greșeala tipică e să crezi că engines blochează automat instalarea pe o versiune greșită.

31 Mid

npm ls lodash arată patru versiuni diferite de lodash în node_modules. Cum e posibil și când e o problemă?

Răspuns scurt: Când dependențele cer intervale semver incompatibile, npm instalează copii separate în node_modules interne. Devine problemă la pachetele care trebuie să fie unice (stare sau clase comune), la mărimea bundle-ului și când o copie veche are vulnerabilități.

npm (din versiunea 3) construiește un arbore cât mai „plat”: încearcă să pună fiecare pachet direct în node_modules din rădăcină. Dacă pachetul A cere lodash@^4.17.0 și pachetul B cere lodash@^3.10.0, nu pot împărți o copie. Una ajunge în rădăcină, cealaltă în node_modules/B/node_modules/lodash. Rezolvarea require urcă prin dosare, deci fiecare pachet o găsește pe a sa.

Comenzi utile:

BASH
npm ls lodash          # cine depinde de ce versiune
npm explain lodash     # de ce e instalată fiecare copie
npm dedupe             # încearcă să reducă duplicatele compatibile
npm outdated           # ce dependențe directe au versiuni mai noi

Când e acceptabil: pentru biblioteci fără stare, copiile multiple doar ocupă spațiu pe disc.

Când e o problemă:

  • Pachete cu identitate: dacă există două copii de react, de un ORM sau de o bibliotecă cu instanceof și registre globale, obții erori ciudate („Invalid hook call”, o eroare care nu e instanceof clasa așteptată). Pentru asta există peerDependencies: pachetul cere ca aplicația să ofere o singură copie.
  • Mărimea bundle-ului la frontend.
  • Securitate: o vulnerabilitate reparată în 4.17.21 poate rămâne prezentă printr-o copie veche cerută de o dependență nemenținută.

Remedii: actualizezi dependențele directe care trag versiunea veche, folosești overrides ca soluție temporară, sau înlocuiești pachetul nemenținut.

Ce urmărește intervievatorul: Se verifică dacă înțelegi cum e construit arborele de dependențe și ce efecte are. Candidații spun adesea că e un bug npm sau că npm dedupe rezolvă orice.

32 Mid

npm audit raportează o vulnerabilitate gravă într-o dependență tranzitivă: pachetul tău depinde de A, care depinde de o versiune veche și vulnerabilă a lui B. A nu a fost actualizat. Ce faci?

Răspuns scurt: Verifici întâi dacă vulnerabilitatea te afectează efectiv și dacă există o versiune nouă a lui A. Dacă nu, forțezi o versiune reparată a lui B cu câmpul overrides din package.json (npm 8.3+), rulezi testele și urmărești să elimini override-ul când A se actualizează.

Pași practici:

  • Evaluezi relevanța: citești avizul. O vulnerabilitate ReDoS într-un parser folosit doar la build sau o problemă într-o funcție pe care nu o apelezi are alt nivel de urgență decât una într-o bibliotecă ce procesează input de la utilizatori în producție. npm audit --omit=dev arată doar ce ajunge în producție.
  • Cauți o actualizare oficială: npm explain B îți spune cine o aduce. Poate există o versiune nouă a lui A, poate e o versiune minoră pe care npm update A o ia automat.
  • Override când A nu se mișcă:
JSON
{
  "overrides": {
    "B": "^2.4.1"
  }
}

sau doar pentru calea respectivă: "overrides": { "A": { "B": "^2.4.1" } }. Apoi npm install regenerează lockfile-ul. Riscul: A a fost testat cu versiunea veche; dacă B a schimbat API-ul, A se poate strica. Testele și o verificare manuală a funcționalității care folosește A sunt obligatorii.

  • npm audit fix aplică automat actualizările compatibile semver; npm audit fix --force poate sări peste versiuni majore și e periculos fără verificare.
  • Pe termen lung: un pachet nemenținut care aduce vulnerabilități e un semnal să-l înlocuiești. Unelte ca Dependabot sau Renovate deschid automat PR-uri de actualizare.

Documentezi override-ul (comentariu în PR sau tichet), pentru că fără context devine o configurație pe care nimeni nu mai îndrăznește să o șteargă.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă judecată, nu doar comanda. Greșeala tipică este npm audit fix --force rulat orbește sau ignorarea completă a raportului.

33 Mid

Ce sunt npm workspaces și cum organizezi cu ele un repo cu un API și o bibliotecă internă folosită de el?

Răspuns scurt: Workspaces (npm 7+) permit mai multe pachete într-un singur repo, cu un singur node_modules și un singur lockfile la rădăcină. Pachetele locale sunt legate prin link simbolic, deci API-ul folosește direct codul bibliotecii, fără publicare.

Structura:

repo/
  package.json
  package-lock.json
  packages/
    api/package.json        -> "name": "@firma/api"
    validare/package.json   -> "name": "@firma/validare"
JSON
{
  "name": "repo",
  "private": true,
  "workspaces": ["packages/*"]
}

În packages/api/package.json declari dependența ca pe orice alt pachet: "@firma/validare": "*" (sau versiunea exactă din pachet). La npm install în rădăcină, npm creează node_modules/@firma/validare ca link simbolic către packages/validare. Orice modificare în bibliotecă e vizibilă imediat în API.

Comenzi utile:

BASH
npm install zod -w @firma/validare     # dependență pentru un singur pachet
npm run test --workspaces              # testele din toate pachetele
npm run build -w @firma/api

Ce trebuie avut în vedere:

  • Dacă biblioteca e scrisă în TypeScript, trebuie compilată înainte (sau folosești referințe de proiect TypeScript ori câmpul exports către sursă în dezvoltare).
  • Dependențele „ridicate” la rădăcină pot fi folosite accidental de un pachet care nu le-a declarat; în producție, unde instalezi doar un pachet, apare „Cannot find module”. pnpm e mai strict aici.
  • Pentru Docker trebuie copiat lockfile-ul rădăcinii și fișierele package.json ale pachetelor necesare, apoi npm ci -w @firma/api.
  • Pentru orchestrarea build-urilor (ordine, cache) se adaugă de obicei unelte precum Turborepo sau Nx; workspaces doar leagă pachetele.

Ce urmărește intervievatorul: Se verifică experiența cu proiecte cu mai multe pachete. Candidații confundă adesea workspaces cu publicarea pachetelor sau nu știu de problema dependențelor nedeclarate.

34 Mid

Trebuie să publici pe npm un pachet scris de tine. Cum controlezi ce fișiere ajung în pachet și cum gestionezi versiunile?

Răspuns scurt: Controlezi conținutul cu câmpul files din package.json (listă albă) și verifici cu npm pack --dry-run înainte de publicare. Versiunile le crești cu npm version patch|minor|major după regulile semver, apoi rulezi npm publish.

Ce ajunge în pachet:

  • Câmpul files e o listă albă: "files": ["dist", "README.md"]. Unele fișiere sunt incluse mereu (package.json, README, LICENSE), iar unele sunt excluse mereu (.git, node_modules).
  • .npmignore e o listă neagră și e mai riscant: dacă lipsește, npm folosește .gitignore, iar un fișier .env neignorat de git poate fi publicat.
  • Verifici întotdeauna înainte:
BASH
npm pack --dry-run   # listează fișierele și mărimea
npm pack             # creează .tgz pe care îl poți instala local pentru test

Versiunile urmează semver: patch pentru remedieri compatibile, minor pentru funcționalități noi compatibile, major pentru orice schimbare care poate strica utilizatorii (inclusiv eliminarea suportului pentru o versiune Node sau adăugarea câmpului exports).

BASH
npm version minor      # 1.3.2 -> 1.4.0, commit și tag git
npm publish --access public   # pentru pachete cu scope (@firma/x)

Bune practici:

  • prepublishOnly sau un pipeline CI face build și teste înainte de publicare.
  • Publicarea din CI cu provenance (npm publish --provenance) leagă pachetul de commit-ul și workflow-ul care l-au creat.
  • Autentificare în doi pași pe contul npm și tokenuri cu drepturi minime.
  • Versiuni de test cu tag: npm publish --tag next, ca npm install pachet să nu primească automat varianta instabilă.
  • O versiune publicată nu poate fi republicată cu același număr; npm unpublish e limitat în timp și nerecomandat, preferi npm deprecate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai publicat efectiv un pachet și dacă respecți semver. Greșeala tipică e publicarea accidentală a fișierelor sursă, a testelor sau a secretelor.

35 Senior

Ce riscuri de tip supply chain are un proiect Node cu sute de dependențe și ce măsuri concrete ai lua?

Răspuns scurt: Riscurile principale: pachete compromise sau preluate de altcineva, nume asemănătoare (typosquatting) și scripturi postinstall care rulează cod arbitrar la instalare. Măsuri: lockfile verificat în review, npm ci, scripturi de instalare dezactivate unde e posibil, puține dependențe, audit automat și tokenuri CI cu drepturi minime.

Orice pachet din arbore, inclusiv cele tranzitive, rulează cu drepturile procesului tău. Vectori cunoscuți:

  • Cont de maintainer compromis: o versiune nouă, patch, a unui pachet popular conține cod malițios; cine are ^1.2.0 și face npm install o ia automat.
  • Typosquatting: expres în loc de express, publicat de un atacator.
  • Scripturi de ciclu de viață: preinstall/postinstall rulează la npm install, pe laptopul dezvoltatorului și în CI, cu acces la variabile de mediu și tokenuri.
  • Dependency confusion: un pachet intern @firma/x sau fără scope, publicat de altcineva pe registrul public cu o versiune mai mare.
  • Pachete abandonate cu vulnerabilități nereparate.

Măsuri:

  • package-lock.json comis și citit în review; o dependență nouă sau un salt de versiune neașteptat se discută.
  • npm ci peste tot, nu npm install.
  • npm ci --ignore-scripts (sau ignore-scripts=true în .npmrc), cu excepții explicite pentru pachetele care chiar au nevoie (de exemplu module native).
  • Scope privat și registru configurat pe scope în .npmrc, ca pachetele interne să nu poată fi luate de pe registrul public.
  • Minimizarea dependențelor: pentru funcții mici, codul propriu sau modulele din Node (fetch, node:test, util.parseArgs, crypto.randomUUID) elimină pachete întregi.
  • Audit automat (npm audit, Dependabot, Socket sau Snyk) și o politică de actualizare regulată, cu un mic decalaj față de versiunile proaspăt publicate.
  • Verificarea provenance și a semnăturilor: npm audit signatures.
  • În CI: tokenuri de publicare separate, cu drepturi minime și durată scurtă, secretele expuse doar job-urilor care au nevoie de ele.

Ce urmărește intervievatorul: Se verifică maturitatea în securitatea dependențelor, un subiect real pentru echipe. Răspunsul slab se rezumă la „rulez npm audit”.

36 Senior

Aplicația rulează pe o versiune de Node ieșită din suport și trebuie mutată pe LTS-ul curent. Cum planifici și execuți upgrade-ul?

Răspuns scurt: Citesc notele de schimbări pentru fiecare versiune majoră sărită, actualizez întâi local și în CI cu testele complete, verific dependențele native și uneltele, rulez pe staging cu trafic realist și fac trecerea în producție treptat, cu posibilitate de revenire.

Model de răspuns structurat:

  • Inventar: unde e fixată versiunea (Dockerfile, CI, .nvmrc, engines, serverless runtime, mașinile dezvoltatorilor); ce dependențe au module native (bcrypt, sharp, drivere de baze de date) și trebuie recompilate sau actualizate; ce unelte (Jest, TypeScript, APM) au cerințe de versiune.
  • Documentare: notele de lansare și listele de „breaking changes” ale fiecărei versiuni majore sărite. Exemple reale de schimbări: OpenSSL 3 din Node 17 (algoritmi vechi dezactivați), fetch global din Node 18, keep-alive implicit în agentul HTTP din Node 19, highWaterMark implicit mărit în Node 22, API-uri marcate depreciate care au devenit erori.
  • Dependențe: actualizez întâi pachetele care declară engines incompatibil; npm ls și npm outdated arată ce trebuie mișcat.
  • Execuție: un branch în care schimb versiunea peste tot; CI rulează testele pe versiunea veche și pe cea nouă (matrix) până la final. Rulez aplicația cu --trace-deprecation și caut avertismentele noi.
  • Validare: staging cu test de încărcare și comparație de metrici (latență p95, memorie, CPU, timp de pornire); comportamentul garbage collector-ului și al memoriei se poate schimba între versiuni.
  • Lansare: canary sau o parte din instanțe întâi, monitorizare de erori și metrici, imaginea veche păstrată pentru rollback rapid.
  • După: actualizez documentația și introduc un proces periodic (de exemplu verificarea calendarului LTS de două ori pe an), ca să nu mai sărim peste mai multe versiuni majore deodată.

Ce urmărește intervievatorul: Intervievatorul evaluează abordarea sistematică și gestionarea riscului într-o schimbare de infrastructură. Răspunsul slab este „schimb versiunea din Dockerfile și văd dacă trec testele”.

Eroarea, în practică:Unexpected identifier 'assert' (import JSON)util.isString is not a function (Node 23+)

fs, path și process

37 Junior

Modulul fs are trei variante de API: sincron (readFileSync), cu callback (readFile) și cu promisiuni (fs/promises). Când folosești fiecare?

Răspuns scurt: În codul nou folosești varianta cu promisiuni și async/await. Cea sincronă e potrivită la pornire, în scripturi și CLI-uri, iar cea cu callback apare mai ales în cod vechi.

Cele trei variante fac aceleași operații, diferă modul de așteptare a rezultatului:

JavaScript
const fs = require('node:fs');
const fsp = require('node:fs/promises');

const a = fs.readFileSync('date.txt', 'utf8');              // blochează thread-ul
fs.readFile('date.txt', 'utf8', (err, b) => { /* ... */ });  // error-first callback
const c = await fsp.readFile('date.txt', 'utf8');           // promisiune

Sincron: simplu, excepțiile se prind cu try/catch obișnuit, dar blochează event loop-ul. Bun pentru: citirea configurației la pornire, înainte de listen(); scripturi și CLI-uri care fac un singur lucru; unelte de build. Rău pentru orice cod care rulează la fiecare cerere într-un server.

Callback: API-ul original, cu convenția error-first: primul argument e eroarea sau null. Funcționează peste tot, dar compunerea mai multor operații duce la imbricare adâncă și la tratarea repetată a erorilor.

Promisiuni (node:fs/promises, stabil din Node 14): se combină natural cu async/await, Promise.all și try/catch. E alegerea implicită în codul nou. Oferă și FileHandle (await fsp.open()), care trebuie închis explicit cu await handle.close().

Câteva funcții de stream (createReadStream, createWriteStream) și watch sunt în modulul fs principal, nu în fs/promises.

Un argument des greșit: varianta sincronă nu e „mai rapidă” per total. O singură citire poate fi la fel de rapidă, dar sub încărcare blochează toate celelalte cereri.

Ce urmărește intervievatorul: Se verifică dacă alegi API-ul după context, nu din obișnuință. Greșeala tipică e folosirea variantelor Sync în rutele unui server sau, invers, interzicerea lor și în scripturi unde sunt perfect potrivite.

Eroarea, în practică:fs.readFileSync is not a functionThe "cb" argument must be of type function

38 Junior

Scriptul de mai jos merge când rulezi node index.js din dosarul proiectului, dar dă ENOENT când rulezi node src/index.js din rădăcină sau din cron. De ce și cum îl repari?

JavaScript
// src/index.js
const fs = require('node:fs');
const sabloane = fs.readFileSync('./sabloane/email.html', 'utf8');

Răspuns scurt: Căile relative din fs se rezolvă față de dosarul curent al procesului (process.cwd()), nu față de fișierul care le conține. Construiești calea față de fișier: path.join(__dirname, 'sabloane', 'email.html') în CommonJS sau new URL('./sabloane/email.html', import.meta.url) în ESM.

Aici sunt două concepte diferite care se confundă ușor:

  • require('./util') și import './util.js' se rezolvă față de fișierul în care sunt scrise;
  • fs.readFileSync('./x'), fs.writeFile, path.resolve('x') se rezolvă față de dosarul curent de lucru al procesului, adică dosarul din care ai pornit comanda.

Când rulezi din src/, ./sabloane/email.html înseamnă src/sabloane/email.html și există. Când rulezi din rădăcină, cron sau un manager de procese, același șir înseamnă <rădăcină>/sabloane/email.html și nu există.

Reparația, în CommonJS:

JavaScript
const path = require('node:path');
const fs = require('node:fs');

const cale = path.join(__dirname, 'sabloane', 'email.html');
const sabloane = fs.readFileSync(cale, 'utf8');

În ESM:

JavaScript
import { readFileSync } from 'node:fs';
const sabloane = readFileSync(new URL('./sabloane/email.html', import.meta.url), 'utf8');
// sau path.join(import.meta.dirname, 'sabloane', 'email.html') în Node 20.11+

fs acceptă direct obiecte URL cu protocolul file:.

Când e corect să folosești process.cwd(): la un CLI care lucrează pe fișierele utilizatorului (de exemplu un formatter rulat în proiectul lui). Pentru resursele aplicației tale (șabloane, migrații, fișiere statice) folosești mereu calea față de fișier.

path.join în loc de concatenare cu / contează și pentru Windows, unde separatorul e \.

Ce urmărește intervievatorul: Intervievatorul verifică distincția dintre dosarul curent și dosarul fișierului, sursa unor bug-uri clasice de deploy. Mulți candidați „repară” problema schimbând dosarul din care pornesc scriptul.

Eroarea, în practică:ENOENT: no such file or directory, openENOENT: no such file or directory, scandir

39 Junior

Ce afișează fiecare linie pe Linux, dacă procesul rulează în /home/ana/app?

JavaScript
const path = require('node:path');
console.log(path.join('/date', 'rapoarte', '../export', 'iunie.csv'));
console.log(path.resolve('/date', '/tmp', 'fisier.txt'));
console.log(path.resolve('config', 'app.json'));
console.log(path.join('uploads', '/poze/'));
console.log(path.extname('arhiva.tar.gz'), path.basename('/a/b/raport.pdf', '.pdf'));

Răspuns scurt: Afișează /date/export/iunie.csv, /tmp/fisier.txt, /home/ana/app/config/app.json, uploads/poze/ și .gz raport. join lipește segmentele și normalizează, iar resolve construiește o cale absolută și o ia de la capăt la fiecare segment absolut.

Diferența esențială:

  • path.join(...segmente) concatenează toate segmentele cu separatorul sistemului și normalizează rezultatul (elimină .., . și separatorii dubli). Un segment care începe cu / nu e tratat special, deci join('uploads', '/poze/') dă uploads/poze/. Rezultatul e relativ dacă primul segment e relativ.
  • path.resolve(...segmente) procesează segmentele de la dreapta la stânga până obține o cale absolută. Un segment absolut, cum e /tmp, „resetează” tot ce era înainte, deci /date e ignorat. Dacă nici un segment nu e absolut, se adaugă process.cwd() la început, de aici /home/ana/app/config/app.json. Rezultatul nu are separator final.

Pe rând:

  • /date/rapoarte/../export/iunie.csv normalizat devine /date/export/iunie.csv;
  • /tmp/fisier.txt;
  • /home/ana/app/config/app.json;
  • uploads/poze/ (join păstrează separatorul final);
  • extname întoarce doar ultima extensie, .gz, iar basename cu al doilea argument taie sufixul: raport.

Unde contează în practică:

  • path.join(dosarUpload, numeDinCerere) cu numeDinCerere = '../../etc/passwd' iese din dosar. Pentru securitate verifici rezultatul cu path.resolve și startsWith(dosarUpload + path.sep).
  • Pe Windows separatorul e \; pentru URL-uri sau chei de stocare care trebuie să aibă mereu / folosești path.posix.join.
  • path lucrează doar pe șiruri: nu verifică dacă fișierele există.

Ce urmărește intervievatorul: Se verifică dacă știi diferența practică dintre join și resolve, nu doar că amândouă „construiesc căi”. Capcana cu segmentul absolut în resolve prinde mulți candidați.

40 Junior

Ce e greșit în această abordare și cum o scrii corect?

JavaScript
if (fs.existsSync(cale)) {
  const text = await fs.promises.readFile(cale, 'utf8');
  return JSON.parse(text);
}
return {};

Răspuns scurt: Între verificare și citire fișierul poate fi șters sau creat de alt proces (race condition de tip TOCTOU), iar existsSync mai și blochează. Corect este să încerci direct operația și să tratezi eroarea după err.code, de exemplu ENOENT.

Problema se numește TOCTOU (time of check to time of use): starea fișierului se poate schimba între momentul în care o verifici și momentul în care o folosești. Alt proces, un job de curățare sau o altă cerere a aceleiași aplicații poate șterge fișierul imediat după existsSync, iar readFile aruncă oricum. Verificarea dă doar o falsă siguranță și adaugă un apel de sistem în plus, sincron.

Varianta corectă tratează eroarea specifică:

JavaScript
async function citesteSetari(cale) {
  try {
    const text = await fs.promises.readFile(cale, 'utf8');
    return JSON.parse(text);
  } catch (err) {
    if (err.code === 'ENOENT') return {};   // fișierul lipsește: valori implicite
    throw err;                              // alte erori nu le ascundem
  }
}

Coduri de eroare frecvente în fs, venite din sistemul de operare:

  • ENOENT: fișierul sau dosarul nu există;
  • EEXIST: există deja (la mkdir fără recursive sau la deschidere cu flag-ul wx);
  • EACCES / EPERM: lipsă de permisiuni;
  • EISDIR, ENOTDIR: ai cerut un fișier și e dosar, sau invers;
  • EMFILE: prea multe fișiere deschise în proces.

Același principiu la creare: în loc de „verific dacă există, apoi scriu”, folosești fs.promises.writeFile(cale, date, { flag: 'wx' }), care eșuează atomic cu EEXIST dacă fișierul există. La dosare, mkdir(cale, { recursive: true }) nu dă eroare dacă dosarul există.

Și JSON.parse poate arunca; în exemplu eroarea urcă, ceea ce e corect: un fișier de setări corupt nu trebuie tratat ca lipsă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști race condition-ul și știi să tratezi erorile după cod. Greșeala tipică este un catch care înghite orice eroare și întoarce valori implicite.

Eroarea, în practică:ENOENT: no such file or directory, open

41 Junior

Scrie un CLI node raport.js --luna 10 --format csv fisier.json care citește opțiunile fără biblioteci externe.

Răspuns scurt: Argumentele sunt în process.argv (primele două elemente sunt calea lui node și a scriptului). Pentru opțiuni folosești util.parseArgs, inclus în Node (stabil din 20), care validează tipurile și separă opțiunile de argumentele poziționale.

process.argv pentru comanda dată arată așa: ['/usr/bin/node', '/cale/raport.js', '--luna', '10', '--format', 'csv', 'fisier.json']. Parsarea manuală cu indici devine repede fragilă (--luna=10, opțiuni lipsă, ordine diferită), așa că Node oferă parseArgs:

JavaScript
const { parseArgs } = require('node:util');

const { values, positionals } = parseArgs({
  args: process.argv.slice(2),
  options: {
    luna:   { type: 'string', short: 'l' },
    format: { type: 'string', default: 'json' },
    detaliat: { type: 'boolean', short: 'v', default: false },
  },
  allowPositionals: true,
});

const luna = Number(values.luna);
if (!Number.isInteger(luna) || luna < 1 || luna > 12) {
  console.error('Eroare: --luna trebuie să fie un număr între 1 și 12');
  process.exit(2);
}
if (!['json', 'csv'].includes(values.format)) {
  console.error('Eroare: --format acceptă json sau csv');
  process.exit(2);
}
const [fisier] = positionals;
if (!fisier) {
  console.error('Utilizare: node raport.js --luna <1-12> [--format csv] <fisier>');
  process.exit(2);
}

Observații:

  • parseArgs aruncă eroare la opțiuni necunoscute (modul strict, implicit), ceea ce prinde greșelile de tipar.
  • Tipurile sunt doar string și boolean; conversia și validarea numerelor le faci tu.
  • Mesajele de eroare merg pe stderr (console.error), iar rezultatul util pe stdout, ca CLI-ul să poată fi folosit într-un pipe.
  • Codul de ieșire nenul semnalează eroarea scripturilor care te apelează; 2 e folosit convențional pentru utilizare greșită.

Pentru CLI-uri mari cu subcomenzi și help generat, bibliotecile ca commander rămân utile.

Ce urmărește intervievatorul: Se verifică dacă știi să construiești un CLI corect: argumente, validare, stderr și coduri de ieșire. Mulți candidați uită de primele două elemente din process.argv sau de validarea valorilor.

Eroarea, în practică:ERR_PARSE_ARGS_UNKNOWN_OPTION: Unknown optionparseArgs: Option '--port <value>' argument missing

42 Junior

De ce acest script poate pierde o parte din output când e redirecționat într-un fișier sau într-un pipe? Cum îl repari?

JavaScript
const rezultate = genereazaMiiDeLinii();
for (const linie of rezultate) process.stdout.write(linie + '\n');
if (rezultate.some(r => r.includes('EROARE'))) process.exit(1);
process.exit(0);

Răspuns scurt: process.exit() oprește procesul imediat, iar scrierile în stdout pot fi încă în buffer când ieșirea e un pipe asincron. Setezi process.exitCode = 1 și lași procesul să se termine natural, după ce event loop-ul golește tot.

process.stdout și process.stderr se comportă diferit în funcție de destinație: la fișiere scrierea e sincronă, dar la pipe-uri și socket-uri (de exemplu node script.js | grep x sau output capturat de un alt program) poate fi asincronă, în funcție de platformă (documentația Node descrie exact cazurile; pe macOS, de exemplu, pipe-urile sunt asincrone). Datele ajung într-un buffer intern și se golesc pe măsură ce consumatorul citește. process.exit() nu așteaptă: rulează sincron listener-ii evenimentului exit și oprește procesul. Ce era încă în buffer se pierde, iar consumatorul primește un output trunchiat.

Reparația:

JavaScript
const rezultate = genereazaMiiDeLinii();
for (const linie of rezultate) process.stdout.write(linie + '\n');
if (rezultate.some(r => r.includes('EROARE'))) process.exitCode = 1;
// nimic altceva: procesul iese singur cu exitCode când event loop-ul se golește

process.exitCode doar memorează codul; procesul se termină normal când nu mai are nimic de făcut, deci după golirea stream-urilor.

Când ai totuși nevoie de oprire explicită (de exemplu într-un handler de semnal), închizi întâi resursele (server, conexiuni la baza de date) și eventual aștepți golirea cu callback-ul lui write.

Despre evenimentele de ieșire:

  • beforeExit se emite când event loop-ul se golește, dar nu și la process.exit() explicit; poți programa lucruri asincrone în el.
  • exit se emite mereu, dar în listener-ii lui doar codul sincron mai rulează.

O regulă bună pentru biblioteci: nu apela niciodată process.exit(). Aruncă o eroare sau returnează un rezultat și lasă aplicația să decidă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre exit() și exitCode și comportamentul asincron al stdout. Bug-ul apare doar în CI sau în pipe-uri, de aceea mulți candidați nu l-au observat niciodată local.

43 Junior

Scrie o funcție care numără câte linii dintr-un fișier de log de 10 GB conțin textul ERROR, fără să încarci fișierul în memorie.

Răspuns scurt: Combini fs.createReadStream cu readline.createInterface și parcurgi liniile cu for await...of. Memoria rămâne mică și constantă, pentru că se citește câte o bucată de 64 KiB și se procesează linie cu linie.

fs.readFile pe 10 GB ar eșua: un string în V8 are o limită de aproximativ 512 MB, iar un Buffer de mărimea fișierului ar consuma toată memoria. Soluția e citirea în flux:

JavaScript
const fs = require('node:fs');
const readline = require('node:readline');

async function numaraErori(cale) {
  const rl = readline.createInterface({
    input: fs.createReadStream(cale, { encoding: 'utf8' }),
    crlfDelay: Infinity, // tratează \r\n ca un singur sfârșit de linie
  });

  let total = 0;
  for await (const linie of rl) {
    if (linie.includes('ERROR')) total++;
  }
  return total;
}

numaraErori('/var/log/app.log')
  .then((n) => console.log('linii cu ERROR:', n))
  .catch((err) => { console.error(err); process.exitCode = 1; });

De ce funcționează bine:

  • createReadStream citește bucăți (implicit 64 KiB pentru stream-urile de fișiere).
  • readline lipește bucățile și împarte textul în linii, inclusiv când o linie e tăiată între două bucăți.
  • for await respectă backpressure: următoarea bucată se citește doar după ce bucla a consumat liniile curente.
  • encoding: 'utf8' face ca un caracter multi-byte (de exemplu ț) tăiat între bucăți să fie decodat corect.

Eroarea de deschidere (fișier inexistent) apare ca excepție în bucla for await, deci e prinsă de catch.

Dacă performanța contează mult, varianta mai rapidă lucrează direct pe Buffer-e și caută octeții lui ERROR fără să creeze un string pentru fiecare linie. Pentru o întrebare de interviu, varianta cu readline e cea așteptată.

Ce urmărește intervievatorul: Se verifică dacă știi să procesezi fișiere mari cu memorie constantă. Greșeala tipică e readFile plus split('\n'), care merge pe fișierul de test și pică în producție.

44 Mid

Aplicația ta salvează starea într-un fișier JSON cu writeFile. După o cădere de curent, fișierul a rămas gol sau pe jumătate scris. Cum faci scrierea sigură?

Răspuns scurt: Scrii întâi într-un fișier temporar din același dosar, opțional forțezi scrierea pe disc cu fsync, apoi faci rename peste fișierul final. Pe același sistem de fișiere, rename e atomic: cititorii văd fie versiunea veche completă, fie pe cea nouă completă.

writeFile deschide fișierul cu trunchiere și apoi scrie conținutul. Dacă procesul moare, serverul se oprește sau discul se umple între cele două momente, rămâi cu un fișier gol sau parțial, iar la următoarea pornire JSON.parse aruncă. Și doi scriitori concurenți pot amesteca datele.

Tiparul standard:

JavaScript
const fsp = require('node:fs/promises');
const path = require('node:path');
const { randomUUID } = require('node:crypto');

async function scrieAtomic(cale, date) {
  const tmp = path.join(path.dirname(cale), `.${path.basename(cale)}.${randomUUID()}.tmp`);
  const handle = await fsp.open(tmp, 'w');
  try {
    await handle.writeFile(JSON.stringify(date));
    await handle.sync();          // datele ajung fizic pe disc
  } finally {
    await handle.close();
  }
  try {
    await fsp.rename(tmp, cale);  // înlocuire atomică
  } catch (err) {
    await fsp.rm(tmp, { force: true });
    throw err;
  }
}

Detalii care contează:

  • Fișierul temporar trebuie să fie pe același sistem de fișiere cu destinația; între sisteme diferite rename dă EXDEV. De aceea îl pui în același dosar, nu în /tmp.
  • sync() (fsync) previne situația în care după o cădere de curent rename-ul e pe disc, dar conținutul nu. Pentru durabilitate completă se face fsync și pe dosar.
  • Pe Windows, rename peste un fișier deschis de alt proces poate eșua cu EPERM; bibliotecile ca write-file-atomic tratează aceste cazuri cu reîncercări.
  • Scrierea atomică nu rezolvă concurența între mai multe procese care modifică aceeași stare: ultimul câștigă. Pentru asta ai nevoie de blocări sau, mai realist, de o bază de date (chiar și SQLite).

Ce urmărește intervievatorul: Intervievatorul verifică dacă te gândești la eșecuri parțiale și cunoști tiparul temp + rename. Candidații propun des un try/catch în jurul lui writeFile, care nu ajută la o cădere de proces.

45 Mid

Cum încarci variabilele dintr-un fișier .env în Node 22 fără pachetul dotenv, și ce trebuie să știi despre ordinea de prioritate?

Răspuns scurt: Pornești aplicația cu node --env-file=.env app.js (Node 20.6+) sau apelezi process.loadEnvFile() (Node 20.12+, 21.7+). Variabilele deja setate în mediul procesului au prioritate față de cele din fișier, deci producția le poate suprascrie.

Node a preluat cea mai frecventă funcționalitate din dotenv:

BASH
node --env-file=.env app.js
node --env-file=.env --env-file=.env.local app.js     # mai multe fișiere
node --env-file-if-exists=.env app.js                 # fără eroare dacă lipsește (Node 22.9+)
JavaScript
// din cod, de exemplu doar în dezvoltare
if (process.env.NODE_ENV !== 'production') {
  process.loadEnvFile('.env');
}
// sau parsarea unui text: util.parseEnv('A=1\nB=2')

Reguli de reținut:

  • Dacă o variabilă există deja în mediu (setată de shell, Docker, Kubernetes, platforma de hosting), valoarea din mediu câștigă. Asta e comportamentul dorit: fișierul dă valori implicite pentru dezvoltare, producția le suprascrie.
  • La mai multe fișiere, cele de mai târziu le suprascriu pe cele anterioare.
  • --env-file e procesat înainte de pornirea aplicației, deci poate seta și opțiuni Node prin NODE_OPTIONS din fișier.
  • Toate valorile sunt string-uri: PORT=3000 ajunge ca '3000', DEBUG=false ca 'false', care e truthy. Convertești și validezi la pornire, într-un singur modul de configurare.
  • Fișierul nu suportă expandarea de variabile (${ALTA}) cum face dotenv-expand.

Ce rămâne neschimbat: .env cu secrete nu se pune în git (comiți un .env.example fără valori reale), iar în producție secretele vin din managerul de secrete al platformei, nu din fișiere copiate pe server.

Ce urmărește intervievatorul: Se verifică dacă cunoști funcționalitățile noi din runtime și înțelegi prioritatea configurării. Greșeala tipică e să presupui că fișierul suprascrie mediul sau că valorile sunt deja numere și booleeni.

Eroarea, în practică:The "path" argument must be of type stringThe "key" argument must be of type string

46 Mid

Scrie o funcție asincronă care calculează mărimea totală, în octeți, a tuturor fișierelor dintr-un dosar, inclusiv din subdosare.

Răspuns scurt: Parcurgi recursiv dosarul cu fs.promises.readdir(dosar, { withFileTypes: true }), intri în subdosare, faci stat pe fișiere și aduni size. Limitezi paralelismul ca să nu deschizi mii de operații simultan și ignori legăturile simbolice ca să eviți ciclurile.

O variantă clară, cu paralelism moderat pe fiecare nivel:

JavaScript
const fsp = require('node:fs/promises');
const path = require('node:path');

async function marimeDosar(dosar) {
  const intrari = await fsp.readdir(dosar, { withFileTypes: true });
  let total = 0;

  for (let i = 0; i < intrari.length; i += 50) {
    const lot = intrari.slice(i, i + 50);
    const marimi = await Promise.all(lot.map(async (intrare) => {
      const cale = path.join(dosar, intrare.name);
      if (intrare.isSymbolicLink()) return 0;          // evită cicluri
      if (intrare.isDirectory()) return marimeDosar(cale);
      if (intrare.isFile()) return (await fsp.stat(cale)).size;
      return 0;                                        // socket-uri, dispozitive
    }));
    total += marimi.reduce((a, b) => a + b, 0);
  }
  return total;
}

De ce așa:

  • withFileTypes: true întoarce obiecte Dirent, deci afli tipul fără un stat pentru fiecare intrare.
  • Loturile de 50 limitează câte operații sunt în zbor pe nivel. Un Promise.all pe zeci de mii de fișiere poate da EMFILE (prea multe fișiere deschise) și umple thread pool-ul. Recursivitatea poate totuși înmulți limita pe niveluri; pentru limită globală folosești o coadă cu concurență fixă.
  • Legăturile simbolice sunt sărite; altfel o legătură către un dosar părinte produce recursivitate infinită.

Variantă mai scurtă în Node 20.1+: readdir(dosar, { recursive: true, withFileTypes: true }) întoarce tot arborele, dar ține toate intrările în memorie simultan. fsp.opendir dă un iterator asincron, potrivit pentru dosare uriașe.

Pentru robustețe, decizi ce faci la EACCES pe un subdosar: oprești tot sau sari peste el și raportezi la final.

Ce urmărește intervievatorul: Intervievatorul verifică recursivitatea asincronă și grija pentru resurse (descriptori, cicluri). Soluția naivă cu Promise.all nelimitat sau cu variantele Sync e semnalul pe care îl caută.

Eroarea, în practică:ENOTDIR: not a directory, scandir

Streams, Buffer și EventEmitter

47 Junior

Care sunt cele patru tipuri de stream din Node.js? Dă câte un exemplu din API-urile incluse.

Răspuns scurt: Readable (sursă de date, de exemplu fs.createReadStream, req pe server), Writable (destinație, de exemplu fs.createWriteStream, res), Duplex (citește și scrie independent, de exemplu un socket TCP) și Transform (un Duplex care transformă ce intră în ce iese, de exemplu zlib.createGzip).

Toate stream-urile sunt EventEmitter-e și moștenesc din clasele modulului node:stream:

  • Readable: produce date pe care le consumi. Exemple: fs.createReadStream, process.stdin, http.IncomingMessage (obiectul req pe server sau răspunsul primit de un client). Evenimente importante: data, end, error, close.
  • Writable: primește date. Exemple: fs.createWriteStream, process.stdout, http.ServerResponse (obiectul res). Metode: write(), end(); evenimente: drain, finish, error.
  • Duplex: are o parte readable și una writable, independente una de alta. Exemplu: net.Socket (ce scrii pleacă spre celălalt capăt, ce citești vine de la el).
  • Transform: un Duplex în care ieșirea e calculată din intrare. Exemple: zlib.createGzip(), crypto.createHash() (în mod stream), un parser CSV.

Un lanț tipic le combină pe toate:

JavaScript
const { pipeline } = require('node:stream/promises');
const fs = require('node:fs');
const zlib = require('node:zlib');

await pipeline(
  fs.createReadStream('acces.log'),     // Readable
  zlib.createGzip(),                     // Transform
  fs.createWriteStream('acces.log.gz'),  // Writable
);

Avantajul față de citirea completă: memoria folosită e limitată la câteva bucăți (chunk-uri), indiferent de mărimea fișierului, iar procesarea începe imediat ce sosește prima bucată.

Stream-urile lucrează implicit cu Buffer-e sau string-uri. Cu objectMode: true pot transporta orice valoare JavaScript, de exemplu un obiect pe fiecare rând dintr-un CSV.

Ce urmărește intervievatorul: Se verifică dacă știi tipurile și le recunoști în API-urile pe care le folosești zilnic (req, res). Mulți candidați nu știu că obiectele din http sunt stream-uri.

48 Junior

Codul de mai jos generează un fișier mare, dar procesul ajunge să consume gigaocteți de memorie. De ce și cum îl repari?

JavaScript
const fs = require('node:fs');
const out = fs.createWriteStream('numere.txt');
for (let i = 0; i < 1e8; i++) {
  out.write(`${i}\n`);
}
out.end();

Răspuns scurt: Codul ignoră backpressure: write() întoarce false când buffer-ul intern a depășit highWaterMark, iar datele continuă să se adune în memorie pentru că discul nu ține pasul. Trebuie să te oprești când write() dă false și să continui la evenimentul drain.

Backpressure este mecanismul prin care un consumator lent îi spune producătorului să încetinească. Un Writable are un buffer intern; write() adaugă datele în el și întoarce:

  • true dacă buffer-ul e încă sub highWaterMark, deci poți continua;
  • false dacă a depășit pragul; datele sunt acceptate, dar ar trebui să aștepți evenimentul drain.

Bucla sincronă din exemplu nu așteaptă niciodată: scrie 100 de milioane de string-uri în buffer mult mai repede decât le poate scrie discul. Toate stau în memorie până la final.

Reparația cu drain:

JavaScript
const fs = require('node:fs');
const { once } = require('node:events');

async function genereaza() {
  const out = fs.createWriteStream('numere.txt');
  for (let i = 0; i < 1e8; i++) {
    if (!out.write(`${i}\n`)) {
      await once(out, 'drain');   // așteaptă golirea buffer-ului
    }
  }
  out.end();
  await once(out, 'finish');
}

Variantă mai idiomatică: un Readable din generator, conectat cu pipeline, care gestionează automat backpressure-ul și erorile:

JavaScript
const { Readable } = require('node:stream');
const { pipeline } = require('node:stream/promises');

function* linii() { for (let i = 0; i < 1e8; i++) yield `${i}\n`; }
await pipeline(Readable.from(linii()), fs.createWriteStream('numere.txt'));

Pentru performanță, ar fi mai bine să grupezi mai multe numere într-o singură scriere: 100 de milioane de apeluri write mici au overhead mare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce înseamnă valoarea returnată de write(). Greșeala tipică e să crezi că stream-urile limitează memoria automat, oricum ai scrie în ele.

49 Junior

Care e diferența între a.pipe(b).pipe(c) și stream.pipeline(a, b, c)? Pe care îl folosești și de ce?

Răspuns scurt: Ambele conectează stream-urile cu backpressure, dar pipe nu propagă erorile și nu închide celelalte stream-uri când unul eșuează, ceea ce lasă descriptori deschiși și erori netratate. pipeline (sau varianta cu promisiuni din node:stream/promises) tratează erorile o singură dată și distruge tot lanțul.

Problema cu pipe:

JavaScript
fs.createReadStream('intrare.csv')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('iesire.gz'));
  • Un error emis de stream-ul de citire (de exemplu fișierul nu există) nu ajunge la celelalte; dacă nu ai pus .on('error') pe fiecare stream, eroarea devine excepție netratată și oprește procesul.
  • Dacă destinația eșuează (disc plin), sursa nu e oprită și rămâne deschisă: scurgere de descriptori de fișiere sau de socket-uri.
  • Nu ai un singur loc în care să afli că totul s-a terminat cu succes.

pipeline rezolvă toate trei:

JavaScript
const { pipeline } = require('node:stream/promises');

try {
  await pipeline(
    fs.createReadStream('intrare.csv'),
    zlib.createGzip(),
    fs.createWriteStream('iesire.gz'),
  );
  console.log('gata');
} catch (err) {
  console.error('a eșuat:', err.message); // o singură eroare, toate stream-urile distruse
}

Avantaje în plus:

  • Acceptă și funcții generatoare asincrone ca pași de transformare, deci poți scrie un Transform fără clasă.
  • Acceptă un signal (AbortSignal) în opțiuni pentru anulare.
  • La un server HTTP, dacă clientul închide conexiunea în timpul trimiterii, pipeline închide și fișierul citit.

pipe rămâne în cod vechi și e suficient în cazuri foarte simple, cum ar fi process.stdin.pipe(process.stdout), dar în cod nou alegerea implicită e pipeline.

Ce urmărește intervievatorul: Se verifică dacă știi de problemele de tratare a erorilor și de resurse rămase deschise la pipe. Răspunsul slab este „sunt la fel, pipeline e doar sintaxă nouă”.

50 Junior

Ce afișează codul?

JavaScript
const text = 'Știință';
const buf = Buffer.from(text);
console.log(text.length, buf.length);
console.log(buf.subarray(0, 2).toString());
console.log(Buffer.byteLength('abc'), buf.toString('base64').length > 0);

Răspuns scurt: Afișează 7 10, apoi Ș, apoi 3 true. text.length numără unități UTF-16 (7), iar Buffer-ul conține octeți UTF-8: fiecare dintre Ș, ț, ă ocupă 2 octeți, deci 10. Primii doi octeți formează exact litera Ș.

Un Buffer e o secvență de octeți (o subclasă de Uint8Array), nu de caractere. Buffer.from(string) folosește implicit codificarea UTF-8, în care:

  • literele ASCII (t, i, n) ocupă un octet;
  • literele românești cu diacritice (ș, ț, ă, î, â și majusculele lor) ocupă doi octeți.

Știință are 7 caractere, dintre care 3 cu diacritice: 4 + 3 × 2 = 10 octeți.

buf.subarray(0, 2) ia primii doi octeți, adică exact codificarea lui Ș, deci toString() afișează Ș. Dacă ai fi luat doar primul octet, ai fi obținut caracterul de înlocuire (un semn de întrebare într-un romb), pentru că secvența UTF-8 e incompletă. Atenție: subarray (și slice pe Buffer) nu copiază, ci creează o vedere peste aceeași memorie; modificarea ei modifică și originalul.

Buffer.byteLength('abc') e 3. Mai departe, toString('base64') codifică octeții în text sigur pentru transport.

De ce contează în practică:

  • Header-ul Content-Length trebuie să conțină numărul de octeți, deci Buffer.byteLength(corp), nu corp.length. Cu diacritice, corp.length trimite o valoare prea mică și clientul taie răspunsul.
  • Limitele de mărime pentru câmpuri (de exemplu „maxim 255 de octeți” într-o bază de date) se verifică pe octeți.
  • text.length poate surprinde și la caractere din afara planului de bază Unicode, care ocupă două unități UTF-16.

Ce urmărește intervievatorul: Intervievatorul verifică distincția caractere vs octeți, foarte relevantă pentru texte în română. Greșeala tipică este calculul Content-Length cu string.length.

51 Junior

Unde e bug-ul? Uneori, în textele cu diacritice, apar caractere stricate în corpul cererii.

JavaScript
let corp = '';
req.on('data', (chunk) => { corp += chunk; });
req.on('end', () => {
  const date = JSON.parse(corp);
  // ...
});

Răspuns scurt: corp += chunk convertește fiecare Buffer separat în string. Dacă un caracter UTF-8 pe doi octeți, cum e ș, e tăiat între două bucăți, fiecare jumătate devine caracter invalid. Aduni Buffer-ele și faci Buffer.concat(bucati).toString('utf8') la final, sau setezi req.setEncoding('utf8').

Datele din rețea sosesc în bucăți de mărimi arbitrare, decise de TCP și de buffer-ele interne, nu la granițe de caractere. Concatenarea string + Buffer apelează implicit chunk.toString('utf8') pe fiecare bucată în parte. Când bucata 1 se termină cu primul octet al lui ș și bucata 2 începe cu al doilea, ambele jumătăți sunt decodate separat ca secvențe invalide și devin caracterul de înlocuire U+FFFD. Bug-ul apare rar, doar la corpuri mari, deci e greu de reprodus local.

Varianta corectă cu Buffer-e:

JavaScript
const bucati = [];
let marime = 0;
req.on('data', (chunk) => {
  marime += chunk.length;
  if (marime > 1_000_000) {           // limită de 1 MB
    res.writeHead(413).end();
    req.destroy();
    return;
  }
  bucati.push(chunk);
});
req.on('end', () => {
  const text = Buffer.concat(bucati).toString('utf8');
  // JSON.parse în try/catch, cu 400 la eroare
});

Alternative:

  • req.setEncoding('utf8'): stream-ul folosește intern un StringDecoder, care păstrează octeții incompleți până sosește restul caracterului, iar evenimentele data primesc string-uri corecte.
  • Cu iterare asincronă: for await (const chunk of req) bucati.push(chunk);.
  • În Node 18+, modulul node:stream/consumers oferă await text(req) sau await json(req), care fac exact acest lucru (dar fără limită de mărime, deci limita o pui tu).

Limita de mărime e la fel de importantă ca encoding-ul: fără ea, un client poate trimite un corp de gigaocteți care stă tot în memorie.

Ce urmărește intervievatorul: Se verifică dacă știi că bucățile nu respectă granițele caracterelor. Mulți candidați scriu acest cod din tutoriale și nu au observat problema pentru că testează doar cu texte ASCII scurte.

Eroarea, în practică:The "list[0]" argument must be an instance of Buffer

52 Junior

Ce se întâmplă la rularea acestui cod?

JavaScript
const { EventEmitter } = require('node:events');
const coada = new EventEmitter();

coada.on('mesaj', (m) => console.log('primit', m));
coada.emit('mesaj', 'a');
coada.emit('error', new Error('conexiune pierdută'));
console.log('după error');

Răspuns scurt: Afișează primit a, apoi procesul se oprește cu eroarea „conexiune pierdută”, iar după error nu se afișează. Un eveniment error emis fără niciun listener este aruncat ca excepție.

Evenimentul error are un tratament special în EventEmitter: dacă nu există niciun listener pentru el, emit('error', err) aruncă err sincron, din locul în care s-a apelat emit. Fără un try/catch în jur, eroarea devine uncaughtException și procesul se oprește. Pentru alte evenimente, un emit fără listeneri întoarce simplu false.

Motivul acestui design: erorile nu trebuie să treacă neobservate. Un stream care nu poate citi un fișier sau un socket care pierde conexiunea ar putea altfel să eșueze silențios.

Reparația este un listener de error:

JavaScript
coada.on('error', (err) => {
  console.error('eroare în coadă:', err.message);
  // reconectare, metrică, sau oprire controlată
});

Consecințe practice:

  • Orice stream, socket, server sau client de bază de date care emite error trebuie să aibă un listener. pipeline adaugă unul pentru tine.
  • events.errorMonitor permite atașarea unui listener care doar observă erorile (pentru logging), fără să le considere tratate.
  • events.once(emitter, 'eveniment') respinge promisiunea dacă se emite error între timp, ceea ce o face sigură de folosit cu await.
  • Opțiunea captureRejections: true la construirea emitter-ului face ca promisiunile respinse din listeneri async să fie trimise ca evenimente error, în loc să devină unhandled rejections.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi comportamentul special al evenimentului error. Greșeala tipică este să crezi că un emit fără listener e ignorat întotdeauna.

Eroarea, în practică:ERR_UNHANDLED_ERROR: Unhandled error.

53 Junior

Ce afișează codul și ce spune asta despre modul în care rulează listenerii?

JavaScript
const { EventEmitter } = require('node:events');
const e = new EventEmitter();

e.on('comanda', () => console.log('1: salvez comanda'));
e.on('comanda', async () => {
  await null;
  console.log('2: trimit email');
});
e.prependListener('comanda', () => console.log('0: validez'));

console.log('înainte');
console.log('emit a întors', e.emit('comanda'));
console.log('după');

Răspuns scurt: Afișează înainte, 0: validez, 1: salvez comanda, emit a întors true, după, 2: trimit email. emit apelează listenerii sincron, în ordinea înregistrării (prependListener pune unul la început), iar partea de după await rulează mai târziu.

Un lucru pe care mulți îl presupun greșit: EventEmitter nu e asincron. emit parcurge lista de listeneri și îi apelează unul câte unul, pe loc, înainte să întoarcă. Întoarce true dacă a existat cel puțin un listener.

Pe rând:

  • înainte din codul sincron;
  • 0: validez, pentru că prependListener l-a pus primul în listă;
  • 1: salvez comanda;
  • listenerul async începe, ajunge la await null și întoarce o promisiune; emit nu o așteaptă;
  • emit a întors true, apoi după;
  • după terminarea codului sincron, microtask-ul continuă funcția async: 2: trimit email.

Consecințe practice:

  • Un listener lent blochează emit și pe toți cei care urmează; un listener care aruncă excepție oprește execuția celorlalți și excepția urcă în codul care a apelat emit.
  • Erorile din listenerii async nu sunt prinse de emit; devin promisiuni respinse netratate, dacă nu folosești captureRejections.
  • Ordinea e garantată, deci poți conta pe ea, dar e mai sănătos ca listenerii să fie independenți unul de altul.
  • Dacă vrei ca un eveniment să fie procesat după operația curentă, îl emiți cu process.nextTick(() => e.emit(...)) sau setImmediate.

Pentru un sistem de evenimente de domeniu („comandă plasată” → email, factură), un emitter în proces nu oferă persistență și nici reîncercări; la căderea procesului evenimentele se pierd, de aceea se folosesc cozi externe.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că emiterea e sincronă și ce implică asta pentru erori și performanță. Candidații presupun des că listenerii rulează în paralel sau după emit.

54 Mid

Scrie un Transform stream care primește text și scoate doar liniile care conțin un cuvânt dat, apoi folosește-l într-un pipeline.

Răspuns scurt: Extinzi stream.Transform și implementezi transform(chunk, encoding, callback), păstrând ultima linie incompletă între bucăți, plus flush(callback) pentru restul de la final. Alternativ, folosești un generator asincron ca pas în pipeline.

Varianta cu clasă:

JavaScript
const { Transform } = require('node:stream');
const { pipeline } = require('node:stream/promises');
const fs = require('node:fs');

class FiltruLinii extends Transform {
  constructor(cuvant) {
    super();
    this.cuvant = cuvant;
    this.rest = '';
    this.setDefaultEncoding('utf8');
  }
  _transform(chunk, encoding, callback) {
    const text = this.rest + chunk.toString();
    const linii = text.split('\n');
    this.rest = linii.pop();               // ultima poate fi incompletă
    for (const l of linii) {
      if (l.includes(this.cuvant)) this.push(l + '\n');
    }
    callback();
  }
  _flush(callback) {
    if (this.rest.includes(this.cuvant)) this.push(this.rest + '\n');
    callback();
  }
}

await pipeline(
  fs.createReadStream('app.log', { encoding: 'utf8' }),
  new FiltruLinii('ERROR'),
  fs.createWriteStream('erori.log'),
);

Puncte cheie:

  • push() trimite date spre partea readable; poți apela de zero sau mai multe ori pe bucată.
  • callback() semnalează că bucata a fost procesată; callback(err) oprește lanțul cu eroare. Fără apelul lui, stream-ul se blochează.
  • _flush rulează după ultima bucată, înainte de end; fără el s-ar pierde ultima linie dacă fișierul nu se termină cu \n.
  • encoding: 'utf8' la citire evită tăierea caracterelor multi-byte.
  • Backpressure-ul e gestionat de clasa de bază.

Varianta modernă, fără clasă:

JavaScript
await pipeline(
  fs.createReadStream('app.log', { encoding: 'utf8' }),
  async function* (sursa) {
    let rest = '';
    for await (const bucata of sursa) {
      const linii = (rest + bucata).split('\n');
      rest = linii.pop();
      for (const l of linii) if (l.includes('ERROR')) yield l + '\n';
    }
    if (rest.includes('ERROR')) yield rest + '\n';
  },
  fs.createWriteStream('erori.log'),
);

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi contractul unui Transform și cazurile limită (linii tăiate, flush). Soluțiile slabe uită ultima linie sau presupun că fiecare bucată conține linii întregi.

55 Mid

Ce controlează highWaterMark la un stream și ce se schimbă când activezi objectMode?

Răspuns scurt: highWaterMark e pragul de buffer de la care stream-ul semnalează backpressure: în octeți pentru stream-urile normale, în număr de obiecte în objectMode. Nu e o limită strictă de memorie, ci un semnal pe care producătorul trebuie să-l respecte.

Fiecare stream are un buffer intern. highWaterMark stabilește când acesta e considerat „plin”:

  • La un Writable, write() întoarce false când datele din buffer ating pragul.
  • La un Readable, stream-ul nu mai cere date de la sursă (nu mai apelează _read) când buffer-ul a ajuns la prag și nimeni nu consumă.

Valori implicite: în Node 22 pragul general a crescut la 64 KiB (era 16 KiB înainte); fs.createReadStream folosește 64 KiB. În objectMode, pragul implicit e 16 obiecte.

JavaScript
const sursa = fs.createReadStream('mare.bin', { highWaterMark: 1024 * 1024 }); // bucăți de 1 MiB

Cu un prag mai mare faci mai puține apeluri de sistem și ai mai puțin overhead, dar fiecare stream ține mai multă memorie. Pe un server cu mii de conexiuni simultane, 1 MiB pe conexiune înseamnă gigaocteți.

objectMode: stream-ul poate transporta orice valoare JavaScript (în afară de null, care marchează sfârșitul), iar pragul se măsoară în număr de elemente, nu în octeți:

JavaScript
const { Readable } = require('node:stream');
const randuri = Readable.from([{ id: 1 }, { id: 2 }]); // from() e objectMode implicit

Capcana: în objectMode, 16 obiecte pot însemna 16 octeți sau 16 MB, în funcție de obiecte. Dacă fiecare element e un lot de 1000 de rânduri, pragul real de memorie e mare.

highWaterMark nu e limită strictă: un write() peste prag e totuși acceptat. Doar respectarea lui false și a evenimentului drain ține memoria sub control. Pentru stream-uri combinate (Duplex/Transform) poți seta separat readableHighWaterMark și writableHighWaterMark.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului de backpressure la nivel de configurare. Greșeala tipică e să crezi că highWaterMark e o limită strictă sau că în objectMode se măsoară tot în octeți.

56 Mid

În loguri apare MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 close listeners added. Ce înseamnă și cum investighezi?

Răspuns scurt: Pe același emitter s-au atașat peste 10 listeneri pentru același eveniment. De obicei, un listener e adăugat la fiecare cerere pe un obiect de lungă durată și nu e eliminat. Găsești locul cu --trace-warnings și elimini listenerul.

Limita de 10 nu e o limită reală: Node doar avertizează, pentru că un număr de listeneri care crește continuu pe același obiect e aproape mereu o scurgere de memorie. Fiecare listener ține în viață closure-ul lui, deci și obiectele la care face referire (de exemplu req, res, un buffer mare).

Tiparul tipic de bug:

JavaScript
const db = creeazaConexiune(); // trăiește cât procesul

app.get('/date', (req, res) => {
  db.on('close', () => res.status(503).end()); // adăugat la fiecare cerere
  // ...
});

După 11 cereri apare avertismentul, iar după un milion de cereri ai un milion de closure-uri care țin res în memorie.

Cum investighezi:

  • node --trace-warnings app.js afișează stack trace-ul locului în care s-a adăugat listenerul care a depășit limita.
  • emitter.listenerCount('close') și emitter.listeners('close') în timpul rulării, ca să vezi dacă numărul crește.
  • Un heap snapshot arată closure-urile reținute de emitter.

Reparații:

  • once în loc de on, dacă ai nevoie de un singur eveniment;
  • off / removeListener când operația s-a terminat, de exemplu pe res.on('finish');
  • un AbortSignal cu events.addAbortListener sau { signal } la events.once;
  • mutarea logicii la un singur listener global care notifică cererile active.

Mărirea limitei cu setMaxListeners(n) este corectă doar când ai verificat că numărul de listeneri e mare, dar fix și justificat (de exemplu 20 de module care ascultă același eveniment de configurare). setMaxListeners(0) doar ascunde problema.

Ce urmărește intervievatorul: Intervievatorul verifică dacă tratezi avertismentul ca simptom de leak, nu ca zgomot. Răspunsul slab este „măresc limita cu setMaxListeners”.

Eroarea, în practică:MaxListenersExceededWarning: possible memory leak

57 Mid

Care e diferența dintre modurile flowing și paused ale unui Readable? Ce se întâmplă dacă atașezi on('data') la un stream și, separat, îl parcurgi cu for await?

Răspuns scurt: În modul paused datele se citesc la cerere, în modul flowing curg automat prin evenimente data, iar un listener data pornește curgerea. Două metode de consum pe același stream își împart bucățile, deci alegi una singură.

Un Readable pornește în modul paused: datele se adună în buffer până la highWaterMark și nu sunt trimise nicăieri. Trece în modul flowing când:

  • atașezi un listener data;
  • apelezi resume();
  • îl conectezi cu pipe().

În flowing, datele sunt emise cât de repede vin. Dacă nimeni nu ascultă data (de exemplu ai chemat resume() fără listener), datele se pierd. pause() oprește curgerea.

Metode de consum, de ales una:

  • evenimente data/end, cu backpressure gestionat manual prin pause()/resume();
  • pipe() sau pipeline() către un Writable;
  • iterare asincronă cu for await, care respectă backpressure-ul automat și transformă error în excepție;
  • citire manuală cu read() în evenimentul readable.

Amestecarea produce bug-uri: un listener data pentru „logare” și un for await pentru procesare se luptă pe aceleași bucăți; unele ajung doar la listener, iar iteratorul vede o parte din date. La fel, dacă citești câteva bucăți cu for await și ieși cu break, iteratorul distruge stream-ul: nu mai poți continua citirea altundeva.

Iterarea asincronă e de obicei cea mai lizibilă:

JavaScript
let total = 0;
for await (const bucata of fs.createReadStream('date.bin')) {
  total += bucata.length;
}

Pentru operații pe obiecte, Node are și metode experimentale pe Readable: map, filter, take, toArray, cu opțiune de concurență.

Ce urmărește intervievatorul: Se verifică dacă înțelegi cum se pornesc stream-urile și de ce contează să ai un singur consumator. Greșeala frecventă e listenerul data adăugat pentru debugging care strică procesarea principală.

58 Mid

Care e diferența dintre Buffer.alloc(n), Buffer.allocUnsafe(n) și Buffer.from(...)? De ce „unsafe”?

Răspuns scurt: alloc creează un Buffer umplut cu zerouri. allocUnsafe e mai rapid pentru că nu inițializează memoria, deci poate conține date rămase din alte operații, inclusiv date sensibile. from creează un Buffer copiind un string, un array sau alt Buffer.

Detalii:

  • Buffer.alloc(n): alocă n octeți și îi pune pe 0. Sigur, puțin mai lent.
  • Buffer.allocUnsafe(n): alocă fără inițializare. Pentru dimensiuni mici (sub jumătate din Buffer.poolSize, adică sub 4 KiB implicit), memoria vine dintr-un pool comun pre-alocat, ceea ce reduce alocările. Conținutul inițial e nedefinit: pot fi octeți din cereri anterioare, din parole, din tokenuri.
  • Buffer.from(sursa): copiază datele dintr-un string (cu encoding), dintr-un array de numere, dintr-un alt Buffer; Buffer.from(arrayBuffer) creează o vedere peste aceeași memorie fără copiere.

De ce contează „unsafe”: dacă aloci cu allocUnsafe și nu suprascrii toți octeții înainte să trimiți Buffer-ul în rețea, clientul primește fragmente din memoria procesului. Un exemplu:

JavaScript
// periculos dacă scriem mai puțin decât am alocat
const buf = Buffer.allocUnsafe(1024);
const scrisi = buf.write(mesajScurt);
socket.write(buf);            // trimite și restul memoriei neinițializate
socket.write(buf.subarray(0, scrisi)); // corect

Folosești allocUnsafe doar când urmează sigur să umpli tot Buffer-ul (de exemplu citești exact n octeți dintr-un fișier sau copiezi date în el) și performanța contează. În rest, alloc.

Istoric, constructorul new Buffer(n) se comporta ca allocUnsafe pentru numere și ca from pentru string-uri, iar ambiguitatea a produs vulnerabilități reale; constructorul e depreciat și nu trebuie folosit.

Încă un detaliu: Buffer-urile mici din pool partajează același ArrayBuffer subiacent, deci buf.buffer poate fi mai mare decât Buffer-ul; folosește buf.byteOffset și buf.length când lucrezi cu el.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi riscul de scurgere de date din memorie. Mulți candidați aleg allocUnsafe pentru viteză fără să știe ce implică.

Eroarea, în practică:[DEP0005] DeprecationWarning: Buffer() is deprecated

59 Senior

Utilizatorii încarcă fișiere CSV de câțiva gigaocteți care trebuie validate și inserate într-o bază de date. Cum proiectezi importul într-un serviciu Node, astfel încât memoria să rămână constantă și baza de date să nu fie copleșită?

Răspuns scurt: Procesez totul ca stream: citire, parser CSV, validare rând cu rând, loturi și inserare cu concurență limitată, într-un pipeline care propagă backpressure-ul până la baza de date. Importul rulează ca job în fundal, cu progres și raport de erori.

Arhitectura:

  • Upload: fișierul nu trece prin memoria serverului. Fie e trimis direct în object storage (URL presemnat), fie request-ul e scris în stream pe disc sau în storage. API-ul răspunde cu 202 Accepted și un ID de job.
  • Procesare în worker separat (proces sau container de joburi), ca importul să nu concureze cu traficul HTTP.
  • Pipeline cu backpressure:
JavaScript
const { pipeline } = require('node:stream/promises');
const { parse } = require('csv-parse');

await pipeline(
  sursaDinStorage(job.cheie),
  parse({ columns: true }),
  async function* (randuri) {
    let lot = [];
    for await (const rand of randuri) {
      const rezultat = valideaza(rand);
      if (!rezultat.ok) { raport.adaugaEroare(rand, rezultat.erori); continue; }
      lot.push(rezultat.valoare);
      if (lot.length === 1000) { yield lot; lot = []; }
    }
    if (lot.length) yield lot;
  },
  async function (loturi) {
    for await (const lot of loturi) {
      await db.insereazaLot(lot);   // inserare multi-rând sau COPY
      progres.adauga(lot.length);
    }
  },
);

Fiecare pas consumă doar când cel următor e gata, deci dacă baza de date încetinește, citirea fișierului încetinește și ea. Memoria e limitată la câteva loturi.

Decizii de discutat:

  • Inserare: loturi de sute până la mii de rânduri; COPY în PostgreSQL e mult mai rapid. Concurența (2–4 loturi în paralel) se ajustează după ce suportă baza de date.
  • Atomicitate: tot sau nimic (tabel de staging, apoi mutare într-o tranzacție) sau parțial cu raport de erori; depinde de cerința de business.
  • Reluare: salvez offset-ul sau numărul ultimului lot confirmat, ca un job întrerupt să poată continua; inserările idempotente (upsert pe o cheie naturală) evită duplicatele.

Ce urmărește intervievatorul: Se verifică dacă poți duce backpressure-ul cap-coadă și dacă te gândești la eșec, reluare și impactul asupra bazei de date. Răspunsurile slabe citesc tot fișierul în memorie sau inserează rând cu rând fără control al concurenței.

Modulul http și fetch

Exersează capitolul cu exerciții reale: Curs Node.js pentru începători →
60 Junior

Scrie, doar cu modulul node:http, un server care răspunde la GET /sanatate cu JSON {"status":"ok"} și la orice altceva cu 404.

Răspuns scurt: Creezi serverul cu http.createServer((req, res) => ...), verifici req.method și calea din req.url, setezi status-ul și header-ul Content-Type: application/json, apoi trimiți corpul cu res.end(JSON.stringify(...)).

Varianta minimă, corectă:

JavaScript
const http = require('node:http');

function trimiteJson(res, status, obiect) {
  const corp = JSON.stringify(obiect);
  res.writeHead(status, {
    'Content-Type': 'application/json; charset=utf-8',
    'Content-Length': Buffer.byteLength(corp),
  });
  res.end(corp);
}

const server = http.createServer((req, res) => {
  const { pathname } = new URL(req.url, 'http://localhost');

  if (req.method === 'GET' && pathname === '/sanatate') {
    return trimiteJson(res, 200, { status: 'ok' });
  }
  trimiteJson(res, 404, { eroare: 'Ruta nu există' });
});

server.listen(process.env.PORT || 3000, () => {
  console.log('ascult pe portul', server.address().port);
});

Detalii care contează:

  • req.url conține calea și query string-ul (/sanatate?x=1), deci o compari după ce o parsezi cu URL. new URL are nevoie de o bază, pentru că req.url nu conține protocolul și host-ul.
  • Content-Length se calculează în octeți cu Buffer.byteLength, nu cu corp.length.
  • Fiecare cerere trebuie să primească exact un răspuns: return după primul răspuns evită trimiterea a două.
  • Callback-ul lui createServer e listener pentru evenimentul request; serverul e un EventEmitter, deci poți asculta și error (de exemplu EADDRINUSE la pornire).
  • Portul vine din variabila de mediu, cum cer majoritatea platformelor de hosting.

Pentru un serviciu real ai nevoie în plus de: tratarea metodelor nepermise (405), citirea corpului, erori 500 la excepții, timeout-uri și oprire controlată, motiv pentru care se folosește de obicei un framework peste http.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi ce face un framework pentru tine. Greșelile tipice: compararea lui req.url cu query string inclus, lipsa header-ului Content-Type sau răspunsuri duble.

61 Junior

Cum citești și parsezi un corp JSON dintr-o cerere POST în node:http, fără Express, inclusiv tratarea JSON-ului invalid și a corpurilor prea mari?

Răspuns scurt: Consumi req ca stream (cu for await sau evenimentele data/end), aduni Buffer-ele cu o limită de mărime, verifici Content-Type, apoi faci JSON.parse în try/catch. Răspunzi cu 413 la corp prea mare, 415 la tip greșit și 400 la JSON invalid.

JavaScript
class EroareHttp extends Error {
  constructor(status, mesaj) { super(mesaj); this.status = status; }
}

async function citesteJson(req, limita = 100_000) {
  const tip = req.headers['content-type'] || '';
  if (!tip.startsWith('application/json')) {
    throw new EroareHttp(415, 'Se acceptă doar application/json');
  }
  const declarat = Number(req.headers['content-length']);
  if (declarat > limita) throw new EroareHttp(413, 'Corp prea mare');

  const bucati = [];
  let marime = 0;
  for await (const bucata of req) {
    marime += bucata.length;
    if (marime > limita) throw new EroareHttp(413, 'Corp prea mare');
    bucati.push(bucata);
  }
  try {
    return JSON.parse(Buffer.concat(bucati).toString('utf8'));
  } catch {
    throw new EroareHttp(400, 'JSON invalid');
  }
}

http.createServer(async (req, res) => {
  try {
    if (req.method === 'POST' && req.url === '/produse') {
      const produs = await citesteJson(req);
      res.writeHead(201, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ id: 1, ...produs }));
    }
    res.writeHead(404).end();
  } catch (err) {
    const status = err.status || 500;
    res.writeHead(status, { 'Content-Type': 'application/json', Connection: 'close' });
    res.end(JSON.stringify({ eroare: status === 500 ? 'Eroare internă' : err.message }));
  }
}).listen(3000);

Puncte importante:

  • Content-Length poate lipsi (transfer chunked) sau poate minți, deci limita se verifică și în timpul citirii.
  • Bucățile se adună ca Buffer-e și se decodează o singură dată la final, ca diacriticele tăiate între bucăți să nu se strice.
  • Erorile 4xx au mesaje clare; la 500 nu expui detalii interne.
  • Connection: close la eroare previne refolosirea unei conexiuni pe care a rămas corp necitit.

Exact aceste lucruri le face express.json() (cu limită implicită de 100 KB).

Ce urmărește intervievatorul: Se verifică dacă înțelegi că req e un stream și te gândești la limite și erori. Codul fără limită de mărime sau cu JSON.parse fără try/catch e semnalul negativ principal.

62 Junior

Ce diferență este între un răspuns trimis cu res.end(corp) și unul trimis în mai multe apeluri res.write()? Ce înseamnă Transfer-Encoding: chunked?

Răspuns scurt: res este un Writable: end(corp) trimite totul o dată, cu Content-Length, iar mai multe write() trimit corpul în bucăți. Când lungimea nu e cunoscută, HTTP/1.1 folosește Transfer-Encoding: chunked, fiecare bucată fiind precedată de mărimea ei.

Când apelezi prima dată res.write() sau res.end(), Node trimite linia de status și header-ele. După aceea nu le mai poți modifica.

  • res.end(corp) cu un corp complet: dacă nu ai setat tu Content-Length, Node îl poate calcula și îl adaugă. Clientul știe exact câți octeți să aștepte.
  • res.write(bucata) de mai multe ori, apoi res.end(): Node nu cunoaște lungimea totală, deci în HTTP/1.1 folosește automat chunked transfer encoding. Fiecare bucată e trimisă cu lungimea ei în hexazecimal, iar sfârșitul e marcat de o bucată de lungime zero.

Exemplu util: un export mare generat din baza de date, trimis pe măsură ce se citește:

JavaScript
res.writeHead(200, { 'Content-Type': 'text/csv; charset=utf-8' });
res.write('id,nume\n');
for await (const rand of cursorDinBaza()) {
  if (!res.write(`${rand.id},${rand.nume}\n`)) {
    await once(res, 'drain');      // backpressure: clientul citește încet
  }
}
res.end();

Primul octet ajunge la client imediat, memoria serverului rămâne mică, iar clientul poate începe procesarea.

Lucruri de știut:

  • Ce scrii cu write() respectă backpressure, ca la orice Writable.
  • Dacă clientul închide conexiunea, res emite close; trebuie să oprești generarea, altfel citești degeaba din baza de date.
  • Odată pornit răspunsul cu 200, nu mai poți trimite un status de eroare; o eroare la jumătate se semnalează distrugând conexiunea, iar clientul vede un răspuns incomplet.
  • În HTTP/2 nu există chunked; framing-ul e făcut de protocol, dar API-ul write() rămâne același.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi res ca stream și înțelegi cum ajung datele pe fir. Mulți candidați nu știu că header-ele pleacă la primul write.

Eroarea, în practică:ERR_STREAM_WRITE_AFTER_END: write after endThe "chunk" argument must be of type string

63 Junior

Aplicația aruncă intermitent Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client. Ce cauzează eroarea în codul de mai jos?

JavaScript
app.get('/comenzi/:id', async (req, res) => {
  const comanda = await db.gaseste(req.params.id);
  if (!comanda) {
    res.status(404).json({ eroare: 'Nu există' });
  }
  if (comanda.client !== req.user.id) {
    res.status(403).json({ eroare: 'Interzis' });
  }
  res.json(comanda);
});

Răspuns scurt: Lipsesc instrucțiunile return după răspunsurile de eroare, deci handler-ul continuă și încearcă să trimită un al doilea răspuns. La comanda inexistentă, codul mai aruncă și TypeError, pentru că accesează comanda.client pe null.

res.json() nu oprește execuția funcției: trimite răspunsul și se întoarce. Codul de după rulează în continuare. Urmărind cazurile:

  • comanda nu există: se trimite 404, apoi comanda.client aruncă TypeError (proprietate citită pe null); eroarea ajunge la handler-ul de erori, care încearcă să trimită 500 peste răspunsul deja trimis;
  • comanda e a altui client: se trimite 403, apoi res.json(comanda) încearcă să trimită din nou, deci ERR_HTTP_HEADERS_SENT. Mai grav, în unele situații datele comenzii ajung să fie procesate deși accesul era interzis.

Reparația:

JavaScript
app.get('/comenzi/:id', async (req, res) => {
  const comanda = await db.gaseste(req.params.id);
  if (!comanda) return res.status(404).json({ eroare: 'Nu există' });
  if (comanda.client !== req.user.id) return res.status(403).json({ eroare: 'Interzis' });
  res.json(comanda);
});

Alte cauze frecvente ale aceleiași erori:

  • un middleware care apelează și next(), și trimite răspuns;
  • un callback apelat de două ori (de exemplu un on('error') și un on('end') care răspund amândouă);
  • un timeout care trimite 504, apoi operația lentă se termină și trimite 200;
  • un handler de erori care nu verifică res.headersSent înainte să răspundă.

În handler-ul de erori, regula este:

JavaScript
if (res.headersSent) return next(err); // lasă Express să închidă conexiunea

Mesajul erorii arată unde s-a încercat al doilea răspuns, nu unde s-a trimis primul, deci te uiți în urmă, pe drumul codului.

Ce urmărește intervievatorul: Se verifică înțelegerea faptului că trimiterea răspunsului nu e un return. Intervievatorii apreciază dacă observi și problema de securitate (403 urmat de date).

Eroarea, în practică:Cannot set headers after they are sent to the client

64 Junior

Cum citești parametrii din req.url pentru o cerere GET /produse?categorie=carti&tag=nou&tag=reducere&pret_max=50?

Răspuns scurt: Construiești un obiect URL din req.url și o bază, apoi folosești url.searchParams: get('categorie') întoarce prima valoare, getAll('tag') toate valorile repetate. Toate valorile sunt string-uri, deci convertești și validezi numerele.

JavaScript
http.createServer((req, res) => {
  const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);

  if (url.pathname === '/produse') {
    const categorie = url.searchParams.get('categorie');   // 'carti'
    const taguri = url.searchParams.getAll('tag');          // ['nou', 'reducere']
    const pretMax = Number(url.searchParams.get('pret_max') ?? Infinity);

    if (Number.isNaN(pretMax)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ eroare: 'pret_max trebuie să fie număr' }));
    }
    // filtrare...
  }
}).listen(3000);

Ce face URLSearchParams pentru tine:

  • decodează procentele și + ca spațiu: ?q=caiet%20de%20matematic%C4%83 devine caiet de matematică;
  • păstrează parametrii repetați, pe care o parsare manuală cu split('&') și un obiect simplu i-ar suprascrie;
  • has(), entries(), iterare cu for...of, iar Object.fromEntries(url.searchParams) dă un obiect simplu (păstrând doar ultima valoare la chei repetate).

Capcane:

  • get întoarce null dacă parametrul lipsește și '' dacă apare fără valoare (?pret_max=); Number('') este 0, nu NaN, deci tratezi explicit șirul gol.
  • Valorile pot fi orice text: nu le pui direct într-un query SQL sau într-un regex.
  • Modulul vechi querystring și url.parse() sunt considerate legacy; URL e standardul WHATWG, identic cu cel din browser.
  • În Express, req.query e populat automat, iar parametrii repetați devin array-uri, deci codul trebuie să accepte ambele forme sau să valideze tipul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești API-ul standard și te gândești la parametri repetați și la conversii. Parsarea manuală cu split e semnalul negativ.

Eroarea, în practică:TypeError: Invalid URL (new URL)[DEP0169] url.parse() behavior is not standardized

65 Junior

Ce diferențe sunt între fetch din Node.js (18+) și fetch din browser? Ce trebuie să faci în plus pe server?

Răspuns scurt: API-ul e același (implementat cu undici), dar pe server nu există CORS, nici cookie-uri trimise automat, iar fetch nu are timeout implicit scurt. Tu adaugi timeout cu AbortSignal.timeout, verifici response.ok și consumi sau anulezi mereu corpul răspunsului.

fetch global a apărut în Node 18 și este considerat stabil din Node 21. E construit pe biblioteca undici. Interfața e cea standard (Request, Response, Headers, FormData), dar contextul diferă:

  • Fără CORS: CORS e o regulă impusă de browser. Pe server poți apela orice adresă, iar header-ele de tipul Access-Control-* nu contează.
  • Fără cookie jar: browserul trimite cookie-urile automat; în Node trimiți manual header-ul Cookie și citești set-cookie cu response.headers.getSetCookie().
  • Timeout: nu există un timeout implicit scurt; o cerere către un serviciu blocat poate aștepta minute. Îl pui explicit:
JavaScript
const r = await fetch('https://api.exemplu.ro/curs', {
  signal: AbortSignal.timeout(5000),
  headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
});
if (!r.ok) throw new Error(`API extern: ${r.status}`);
const date = await r.json();
  • fetch nu respinge promisiunea pentru 4xx/5xx: doar pentru erori de rețea sau anulare. Verifici r.ok sau r.status.
  • Corpul trebuie consumat: dacă nu citești și nu anulezi corpul (await r.body?.cancel()), conexiunea nu poate fi refolosită imediat, iar sub încărcare se pot epuiza conexiunile.
  • Pool de conexiuni: undici refolosește conexiunile per origine; pentru setări fine (număr de conexiuni, keep-alive) folosești un Agent din pachetul undici ca dispatcher.
  • Proxy: variabilele HTTP_PROXY nu sunt respectate implicit în versiunile LTS mai vechi; în versiunile recente există suport opțional, verifici documentația versiunii tale.

Pentru streaming, r.body e un ReadableStream web; îl transformi în stream Node cu Readable.fromWeb(r.body).

Ce urmărește intervievatorul: Se verifică dacă știi ce nu face fetch pe server și dacă tratezi erorile și timeout-urile. Greșeala tipică e să presupui că un 500 aruncă excepție.

Eroarea, în practică:Failed to parse URL from ... (fetch)

66 Mid

Ai un server de fișiere statice scris cu node:http. Unde e vulnerabilitatea și cum o repari?

JavaScript
const radacina = path.join(__dirname, 'public');
http.createServer(async (req, res) => {
  const cale = path.join(radacina, decodeURIComponent(req.url));
  try {
    const continut = await fsp.readFile(cale);
    res.end(continut);
  } catch {
    res.writeHead(404).end();
  }
}).listen(3000);

Răspuns scurt: Path traversal: o cerere ca /..%2F..%2Fetc%2Fpasswd produce, după decodare și path.join, o cale în afara dosarului public. Reparația: elimini query string-ul, rezolvi calea absolută și verifici că începe cu rădăcina plus separator, altfel răspunzi 403 sau 404.

path.join normalizează segmentele .., deci path.join('/app/public', '/../../etc/passwd') devine /etc/passwd. Clienții HTTP normalizează de obicei .. din URL, dar un atacator trimite varianta codificată (%2E%2E%2F) sau folosește direct un socket. decodeURIComponent transformă codificarea înapoi în ../. Rezultatul: oricine poate citi fișiere precum .env, codul sursă sau chei private. Alte probleme: req.url include query string-ul, iar decodeURIComponent aruncă URIError la secvențe invalide (%E0%A4%A), ceea ce aici e ascuns ca 404.

Varianta corectă:

JavaScript
const radacina = path.resolve(__dirname, 'public');

http.createServer(async (req, res) => {
  let relativ;
  try {
    relativ = decodeURIComponent(new URL(req.url, 'http://x').pathname);
  } catch {
    return res.writeHead(400).end();
  }
  if (relativ.includes('\0')) return res.writeHead(400).end();

  const cale = path.resolve(radacina, '.' + relativ);
  if (cale !== radacina && !cale.startsWith(radacina + path.sep)) {
    return res.writeHead(403).end();
  }
  // apoi: stat, index.html pentru dosare, Content-Type după extensie,
  // createReadStream + pipeline în loc de readFile
}).listen(3000);

De ce radacina + path.sep: fără separator, /app/public-secret/x ar trece verificarea startsWith('/app/public').

Mai sunt de luat în calcul: legăturile simbolice din dosar (cu fs.realpath verifici destinația reală), fișierele ascunse (.git, .env) pe care le refuzi explicit, și header-ul X-Content-Type-Options: nosniff.

În practică folosești express.static sau serve-static, care tratează aceste cazuri, ori servești fișierele statice direct din Nginx sau CDN.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști o vulnerabilitate clasică și știi o verificare corectă, nu doar un replace('..', ''), care poate fi ocolit. Detaliul cu separatorul arată experiență.

67 Senior

După ce ați pus serviciul Node în spatele unui load balancer, clienții primesc sporadic erori 502, fără nimic în logurile aplicației. Cum investighezi?

Răspuns scurt: Suspectez nepotrivirea timeout-urilor keep-alive: Node închide conexiunile inactive după 5 secunde implicit, iar load balancer-ul le refolosește mai mult timp. Confirm din logurile acestuia și setez server.keepAliveTimeout peste timeout-ul lui de inactivitate.

Model de răspuns structurat:

  • Observ tiparul: 502 sporadic, la trafic moderat, fără erori în aplicație, înseamnă că cererea probabil nici nu a ajuns la handler. Mă uit în logurile și metricile load balancer-ului: motivul erorii (conexiune resetată sau închisă de backend), ora, instanța țintă.
  • Formulez ipoteza: load balancer-ul păstrează conexiuni persistente către backend și le refolosește. Node închide o conexiune inactivă după server.keepAliveTimeout (implicit 5000 ms în Node 20 și 22). Dacă load balancer-ul are un timeout de inactivitate mai mare (de exemplu 60 de secunde, frecvent la AWS ALB), există o fereastră în care el trimite o cerere pe o conexiune pe care Node tocmai o închide, iar rezultatul e un reset, deci 502.
  • Confirm: corelez momentele 502 cu conexiuni inactive de aproximativ 5 secunde; reproduc cu un test de încărcare cu pauze între cereri; captura de rețea (tcpdump) arată FIN de la Node urmat de cererea load balancer-ului.
  • Repar:
JavaScript
const server = app.listen(port);
server.keepAliveTimeout = 65_000;   // mai mare decât idle timeout-ul LB (60 s)
server.headersTimeout = 66_000;     // trebuie să fie mai mare decât keepAliveTimeout
  • Verific și alte cauze dacă problema persistă: restarturi ale instanțelor fără graceful shutdown (deploy-uri care taie cereri în curs), health check-uri care scot instanțe din rotație, procese oprite de OOM, event loop blocat peste timeout-ul LB.
  • Previn: alertă pe rata de 5xx de la load balancer, nu doar din aplicație; documentez valorile de timeout ale fiecărui strat (CDN, LB, Node, baza de date), care trebuie să descrească de la exterior spre interior.

Ce urmărește intervievatorul: Se verifică depanarea pe mai multe straturi și cunoașterea unei probleme reale de producție. Candidații caută de obicei bug-ul în aplicație și ignoră că eroarea poate apărea înainte de handler.

68 Senior

Ce setări de timeout și de limită are serverul node:http și cum le configurezi ca să reziști la clienți lenți sau malițioși (de tip Slowloris)?

Răspuns scurt: Principalele sunt headersTimeout, requestTimeout (implicit 300 s din Node 18), keepAliveTimeout, maxHeaderSize și limita de mărime a corpului, pe care o impui tu. În producție, un reverse proxy preia mare parte din apărare.

Un atac Slowloris deschide multe conexiuni și trimite header-ele extrem de încet, câte un octet la câteva secunde, ca să țină ocupate resursele serverului. Node nu creează un thread per conexiune, deci rezistă mai bine decât serverele clasice, dar fiecare conexiune deschisă consumă memorie și descriptori de fișiere.

Setările relevante (Node 18+):

JavaScript
const server = http.createServer({
  headersTimeout: 20_000,      // implicit 60 s
  requestTimeout: 60_000,      // implicit 300 s; 0 dezactivează
  keepAliveTimeout: 5_000,     // inactivitate între cereri pe aceeași conexiune
  maxHeaderSize: 16 * 1024,    // implicit 16 KiB
}, app);

server.maxRequestsPerSocket = 1000;
server.timeout = 0;            // timeout de inactivitate a socket-ului; implicit 0 (dezactivat)
  • headersTimeout: dacă header-ele nu au sosit complet în acest interval, conexiunea e închisă cu 408.
  • requestTimeout: limita pentru întreaga cerere, inclusiv corpul; protejează împotriva corpurilor trimise extrem de încet. Pentru upload-uri mari legitime, fie o ridici, fie le direcționezi direct spre object storage.
  • maxHeaderSize: header-ele mai mari primesc 431.
  • Mărimea corpului: Node nu o limitează; o faci în parserul de corp (express.json({ limit: '100kb' })).
  • server.maxConnections limitează numărul de conexiuni simultane.

Ce nu rezolvă aceste setări: un flood volumetric sau multe cereri valide, dar costisitoare. Pentru asta ai rate limiting, iar în producție, un reverse proxy (Nginx, load balancer cloud, CDN) care bufferizează cererile lente și trimite la Node doar cereri complete, plus limite per IP. Timeout-urile Node trebuie aliniate cu ale proxy-ului.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce protecții are runtime-ul și unde se termină ele. Răspunsul slab este „pun un rate limiter”, care nu ajută la conexiuni lente.

Express

69 Junior

Care e diferența dintre app.use('/api', fn), app.get('/api', fn) și app.all('/api', fn)? La ce cereri răspunde fiecare?

Răspuns scurt: app.use('/api', fn) rulează pentru orice metodă și pentru orice cale care începe cu segmentul /api (/api, /api/produse), iar în fn req.url e scurtat fără prefix. app.get rulează doar pentru GET (și HEAD) pe calea exactă /api, iar app.all pe calea exactă, pentru orice metodă.

Diferențele, pe exemple:

JavaScript
app.use('/api', (req, res, next) => {
  console.log('use:', req.method, req.originalUrl, '->', req.url);
  next();
});
app.get('/api', (req, res) => res.send('get exact'));
app.all('/api/ping', (req, res) => res.send('orice metodă'));
  • GET /api/produse/3: rulează use (afișează /api/produse/3 -> /produse/3), nu rulează app.get('/api'), pentru că nu e calea exactă.
  • POST /api: rulează use, nu și get; dacă nimic altceva nu răspunde, ajunge la 404.
  • DELETE /api/ping: rulează use, apoi all.
  • GET /apis: nu rulează nici use, pentru că potrivirea e pe segmente întregi, nu pe prefix de text.

Detalii utile:

  • app.use(fn) fără cale înseamnă /, adică toate cererile; e locul pentru middleware global (parsare de corp, logging, CORS).
  • În interiorul unui middleware montat cu use, req.baseUrl conține prefixul (/api), req.url restul, iar req.originalUrl calea completă. De aceea un router montat cu app.use('/api/produse', router) își definește rutele relativ, ca router.get('/:id').
  • app.get răspunde automat și la HEAD, cu header-ele, dar fără corp.
  • app.all e util pentru reguli pe o cale specifică indiferent de metodă, de exemplu autentificare sau 405 pentru metode nepermise.

Ordinea înregistrării contează pentru toate: Express parcurge lista de middleware și rute în ordinea în care le-ai adăugat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semantica de montare a lui use și potrivirea exactă a rutelor. Greșeala frecventă este să crezi că app.use se potrivește doar pe calea exactă sau că app.get('/api') prinde și subcăile.

Eroarea, în practică:Cannot GET /api/produs (Express 404)

70 Junior

Un coleg scrie un endpoint POST /produse, trimite JSON din Postman, dar în handler req.body este undefined. Care sunt cauzele posibile?

Răspuns scurt: Cel mai des lipsește app.use(express.json()) sau e înregistrat după rută. Alte cauze: clientul nu trimite header-ul Content-Type: application/json, corpul e trimis ca form-data, sau parserul e montat doar pe alt router.

Express nu citește corpul cererii implicit: req e un stream, iar parsarea e treaba unui middleware. Lista de verificat, în ordinea probabilității:

  • Parserul lipsește: adaugi app.use(express.json()). Pentru formulare HTML clasice e nevoie de express.urlencoded(), pentru text simplu de express.text().
  • Ordinea: middleware-ul trebuie înregistrat înaintea rutelor care au nevoie de el. Un app.use(express.json()) pus la finalul fișierului nu ajută rutele de deasupra.
  • Content-Type: express.json() parsează doar cererile cu Content-Type: application/json (opțiunea type poate schimba asta). Dacă în Postman ai ales „Text” în loc de „JSON”, header-ul e text/plain, iar parserul ignoră cererea. În Express 5, req.body rămâne undefined; în Express 4 era {} după ce un parser rula, ceea ce ascundea uneori problema.
  • Form-data multipart: încărcările de fișiere (multipart/form-data) au nevoie de un parser separat, ca multer sau busboy.
  • Montare pe alt router: parserul e pus pe routerA, iar ruta e pe routerB.

Configurare tipică:

JavaScript
const app = express();
app.use(express.json({ limit: '100kb' }));
app.use('/api/produse', produseRouter);

Celelalte surse de date în Express:

  • req.params: segmentele din cale, de exemplu id din /produse/:id;
  • req.query: query string-ul, deja parsat;
  • req.body: corpul, doar după un parser;
  • req.get('Header'): header-ele.

Toate valorile din params și query sunt string-uri (sau array-uri), deci le validezi și le convertești.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că parsarea corpului e un middleware explicit. Răspunsul bun include și cauzele din partea clientului, nu doar codul serverului.

Eroarea, în practică:Cannot destructure property of 'req.body'

71 Junior

Care e diferența dintre res.send(), res.json(), res.end() și res.sendStatus() în Express? Cum răspunzi corect la un DELETE reușit?

Răspuns scurt: res.json() serializează obiectul și pune Content-Type: application/json; res.send() alege tipul după argument; res.end() vine din Node și închide răspunsul fără logica Express; res.sendStatus(n) trimite statusul cu textul lui ca corp. La un DELETE reușit răspunzi de obicei cu res.status(204).end().

Ce face fiecare:

  • res.json(obiect): apelează JSON.stringify (cu setările aplicației json replacer și json spaces), pune Content-Type: application/json; charset=utf-8 și trimite. Merge și cu null, numere sau array-uri.
  • res.send(valoare): pentru string pune text/html, pentru Buffer application/octet-stream, pentru obiect sau array se comportă ca res.json. Calculează Content-Length și un ETag, iar la cereri condiționale potrivite răspunde automat cu 304.
  • res.end(): metoda din http.ServerResponse; trimite ce i-ai dat, fără să seteze tipul sau ETag-ul. Potrivită când nu ai corp.
  • res.sendStatus(404): setează statusul și trimite textul lui (Not Found) ca text/plain.
  • res.status(201): doar setează statusul și întoarce res, ca să poți înlănțui: res.status(201).json(produs). Singur nu trimite nimic.

Pentru un DELETE reușit:

JavaScript
router.delete('/:id', async (req, res) => {
  const sters = await produse.sterge(req.params.id);
  if (!sters) return res.status(404).json({ eroare: 'Produsul nu există' });
  res.status(204).end();
});

204 No Content nu are voie să aibă corp; Express ignoră corpul la 204 chiar dacă trimiți unul, ceea ce poate deruta. Dacă vrei să întorci resursa ștearsă, folosești 200 cu JSON.

Greșeli frecvente: res.send(200) (un număr ca argument era interpretat ca status în Express 4 și e eliminat în 5), res.json() cu un obiect care are referințe circulare (aruncă eroare), sau uitarea lui return după un răspuns de eroare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce header-e și ce comportament adaugă fiecare metodă. Greșeala tipică este folosirea lui res.status() crezând că trimite răspunsul.

Eroarea, în practică:Cannot set headers after they are sent to the client

72 Junior

De ce cererea GET /utilizatori/eu primește „Utilizator invalid” în loc de profilul utilizatorului logat?

JavaScript
router.get('/utilizatori/:id', async (req, res) => {
  const id = Number(req.params.id);
  if (!Number.isInteger(id)) return res.status(400).json({ eroare: 'Utilizator invalid' });
  res.json(await utilizatori.gaseste(id));
});

router.get('/utilizatori/eu', (req, res) => {
  res.json(req.user);
});

Răspuns scurt: Express verifică rutele în ordinea înregistrării, iar /utilizatori/:id se potrivește și cu /utilizatori/eu, cu id = 'eu'. Prima rută răspunde, deci a doua nu mai e atinsă. Pui rutele fixe înaintea celor cu parametri.

Un parametru :id se potrivește cu orice segment de cale, inclusiv cu textul eu. Pentru că ruta cu parametru e înregistrată prima, ea primește cererea, conversia la număr dă NaN, iar răspunsul e 400. Ruta /utilizatori/eu nu ajunge niciodată să ruleze.

Reparații:

  • Ordinea: rutele specifice înaintea celor generale.
JavaScript
router.get('/utilizatori/eu', (req, res) => res.json(req.user));
router.get('/utilizatori/:id', handlerDupaId);
  • Validare la nivel de rută: în Express 4 poți restrânge parametrul cu o expresie regulată, '/utilizatori/:id(\\d+)'. În Express 5 sintaxa aceasta nu mai e suportată (biblioteca path-to-regexp a fost actualizată), deci validarea se face în handler sau într-un middleware, iar ordinea rămâne soluția principală.
  • router.param('id', fn): rulează o funcție pentru orice rută care conține :id, util pentru încărcarea resursei o singură dată și răspunsul 404 comun.

Aceeași problemă apare între routere: dacă montezi app.use('/utilizatori', utilizatoriRouter) înaintea unui alt router care ar trebui să trateze /utilizatori/export, primul îl poate intercepta.

Un test de integrare pentru fiecare rută fixă (de exemplu GET /utilizatori/eu întoarce 200 cu utilizatorul curent) prinde regresia când cineva reordonează fișierele.

Ce urmărește intervievatorul: Se verifică dacă știi că potrivirea rutelor e secvențială și că parametrii prind orice segment. Candidații caută de obicei bug-ul în conversia numerică, nu în ordinea rutelor.

Eroarea, în practică:Cannot GET /api/produs (Express 404)

73 Junior

Cum organizezi rutele cu express.Router() pentru resurse imbricate, de exemplu comentariile unui articol la /articole/:articolId/comentarii?

Răspuns scurt: Creezi câte un router per resursă, montat cu app.use pe prefixul lui. Pentru routerul imbricat folosești express.Router({ mergeParams: true }), altfel nu are acces la req.params.articolId definit în calea părintelui.

Un Router e un mini-aplicație: are propriile middleware-uri și rute și se montează pe o cale. Structura:

JavaScript
// routes/comentarii.js
const express = require('express');
const router = express.Router({ mergeParams: true });

router.get('/', async (req, res) => {
  const lista = await comentarii.pentruArticol(req.params.articolId);
  res.json(lista);
});
router.post('/', async (req, res) => {
  const c = await comentarii.adauga(req.params.articolId, req.body);
  res.status(201).json(c);
});
module.exports = router;

// routes/articole.js
const router = express.Router();
router.get('/:articolId', handlerArticol);
router.use('/:articolId/comentarii', require('./comentarii'));
module.exports = router;

// app.js
app.use('/articole', require('./routes/articole'));

Fără mergeParams: true, în routerul de comentarii req.params ar fi {}: fiecare router își vede doar parametrii din propriile căi, iar :articolId aparține căii pe care e montat.

Avantaje:

  • fiecare fișier se ocupă de o resursă, ușor de găsit și de testat;
  • middleware-uri doar pentru un grup de rute: router.use(autentificare) protejează toate rutele routerului, fără să afecteze restul aplicației;
  • căile sunt relative, deci schimbi prefixul (de exemplu /v2/articole) într-un singur loc.

Încă o funcționalitate utilă: router.route('/:id').get(...).put(...).delete(...) grupează metodele pe aceeași cale.

Pe măsură ce aplicația crește, routerul ar trebui să rămână subțire: extrage datele din cerere, apelează un serviciu, formatează răspunsul. Logica de business stă în servicii, nu în handlere.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai structurat o aplicație Express reală. Mulți candidați nu știu de mergeParams și ajung să repete parametrii sau să-i extragă manual din req.originalUrl.

Eroarea, în practică:Router.use() requires a middleware function

74 Mid

Ce se întâmplă cu această rută în Express 4 și în Express 5 când baza de date aruncă o eroare?

JavaScript
app.get('/rapoarte/:id', async (req, res) => {
  const raport = await db.raport(req.params.id); // aruncă
  res.json(raport);
});

Răspuns scurt: În Express 4 promisiunea respinsă nu e prinsă: cererea rămâne fără răspuns, iar unhandled rejection oprește procesul implicit din Node 15. Express 5 prinde promisiunile respinse și le trimite la next(err), deci ajung la handler-ul de erori.

Express 4 a fost proiectat înainte de async/await: apelează handler-ul și ignoră valoarea întoarsă. O funcție async întoarce o promisiune; dacă aceasta e respinsă, nimeni nu o tratează.

Consecințe în Express 4:

  • clientul nu primește răspuns și așteaptă până la timeout;
  • Node emite unhandledRejection; începând cu Node 15, modul implicit este throw, deci procesul se oprește. Toate cererile în curs pe acel proces eșuează.

Soluții în Express 4:

JavaScript
const async = (fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);

app.get('/rapoarte/:id', async(async (req, res) => {
  res.json(await db.raport(req.params.id));
}));

sau pachetul express-async-errors, care modifică routerul ca să facă același lucru, ori try/catch cu next(err) în fiecare handler.

În Express 5 (stabil din 2024), dacă un handler sau un middleware întoarce o promisiune respinsă, routerul apelează automat next(err). Codul din întrebare funcționează corect: eroarea ajunge la middleware-ul de erori cu patru parametri.

JavaScript
app.use((err, req, res, next) => {
  req.log?.error(err);
  if (res.headersSent) return next(err);
  res.status(err.status || 500).json({ eroare: err.expose ? err.message : 'Eroare internă' });
});

Ce nu acoperă nici Express 5: erorile aruncate în callback-uri care nu fac parte din lanțul promisiunii (un setTimeout, un stream.on('data') sau un callback vechi). Acestea trebuie transformate în promisiuni sau trimise explicit la next(err).

Ce urmărește intervievatorul: Se verifică dacă știi diferența concretă între versiuni și consecința în runtime-ul Node actual. Greșeala tipică este să crezi că Express 4 prinde automat erorile din funcțiile async.

Eroarea, în practică:UnhandledPromiseRejection500 Internal Server Error (Express)

75 Mid

Ce fac next(), next('route'), next('router') și next(err) într-un handler Express? Dă un exemplu în care next('route') e util.

Răspuns scurt: next() trece la următorul middleware potrivit; next(err) sare direct la middleware-urile de erori; next('route') sare peste restul funcțiilor din ruta curentă, la următoarea rută potrivită; next('router') iese din routerul curent. Ultimele două funcționează doar în funcțiile definite cu app.METHOD sau router.METHOD.

O rută poate avea mai multe funcții: app.get('/x', f1, f2, f3). Express le apelează în ordine, cât timp fiecare cheamă next().

  • next(): continuă cu următoarea funcție din aceeași rută sau cu următorul middleware ori următoarea rută potrivită.
  • next(err) (orice valoare în afară de 'route' și 'router'): Express sare peste toate middleware-urile normale și caută middleware-uri cu semnătura (err, req, res, next).
  • next('route'): sare peste funcțiile rămase din ruta curentă și trece la următoarea rută înregistrată care se potrivește.
  • next('router'): iese din routerul curent și continuă în părinte, după montarea routerului.

Exemplu util pentru next('route'): aceeași cale, comportament diferit pentru administratori.

JavaScript
app.get('/comenzi/:id',
  (req, res, next) => {
    if (req.user.rol === 'admin') return next('route'); // admin: ruta următoare
    next();
  },
  async (req, res) => {
    const c = await comenzi.aClientului(req.params.id, req.user.id);
    if (!c) return res.sendStatus(404);
    res.json(c);
  },
);

app.get('/comenzi/:id', async (req, res) => {
  res.json(await comenzi.completaPentruAdmin(req.params.id));
});

Un middleware de autorizare montat cu router.use poate folosi next('router') ca să treacă cererea mai departe, către alt router, în loc să răspundă cu 403.

Capcane: în middleware-uri montate cu app.use, next('route') e tratat ca next(); iar next() apelat după ce ai trimis deja răspunsul duce la ERR_HTTP_HEADERS_SENT dacă un middleware ulterior răspunde și el.

Ce urmărește intervievatorul: Intervievatorul verifică o cunoaștere a routerului peste nivelul de bază. Candidații confundă des next('route') cu next(err) sau nu știu că funcționează doar în rute.

Eroarea, în practică:next is not defined (middleware Express)

76 Mid

Aplicația rulează în spatele unui load balancer, iar req.ip întoarce mereu adresa load balancer-ului, iar req.protocol e http, deși clientul folosește HTTPS. Rate limiting-ul blochează astfel pe toată lumea. Cum repari corect?

Răspuns scurt: Configurezi app.set('trust proxy', ...) ca Express să citească X-Forwarded-For și X-Forwarded-Proto setate de proxy. Valoarea trebuie să indice exact câte proxy-uri sau ce adrese sunt de încredere; true necondiționat permite clienților să-și falsifice IP-ul.

Când un proxy stă în fața aplicației, conexiunea TCP vine de la proxy. Adresa reală a clientului și protocolul original sunt transmise în header-e:

  • X-Forwarded-For: client, proxy1, proxy2
  • X-Forwarded-Proto: https
  • X-Forwarded-Host: magazin.ro

Express le ignoră implicit, pentru că oricine poate trimite aceste header-e. Cu trust proxy îi spui în cine să aibă încredere:

JavaScript
app.set('trust proxy', 1);              // exact un proxy în față (load balancer-ul)
// sau
app.set('trust proxy', 'loopback, 10.0.0.0/8'); // doar proxy-uri din aceste rețele

Efecte după configurare:

  • req.ip și req.ips iau adresa clientului din X-Forwarded-For;
  • req.protocol și req.secure țin cont de X-Forwarded-Proto, deci cookie-urile secure din express-session funcționează și redirecționările spre HTTPS nu intră în buclă;
  • req.hostname folosește X-Forwarded-Host.

De ce nu true: cu trust proxy setat pe true, Express ia cea mai din stânga adresă din X-Forwarded-For, pe care o poate scrie clientul. Un atacator trimite X-Forwarded-For: 1.2.3.4 la fiecare cerere, cu o valoare diferită, și ocolește rate limiting-ul sau falsifică logurile de audit. Cu numărul exact de hop-uri, Express ia adresa adăugată de proxy-ul tău.

Configurarea depinde de infrastructură: un CDN în fața load balancer-ului înseamnă două hop-uri. Se verifică în staging prin logarea lui req.ip, req.ips și a header-elor brute. Unele platforme pun adresa reală într-un header propriu, documentat de furnizor.

Ce urmărește intervievatorul: Se verifică dacă știi cum se propagă informația prin proxy-uri și implicația de securitate a încrederii oarbe. Răspunsul slab este trust proxy: true fără nicio discuție.

77 Mid

Scrie un middleware configurabil care loghează metoda, calea, statusul și durata fiecărei cereri, și care poate ignora anumite căi (de exemplu /sanatate).

Răspuns scurt: Scrii o funcție-fabrică ce primește opțiunile și întoarce middleware-ul. Măsori timpul cu process.hrtime.bigint() la intrare și loghezi în evenimentul finish al lui res, pentru că statusul final se cunoaște doar după ce răspunsul a fost trimis.

JavaScript
function jurnalCereri({ ignora = [], log = console.log } = {}) {
  const ignorate = new Set(ignora);

  return function (req, res, next) {
    if (ignorate.has(req.path)) return next();
    const start = process.hrtime.bigint();

    function gata(eveniment) {
      res.off('finish', laFinish);
      res.off('close', laClose);
      const ms = Number(process.hrtime.bigint() - start) / 1e6;
      log(JSON.stringify({
        metoda: req.method,
        cale: req.originalUrl,
        status: res.statusCode,
        durataMs: Math.round(ms * 10) / 10,
        intrerupt: eveniment === 'close',
      }));
    }
    const laFinish = () => gata('finish');
    const laClose = () => { if (!res.writableFinished) gata('close'); };

    res.on('finish', laFinish);
    res.on('close', laClose);
    next();
  };
}

app.use(jurnalCereri({ ignora: ['/sanatate'] }));

Decizii explicate:

  • Fabrică: configurația e dată o singură dată, la montare; middleware-ul întors e o closure care o folosește. Tiparul e același cu express.json(opts).
  • finish vs close: finish se emite când răspunsul a fost predat complet sistemului de operare; close se emite și când clientul închide conexiunea înainte, caz în care logăm cererea ca întreruptă. Eliminăm listenerii ca să nu logăm de două ori.
  • process.hrtime.bigint(): ceas monoton, de înaltă rezoluție, care nu e afectat de ajustările orei sistemului, spre deosebire de Date.now().
  • req.originalUrl: într-un router, req.url e relativ la punctul de montare.
  • JSON pe o linie: ușor de interogat în sisteme de loguri; în producție se folosește un logger ca pino, cu ID de cerere.

Middleware-ul trebuie montat primul, ca să măsoare tot timpul cererii, inclusiv parsarea corpului și autentificarea.

Ce urmărește intervievatorul: Intervievatorul verifică tiparul de middleware configurabil și înțelegerea ciclului de viață al răspunsului. Greșeala tipică este logarea înainte de next(), când statusul încă nu e cunoscut.

78 Mid

Ce se schimbă într-o aplicație Express când setezi NODE_ENV=production și ce alte setări verifici înainte de lansare?

Răspuns scurt: Express pune în cache șabloanele și nu mai trimite stack trace-ul în erorile implicite, iar multe biblioteci reduc verificările. Mai verifici: handler de erori propriu, x-powered-by dezactivat, trust proxy, limite la corp, compresie și fișiere statice eficiente.

NODE_ENV nu e o setare a lui Node însuși, ci o convenție citită de biblioteci. În Express:

  • app.get('env') devine 'production';
  • șabloanele (Pug, EJS) sunt compilate o dată și puse în cache, în loc să fie citite de pe disc la fiecare cerere;
  • handler-ul implicit de erori nu mai include stack trace-ul în corpul răspunsului.

Alte biblioteci folosesc variabila pentru a dezactiva verificări de dezvoltare sau logare detaliată. Lipsa ei în producție poate costa performanță vizibil, de aceea se setează explicit în Dockerfile sau în configurația platformei. Pe de altă parte, nu trebuie folosită pentru a distinge staging de producție: pentru asta ai variabile proprii (APP_ENV), ca staging-ul să ruleze exact codul de producție.

Lista de verificat înainte de lansare:

  • handler de erori propriu, care loghează eroarea și trimite clientului un mesaj generic;
  • app.disable('x-powered-by') sau helmet(), care adaugă și alte header-e de securitate;
  • app.set('trust proxy', n) corect pentru infrastructură;
  • limite explicite: express.json({ limit: '100kb' });
  • compresia, de preferat la reverse proxy; dacă o faci în Node, cu middleware-ul compression;
  • express.static cu maxAge și fișiere cu hash în nume, sau, mai bine, servite de un CDN;
  • logare structurată cu ID de cerere, fără date sensibile;
  • endpoint de health check și oprire controlată la SIGTERM;
  • dependențe instalate cu npm ci --omit=dev.

Ce urmărește intervievatorul: Se verifică dacă știi ce face concret variabila și dacă ai o listă mentală pentru producție. Greșeala tipică e folosirea lui NODE_ENV pentru a separa configurații de mediu, cu staging rulând în modul de dezvoltare.

79 Senior

Echipa vrea să treacă o aplicație de la Express 4 la Express 5. Ce schimbări te aștepți și cum organizezi migrarea?

Răspuns scurt: Mă aștept la altă sintaxă pentru căi, metode vechi eliminate, req.query doar pentru citire și promisiuni respinse tratate automat. Migrez pe un branch, cu inventarul locurilor afectate, teste de integrare pe toate rutele și lansare treptată.

Model de răspuns structurat:

  • Cerințe: Express 5 cere Node 18 sau mai nou; verific întâi versiunea din toate mediile și compatibilitatea middleware-urilor folosite (unele pachete vechi accesează API-uri eliminate).
  • Inventar al schimbărilor cunoscute:
  • sintaxa căilor, prin path-to-regexp nou: * trebuie să aibă nume (/fisiere/*cale), parametrii opționali se scriu cu acolade (/:fisier{.:extensie}), expresiile regulate din parametri (:id(\\d+)) nu mai sunt acceptate;
  • metode eliminate sau schimbate: app.del (devine app.delete), req.param(), res.send(status) cu număr, res.redirect('back'), semnăturile res.json(obj, status);
  • req.query e un getter, nu se mai poate reatribui (unele middleware-uri de sanitizare făceau asta);
  • req.body rămâne undefined fără parser, iar express.urlencoded are extended: false implicit;
  • res.status() aruncă eroare la coduri invalide;
  • promisiunile respinse merg automat la next(err), deci wrapper-ele asyncHandler și express-async-errors devin inutile.
  • Pași: branch dedicat; actualizez Express și middleware-urile; caut în cod tiparele de mai sus (grep pe '*', req.param(, app.del(, (\\d+)); rulez testele de integrare, care trebuie să acopere fiecare rută, inclusiv 404 și erori. Dacă testele lipsesc, scriu teste de caracterizare înainte de migrare.
  • Lansare: staging, apoi canary pe o parte din trafic, cu monitorizarea ratei de 404 și 500 comparată cu versiunea veche; o rută care nu se mai potrivește apare imediat ca 404.
  • Curățenie: scot wrapper-ele async și actualizez documentația internă.

Ce urmărește intervievatorul: Intervievatorul evaluează capacitatea de a planifica o actualizare majoră cu risc controlat. Răspunsul slab e „schimb versiunea din package.json și repar ce pică la testare”.

Eroarea, în practică:Cannot set property query ... only a getter

worker_threads, cluster și child_process

80 Junior

Care e diferența între exec, execFile, spawn și fork din node:child_process? Când folosești fiecare?

Răspuns scurt: exec rulează comanda printr-un shell și dă output-ul la final, într-un buffer limitat; execFile rulează executabilul direct, fără shell; spawn dă output-ul ca stream, pentru output mare; fork pornește un script Node cu canal IPC.

  • exec(comanda, cb): trece comanda unui shell (/bin/sh, cmd.exe), deci poți folosi pipe-uri, redirecționări, wildcard-uri. Output-ul e strâns într-un buffer și dat callback-ului la final; peste maxBuffer (implicit 1 MiB) procesul e oprit cu eroare. Riscant cu input de la utilizator, din cauza injecției de comenzi.
  • execFile(fisier, argumente, cb): rulează executabilul direct, cu argumentele ca array, fără shell. Mai sigur și puțin mai rapid; tot cu buffer la final.
  • spawn(comanda, argumente): întoarce imediat un ChildProcess cu stdout, stderr, stdin ca stream-uri. Potrivit pentru output mare (de exemplu ffmpeg, pg_dump) sau pentru procese care rulează mult; nu are limită de buffer.
  • fork(modul): un spawn specializat pentru scripturi Node, cu un canal IPC: părintele și copilul își trimit obiecte cu send() și primesc cu on('message').
JavaScript
const { execFile, spawn } = require('node:child_process');
const { promisify } = require('node:util');

const { stdout } = await promisify(execFile)('git', ['rev-parse', 'HEAD']);

const dump = spawn('pg_dump', ['--format=custom', 'magazin']);
dump.stdout.pipe(fs.createWriteStream('backup.dump'));
dump.on('close', (cod) => console.log('pg_dump a ieșit cu', cod));

Toate au variante sincrone (execFileSync, spawnSync), potrivite în scripturi, nu în servere.

Lucruri de verificat întotdeauna: codul de ieșire (evenimentul close sau eroarea din callback), stderr, timeout-ul (opțiunea timeout sau un AbortSignal) și oprirea copilului dacă părintele se oprește. Un proces copil e un proces separat al sistemului de operare, cu memorie proprie, deci pornirea lui e mult mai costisitoare decât a unui worker thread.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi funcția potrivită după mărimea output-ului și riscul de securitate. Greșeala frecventă e folosirea lui exec pentru output mare, care pică la depășirea buffer-ului.

81 Mid

Scrie codul care calculează un hash costisitor (de exemplu, o funcție calculGreu(n) sincronă) într-un worker_thread, fără să blocheze serverul, și întoarce rezultatul ca promisiune.

Răspuns scurt: Creezi un Worker cu scriptul și datele de intrare în workerData, iar workerul trimite rezultatul cu parentPort.postMessage. Pe thread-ul principal împachetezi evenimentele message, error și exit într-o promisiune.

JavaScript
// calcul.js
const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads');

function calculGreu(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x = (x * 31 + i) % 1_000_000_007;
  return x;
}

if (!isMainThread) {
  parentPort.postMessage(calculGreu(workerData.n));
}

function calculInWorker(n) {
  return new Promise((resolve, reject) => {
    const w = new Worker(__filename, { workerData: { n } });
    w.once('message', resolve);
    w.once('error', reject);
    w.once('exit', (cod) => {
      if (cod !== 0) reject(new Error(`workerul a ieșit cu codul ${cod}`));
    });
  });
}

module.exports = { calculInWorker };

// server.js
app.get('/calcul', async (req, res, next) => {
  try {
    res.json({ rezultat: await calculInWorker(Number(req.query.n) || 1e8) });
  } catch (err) { next(err); }
});

Ce trebuie explicat:

  • Workerul are propriul event loop, propriul heap V8 și propriul context JavaScript; nu vede variabilele thread-ului principal. Comunicarea se face prin mesaje.
  • Mesajele sunt copiate cu algoritmul structured clone: obiectele simple, Map, Set, Date, Buffer funcționează; funcțiile și instanțele de clase cu metode nu se transmit ca atare.
  • Erorile aruncate în worker ajung ca eveniment error; un worker care iese cu cod nenul fără mesaj trebuie tratat separat.
  • Crearea unui worker costă (zeci de milisecunde și memorie pentru un nou izolat V8). Exemplul creează unul per cerere doar pentru claritate; în producție folosești un pool fix de workeri.
  • În ESM, scriptul se dă cu new URL('./calcul.js', import.meta.url).

Workerii au sens pentru muncă CPU. Pentru I/O nu aduc nimic: Node e deja asincron.

Ce urmărește intervievatorul: Se verifică dacă știi API-ul de bază și înțelegi izolarea workerilor. Greșeala tipică este presupunerea că workerul poate accesa variabilele sau conexiunile thread-ului principal.

82 Mid

Unde e problema de securitate și cum o repari?

JavaScript
app.post('/miniaturi', (req, res) => {
  const { fisier, latime } = req.body;
  exec(`convert uploads/${fisier} -resize ${latime} thumbs/${fisier}`, (err) => {
    if (err) return res.status(500).end();
    res.sendStatus(201);
  });
});

Răspuns scurt: Injecție de comenzi: exec trece textul unui shell, deci un nume de fișier cu ; execută comenzi arbitrare. Folosești execFile cu argumente în array, validezi strict valorile după listă albă și verifici că, după rezolvare, calea rămâne în dosarul permis.

exec construiește un singur șir pe care îl dă lui /bin/sh -c. Shell-ul interpretează caractere speciale: ;, &&, |, $( ), backtick-uri, redirecționări. Orice valoare de la utilizator interpolată în acel șir poate adăuga comenzi. Mai e și path traversal: fisier = '../../etc/passwd' și scriere în locuri neprevăzute.

Reparația are trei straturi:

JavaScript
const { execFile } = require('node:child_process');
const { promisify } = require('node:util');
const execFileP = promisify(execFile);

const NUME_VALID = /^[a-zA-Z0-9_-]{1,64}\.(jpg|jpeg|png|webp)$/;

app.post('/miniaturi', async (req, res, next) => {
  try {
    const { fisier, latime } = req.body;
    const l = Number(latime);
    if (!NUME_VALID.test(fisier) || !Number.isInteger(l) || l < 16 || l > 2000) {
      return res.status(400).json({ eroare: 'Parametri invalizi' });
    }
    const sursa = path.join(UPLOADS, fisier);
    const dest = path.join(THUMBS, fisier);
    await execFileP('convert', [sursa, '-resize', String(l), dest], { timeout: 10_000 });
    res.sendStatus(201);
  } catch (err) { next(err); }
});
  • Fără shell: execFile dă argumentele direct programului, deci ; sau | sunt doar caractere dintr-un nume de fișier. Opțiunea shell: true la spawn reintroduce problema.
  • Validare cu listă albă: format exact pentru nume și interval numeric pentru lățime. Un argument care începe cu - poate fi interpretat ca opțiune de program (argument injection); regex-ul de mai sus nu permite asta la început.
  • Limite: timeout, și pe cât posibil un utilizator de sistem cu drepturi minime.

Pentru imagini, o bibliotecă precum sharp elimină complet procesul extern. Pe Windows, execFile cu fișiere .bat/.cmd trece totuși prin shell, de aceea Node a introdus restricții suplimentare acolo.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști injecția de comenzi și știi că escaparea manuală nu e soluția. Candidații propun des un replace pe caractere periculoase, ușor de ocolit.

83 Mid

Cum trimiți date mari între thread-ul principal și un worker fără să le copiezi? Ce sunt transferList, SharedArrayBuffer și Atomics?

Răspuns scurt: Cu transferList muți proprietatea unui ArrayBuffer la worker fără copiere: emițătorul nu-l mai poate folosi. Cu SharedArrayBuffer, ambele thread-uri lucrează pe aceeași memorie simultan, iar Atomics oferă operații atomice și sincronizare (wait/notify) ca să eviți condițiile de cursă.

Implicit, postMessage copiază datele cu structured clone. Pentru un buffer de 200 MB, copierea costă timp și dublează memoria.

Transfer (mutare):

JavaScript
const imagine = new Uint8Array(200 * 1024 * 1024);
worker.postMessage({ imagine }, [imagine.buffer]);
console.log(imagine.byteLength); // 0: buffer-ul a fost mutat

Memoria trece la worker instantaneu; în thread-ul principal buffer-ul devine „detașat”. Bun pentru procesare de tip „trimit, primesc rezultatul înapoi tot prin transfer”. Atenție: Buffer-ele mici din Node pot face parte din pool-ul comun, iar transferul lor mută tot pool-ul sau eșuează; pentru transfer folosești un ArrayBuffer alocat separat.

Memorie partajată:

JavaScript
// principal
const sab = new SharedArrayBuffer(4 * 1024);
const contoare = new Int32Array(sab);
for (let i = 0; i < 4; i++) new Worker('./numara.js', { workerData: { sab } });

// numara.js
const { workerData } = require('node:worker_threads');
const contoare = new Int32Array(workerData.sab);
Atomics.add(contoare, 0, 1);       // incrementare sigură între thread-uri

Toate thread-urile văd aceeași memorie. O operație contoare[0]++ simplă nu e atomică (citire, adunare, scriere) și pierde incrementări când două thread-uri rulează simultan; Atomics.add, compareExchange și celelalte sunt atomice. Atomics.wait blochează un thread până la Atomics.notify (pe thread-ul principal nu se recomandă, pentru că blochează event loop-ul; există Atomics.waitAsync).

Când folosești ce: transfer pentru predarea datelor, memorie partajată pentru structuri accesate concurent intens (buffer-e circulare, contoare). Memoria partajată aduce complexitatea programării cu thread-uri clasice, deci o folosești doar când mesajele simple sunt prea lente.

Ce urmărește intervievatorul: Se verifică înțelegerea costului copierii și a diferenței transfer vs. partajare. Răspunsul slab ignoră condițiile de cursă la memoria partajată.

84 Senior

Folosești modulul cluster ca să rulezi aplicația pe toate nucleele. Cum sunt distribuite conexiunile între procese, ce nu mai funcționează față de un singur proces și când ai alege altă soluție?

Răspuns scurt: Primary-ul ascultă pe port și, în afară de Windows, distribuie conexiunile round-robin către workeri. Fiecare worker are memorie proprie, deci cache-urile, sesiunile și rate limiting-ul local nu mai sunt comune. În containere preferi de obicei un proces per container.

Cum funcționează:

JavaScript
const cluster = require('node:cluster');
const os = require('node:os');

if (cluster.isPrimary) {
  for (let i = 0; i < os.availableParallelism(); i++) cluster.fork();
  cluster.on('exit', (w, cod) => {
    console.error(`worker ${w.process.pid} oprit (${cod}), pornesc altul`);
    cluster.fork();
  });
} else {
  require('./server'); // fiecare worker face app.listen(3000)
}

Workerii sunt procese separate. Când un worker face listen(3000), primary-ul deține socket-ul real. Pe Linux și macOS, politica implicită e round-robin: primary acceptă conexiunea și o predă unui worker. Pe Windows, socket-ul e partajat și sistemul de operare alege. Distribuția e pe conexiuni, nu pe cereri: o conexiune keep-alive cu multe cereri rămâne la același worker.

Ce se strică față de un proces:

  • stare în memorie: cache-uri, sesiuni, contoare de rate limiting, conexiuni WebSocket indexate în memorie; fiecare worker are propria copie. Soluția: Redis sau altă stocare comună;
  • joburi programate (setInterval, cron în proces): rulează de N ori; le lași doar în primary sau într-un serviciu separat;
  • memorie totală: fiecare worker are heap-ul lui;
  • conexiuni la baza de date: N pool-uri, deci de N ori mai multe conexiuni.

Alternative și când le alegi:

  • Containere/orchestrator (Kubernetes, ECS): un proces per container, scalare după încărcare, restart și health check-uri făcute de platformă. Aici cluster doar complică metricile și limitele de memorie.
  • PM2 în mod cluster, pe servere clasice: același mecanism, cu management de procese gata făcut.
  • worker_threads: pentru calcule CPU în același proces, nu pentru a servi mai multe cereri HTTP.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi consecințele proceselor separate și compromisurile operaționale. Greșeala tipică e să consideri cluster o optimizare gratuită care nu schimbă nimic în cod.

85 Senior

Serviciul tău generează PDF-uri cu calcule grele de layout, iar tu muți munca în worker_threads. De ce nu creezi un worker nou pentru fiecare cerere și cum ar arăta un pool corect?

Răspuns scurt: Fiecare worker e un izolat V8 nou, cu cost de pornire și memorie proprie; sub trafic mare ai epuiza resursele. Un pool are un număr fix de workeri, apropiat de numărul de nuclee, și o coadă limitată, cu timeout și respingere când e plină.

Problemele unui worker per cerere:

  • cost de pornire: încărcarea runtime-ului și a modulelor la fiecare cerere adaugă latență;
  • memorie: fiecare worker are heap separat; 300 de cereri simultane înseamnă 300 de heap-uri;
  • CPU: mai mulți workeri decât nuclee nu termină munca mai repede, doar cresc comutările de context și latența tuturor;
  • fără control al încărcării: nimic nu oprește crearea a încă unui worker.

Un pool corect:

  • N workeri ficși, de obicei numărul de nuclee disponibile minus unul pentru thread-ul principal, creați la pornire și refolosiți;
  • o coadă de sarcini cu lungime maximă; când coada e plină, răspunzi rapid cu 503 și Retry-After, în loc să accepți muncă pe care nu o poți termina la timp (load shedding);
  • timeout per sarcină: dacă un PDF durează peste limită, workerul e oprit cu worker.terminate() și înlocuit, ca să nu rămână blocat;
  • reînlocuirea workerilor care se opresc cu eroare;
  • limite de memorie per worker cu resourceLimits: { maxOldGenerationSizeMb }, ca un document patologic să nu doboare tot procesul;
  • metrici: lungimea cozii, timp de așteptare, timp de execuție, ca să știi când să scalezi.

În practică folosești biblioteca piscina, care implementează toate acestea:

JavaScript
const Piscina = require('piscina');
const pool = new Piscina({
  filename: path.resolve(__dirname, 'genereaza-pdf.js'),
  maxThreads: 4,
  maxQueue: 100,
});
app.post('/facturi/:id/pdf', async (req, res) => {
  const pdf = await pool.run({ id: req.params.id }, { signal: AbortSignal.timeout(15000) });
  res.type('application/pdf').send(Buffer.from(pdf));
});

Dacă volumul crește mult, următorul pas e un serviciu separat de generare, alimentat dintr-o coadă, care se scalează independent de API.

Ce urmărește intervievatorul: Se verifică gândirea despre resurse limitate și controlul încărcării. Răspunsurile slabe ignoră coada nelimitată, care mută problema din CPU în memorie și latență.

Erori, memorie și profilare

Exersează capitolul cu exerciții reale: Curs Node.js pentru începători →
86 Junior

Care e diferența dintre o eroare operațională și o eroare de programare în Node.js? De ce contează distincția?

Răspuns scurt: Erorile operaționale vin din mediu (fișier lipsă, timeout, date invalide) și le tratezi: reîncercare, 4xx, 503. Erorile de programare sunt bug-uri (undefined accesat, argument greșit): le repari în cod, iar procesul ar trebui adesea repornit.

Distincția vine din practica Node și ajută la decizia ce faci cu o eroare.

Erori operaționale (codul e corect, lumea nu e):

  • ENOENT, ECONNREFUSED, ETIMEDOUT, disc plin;
  • un serviciu extern răspunde cu 503;
  • input invalid, conflict de date, resursă inexistentă.

Le anticipezi și le tratezi local: reîncercare cu backoff, valoare implicită, răspuns 400/404/409/503 cu mesaj clar, logare la nivel de avertisment.

Erori de programare (codul e greșit):

  • TypeError: Cannot read properties of undefined;
  • o funcție chemată cu argumente de tip greșit;
  • o promisiune uitată fără await;
  • o invariantă încălcată.

Nu are sens să le „tratezi” cu reîncercări: vor eșua la fel. Le loghezi ca erori, răspunzi cu 500 generic și le repari în cod. Dacă apar în afara unui context controlat (de exemplu ca uncaughtException), starea procesului poate fi coruptă, iar oprirea și repornirea lui e varianta sigură.

În cod:

JavaScript
class EroareAplicatie extends Error {
  constructor(mesaj, { status = 500, cod, expune = false, cause } = {}) {
    super(mesaj, { cause });
    this.name = 'EroareAplicatie';
    this.status = status;
    this.cod = cod;
    this.expune = expune; // mesajul poate fi arătat clientului
  }
}
throw new EroareAplicatie('Produsul nu există', { status: 404, cod: 'PRODUS_INEXISTENT', expune: true });

Handler-ul central de erori verifică tipul: erorile cunoscute primesc statusul și mesajul lor, orice altceva e tratat ca bug, cu 500 și alertă. Fără distincție, ajungi fie să ascunzi bug-uri sub mesaje „încercați din nou”, fie să răspunzi cu 500 la date invalide.

Ce urmărește intervievatorul: Se verifică dacă ai o strategie de tratare a erorilor, nu doar try/catch peste tot. Greșeala tipică este tratarea uniformă a tuturor erorilor, cu același mesaj și status.

87 Junior

De ce catch nu prinde eroarea și procesul se oprește?

JavaScript
try {
  setTimeout(() => {
    const date = JSON.parse('{ invalid');
  }, 100);
} catch (err) {
  console.error('prins:', err.message);
}

Răspuns scurt: try/catch prinde doar erorile aruncate cât timp rulează blocul try. Callback-ul lui setTimeout rulează mai târziu, din event loop, când blocul s-a terminat de mult, deci eroarea devine uncaughtException. Pui try/catch în interiorul callback-ului sau folosești promisiuni cu await.

Execuția pas cu pas:

  • intră în try, apelează setTimeout, care doar înregistrează callback-ul și se întoarce imediat;
  • blocul try se termină fără eroare, catch nu rulează;
  • după 100 ms event loop-ul apelează callback-ul, pe o stivă de apeluri nouă, în care nu mai există niciun try din jur;
  • JSON.parse aruncă SyntaxError, care urcă până la event loop și devine uncaughtException; procesul se oprește.

Variante corecte:

JavaScript
// 1. try/catch în callback
setTimeout(() => {
  try {
    const date = JSON.parse('{ invalid');
  } catch (err) {
    console.error('prins:', err.message);
  }
}, 100);

// 2. cu promisiuni și await
const { setTimeout: asteapta } = require('node:timers/promises');
async function main() {
  try {
    await asteapta(100);
    JSON.parse('{ invalid');
  } catch (err) {
    console.error('prins:', err.message);
  }
}
main();

În a doua variantă, await „suspendă” funcția și o reia în același bloc try, deci eroarea e prinsă.

Același principiu se aplică la callback-urile din fs.readFile, la evenimentele on('data'), la process.nextTick și la orice API bazat pe callback: fiecare callback e responsabil pentru propriile erori. De aceea convenția error-first din Node transmite eroarea ca argument, în loc să o arunce.

Și invers: o promisiune creată în try fără await (try { faCeva(); }) nu e prinsă nici ea; respingerea devine unhandled rejection.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi legătura dintre stiva de apeluri și event loop. E una dintre cele mai frecvente surse de crash-uri la începători.

Eroarea, în practică:UnhandledPromiseRejection

88 Junior

Ce este error.cause și cum îl folosești ca să nu pierzi informație când reîmpachetezi o eroare?

Răspuns scurt: cause (Node 16.9+, standard ES2022) e o opțiune a constructorului Error care păstrează eroarea originală în eroarea nouă. Poți adăuga context („nu am putut încărca comanda 42”) fără să pierzi stack trace-ul și codul erorii de jos, iar console.error și loggerele le afișează pe amândouă.

Problema clasică: reîmpachetezi o eroare și pierzi cauza.

JavaScript
// rău: mesajul original, codul și stack-ul s-au pierdut
catch (err) {
  throw new Error('Nu am putut încărca setările');
}

// rău altfel: aruncând eroarea brută, pierzi contextul
catch (err) { throw err; }

Cu cause:

JavaScript
async function incarcaSetari(cale) {
  try {
    return JSON.parse(await fsp.readFile(cale, 'utf8'));
  } catch (err) {
    throw new Error(`Nu am putut încărca setările din ${cale}`, { cause: err });
  }
}

try {
  await incarcaSetari('/etc/app/setari.json');
} catch (err) {
  console.error(err);          // afișează și lanțul [cause]: Error: ENOENT...
  console.log(err.cause.code); // 'ENOENT'
}

De ce e util:

  • fiecare strat adaugă context în termenii lui (repository: „interogarea comenzii a eșuat”, serviciu: „plasarea comenzii a eșuat”), iar cauza de la bază rămâne disponibilă;
  • codul care decide ce face poate inspecta lanțul: de exemplu un retry doar dacă undeva în cause e ECONNRESET;
  • console.error și util.inspect afișează cauzele imbricate, iar loggerele moderne (pino) le serializează.

Bune practici legate:

  • clase de erori proprii cu name și un code stabil (de exemplu 'COMANDA_INEXISTENTA'), pe care se bazează logica, nu mesajele, care se pot schimba;
  • nu trimiți niciodată lanțul cause la client: poate conține căi interne, interogări SQL sau date sensibile;
  • AggregateError pentru situațiile cu mai multe erori simultane, de exemplu rezultatul unui Promise.any.

Ce urmărește intervievatorul: Se verifică dacă știi să păstrezi informația de diagnostic de-a lungul straturilor. Greșeala tipică este înlocuirea erorii originale cu un mesaj generic, care face depanarea în producție aproape imposibilă.

89 Mid

Un coleg adaugă în aplicație process.on('uncaughtException', (err) => console.error(err)) ca serverul „să nu mai cadă”. Ce probleme are abordarea și ce ai face în loc?

Răspuns scurt: După o excepție neprinsă, aplicația poate fi într-o stare inconsistentă: resurse nefinalizate, tranzacții deschise, cereri fără răspuns. Handler-ul ar trebui doar să logheze sincron, să încerce o oprire scurtă și controlată și să iasă cu cod nenul, iar un manager de procese repornește aplicația.

Ce se întâmplă de fapt: o excepție aruncată în mijlocul unei operații întrerupe codul la acel punct. Lucrurile care trebuiau făcute după (eliberarea unei blocări, release() pe o conexiune din pool, res.end(), decrementarea unui contor) nu se mai fac. Dacă procesul continuă, aceste efecte se acumulează: pool-ul de conexiuni se golește, cererile rămân agățate, iar datele din memorie pot fi parțial actualizate. Documentația Node spune explicit că nu e sigur să reiei funcționarea normală după uncaughtException.

Abordarea corectă:

JavaScript
process.on('uncaughtException', (err, origine) => {
  logger.fatal({ err, origine }, 'excepție neprinsă, opresc procesul');
  oprireControlata(1);
});

process.on('unhandledRejection', (motiv) => {
  logger.fatal({ err: motiv }, 'promisiune respinsă netratată');
  oprireControlata(1);
});

function oprireControlata(cod) {
  server.close(() => process.exit(cod));         // nu mai accepta conexiuni noi
  setTimeout(() => process.exit(cod), 10_000).unref(); // limită de siguranță
}

Și infrastructura din jur:

  • un manager de procese (systemd, PM2, Kubernetes, platforma de hosting) care repornește procesul;
  • mai multe instanțe în spatele unui load balancer, ca oprirea uneia să nu întrerupă serviciul;
  • alertă pe numărul de restarturi.

Rădăcina problemei rămâne însă codul: excepțiile neprinse înseamnă bug-uri care trebuie reparate, de obicei callback-uri fără try/catch, emitteri fără listener de error sau promisiuni fără await. Handler-ul global e plasa de siguranță, nu mecanismul de tratare.

process.on('uncaughtExceptionMonitor') permite logarea fără a schimba comportamentul implicit de oprire.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce oprirea e varianta sigură. Răspunsul slab acceptă handler-ul care înghite excepțiile ca soluție de stabilitate.

Eroarea, în practică:UnhandledPromiseRejection

90 Mid

process.memoryUsage() arată rss: 1.4 GB, heapTotal: 300 MB, heapUsed: 250 MB, external: 900 MB. Cum interpretezi valorile și unde cauți problema?

Răspuns scurt: rss e toată memoria fizică a procesului, heapUsed memoria obiectelor JavaScript, iar external memoria din afara heap-ului, mai ales Buffer-e. Heap-ul e mic și external mare, deci cauți Buffer-e reținute: fișiere ținute în memorie, stream-uri fără backpressure.

Ce înseamnă fiecare câmp:

  • rss (resident set size): toată memoria fizică ocupată de proces: heap-ul V8, codul compilat, stivele, memoria nativă a Buffer-elor, bibliotecile C++. Asta vede sistemul de operare și asta numără limita containerului.
  • heapTotal: cât a rezervat V8 pentru heap.
  • heapUsed: cât ocupă efectiv obiectele JavaScript.
  • external: memorie alocată în afara heap-ului, dar legată de obiecte JavaScript, mai ales conținutul Buffer-elor.
  • arrayBuffers: partea din external folosită de ArrayBuffer-e și Buffer-e.

Interpretare pentru exemplu: heap-ul are 250 MB, normal pentru multe aplicații, dar external are 900 MB. Problema nu e în obiectele JavaScript obișnuite, ci în date binare. Cauze tipice:

  • fișiere întregi citite cu readFile pentru upload sau download, în loc de stream-uri;
  • Buffer-e mici, păstrate cu subarray dintr-unul mare, care țin în viață tot buffer-ul mare;
  • un Writable către un client lent, fără respectarea lui write() === false;
  • cache-uri de imagini sau de răspunsuri comprimate fără limită;
  • module native care alocă memorie proprie (procesare de imagini).

Limita heap-ului se setează cu --max-old-space-size=MB; ea nu limitează external. Într-un container, setezi limita heap-ului sub limita containerului, ca să lași loc memoriei native, altfel procesul e oprit de kernel (OOM kill) fără vreun mesaj de la Node.

Pași de investigație: urmărești metricile în timp (crește constant sau doar la vârfuri?), corelezi cu endpoint-urile active, faci heap snapshot (care arată și obiectele Buffer care rețin memoria externă) și verifici codul pentru citiri complete în memorie.

Ce urmărește intervievatorul: Se verifică dacă știi să citești metricile de memorie și să distingi heap-ul de memoria nativă. Mulți candidați se uită doar la heapUsed și caută degeaba un leak de obiecte.

91 Mid

Un endpoint folosește 100% CPU și răspunde în 2 secunde, dar nu e clar de ce. Cum faci profilare CPU pe o aplicație Node.js?

Răspuns scurt: Generezi un profil CPU cu node --cpu-prof sau te conectezi cu Chrome DevTools prin --inspect, reproduci încărcarea, apoi analizezi flame graph-ul ca să vezi funcțiile care ocupă cel mai mult timp. Optimizezi doar ce arată profilul și măsori din nou.

Unelte și pași:

  • Reproduci problema local sau în staging, cu un generator de încărcare (autocannon, k6) pe endpoint-ul lent, ca profilul să conțină destule eșantioane.
  • Profil cu flag:
BASH
node --cpu-prof --cpu-prof-dir=./profile server.js
# rulezi încărcarea, apoi oprești procesul cu Ctrl+C

La oprire se scrie un fișier .cpuprofile, pe care îl deschizi în Chrome DevTools (tab-ul Performance) sau în VS Code.

  • Inspector live: node --inspect server.js, apoi chrome://inspect, tab-ul Profiler, Start, încărcare, Stop. Pe un server la distanță, portul inspectorului se expune doar prin tunel SSH, niciodată public, pentru că permite execuție de cod.
  • Programatic: node:inspector (cu Session) permite pornirea profilării la cerere, de exemplu printr-un endpoint de administrare protejat.
  • Unelte suplimentare: 0x sau clinic flame produc flame graph-uri direct; --prof cu --prof-process dă profilul V8 brut.

Cum citești un flame graph: axa orizontală e proporția de timp, nu ordinea în timp; blocurile late din vârful stivei sunt funcțiile care consumă CPU direct. Cauze frecvente în aplicații Node:

  • JSON.stringify/JSON.parse pe obiecte mari;
  • expresii regulate cu backtracking excesiv;
  • sortări sau căutări liniare repetate în bucle (array.find în interiorul unui map, adică O(n²));
  • hash-uri criptografice sincrone;
  • logare excesivă, serializare de obiecte mari în loguri.

După modificare, rulezi din nou același test de încărcare și compari latența p95 și throughput-ul. Fără măsurare înainte și după, „optimizarea” e o presupunere.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să măsori înainte să optimizezi și cunoști uneltele runtime-ului. Răspunsul slab propune direct rescrieri sau mai multe servere, fără date.

92 Senior

Memoria acestui serviciu crește continuu până când procesul e oprit. Unde e leak-ul și cum l-ai confirma cu un heap snapshot?

JavaScript
const sesiuniActive = new Map();

app.use((req, res, next) => {
  const id = req.get('x-sesiune') || crypto.randomUUID();
  sesiuniActive.set(id, { ultimaCerere: Date.now(), req });
  res.on('finish', () => {
    sesiuniActive.get(id).ultimaCerere = Date.now();
  });
  next();
});

Răspuns scurt: Map-ul crește la nesfârșit: ID-urile noi nu se șterg niciodată, iar fiecare intrare ține referința la req, cu socket și header-e. Confirmi comparând două sau trei heap snapshot-uri sub încărcare: obiectele IncomingMessage reținute de Map se înmulțesc.

Probleme în cod:

  • Creștere nelimitată: intrările nu se șterg niciodată. Fiecare client fără x-sesiune (boți, health check-uri, oricine) adaugă o intrare nouă la fiecare cerere.
  • Referință la req: în loc de câțiva octeți, fiecare intrare ține în viață obiectul cererii și tot ce e legat de el. Garbage collector-ul nu le poate elibera, pentru că Map-ul, accesibil global, le referă.
  • Vector de atac: un client poate umple memoria trimițând ID-uri diferite.

Confirmare cu heap snapshot:

  • pornești cu --inspect sau folosești v8.writeHeapSnapshot() (ori semnalul configurat cu --heapsnapshot-signal=SIGUSR2);
  • iei un snapshot, rulezi încărcare câteva minute, iei al doilea și al treilea;
  • în Chrome DevTools, vizualizarea Comparison arată ce tipuri de obiecte au crescut: vei vedea mii de IncomingMessage, Socket, string-uri de header-e;
  • la un obiect selectat, panoul Retainers arată lanțul de referințe până la rădăcină: Map → sesiuniActive → closure-ul modulului. Asta indică exact variabila.

Atenție: un snapshot oprește procesul cât îl scrie și are nevoie de memorie suplimentară, apropiată de mărimea heap-ului. În producție îl faci pe o singură instanță scoasă din rotație. --heapsnapshot-near-heap-limit=1 scrie automat un snapshot când procesul se apropie de limită.

Reparația:

  • nu ții req, doar datele necesare ({ ultimaCerere });
  • limitezi mărimea și durata: un cache LRU cu TTL (de exemplu pachetul lru-cache) sau curățare periodică;
  • pentru sesiuni reale, stocare externă (Redis cu expirare), care merge și cu mai multe instanțe;
  • metrică pe mărimea structurii, ca o creștere anormală să declanșeze alertă înainte de OOM.

Ce urmărește intervievatorul: Se verifică dacă poți găsi un leak în cod și știi metoda de confirmare cu unelte, nu doar teoria. Candidații de nivel mediu văd de obicei doar Map-ul nelimitat, nu și efectul referinței la req.

Securitate și testare

93 Junior

Scrie teste cu runner-ul inclus în Node (node:test) pentru o funcție calculeazaTotal(produse, codReducere). Cum le rulezi?

Răspuns scurt: Imporți describe/it (sau test) din node:test și assert din node:assert/strict, scrii testele într-un fișier *.test.js și le rulezi cu node --test. Runner-ul e stabil din Node 20 și nu cere nicio dependență.

JavaScript
// total.js
function calculeazaTotal(produse, codReducere) {
  const brut = produse.reduce((s, p) => s + p.pret * p.cantitate, 0);
  if (codReducere === 'TOAMNA10') return Math.round(brut * 0.9 * 100) / 100;
  if (codReducere) throw new Error(`Cod invalid: ${codReducere}`);
  return brut;
}
module.exports = { calculeazaTotal };

// total.test.js
const { describe, it } = require('node:test');
const assert = require('node:assert/strict');
const { calculeazaTotal } = require('./total');

describe('calculeazaTotal', () => {
  it('adună prețul înmulțit cu cantitatea', () => {
    const total = calculeazaTotal([{ pret: 10, cantitate: 2 }, { pret: 5.5, cantitate: 1 }]);
    assert.equal(total, 25.5);
  });

  it('întoarce 0 pentru coș gol', () => {
    assert.equal(calculeazaTotal([]), 0);
  });

  it('aplică reducerea de 10%', () => {
    assert.equal(calculeazaTotal([{ pret: 99.99, cantitate: 1 }], 'TOAMNA10'), 89.99);
  });

  it('respinge un cod necunoscut', () => {
    assert.throws(() => calculeazaTotal([], 'FALS'), { message: /Cod invalid/ });
  });
});

Rulare:

BASH
node --test                       # caută automat fișierele *.test.js, *.spec.js, test/*
node --test --watch               # rulează din nou la modificări
node --test --experimental-test-coverage

Puncte de reținut:

  • node:assert/strict folosește comparații stricte (=== și egalitate profundă strictă), ceea ce evită surprize de tipul 1 == '1'.
  • Un test e trecut dacă funcția nu aruncă și, pentru testele async, dacă promisiunea se rezolvă.
  • before, after, beforeEach, afterEach pentru pregătire și curățenie.
  • Fiecare fișier de test rulează implicit în proces separat, deci starea globală nu se scurge între fișiere.

Avantajul față de Jest: zero dependențe, ESM nativ, pornire rapidă. Jest și Vitest oferă mai multe facilități (snapshot-uri, mock-uri de module mai comode, ecosistem), deci alegerea depinde de proiect.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii teste utile, cu cazuri limită, și dacă știi uneltele incluse. Testele care verifică doar „cazul fericit” sunt semnalul slab.

94 Junior

De ce trec sau pică aceste aserțiuni? Cum testezi corect o funcție async care trebuie să arunce?

JavaScript
const assert = require('node:assert');

assert.equal(1, '1');
assert.deepEqual({ a: 1 }, { a: '1' });
assert.strictEqual({ id: 1 }, { id: 1 });
assert.deepStrictEqual([1, 2], [1, 2]);

it('respinge email invalid', () => {
  assert.throws(() => inregistreaza({ email: 'x' }));
});

Răspuns scurt: equal și deepEqual din modul legacy folosesc ==, deci primele două trec, deși valorile au tipuri diferite. strictEqual pe două obiecte pică, pentru că sunt referințe diferite; deepStrictEqual trece. Dacă inregistreaza e async, assert.throws pică: trebuie await assert.rejects(...).

Rând cu rând:

  • assert.equal(1, '1') trece: în modul legacy, equal folosește ==, cu conversie de tip.
  • assert.deepEqual({ a: 1 }, { a: '1' }) trece din același motiv, aplicat recursiv. Un test care ar trebui să prindă un ID primit ca string în loc de număr nu prinde nimic.
  • assert.strictEqual({ id: 1 }, { id: 1 }) pică: === compară referințe, iar cele două obiecte sunt distincte.
  • assert.deepStrictEqual([1, 2], [1, 2]) trece: compară structura și tipurile, inclusiv prototipurile.

De aceea se recomandă require('node:assert/strict'), în care equal devine strictEqual și deepEqual devine deepStrictEqual.

Funcțiile asincrone nu aruncă sincron, ci întorc o promisiune respinsă. assert.throws apelează funcția, primește o promisiune (fără excepție) și raportează „Missing expected exception”. Varianta corectă:

JavaScript
it('respinge email invalid', async () => {
  await assert.rejects(
    () => inregistreaza({ email: 'x' }),
    { name: 'EroareValidare', message: /email/i },
  );
});

Două greșeli frecvente aici:

  • lipsa lui await în fața lui assert.rejects: testul se termină înainte de verificare și poate trece fals;
  • verificarea doar că „aruncă ceva”: o eroare TypeError din cauza unui bug ar trece testul. Validezi tipul sau mesajul erorii, cum face al doilea argument.

În Jest, echivalentele sunt expect(x).toBe(y) (identitate), toEqual (egalitate structurală), toStrictEqual (include undefined și clasele) și await expect(promisiune).rejects.toThrow(...).

Ce urmărește intervievatorul: Se verifică dacă înțelegi semantica aserțiunilor și testarea codului asincron. Testele care trec fals, din cauza lui == sau a lipsei lui await, sunt o problemă reală în multe proiecte.

Eroarea, în practică:AssertionError: Expected values to be strictly equalSame structure but are not reference-equal

95 Mid

Cum testezi o funcție care trimite un email printr-un client extern și reîncearcă după 30 de secunde dacă trimiterea eșuează, fără să aștepți efectiv 30 de secunde și fără să trimiți emailuri reale?

Răspuns scurt: Injectezi clientul de email ca dependență și îl înlocuiești în test cu o funcție mock (mock.fn în node:test sau jest.fn) care eșuează prima dată și reușește a doua oară. Timpul îl controlezi cu timere false (mock.timers în node:test, jest.useFakeTimers în Jest), avansând ceasul manual.

Codul testat, scris ca să fie testabil (clientul e primit ca parametru):

JavaScript
// notificari.js
const { setTimeout: asteapta } = require('node:timers/promises');

async function trimiteCuReincercare(client, mesaj, { pauzaMs = 30_000 } = {}) {
  try {
    return await client.trimite(mesaj);
  } catch {
    await asteapta(pauzaMs);
    return client.trimite(mesaj);
  }
}
module.exports = { trimiteCuReincercare };

Testul cu node:test:

JavaScript
const { test, mock } = require('node:test');
const assert = require('node:assert/strict');
const { trimiteCuReincercare } = require('./notificari');

test('reîncearcă o dată după eșec', async () => {
  const client = {
    trimite: mock.fn(async () => ({ id: 'm1' })),
  };
  client.trimite.mock.mockImplementationOnce(async () => { throw new Error('SMTP indisponibil'); });

  const rezultat = await trimiteCuReincercare(client, { catre: 'ana@exemplu.ro' }, { pauzaMs: 1 });

  assert.deepEqual(rezultat, { id: 'm1' });
  assert.equal(client.trimite.mock.callCount(), 2);
  assert.deepEqual(client.trimite.mock.calls[1].arguments, [{ catre: 'ana@exemplu.ro' }]);
});

Aici timpul e evitat printr-un parametru (pauzaMs: 1), cea mai simplă și robustă tehnică. Când nu poți schimba codul, folosești timere false: mock.timers.enable({ apis: ['setTimeout'] }) și mock.timers.tick(30_000) în node:test (adăugat în Node 20.4, încă marcat experimental), sau jest.useFakeTimers() cu await jest.advanceTimersByTimeAsync(30_000) în Jest. Cu timere false și promisiuni, trebuie avansat ceasul după ce codul a ajuns la await, altfel testul se blochează.

Alte unelte: mock.method(obiect, 'metoda') înlocuiește temporar o metodă existentă; mock.restoreAll() în afterEach. Pentru module întregi, jest.mock('./email') sau mock.module în node:test (experimental).

Principiul general: mock-uiești granițele sistemului (email, plăți, ceas), nu logica proprie.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să controlezi dependențele și timpul în teste. Greșelile tipice: teste care chiar așteaptă 30 de secunde sau mock-uri ale codului testat în sine.

96 Mid

Cum scrii teste de integrare pentru un API Express, fără să pornești serverul pe un port fix? Cum trebuie organizat codul ca să fie posibil?

Răspuns scurt: Separi crearea aplicației (app.js, care exportă app sau o funcție creeazaApp(deps)) de pornirea serverului (server.js, care face listen). În teste folosești supertest(app), care pornește aplicația pe un port aleator, trimite cereri HTTP reale și verifică statusul, header-ele și corpul.

Structura:

JavaScript
// app.js
const express = require('express');
function creeazaApp({ produse }) {
  const app = express();
  app.use(express.json());
  app.post('/produse', async (req, res) => {
    if (!req.body?.nume) return res.status(400).json({ eroare: 'nume obligatoriu' });
    res.status(201).json(await produse.adauga(req.body));
  });
  return app;
}
module.exports = { creeazaApp };

// server.js
const { creeazaApp } = require('./app');
creeazaApp({ produse: repoReal }).listen(process.env.PORT || 3000);

Testul:

JavaScript
const { describe, it, beforeEach } = require('node:test');
const assert = require('node:assert/strict');
const request = require('supertest');
const { creeazaApp } = require('./app');

describe('POST /produse', () => {
  let app;
  beforeEach(() => {
    const date = [];
    app = creeazaApp({ produse: { adauga: async (p) => { date.push(p); return { id: date.length, ...p }; } } });
  });

  it('creează produsul', async () => {
    const r = await request(app).post('/produse').send({ nume: 'Caiet' }).expect(201);
    assert.deepEqual(r.body, { id: 1, nume: 'Caiet' });
  });

  it('răspunde 400 fără nume', async () => {
    await request(app).post('/produse').send({}).expect(400);
  });
});

De ce funcționează: supertest primește app (o funcție handler) și pornește intern un server pe portul 0, adică un port liber ales de sistem. Testele pot rula în paralel fără conflicte, iar serverul e închis după fiecare cerere.

Decizii de discutat:

  • dependențele injectate permit fie un repository în memorie (rapid), fie o bază de date reală de test (mai fidel, de exemplu PostgreSQL în Docker sau Testcontainers), curățată între teste;
  • se testează și middleware-urile reale: parsarea JSON, autentificarea, handler-ul de erori, inclusiv răspunsul la JSON invalid;
  • conexiunile deschise (baza de date, cozi) se închid în after, altfel runner-ul nu se oprește.

Ce urmărește intervievatorul: Se verifică dacă știi să structurezi aplicația pentru testare și diferența față de testele unitare. Greșeala tipică este app.listen(3000) în fișierul importat de teste, care produce conflicte de port și procese agățate.

97 Mid

Ce vulnerabilitate are această funcție folosită pentru a combina setările primite în req.body cu cele implicite?

JavaScript
function combina(tinta, sursa) {
  for (const cheie in sursa) {
    if (typeof sursa[cheie] === 'object' && sursa[cheie] !== null) {
      tinta[cheie] = combina(tinta[cheie] || {}, sursa[cheie]);
    } else {
      tinta[cheie] = sursa[cheie];
    }
  }
  return tinta;
}
app.post('/setari', (req, res) => {
  res.json(combina({ tema: 'luminos' }, req.body));
});

Răspuns scurt: Prototype pollution: corpul {"__proto__": {"esteAdmin": true}} face ca funcția să scrie în Object.prototype, deci toate obiectele din proces primesc esteAdmin === true. Respingi cheile __proto__, constructor și prototype, folosești obiecte fără prototip sau, mai bine, validezi corpul cu o schemă strictă.

Mecanismul: JSON.parse creează o proprietate proprie cu numele __proto__ (nu modifică prototipul), deci req.body are cheia __proto__. În combina, tinta['__proto__'] nu este însă o proprietate obișnuită: accesorul moștenit întoarce Object.prototype. Apelul recursiv scrie apoi esteAdmin = true direct pe Object.prototype.

Efectul, în tot procesul:

JavaScript
const utilizator = {};
console.log(utilizator.esteAdmin); // true

Orice verificare de forma if (user.esteAdmin) pe un obiect fără acea proprietate devine adevărată. În funcție de cod, rezultatele merg de la ocolirea autorizării și erori care opresc serverul până la execuție de cod, când biblioteci de șabloane sau child_process citesc opțiuni din obiecte poluate.

Reparații, de preferat combinate:

  • Validare cu schemă strictă (Zod, Joi, Ajv): accepți doar cheile cunoscute, cu tipuri corecte; cheile necunoscute sunt respinse sau eliminate.
  • Respingerea cheilor periculoase în orice funcție de combinare recursivă:
JavaScript
const INTERZISE = new Set(['__proto__', 'constructor', 'prototype']);
for (const cheie of Object.keys(sursa)) {
  if (INTERZISE.has(cheie)) continue;
  // ...
}

Object.keys iterează doar proprietățile proprii, spre deosebire de for...in.

  • Obiecte fără prototip pentru dicționare: Object.create(null) sau Map.
  • Opțiunea Node --disable-proto=delete, care elimină accesorul __proto__ (cu riscul de a strica biblioteci vechi care îl folosesc).
  • Actualizarea dependențelor: vulnerabilități de acest tip au fost găsite în versiuni vechi ale unor biblioteci populare de combinare a obiectelor.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști o vulnerabilitate specifică JavaScript, frecventă în ecosistemul Node. Puțini candidați știu mecanismul exact prin care __proto__ din JSON ajunge să modifice prototipul.

98 Mid

Un endpoint de validare a email-ului folosește expresia /^([a-zA-Z0-9]+\.?)+@exemplu\.ro$/. Un atacator trimite un șir lung și serverul nu mai răspunde nimănui. Ce s-a întâmplat?

Răspuns scurt: ReDoS: expresia are cuantificatori imbricați, iar pe un input care aproape se potrivește motorul încearcă un număr exponențial de combinații, sincron, pe thread-ul principal. Repari rescriind expresia fără ambiguitate și limitând lungimea input-ului.

Motorul de expresii regulate din V8 folosește backtracking: când o potrivire eșuează, încearcă alte moduri de a împărți textul între părțile expresiei. Grupul ([a-zA-Z0-9]+\.?)+ permite ca șirul aaaa să fie împărțit în multe feluri (a|a|a|a, aa|aa, aaaa etc.), pentru că punctul e opțional. Pentru un input ca aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!, care nu se potrivește la final, motorul încearcă toate împărțirile posibile, adică un număr exponențial în lungimea șirului. Câteva zeci de caractere pot ține CPU-ul ocupat secunde sau minute.

În Node, problema e mai gravă decât în alte platforme: evaluarea e sincronă, deci în acest timp event loop-ul e blocat. O singură cerere oprește serverul pentru toți.

Remedii:

  • Expresii fără ambiguitate: fiecare caracter să poată fi potrivit într-un singur fel.
JavaScript
const EMAIL = /^[a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*@exemplu\.ro$/;

Aici punctul e obligatoriu între segmente, deci nu mai există împărțiri alternative.

  • Limită de lungime înainte de regex: if (email.length > 254) return invalid;. Ieftin și eficient.
  • Biblioteci verificate pentru validări complexe (email, URL), în loc de expresii scrise de mână.
  • Unelte: reguli ESLint (de exemplu eslint-plugin-regexp) și analizatoare care detectează tipare vulnerabile.
  • Izolare: pentru expresii venite de la utilizatori (căutări avansate), rularea într-un worker cu timeout sau folosirea unui motor fără backtracking, ca re2 (modul nativ).

Același risc apare cu expresiile din dependențe: o parte din avertismentele npm audit sunt exact ReDoS în parsere.

Ce urmărește intervievatorul: Se verifică legătura dintre o vulnerabilitate generală și modelul single-thread din Node. Candidații recunosc rar tiparul de cuantificatori imbricați.

99 Mid

Ai preluat un serviciu Node fără niciun test, care merge în producție și primește modificări săptămânal. Cum ai introduce testele?

Răspuns scurt: Nu încerc acoperire completă dintr-odată. Încep cu câteva teste de integrare pe fluxurile critice, care descriu comportamentul actual (teste de caracterizare), le pun în CI ca obligatorii, apoi adaug teste la fiecare bug reparat și la fiecare zonă modificată, refactorizând treptat spre cod testabil.

Model de răspuns structurat:

  • Prioritizare: identific cu echipa și din loguri fluxurile cu cel mai mare impact dacă se strică: autentificare, plasarea comenzii, plăți, exporturi. Acolo pun primele teste.
  • Teste de caracterizare la nivel de API: cu supertest sau cereri HTTP reale, pe o bază de date de test, verific ce răspunde serviciul acum, chiar dacă unele comportamente par ciudate. Scopul e să detectez schimbările neintenționate, nu să judec corectitudinea. Testele la nivel de HTTP nu depind de structura internă, deci rezistă la refactorizări.
  • Infrastructură minimă: un runner (node:test, Jest sau Vitest), o bază de date în Docker pentru teste, date inițiale reproductibile, un singur script npm test care merge local și în CI.
  • CI obligatoriu: testele rulează la fiecare pull request și blochează merge-ul dacă pică. Fără asta, testele se strică și sunt abandonate.
  • Regula de creștere: fiecare bug reparat vine cu un test care l-ar fi prins; fiecare modificare într-o zonă adaugă teste pentru acea zonă. Acoperirea crește acolo unde contează, adică în codul care se schimbă.
  • Refactorizare treptată: unde logica e amestecată în handlere, extrag funcții pure și servicii cu dependențe injectate, ușor de testat unitar.
  • Măsurare și comunicare: urmăresc incidentele și regresiile înainte și după, nu un procent de coverage impus. Explic echipei costul (timp la început) și beneficiul (deploy-uri fără frică), și cer timp alocat explicit în sprint.

Ce evit: o săptămână de „scriem teste pentru tot”, teste unitare cu mock-uri pe tot codul vechi și teste fragile care verifică detalii de implementare.

Ce urmărește intervievatorul: Intervievatorul evaluează pragmatismul și capacitatea de a schimba practicile unei echipe. Răspunsul slab propune rescrierea sau un obiectiv de coverage impus de sus.

100 Senior

Aplicația ta trebuie să ruleze scripturi sau pluginuri scrise de alți dezvoltatori. Poți folosi modulul vm pentru izolare? Ce oferă modelul de permisiuni din Node?

Răspuns scurt: Nu: documentația Node spune clar că vm nu este un mecanism de securitate. Modelul de permisiuni (--permission) restricționează accesul procesului la fișiere și procese copil, dar nu e sandbox. Codul neîncrezut rulează în procese sau containere izolate.

Modulul vm creează un context V8 separat (alt obiect global), util pentru a evalua expresii sau șabloane în care controlezi tu codul. Nu e o barieră de securitate: obiectele transmise în context dau acces la prototipurile din contextul gazdă, iar prin ele (de exemplu this.constructor.constructor('return process')()) codul poate obține process și, de acolo, require și sistemul de fișiere. Nici bucle infinite nu oprește complet: opțiunea timeout nu acoperă codul asincron. Biblioteca vm2, construită peste vm pentru izolare, a fost abandonată după vulnerabilități repetate de evadare.

Modelul de permisiuni limitează ce poate face procesul Node în întregime:

BASH
node --permission --allow-fs-read=/app --allow-fs-write=/app/tmp server.js
# în Node 20: --experimental-permission

Fără permisiuni explicite, accesul la fișiere, child_process, worker_threads și addon-urile native e refuzat (eroare ERR_ACCESS_DENIED); în cod poți verifica cu process.permission.has('fs.write', '/app/tmp'). E util ca strat suplimentar, de apărare în adâncime, pentru propria aplicație: limitează ce poate face o dependență compromisă. Documentația precizează însă că nu protejează împotriva codului malițios care rulează deja în proces și are excepții (de exemplu descriptori de fișiere deja deschiși).

Pentru cod cu adevărat neîncrezut, opțiunile reale:

  • procese separate cu utilizator de sistem fără drepturi, limite de CPU și memorie, fără rețea;
  • containere sau micro-VM-uri efemere (de exemplu gVisor, Firecracker), câte unul per execuție;
  • izolate V8 dedicate (isolated-vm), cu limite de memorie și fără acces la API-urile Node, dacă pluginurile au nevoie doar de logică pură;
  • WebAssembly cu un set restrâns de funcții expuse.

Pe lângă izolare: timeout, limită de output, comunicare doar prin mesaje validate și logarea fiecărei execuții.

Ce urmărește intervievatorul: Se verifică dacă știi limitele reale ale mecanismelor din runtime și nu oferi o falsă siguranță. Răspunsul greșit tipic este „folosesc vm.runInNewContext și e izolat”.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Node.js, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Node.js scriind cod, nu doar citind

Curs Node.js: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.