...
Pregătire interviuri

100 de întrebări de interviu JavaScript, cu răspunsuri

Întrebările despre JavaScript 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 JavaScript: primele 15 lecții sunt gratuite.

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

  • 100întrebări
  • 49junior
  • 38mid
  • 13senior
  • 140 minde citit
Întrebări de interviu JavaScript cu răspunsuri

La un interviu pentru un rol în care se lucrează cu JavaScript, limbajul în sine este verificat aproape întotdeauna, indiferent de framework. Întrebările vin în trei forme: teorie scurtă (tipuri, scope, this, prototipuri, event loop), fragmente de cod la care trebuie să spui ce se afișează și de ce, și exerciții de live coding în care scrii o funcție mică (debounce, memoize, groupBy, o variantă proprie de Promise.all). Unele firme dau și o temă de casă: o pagină mică cu DOM și fetch, fără framework.

Pentru un post de junior se așteaptă să stăpânești bazele fără ezitări: tipurile și conversiile, diferența dintre referință și valoare, metodele de array, closures, promisiunile și lucrul cu DOM-ul. La nivel mid, intervievatorul sapă în de ce: cum se stabilește this, cum arată lanțul de prototipuri, în ce ordine rulează microtask-urile, cum eviți condițiile de cursă în cod asincron și cum scrii cod care se poate testa. Întrebările de senior țin de performanță, memorie, module și deciziile de echipă.

Pagina are 100 de întrebări grupate pe teme, 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. La întrebările cu cod, nu ghici: rulează exemplul în consola browserului sau în Node.js și modifică-l până înțelegi fiecare rând afișat.

Tipuri, numere și coerciție

1 Junior

Ce tipuri de date are JavaScript și ce afișează codul de mai jos?

JavaScript
console.log(typeof 42);
console.log(typeof 10n);
console.log(typeof Symbol("id"));
console.log(typeof function () {});
console.log(typeof []);
console.log(typeof variabilaNedeclarata);

Răspuns scurt: Există șapte tipuri primitive (string, number, bigint, boolean, undefined, symbol, null) și tipul object. Codul afișează: number, bigint, symbol, function, object, undefined.

Valorile primitive sunt imutabile și se compară după valoare: string, number, bigint, boolean, undefined, symbol și null. Tot restul este object: obiecte literale, array-uri, funcții, date, Map, Set, expresii regulate.

typeof are câteva particularități pe care merită să le știi pe de rost:

  • typeof 10n este "bigint", tip introdus în ES2020 pentru întregi de orice mărime.
  • typeof Symbol("id") este "symbol"; fiecare simbol este unic.
  • typeof function () {} este "function", deși funcțiile sunt tot obiecte. Este singurul subtip de obiect pe care typeof îl distinge.
  • typeof [] este "object". Pentru array folosești Array.isArray(x).
  • typeof variabilaNedeclarata întoarce "undefined" fără să arunce eroare. Din acest motiv se folosea typeof window !== "undefined" ca să verifici dacă rulezi în browser. Excepție: o variabilă let sau const aflată încă în Temporal Dead Zone aruncă ReferenceError chiar și la typeof.

Mai e și cazul istoric typeof null === "object", un bug păstrat pentru compatibilitate. Concluzia practică: typeof e bun pentru primitive și funcții, dar pentru obiecte ai nevoie de alte verificări (Array.isArray, instanceof, x === null).

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi că funcțiile și array-urile sunt obiecte și că typeof are limite. Mulți candidați uită de bigint și symbol când enumeră tipurile.

2 Junior

Ce afișează codul de mai jos și cum ai compara corect două numere zecimale sau ai lucra cu sume de bani?

JavaScript
console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);

Răspuns scurt: Afișează 0.30000000000000004 și false, pentru că numerele sunt stocate în virgulă mobilă binară (IEEE 754). Compari cu o toleranță (Number.EPSILON) și lucrezi cu bani în unități întregi (bani, cenți).

Toate valorile de tip number din JavaScript sunt numere în virgulă mobilă pe 64 de biți, după standardul IEEE 754. Fracțiile 0.1 și 0.2 nu au o reprezentare exactă în baza 2, la fel cum 1/3 nu are o reprezentare exactă în baza 10. Rezultatul adunării este cel mai apropiat număr reprezentabil, care se afișează ca 0.30000000000000004, deci comparația strictă cu 0.3 dă false. Problema nu e specifică JavaScript; o au și Java, Python sau C când folosesc double.

Pentru comparații folosești o toleranță:

JavaScript
function aproapeEgale(a, b, eps = Number.EPSILON) {
  return Math.abs(a - b) < eps * Math.max(1, Math.abs(a), Math.abs(b));
}
aproapeEgale(0.1 + 0.2, 0.3); // true

Pentru bani, regula sănătoasă este să nu ții sume în lei cu zecimale, ci în bani, ca întregi: 19,99 lei devine 1999. Adunările și înmulțirile cu întregi sunt exacte până la Number.MAX_SAFE_INTEGER. Abia la afișare formatezi: (1999 / 100).toFixed(2) sau, mai bine, new Intl.NumberFormat("ro-RO", { style: "currency", currency: "RON" }).format(19.99).

Atenție și la toFixed: întoarce un string și rotunjește pe baza reprezentării binare, așa că (1.005).toFixed(2) dă "1.00", nu "1.01".

Ce urmărește intervievatorul: Se verifică dacă înțelegi cauza (reprezentarea binară), nu doar simptomul. Greșeala tipică este să propui toFixed pentru calcule cu bani, în loc de lucrul cu întregi.

3 Junior

Ce afișează fiecare expresie și de ce?

JavaScript
console.log("5" + 3);
console.log("5" - 3);
console.log("5" * "2");
console.log(true + 1);
console.log("3" + 4 + 5);
console.log(3 + 4 + "5");
console.log([] + {});

Răspuns scurt: "53", 2, 10, 2, "345", "75" și "[object Object]". Operatorul + concatenează dacă unul dintre operanzi devine string; ceilalți operatori aritmetici convertesc mereu la număr.

Operatorul + are două roluri: adunare și concatenare. Întâi își convertește operanzii la primitive; dacă cel puțin unul este string, face concatenare, altfel convertește ambii la număr și adună. Operatorii -, *, /, % au un singur rol, deci convertesc mereu la număr.

  • "5" + 3: unul e string, rezultă "53".
  • "5" - 3: - convertește "5" la 5, rezultă 2.
  • "5" * "2": ambele devin numere, rezultă 10.
  • true + 1: niciun string, true devine 1, rezultă 2.
  • "3" + 4 + 5: evaluarea se face de la stânga la dreapta. "3" + 4 este "34", apoi "34" + 5 este "345".
  • 3 + 4 + "5": întâi 3 + 4 = 7, apoi 7 + "5" este "75".
  • [] + {}: array-ul gol devine "", obiectul devine "[object Object]", rezultatul e concatenarea lor.

Exemplul de la stânga la dreapta explică un bug clasic din formulare: valorile din input.value sunt mereu string-uri, așa că total + input.value lipește textul în loc să adune. Soluția este conversia explicită înainte de calcul, cu Number(input.value) sau input.valueAsNumber pentru type="number".

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi regula de la stânga la dreapta și diferența dintre + și ceilalți operatori. Candidații greșesc des "3" + 4 + 5 față de 3 + 4 + "5".

4 Junior

Ce este NaN, de ce NaN === NaN este false și care e diferența dintre isNaN și Number.isNaN?

Răspuns scurt: NaN (Not a Number) este valoarea de tip number pentru rezultate numerice invalide. Este singura valoare diferită de ea însăși. isNaN convertește întâi argumentul la număr, Number.isNaN nu convertește nimic.

NaN apare când o operație numerică nu are un rezultat valid: Number("abc"), 0 / 0, Math.sqrt(-1), undefined + 1. Paradoxal, typeof NaN este "number". Standardul IEEE 754 spune că NaN nu este egal cu nimic, nici cu el însuși, de aceea NaN === NaN și NaN == NaN sunt ambele false. Din același motiv, [NaN].indexOf(NaN) întoarce -1.

Cele două funcții de verificare diferă prin conversie:

JavaScript
isNaN("abc");        // true, pentru că Number("abc") este NaN
isNaN("");           // false, pentru că Number("") este 0
Number.isNaN("abc"); // false, "abc" nu este valoarea NaN
Number.isNaN(NaN);   // true

Funcția globală isNaN răspunde la întrebarea „dacă aș converti asta la număr, aș obține NaN?”, ceea ce produce rezultate surprinzătoare. Number.isNaN (ES2015) răspunde exact: „este valoarea NaN?”. În cod nou folosești Number.isNaN, sau Object.is(x, NaN).

Pentru validarea unui câmp numeric e mai util Number.isFinite(Number(text)), care respinge și NaN, și Infinity. Atenție că Number("") este 0, deci un câmp gol trebuie tratat separat dacă nu vrei să-l accepți ca zero.

Ce urmărește intervievatorul: Se verifică dacă știi de ce comparația cu NaN nu funcționează și care funcție e sigură. Greșeala tipică: if (x === NaN), care nu este niciodată adevărat.

5 Junior

Care e diferența dintre Number(), parseInt(), parseFloat() și operatorul unar +? Ce afișează codul?

JavaScript
console.log(Number(""));
console.log(Number("12px"));
console.log(parseInt("12px"));
console.log(parseFloat("3.14abc"));
console.log(Number(null), Number(undefined));
console.log(parseInt(0.0000005));

Răspuns scurt: Number și + convertesc tot string-ul sau dau NaN; parseInt și parseFloat citesc de la început cât pot și ignoră restul. Codul afișează 0, NaN, 12, 3.14, apoi 0 NaN și, surprinzător, 5.

Number(x) și +x fac aceeași conversie strictă: tot textul (după eliminarea spațiilor de la capete) trebuie să fie un număr valid, altfel rezultatul e NaN. Câteva cazuri de reținut: Number("") și Number(" ") dau 0, Number(null) dă 0, Number(undefined) dă NaN, Number("0x1A") dă 26.

parseInt și parseFloat sunt permisive: citesc caracterele de la început cât timp formează un număr și se opresc la primul caracter invalid. De aceea parseInt("12px") este 12, ceea ce e util pentru valori CSS, iar parseFloat("3.14abc") este 3.14. Dacă primul caracter nu e cifră, rezultatul e NaN.

Cazul parseInt(0.0000005) arată că parseInt lucrează pe string. Dacă îi dai un număr, îl convertește întâi la text, iar 0.0000005 devine "5e-7", din care parseInt citește 5. Nu folosi parseInt ca să trunchiezi numere; pentru asta există Math.trunc.

Recomandări practice:

  • dă mereu baza: parseInt(text, 10);
  • folosește Number când vrei ca „12abc” să fie respins;
  • folosește parseInt/parseFloat când știi că urmează o unitate, ca la "16px".

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că alegi conversia potrivită pentru validare. Mulți candidați nu știu că Number("") este 0, ceea ce lasă câmpuri goale să treacă drept zero.

6 Junior

Ce întorc operatorii && și || când operanzii nu sunt boolean? Unde e problema în codul de mai jos?

JavaScript
function setVolum(nivel) {
  const volum = nivel || 50;
  console.log(volum);
}
setVolum(0);

Răspuns scurt: Nu întorc true sau false, ci unul dintre operanzi: || întoarce primul operand truthy (sau ultimul), && primul falsy (sau ultimul). Aici 0 e falsy, deci se afișează 50 în loc de 0.

În JavaScript, a || b evaluează a; dacă e truthy îl întoarce, altfel întoarce b. a && b face invers: dacă a e falsy îl întoarce, altfel întoarce b. Rezultatul este una dintre valori, nu un boolean:

JavaScript
"" || "implicit";  // "implicit"
"Ana" || "x";      // "Ana"
null && obj.nume;  // null, obj.nume nu se mai evaluează
5 && "da";         // "da"

Ambii operatori fac short-circuit: dacă rezultatul e deja stabilit de primul operand, al doilea nu se mai evaluează. De aceea user && user.save() apelează metoda doar când user există, iar debug || console.log("...") loghează doar când debug e falsy.

Bug-ul din exemplu vine din faptul că 0 e falsy. nivel || 50 nu poate face diferența între „lipsește” și „zero”, deci un utilizator care vrea volumul 0 primește 50. Același lucru se întâmplă cu un string gol sau cu false. Corect este operatorul ??, care tratează ca lipsă doar null și undefined:

JavaScript
const volum = nivel ?? 50; // 0 rămâne 0

Alternativ, un parametru implicit, function setVolum(nivel = 50), care se aplică doar pentru undefined. Pentru a obține un boolean real dintr-o expresie, folosești Boolean(x) sau !!x.

Ce urmărește intervievatorul: Se verifică înțelegerea short-circuit și a valorilor falsy într-un bug real. Greșeala tipică este folosirea lui || pentru valori implicite unde 0 sau "" sunt valori valide.

7 Junior

Un string este o valoare primitivă. Cum se face atunci că poți scrie "abc".toUpperCase() sau "abc".length? Ce afișează codul?

JavaScript
const s = "salut";
s.limba = "ro";
console.log(s.limba);
console.log(typeof new String("salut"));
console.log(new String("a") === new String("a"));

Răspuns scurt: La accesarea unei proprietăți, motorul învelește temporar primitiva într-un obiect String (autoboxing), apoi îl aruncă. Codul afișează undefined, object și false.

Primitivele nu au proprietăți sau metode. Când scrii "abc".toUpperCase(), motorul creează temporar un obiect wrapper de tip String, care moștenește metodele din String.prototype, apelează metoda și renunță la obiect. La fel funcționează Number ((5).toFixed(2)), Boolean, Symbol și BigInt. Pentru null și undefined nu există wrapper, de aceea null.length aruncă TypeError.

Efectele se văd în cod:

  • s.limba = "ro" setează proprietatea pe un obiect temporar care dispare imediat. În modul non-strict atribuirea e ignorată, iar în strict mode aruncă TypeError. Citirea s.limba creează alt wrapper, fără proprietatea respectivă, deci dă undefined.
  • new String("salut") creează explicit un obiect, deci typeof este "object".
  • Două obiecte diferite nu sunt niciodată egale cu ===, chiar dacă au același conținut, deci false.

De aceea new String, new Number și new Boolean nu se folosesc în cod real. Ele produc surprize precum if (new Boolean(false)), care intră pe ramura adevărată pentru că orice obiect e truthy. Când ai nevoie de conversie, apelezi funcțiile fără new: String(x), Number(x), Boolean(x) întorc primitive.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi diferența dintre primitive și obiecte dincolo de definiție. Mulți candidați cred că string-urile sunt obiecte, pentru că au metode.

Eroarea, în practică:Cannot create property on string

8 Mid

Ce afișează comparațiile de mai jos și ce reguli se aplică?

JavaScript
console.log("10" < "9");
console.log(10 < "9");
console.log(null >= 0);
console.log(null == 0);
console.log(undefined >= 0);
console.log("a" < "B");

Răspuns scurt: true, false, true, false, false, false. Două string-uri se compară lexicografic după codurile caracterelor; dacă un operand nu e string, ambii devin numere. null devine 0 la <, >, dar == are reguli separate pentru null.

Operatorii relaționali <, >, <=, >= urmează alt algoritm decât ==, iar asta produce rezultate aparent contradictorii.

  • "10" < "9": ambele sunt string-uri, deci se compară caracter cu caracter după codul UTF-16. "1" are cod mai mic decât "9", deci true. Acesta e motivul pentru care sortarea unor ID-uri ținute ca text dă ordinea „1, 10, 2”.
  • 10 < "9": un operand e număr, deci "9" devine 9, rezultatul e false.
  • null >= 0: la comparații relaționale null devine 0, iar 0 >= 0 e true.
  • null == 0: egalitatea laxă nu convertește null la număr. null este egal doar cu null și undefined, deci false. Rezultatul e că null >= 0 e adevărat, dar nici null > 0, nici null == 0 nu sunt.
  • undefined >= 0: undefined devine NaN, iar orice comparație cu NaN e false.
  • "a" < "B": literele mari au coduri mai mici ("B" e 66, "a" e 97), deci false.

Pentru text afișat utilizatorilor nu compari cu <, ci cu a.localeCompare(b, "ro") sau cu Intl.Collator, care țin cont de majuscule și diacritice. Pentru valori care pot fi null, verifici explicit lipsa înainte de comparație.

Ce urmărește intervievatorul: Se verifică dacă știi că < și == au reguli diferite de conversie. Greșeala tipică este să compari numere citite ca string-uri și să obții o ordine lexicografică.

9 Mid

Care e diferența dintre ===, Object.is și comparația folosită de includes? Ce afișează codul?

JavaScript
console.log(Object.is(NaN, NaN), NaN === NaN);
console.log(Object.is(0, -0), 0 === -0);
console.log([NaN].includes(NaN), [NaN].indexOf(NaN));

Răspuns scurt: === consideră NaN diferit de NaN și 0 egal cu -0; Object.is face invers; includes folosește SameValueZero (NaN egal cu NaN, 0 egal cu -0). Afișează: true false, false true, true -1.

Specificația ECMAScript are trei algoritmi de egalitate strictă, care diferă doar la două cazuri speciale:

  • Strict Equality (===, indexOf, switch): NaN !== NaN, iar 0 === -0.
  • SameValue (Object.is): Object.is(NaN, NaN) este true, Object.is(0, -0) este false.
  • SameValueZero (includes, Map, Set): NaN e egal cu NaN, dar 0 și -0 sunt considerate egale.

De aceea [NaN].includes(NaN) găsește elementul, iar indexOf nu îl găsește. Un Set deduplică și valorile NaN, iar new Map().set(NaN, "x").get(NaN) funcționează.

Valoarea -0 există pentru că IEEE 754 păstrează semnul zero. Apare la -0 * 5, Math.round(-0.4) sau 0 / -3. Se poate observa cu 1 / -0, care dă -Infinity, sau cu Object.is. În practică contează rar, de exemplu în calcule de direcție sau animații unde semnul are sens.

Alegerea în cod:

  • folosești === aproape întotdeauna;
  • folosești Number.isNaN sau Object.is când NaN e un caz posibil;
  • folosești includes în loc de indexOf() !== -1, pentru lizibilitate și pentru NaN.

Object.is e folosit și de biblioteci care detectează schimbarea unei valori, unde o schimbare din NaN în NaN nu trebuie să conteze ca modificare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că există mai multe noțiuni de egalitate și unde apar. Puțini candidați știu de ce includes și indexOf se comportă diferit cu NaN.

10 Mid

Cum convertește JavaScript un obiect la o valoare primitivă? Ce afișează codul de mai jos?

JavaScript
const pret = {
  valueOf() { return 42; },
  toString() { return "pret"; },
};
console.log(`${pret}`);
console.log(pret + "");
console.log(pret * 2);
console.log(String(pret));

Răspuns scurt: Motorul apelează Symbol.toPrimitive dacă există, altfel valueOf și toString, în ordinea dictată de „hint”. Afișează "pret", "42", 84 și "pret".

Când un obiect ajunge într-un context care cere o primitivă, motorul rulează operația ToPrimitive cu un hint: "string", "number" sau "default".

  • Dacă obiectul are metoda [Symbol.toPrimitive](hint), ea decide totul.
  • Altfel, pentru hint "string" se încearcă întâi toString, apoi valueOf.
  • Pentru "number" și "default" se încearcă întâi valueOf, apoi toString.

Prima metodă care întoarce o primitivă câștigă. În exemplu:

  • template literal și String(pret) cer hint "string", deci se apelează toString, rezultatul fiind "pret";
  • pret + "" folosește hint "default", deci valueOf dă 42, iar concatenarea dă "42";
  • pret * 2 folosește hint "number", deci 42 * 2 = 84.

Pentru obiecte obișnuite, valueOf întoarce chiar obiectul (nu e primitivă), așa că se ajunge la toString, care dă "[object Object]". Array-urile au toString care face join(","), de aceea [1, 2] + "" este "1,2". Date este excepția din limbaj: pentru hint "default" preferă string-ul.

Un exemplu modern controlat explicit:

JavaScript
class Bani {
  constructor(bani) { this.bani = bani; }
  [Symbol.toPrimitive](hint) {
    return hint === "string" ? `${(this.bani / 100).toFixed(2)} lei` : this.bani;
  }
}

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului din spatele coerciției, nu doar memorarea rezultatelor. Candidații de nivel mid ar trebui să explice de ce [1,2] + "" dă "1,2".

Eroarea, în practică:Cannot convert object to primitive valueCannot convert a Symbol value to a string

11 Mid

API-ul tău primește un JSON cu un ID numeric foarte mare. Ce afișează codul de mai jos și cum lucrezi corect cu numere întregi mari?

JavaScript
const data = JSON.parse('{"id": 9007199254740993}');
console.log(data.id);
console.log(Number.MAX_SAFE_INTEGER);
console.log(2n ** 64n);
console.log(1n + 1);

Răspuns scurt: Afișează 9007199254740992 (ID-ul greșit), 9007199254740991, 18446744073709551616n, apoi aruncă TypeError. Peste 2^53 - 1, number pierde precizie; pentru întregi mari folosești BigInt sau trimiți ID-urile ca string.

Tipul number are 53 de biți pentru mantisă, deci poate reprezenta exact toți întregii doar până la Number.MAX_SAFE_INTEGER, adică 2^53 - 1 = 9007199254740991. Peste această limită, nu orice întreg are reprezentare, iar valoarea se rotunjește la cel mai apropiat număr reprezentabil. 9007199254740993 devine 9007199254740992, fără eroare și fără avertisment. Verifici cu Number.isSafeInteger(x).

Bug-ul apare frecvent cu ID-uri generate de baze de date sau de sisteme distribuite (de tip Snowflake), stocate pe 64 de biți. JSON.parse le convertește în number și le strică. Soluțiile:

  • serverul trimite ID-urile ca string-uri, varianta cea mai simplă și mai robustă;
  • pe client, ID-urile rămân string-uri; nu faci aritmetică pe ele.

BigInt (ES2020) reprezintă întregi de orice mărime: 2n ** 64n este exact. Reguli:

  • nu poți amesteca BigInt cu number în operații: 1n + 1 aruncă TypeError, deci convertești explicit cu BigInt(1) sau Number(x);
  • împărțirea trunchiază: 7n / 2n este 3n;
  • JSON.stringify aruncă TypeError pentru BigInt, dacă nu definești BigInt.prototype.toJSON sau un replacer;
  • Math nu acceptă BigInt.

BigInt e potrivit pentru calcule exacte cu întregi mari, nu pentru bani cu zecimale sau pentru performanță.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi limita întregilor sigure și un caz real în care contează. Mulți candidați află de problemă abia când ID-urile încep să nu se mai potrivească în producție.

Eroarea, în practică:Do not know how to serialize a BigIntCannot mix BigInt and other types

12 Senior

Cum verifici robust tipul unei valori când typeof nu e suficient? De ce instanceof Array poate da false pentru un array?

Răspuns scurt: Folosești verificări specifice (Array.isArray, x === null, Number.isFinite) și Object.prototype.toString.call pentru tipuri încorporate. instanceof depinde de prototipul din realm-ul curent, deci eșuează pentru obiecte venite din alt iframe sau worker.

instanceof verifică dacă Constructor.prototype apare în lanțul de prototipuri al obiectului. Fiecare realm (o fereastră, un iframe, un worker, un context vm în Node.js) are propriile constructori globali. Un array creat într-un iframe are în lanț Array.prototype al iframe-ului, deci arr instanceof Array din pagina părinte întoarce false. Rezultatul poate fi păcălit și de Object.setPrototypeOf sau de Symbol.hasInstance.

Verificări robuste, în ordinea preferinței:

JavaScript
Array.isArray(x);                     // funcționează între realm-uri
x === null;
typeof x === "object" && x !== null;  // orice obiect
Number.isFinite(x);                   // număr valid, nu NaN, nu Infinity
Object.prototype.toString.call(x);    // "[object Date]", "[object RegExp]"...

Object.prototype.toString.call citește tag-ul intern și dă "[object Array]", "[object Null]", "[object Map]". Poate fi și el personalizat prin Symbol.toStringTag, deci nu e o garanție absolută pentru obiecte definite de utilizator.

Pentru obiectele proprii, întrebarea mai utilă nu e „ce tip are?”, ci „are forma de care am nevoie?” (duck typing): verifici câmpurile și tipurile lor. La granițele aplicației (răspunsuri de API, postMessage, localStorage) validezi cu o funcție dedicată sau cu o bibliotecă de scheme, în loc să presupui tipul. Pentru erori venite din alt realm, verifici err.name sau prezența lui err.message, nu doar instanceof Error.

Ce urmărește intervievatorul: Se verifică experiența cu cazuri reale (iframe-uri, workers, biblioteci) și gândirea de validare la granițe. Răspunsul slab se oprește la typeof și instanceof.

Eroarea, în practică:x.map is not a functionRight-hand side of 'instanceof' is not callable

Scope, hoisting și closures

13 Junior

Ce este scope-ul și ce afișează codul de mai jos?

JavaScript
let mesaj = "global";
function afiseaza() {
  let mesaj = "funcție";
  if (true) {
    let mesaj = "bloc";
    console.log(mesaj);
  }
  console.log(mesaj);
}
afiseaza();
console.log(mesaj);

Răspuns scurt: Scope-ul este zona de cod în care un nume de variabilă este vizibil. Codul afișează "bloc", "funcție", "global": fiecare let creează o variabilă nouă în blocul lui, care o umbrește pe cea exterioară.

JavaScript are trei niveluri principale de scope:

  • global: variabilele declarate în afara oricărei funcții sau bloc;
  • de funcție: tot ce e declarat în corpul unei funcții, inclusiv var;
  • de bloc: tot ce e declarat cu let, const sau class între acolade (if, for, { }).

Scope-ul este lexical: se stabilește după locul în care e scris codul, nu după locul din care e apelată funcția. Când folosești un nume, motorul îl caută întâi în scope-ul curent, apoi în cel care îl conține, până la global. Dacă nu îl găsește, aruncă ReferenceError.

În exemplu există trei variabile diferite, toate numite mesaj. Cea din if o umbrește (shadowing) pe cea din funcție, iar cea din funcție pe cea globală. Fiecare console.log vede variabila cea mai apropiată, deci ordinea e „bloc”, „funcție”, „global”. Nicio atribuire nu afectează alte variabile.

Dacă în if ai scrie var mesaj = "bloc", codul ar arunca SyntaxError, pentru că var nu are scope de bloc și ar intra în conflict cu let mesaj din aceeași funcție. Shadowing-ul e legal, dar în cod real reduce lizibilitatea; regula ESLint no-shadow îl semnalează. Scopurile mici și nume clare previn bug-urile în care modifici altă variabilă decât crezi.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi că fiecare let creează o variabilă separată și că scope-ul e lexical. Greșeala tipică este să crezi că let din if suprascrie variabila exterioară.

Eroarea, în practică:x is not definedIdentifier 'x' has already been declared

14 Junior

Ce este Temporal Dead Zone (TDZ)? Ce se întâmplă la rularea codului de mai jos?

JavaScript
let x = "exterior";
function test() {
  console.log(typeof x);
  let x = "interior";
}
test();

Răspuns scurt: TDZ este intervalul dintre începutul scope-ului și linia declarației unei variabile let, const sau class, în care accesarea ei aruncă ReferenceError. Codul aruncă ReferenceError, chiar și cu typeof.

Și let, și const sunt „ridicate” (hoisted) la începutul blocului: motorul știe de existența lor de la intrarea în scope. Spre deosebire de var, ele nu sunt inițializate cu undefined, ci rămân neinițializate până la linia declarației. Perioada aceasta se numește Temporal Dead Zone, iar orice acces în ea aruncă ReferenceError: Cannot access 'x' before initialization.

În exemplu, let x din funcție umbrește variabila globală pe tot corpul funcției, nu doar de la linia declarației. La console.log(typeof x), x local există, dar e încă în TDZ. Rezultatul e ReferenceError. Faptul că există un x global nu ajută, iar typeof, care altfel e sigur pentru nume nedeclarate, aici aruncă.

TDZ este „temporal” pentru că depinde de momentul execuției, nu de poziția în text:

JavaScript
function arata() { console.log(y); }
let y = 5;
arata(); // 5, funcția rulează după inițializare

Același mecanism se aplică pentru class: nu poți folosi o clasă înainte de declarația ei, spre deosebire de o funcție declarată clasic. Parametrii impliciți au și ei TDZ: function f(a = b, b = 1) aruncă dacă a lipsește.

Scopul TDZ e să transforme un bug tăcut (un undefined neașteptat, ca la var) într-o eroare clară.

Ce urmărește intervievatorul: Se verifică înțelegerea hoisting-ului pentru let și const dincolo de „nu sunt ridicate”, care e o explicație greșită. Puțini candidați știu că typeof aruncă în TDZ.

Eroarea, în practică:Cannot access 'x' before initialization

15 Junior

Ce afișează sau ce eroare aruncă fiecare apel? Explică diferența dintre function declaration și function expression.

JavaScript
console.log(aduna(2, 3));
console.log(inmulteste);
console.log(imparte(6, 3));

function aduna(a, b) { return a + b; }
var inmulteste = function (a, b) { return a * b; };
const imparte = (a, b) => a / b;

Răspuns scurt: Primul apel afișează 5, al doilea undefined, iar al treilea aruncă ReferenceError. Declarațiile de funcție sunt ridicate complet, iar expresiile de funcție urmează regulile variabilei (var, let sau const) căreia îi sunt atribuite.

O function declaration (function aduna() {} ca instrucțiune separată) este ridicată împreună cu corpul ei. La intrarea în scope, funcția există deja și poate fi apelată înainte de linia în care e scrisă. De aceea aduna(2, 3) dă 5.

O function expression este o funcție folosită ca valoare și atribuită unei variabile. Se ridică doar variabila, după regulile ei:

  • var inmulteste e ridicat și inițializat cu undefined, deci console.log(inmulteste) afișează undefined. Dacă ai fi încercat inmulteste(2, 3), ai fi primit TypeError: inmulteste is not a function.
  • const imparte e în Temporal Dead Zone până la declarație, deci accesul aruncă ReferenceError. Execuția se oprește aici.

Același mecanism explică un bug întâlnit des: același cod funcționează sau nu în funcție de ordinea liniilor, când o funcție definită cu const e folosită de un handler înregistrat mai sus, dar apelat înainte de inițializare.

În echipe se preferă de obicei unul dintre stiluri, impus de ESLint. Declarațiile sunt utile pentru funcții ajutătoare puse la finalul fișierului, după logica principală. Expresiile cu const previn reasignarea accidentală și obligă la o ordine clară. Un detaliu în plus: o expresie poate avea nume (const f = function fact(n) { ... }), vizibil doar în interiorul ei, util pentru recursivitate și pentru stack trace-uri mai clare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți prezice exact eroarea (undefined, TypeError sau ReferenceError). Greșeala tipică este să spui că funcțiile nu sunt ridicate deloc sau că sunt toate ridicate.

Eroarea, în practică:Cannot access 'x' before initializationx is not a function

16 Junior

Ce afișează codul de mai jos? Poți modifica o constantă?

JavaScript
const config = { tema: "dark" };
config.tema = "light";
console.log(config.tema);

const lista = [1, 2];
lista.push(3);
console.log(lista);

config = {};

Răspuns scurt: Afișează "light" și [1, 2, 3], apoi ultima linie aruncă TypeError: Assignment to constant variable. const interzice reasignarea variabilei, nu modificarea obiectului spre care arată.

const creează o legătură (binding) care nu poate fi reasignată. Variabila nu poate fi făcută să arate spre altă valoare, dar valoarea în sine nu devine imutabilă. Pentru primitive diferența nu se vede, pentru că primitivele sunt oricum imutabile. Pentru obiecte și array-uri, variabila ține o referință: referința e fixă, dar conținutul obiectului se poate schimba liber.

De aceea config.tema = "light" și lista.push(3) funcționează, iar config = {} aruncă TypeError. Același lucru: const nu se poate declara fără inițializare (const x; e SyntaxError) și nu poate fi folosit ca variabilă de contor într-un for clasic cu i++. În schimb merge în for (const item of lista), pentru că la fiecare iterație se creează o legătură nouă.

Dacă vrei ca obiectul să nu poată fi modificat, ai nevoie de Object.freeze(config), care blochează modificările doar pe primul nivel (obiectele imbricate rămân modificabile).

Convenția din majoritatea echipelor: const implicit, let doar când variabila chiar trebuie reasignată, și var deloc. Avantajul nu e imutabilitatea, ci lizibilitatea: când vezi const, știi că numele va arăta mereu spre aceeași valoare, deci nu trebuie să urmărești reasignări prin cod.

Ce urmărește intervievatorul: Se verifică diferența dintre variabilă și valoare. Greșeala tipică este să crezi că const face obiectul imutabil sau, invers, că un array const nu poate primi elemente.

Eroarea, în practică:Assignment to constant variableMissing initializer in const declaration

17 Junior

Ce face "use strict" și ce schimbă în comportamentul codului? Când este activ automat?

Răspuns scurt: Strict mode transformă unele greșeli tăcute în erori și interzice construcții periculoase: atribuirea la variabile nedeclarate aruncă eroare, this e undefined în funcțiile apelate simplu. Este activ automat în modulele ES și în clase.

Strict mode a fost introdus în ES5 ca un subset mai sigur al limbajului. Se activează cu directiva "use strict"; la începutul unui fișier sau al unei funcții. Principalele schimbări:

  • atribuirea la o variabilă nedeclarată (total = 5 fără let) aruncă ReferenceError, în loc să creeze o variabilă globală accidentală;
  • this este undefined într-o funcție apelată simplu, f(), în loc să fie obiectul global; un this.x = 1 greșit aruncă eroare în loc să polueze window;
  • atribuirea la proprietăți read-only (de exemplu pe un obiect înghețat cu Object.freeze) aruncă TypeError, în loc să fie ignorată;
  • sunt interzise parametrii cu nume duplicat, instrucțiunea with și literalele octale vechi, precum 010;
  • eval nu mai poate crea variabile în scope-ul exterior;
  • arguments nu mai e legat de parametri: modificarea unuia nu îl schimbă pe celălalt.

Strict mode este automat activ în modulele ES (<script type="module">, fișiere .mjs sau proiecte cu "type": "module") și în corpul claselor. Așadar, în proiectele moderne construite cu bundlere, de obicei rulezi deja în strict mode fără să scrii directiva. Scripturile clasice și fișierele CommonJS din Node.js rămân în modul non-strict dacă nu adaugi directiva.

Importanța practică: un cod care „merge” într-un script vechi poate arunca erori după mutarea într-un modul, de exemplu din cauza unei variabile nedeclarate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce erori previne strict mode și că modulele îl activează implicit. Candidații uită adesea efectul asupra lui this.

Eroarea, în practică:Octal literals are not allowed in strict modeUnexpected strict mode reserved word

18 Mid

Ce afișează codul de mai jos? Un closure capturează valoarea variabilei sau variabila însăși?

JavaScript
let pret = 100;
function afiseazaPret() {
  console.log(pret);
}
pret = 120;
afiseazaPret();

function creeaza() {
  let n = 1;
  const citeste = () => n;
  n = 2;
  return citeste;
}
console.log(creeaza()());

Răspuns scurt: Afișează 120 și 2. Un closure păstrează o legătură vie către variabilă, nu o copie a valorii din momentul creării, deci vede ultima valoare atribuită.

O funcție are acces la variabilele din scope-urile în care a fost definită. Mecanismul prin care acest acces rămâne valabil și după ce funcția exterioară s-a terminat se numește closure. Important este ce anume se păstrează: o referință la mediul lexical, adică la variabila însăși, nu o fotografie a valorii.

  • afiseazaPret citește pret în momentul apelului. Până atunci, valoarea a devenit 120, deci se afișează 120.
  • citeste e creată când n e 1, dar n devine 2 înainte de return. Când apelăm funcția, ea citește valoarea curentă, 2.

Aceeași regulă explică de ce mai multe funcții create în același scope împart starea:

JavaScript
function contor() {
  let c = 0;
  return { inc: () => ++c, citeste: () => c };
}
const k = contor();
k.inc(); k.inc();
console.log(k.citeste()); // 2

inc și citeste văd aceeași variabilă c. Dacă vrei să „înghețe” o valoare la un moment dat, trebuie să o copiezi explicit într-o variabilă nouă, de exemplu un parametru sau un const creat la fiecare iterație.

Neînțelegerea acestui lucru produce bug-uri de tip „stale value” în handlere și timere: un callback creat mai demult citește o variabilă care a fost schimbată între timp de alt cod, sau invers, citește un parametru vechi pentru că a fost capturată o variabilă locală diferită.

Ce urmărește intervievatorul: Se verifică un model mental corect al closure-ului. Răspunsul greșit des întâlnit este că funcția „ține minte valoarea de la creare”.

19 Mid

Scrie o funcție once(fn) care întoarce o funcție ce apelează fn o singură dată. La apelurile următoare trebuie să întoarcă rezultatul primului apel.

Răspuns scurt: Folosești un closure cu un flag și o variabilă pentru rezultat. La primul apel rulezi fn cu argumentele și this-ul primite, salvezi rezultatul și ignori apelurile ulterioare.

Funcția întoarsă are nevoie de stare privată care supraviețuiește între apeluri. Closure-ul oferă exact asta, fără variabile globale:

JavaScript
function once(fn) {
  let apelat = false;
  let rezultat;
  return function (...args) {
    if (!apelat) {
      apelat = true;
      rezultat = fn.apply(this, args);
      fn = null; // eliberează referința
    }
    return rezultat;
  };
}

const init = once(() => {
  console.log("inițializare");
  return 42;
});
init(); // afișează "inițializare", întoarce 42
init(); // întoarce 42, fără log

Detalii pe care intervievatorul le urmărește:

  • setezi apelat = true înainte de apel, astfel încât un apel recursiv sau o excepție să nu ducă la rulări multiple; dacă vrei să permiți reîncercarea după o eroare, muți flagul după apel și îl explici;
  • folosești o funcție clasică, nu arrow, și fn.apply(this, args), ca să păstrezi this dacă funcția e folosită ca metodă;
  • argumentele se transmit cu rest parameters;
  • fn = null permite garbage collector-ului să elibereze funcția inițială și tot ce capturează ea.

Utilizări reale: inițializarea unei conexiuni sau a unui SDK, un handler care trebuie să ruleze o dată (deși pentru evenimente DOM există opțiunea { once: true }), sau protecția împotriva dublului apel al unui callback. Varianta asincronă salvează promisiunea, nu rezultatul, astfel încât apelurile simultane primesc aceeași promisiune.

Ce urmărește intervievatorul: Se verifică folosirea practică a closure-urilor și atenția la this și argumente. Răspunsurile slabe uită să întoarcă rezultatul salvat sau pierd this.

20 Mid

Scrie o funcție memoize(fn) care salvează rezultatele unei funcții pure în funcție de argumente. Ce limitări are?

Răspuns scurt: Închizi un Map într-un closure; cheia derivă din argumente, iar la un apel repetat întorci valoarea din cache. Limitările: funcția trebuie să fie pură, cheile pentru obiecte sunt problematice, iar cache-ul crește nelimitat.

O implementare simplă, potrivită pentru argumente primitive:

JavaScript
function memoize(fn) {
  const cache = new Map();
  return function (...args) {
    const cheie = JSON.stringify(args);
    if (cache.has(cheie)) return cache.get(cheie);
    const rezultat = fn.apply(this, args);
    cache.set(cheie, rezultat);
    return rezultat;
  };
}

const fib = memoize((n) => (n < 2 ? n : fib(n - 1) + fib(n - 2)));
fib(50); // rapid, fiecare n se calculează o singură dată

Map e mai potrivit decât un obiect simplu: nu are chei moștenite și se poate goli ușor. Folosești has și nu doar get, pentru că rezultatul poate fi legitim undefined sau 0.

Limitări pe care trebuie să le spui:

  • puritatea: memoizarea are sens doar dacă aceleași argumente dau mereu același rezultat; o funcție care citește data curentă sau face fetch nu trebuie memoizată orbește;
  • cheile: JSON.stringify e lent pentru obiecte mari, ignoră funcțiile și undefined, iar ordinea cheilor contează. Pentru un singur argument de tip obiect, un WeakMap folosit cu referința drept cheie e mai bun și nu împiedică garbage collection;
  • memoria: cache-ul crește nelimitat; în producție pui o limită (LRU, adică eliminarea celei mai vechi intrări folosite) sau un timp de expirare;
  • funcțiile async: salvezi promisiunea, ca apelurile simultane să o împartă, și o ștergi din cache dacă e respinsă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți scrie codul și, mai ales, dacă recunoști când memoizarea face rău. Candidații de nivel mid trebuie să menționeze creșterea nelimitată a cache-ului.

21 Mid

Ce este un IIFE și de ce mai apare în cod, deși avem module ES?

JavaScript
const contor = (function () {
  let valoare = 0;
  return { inc: () => ++valoare };
})();

Răspuns scurt: IIFE (Immediately Invoked Function Expression) este o funcție definită și apelată imediat, pentru un scope privat. Modulele ES l-au înlocuit în mare parte, dar apare în cod vechi, în output-ul bundlerelor și ca async IIFE în scripturi clasice.

Înainte de ES2015, singurul mod de a crea un scope nou era o funcție. Un IIFE combină definiția cu apelul: parantezele din jurul funcției o transformă în expresie, iar () de la final o apelează. Variabilele declarate în interior nu ajung în scope-ul global, iar ce întorci devine API-ul public. Exemplul de mai sus este „module pattern”: valoare e privată, accesibilă doar prin inc.

Ce rezolva istoric:

  • evita poluarea obiectului global când pe pagină erau multe scripturi clasice;
  • crea o variabilă nouă per iterație în bucle cu var;
  • permitea biblioteci de tip UMD, care funcționau și ca script, și ca modul.

Astăzi, majoritatea acestor nevoi le acoperă alte mecanisme: let și const au scope de bloc, iar fiecare modul ES are scope propriu, deci variabilele de la nivelul fișierului nu mai sunt globale.

Unde îl mai întâlnești:

  • în cod vechi sau în snippet-uri incluse direct în pagină (de exemplu scripturi de analytics);
  • în output-ul bundlerelor, care învelesc fiecare modul într-o funcție;
  • ca async IIFE, pentru a folosi await într-un script clasic sau într-un fișier CommonJS, unde nu există top-level await:
JavaScript
(async () => {
  const date = await fetch("/api/config").then((r) => r.json());
  porneste(date);
})();

Atenție la punct și virgulă: un IIFE pe o linie care urmează după o expresie fără ; poate fi interpretat ca apel al acelei expresii.

Ce urmărește intervievatorul: Se verifică dacă înțelegi problema pe care o rezolva IIFE și ce o rezolvă azi. Răspunsul bun leagă IIFE de scope, nu doar de sintaxă.

Eroarea, în practică:Function statements require a function name

22 Mid

De ce var x la nivel global devine window.x, iar let x nu? Ce se schimbă într-un modul ES și ce este globalThis?

Răspuns scurt: Într-un script clasic, var și declarațiile de funcție de la nivel global devin proprietăți ale obiectului global; let, const și class stau într-un scope global separat. Într-un modul nimic nu ajunge global. globalThis este numele standard pentru obiectul global în orice mediu.

Scope-ul global al unui script clasic are două părți:

  • obiectul global (window în browser): aici ajung var-urile de la nivelul cel mai de sus și declarațiile de funcție. var tema = "dark" face ca window.tema să fie "dark";
  • registrul declarativ: aici stau let, const și class de la nivel global. Sunt vizibile în toate scripturile clasice ale paginii, dar nu ca proprietăți ale lui window.

Consecințe practice:

  • un var name global intră în conflict cu window.name, proprietate existentă care convertește valoarea la string;
  • un var cu același nume în două scripturi diferite înseamnă aceeași variabilă, deci scripturile se pot strica reciproc;
  • două let cu același nume în scripturi diferite aruncă SyntaxError la încărcarea celui de-al doilea.

Într-un modul ES (type="module" sau cod procesat de bundler), variabilele de la nivelul fișierului aparțin modulului. Nimic nu ajunge pe window decât dacă scrii explicit window.x = .... Un efect colateral: dacă un handler inline din HTML (onclick="salveaza()") apelează o funcție definită într-un modul, primești ReferenceError, pentru că funcția nu e globală.

globalThis (ES2020) unifică numele obiectului global: window în pagină, self în workers, global în Node.js. Cod care trebuie să ruleze în mai multe medii folosește globalThis.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea mediilor de execuție, utilă la migrarea codului vechi în module. Greșeala tipică: nu știu de ce o funcție din modul nu mai poate fi apelată din onclick.

Eroarea, în practică:document is not defined

23 Senior

Cum pot closure-urile să țină în memorie mai mult decât te aștepți? Ce rămâne reținut în exemplul de mai jos?

JavaScript
function initRaport() {
  const dateMari = new Array(1_000_000).fill({ v: 1 });
  const total = dateMari.length;
  const afiseaza = () => console.log("Total:", total);
  const proceseaza = () => dateMari.map((x) => x.v);
  proceseaza();
  return afiseaza;
}
const handler = initRaport();

Răspuns scurt: O funcție întoarsă poate ține în viață întregul mediu lexical de care depinde. În motoare precum V8, closure-urile create în același scope împart un context, deci dateMari poate rămâne în memorie cât timp handler există, deși afiseaza folosește doar total.

Garbage collector-ul eliberează un obiect doar când nu mai e accesibil din rădăcini (variabile globale, stiva, handlere înregistrate). Un closure face accesibile variabilele pe care le capturează. Partea surprinzătoare este implementarea: în V8 (Chrome, Node.js), toate funcțiile create în același scope împart un singur obiect context, care conține variabilele folosite de oricare dintre ele.

În exemplu, proceseaza folosește dateMari, așa că dateMari intră în contextul comun. afiseaza se referă la același context, deci cât timp handler e ținut (de exemplu ca listener pe un buton sau într-un cache global), milionul de elemente rămâne în memorie, chiar dacă afiseaza nu îl folosește direct. Comportamentul exact ține de motor, nu de specificație, dar trebuie luat în calcul.

Cum previi:

  • extrage datele mari într-o funcție separată, care nu întoarce closure-uri;
  • setează explicit dateMari = null (cu let) după ce nu mai e nevoie;
  • capturează doar valorile mici de care ai nevoie, calculate înainte;
  • dezînregistrează handlerele și timerele (removeEventListener, clearInterval, AbortController) când componenta dispare.

Diagnoza se face cu Chrome DevTools, panoul Memory: faci două heap snapshot-uri înainte și după o acțiune repetată și compari obiectele care cresc. În vizualizarea „Retainers” vezi lanțul de referințe, inclusiv contextul (system / Context) care ține obiectul.

Ce urmărește intervievatorul: Se verifică înțelegerea legăturii dintre closures și garbage collection și experiența cu instrumentele de profilare. Răspunsul slab spune doar că „closure-urile consumă memorie”.

Funcții și this

Exersează capitolul cu exerciții reale: Curs JavaScript pentru începători →
24 Junior

Cum funcționează parametrii impliciți? Ce afișează codul de mai jos?

JavaScript
function adaugaProdus(nume, cantitate = 1, cos = []) {
  cos.push(`${nume} x${cantitate}`);
  return cos;
}
console.log(adaugaProdus("pâine"));
console.log(adaugaProdus("lapte", null));
console.log(adaugaProdus("ouă", undefined));

Răspuns scurt: Valoarea implicită se aplică doar când argumentul lipsește sau este undefined, iar expresia se evaluează la fiecare apel. Codul afișează ["pâine x1"], ["lapte xnull"] și ["ouă x1"], fiecare într-un array nou.

Parametrii impliciți (ES2015) se aplică exact în două situații: argumentul nu a fost transmis sau este undefined. Valoarea null este o valoare explicită, deci nu declanșează valoarea implicită. Asta explică rezultatul "lapte xnull". La fel, 0, "" sau false sunt păstrate.

Expresia implicită se evaluează la fiecare apel, nu o singură dată la definirea funcției. Fiecare apel fără cos primește un array nou, deci rezultatele nu se acumulează. Aici JavaScript diferă de Python, unde un cos=[] implicit e creat o singură dată și împărțit între apeluri.

Alte reguli utile:

  • valoarea implicită poate folosi parametrii anteriori: function f(a, b = a * 2);
  • folosirea unui parametru ulterior aruncă eroare (TDZ): function f(a = b, b);
  • poți apela funcții: function f(id = genereazaId()), care rulează doar când e nevoie;
  • poți impune parametri obligatorii: function f(x = required("x")), unde required aruncă o eroare.

Combinat cu destructurarea, parametrii impliciți dau un stil curat pentru opțiuni:

JavaScript
function fetchDate(url, { timeout = 5000, reincercari = 2 } = {}) {
  // ...
}

Valoarea implicită = {} de la final permite apelul fetchDate(url) fără al doilea argument; fără ea, destructurarea lui undefined ar arunca TypeError. Parametrii cu valoare implicită nu sunt numărați în fn.length.

Ce urmărește intervievatorul: Intervievatorul verifică diferența dintre null și undefined la parametri și momentul evaluării. Candidații care vin din Python greșesc des partea cu array-ul implicit.

Eroarea, în practică:Cannot destructure property of undefined

25 Junior

În afară de this, prin ce diferă o arrow function de o funcție clasică? Ce afișează codul?

JavaScript
const creeaza = () => { id: 1 };
console.log(creeaza());

const Persoana = (nume) => { this.nume = nume; };
const p = new Persoana("Ana");

Răspuns scurt: Arrow functions nu au arguments, prototype și nu pot fi folosite cu new, iar acoladele după săgeată înseamnă bloc de cod. Primul log afișează undefined, iar new Persoana aruncă TypeError: Persoana is not a constructor.

Diferența cea mai cunoscută este că arrow functions preiau this din scope-ul exterior. Pe lângă asta, mai sunt câteva diferențe care apar la interviu:

  • nu au arguments: în interiorul unei arrow, arguments se referă la cel al funcției exterioare; pentru argumente variabile folosești rest parameters, (...args) => {};
  • nu pot fi constructori: nu au proprietatea prototype, iar new pe ele aruncă TypeError;
  • nu au super și new.target proprii;
  • nu pot fi generatoare: nu există sintaxă arrow pentru function*.

Primul exemplu arată o capcană de sintaxă. După săgeată, acoladele sunt interpretate ca bloc de cod, nu ca obiect literal. id: 1 devine o etichetă (label) urmată de expresia 1, iar funcția nu are return, deci întoarce undefined. Pentru a întoarce un obiect, îl pui în paranteze:

JavaScript
const creeaza = () => ({ id: 1 });

Când alegi fiecare tip:

  • arrow pentru callback-uri scurte (map, filter, then) și când vrei this din exterior, de exemplu într-un setTimeout din interiorul unei metode;
  • funcție clasică sau metodă pentru metodele obiectelor care trebuie să folosească propriul this, pentru constructori și pentru funcții care se bazează pe hoisting.

O arrow function definită ca metodă într-un obiect literal ({ salut: () => this.nume }) nu vede obiectul, ci this din jurul literalului.

Ce urmărește intervievatorul: Se verifică cunoașterea completă a diferențelor, nu doar regula despre this. Capcana cu obiectul literal fără paranteze apare frecvent în cod real.

Eroarea, în practică:x is not a constructor'arguments' is not allowed in class field

26 Junior

Ce înseamnă că în JavaScript funcțiile sunt „first-class”? Scrie o funcție cuLog(fn) care întoarce o variantă a lui fn ce afișează argumentele și rezultatul fiecărui apel.

Răspuns scurt: Funcțiile sunt valori: le poți pune în variabile, trimite ca argumente și întoarce din alte funcții. cuLog primește o funcție și întoarce o funcție nouă care o înfășoară, adică o funcție de ordin superior.

„First-class” înseamnă că funcțiile sunt tratate ca orice altă valoare. O funcție poate fi:

  • atribuită unei variabile sau pusă într-un array ori obiect;
  • transmisă ca argument (callback), ca în lista.map(dubleaza);
  • întoarsă ca rezultat din altă funcție;
  • îmbogățită cu proprietăți, pentru că este obiect (fn.name, fn.length).

O funcție care primește sau întoarce funcții se numește funcție de ordin superior. map, filter, addEventListener și setTimeout sunt exemple din limbaj. Un wrapper de logging ilustrează ideea fără să modifice funcția originală:

JavaScript
function cuLog(fn) {
  return function (...args) {
    console.log(`${fn.name || "anonimă"}(${args.join(", ")})`);
    const rezultat = fn.apply(this, args);
    console.log("=>", rezultat);
    return rezultat;
  };
}

function aduna(a, b) { return a + b; }
const adunaLog = cuLog(aduna);
adunaLog(2, 3); // aduna(2, 3) apoi => 5

Detaliile corecte: transmiți toate argumentele cu ...args, păstrezi this cu apply și întorci rezultatul, ca wrapper-ul să poată înlocui funcția originală oriunde. Același model stă la baza multor utilitare: măsurarea timpului de execuție, retry, cache, verificarea permisiunilor, debounce. Este și forma simplă a decoratorilor din alte limbaje: comportament adăugat în jurul unei funcții, fără să-i schimbi codul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi funcțiile ca valori și poți scrie un wrapper corect. Greșeala tipică este să uiți să întorci rezultatul sau să transmiți doar primul argument.

27 Junior

De ce codul de mai jos afișează undefined sau aruncă eroare și cum îl repari?

JavaScript
class Cronometru {
  constructor() { this.secunde = 0; }
  tick() {
    this.secunde++;
    console.log(this.secunde);
  }
}
const c = new Cronometru();
setInterval(c.tick, 1000);

Răspuns scurt: c.tick este transmisă ca funcție detașată, iar setInterval o apelează fără obiect, deci this nu mai este c. În clase (strict mode) this.secunde++ aruncă TypeError. Repari cu o arrow function, cu bind sau cu o metodă definită ca câmp arrow.

this nu ține de locul în care e definită metoda, ci de felul în care e apelată. c.tick() setează this la c. Însă c.tick fără paranteze este doar o referință la funcție. setInterval o păstrează și, după o secundă, o apelează ca funcție simplă, fără obiect în fața punctului.

Corpul unei clase rulează în strict mode, deci this devine undefined, iar this.secunde++ aruncă TypeError: Cannot read properties of undefined. În timerele din browser, this poate fi chiar window, iar codul ar crea în tăcere window.secunde cu valoarea NaN; rezultatul depinde de mediu, așa că bug-ul arată diferit de la caz la caz.

Trei reparații corecte:

JavaScript
setInterval(() => c.tick(), 1000);   // apel cu obiect
setInterval(c.tick.bind(c), 1000);   // this fixat permanent

class Cronometru {
  secunde = 0;
  tick = () => {                      // câmp arrow, legat de instanță
    this.secunde++;
  };
}

Aceeași problemă apare la addEventListener("click", obj.metoda), la destructurare (const { tick } = c) și când transmiți metode ca props. Câmpul arrow e comod, dar fiecare instanță primește propria copie a funcției, iar metoda nu mai e pe prototip, deci nu poate fi suprascrisă natural în subclase. Pentru listener-ele pe care trebuie să le scoți ulterior, păstrezi referința la funcția legată, ca să o poți da lui removeEventListener.

Ce urmărește intervievatorul: Se verifică dacă recunoști cel mai frecvent bug cu this într-un caz concret. Răspunsul bun explică cauza (apelul fără obiect), nu doar soluția.

Eroarea, în practică:this is not a Date object.PromiseResolve called on non-object

28 Junior

Scrie o funcție recursivă care calculează suma cifrelor unui număr. Ce este cazul de bază și ce se întâmplă dacă lipsește?

Răspuns scurt: Funcția se apelează pe o problemă mai mică și se oprește la cazul de bază: dacă n < 10 întorci n, altfel n % 10 plus suma cifrelor lui Math.floor(n / 10). Fără caz de bază primești RangeError: Maximum call stack size exceeded.

Recursivitatea împarte problema în: un caz de bază, care se rezolvă direct, și un pas recursiv, care reduce problema și se apelează din nou.

JavaScript
function sumaCifre(n) {
  n = Math.abs(n);
  if (n < 10) return n;                         // cazul de bază
  return (n % 10) + sumaCifre(Math.floor(n / 10)); // pasul recursiv
}
sumaCifre(4815); // 5 + 1 + 8 + 4 = 18

Fiecare apel se pune pe stiva de apeluri (call stack) și așteaptă rezultatul celui următor. Pentru 4815, stiva ajunge la patru niveluri, apoi rezultatele se adună la întoarcere.

Dacă lipsește cazul de bază sau pasul recursiv nu apropie problema de el (de exemplu sumaCifre(n / 10) fără Math.floor, unde n nu ajunge niciodată sub 10 ca întreg), apelurile continuă până se umple stiva. Motorul aruncă RangeError: Maximum call stack size exceeded. Adâncimea maximă depinde de motor și de dimensiunea cadrelor, de obicei câteva mii sau zeci de mii de apeluri, deci nu te baza pe ea pentru date mari.

Recursivitatea e naturală pentru structuri arborescente: DOM-ul, comentarii imbricate, foldere, JSON imbricat. Pentru calcule liniare pe date mari, o buclă e mai sigură:

JavaScript
function sumaCifreIterativ(n) {
  let s = 0;
  for (n = Math.abs(n); n > 0; n = Math.floor(n / 10)) s += n % 10;
  return s;
}

La interviu, spune întotdeauna explicit cazul de bază înainte să scrii pasul recursiv.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți gândi recursiv și dacă știi limita stivei. Greșeala tipică: un pas care nu micșorează problema, deci recursivitate infinită.

Eroarea, în practică:Maximum call stack size exceeded

29 Junior

Ce este o funcție pură? Care dintre funcțiile de mai jos este pură și de ce contează?

JavaScript
let taxa = 0.19;
function cuTva(pret) { return pret * (1 + taxa); }
function cuTva2(pret, taxa) { return pret * (1 + taxa); }
function adaugaInCos(cos, produs) { cos.push(produs); return cos; }
function adaugaInCos2(cos, produs) { return [...cos, produs]; }

Răspuns scurt: O funcție pură întoarce același rezultat pentru aceleași argumente și nu are efecte secundare. cuTva2 și adaugaInCos2 sunt pure; cuTva depinde de o variabilă externă, iar adaugaInCos modifică array-ul primit.

O funcție este pură dacă îndeplinește două condiții:

  • rezultatul depinde doar de argumente; aceleași intrări dau mereu aceeași ieșire;
  • nu are efecte secundare: nu modifică argumentele sau variabile externe, nu scrie în DOM, nu face cereri de rețea, nu afișează în consolă.

Analiza exemplului:

  • cuTva citește taxa din exterior. Dacă alt cod schimbă taxa, același apel cuTva(100) dă alt rezultat, deci nu e pură;
  • cuTva2 primește tot ce îi trebuie ca parametri, deci e pură;
  • adaugaInCos modifică array-ul primit (mutație). Orice altă parte a aplicației care ține o referință la același coș vede schimbarea, deci are un efect secundar;
  • adaugaInCos2 creează un array nou și lasă originalul neatins, deci e pură.

De ce contează:

  • testare ușoară: dai intrări, verifici ieșirea, fără mock-uri și fără pregătirea stării;
  • predictibilitate: poți citi funcția izolat, fără să cauți cine a mai modificat datele;
  • memoizare și cache sigure, pentru că rezultatul depinde doar de argumente;
  • framework-urile și store-urile care detectează schimbări prin comparația referințelor se bazează pe date noi în loc de mutație.

O aplicație reală are nevoie de efecte (DOM, rețea, stocare). Strategia bună este să ții logica de calcul în funcții pure și să împingi efectele la margini, în puține locuri clar delimitate.

Ce urmărește intervievatorul: Se verifică dacă poți identifica efectele secundare ascunse, mai ales mutația argumentelor. Mulți candidați consideră pură orice funcție care întoarce o valoare.

30 Mid

Ce afișează codul de mai jos și de ce?

JavaScript
const utilizator = {
  nume: "Ana",
  salutArrow: () => `Salut, ${this?.nume}`,
  salutMetoda() { return `Salut, ${this.nume}`; },
  salutIntarziat() {
    setTimeout(function () { console.log("function:", this?.nume); }, 0);
    setTimeout(() => console.log("arrow:", this.nume), 0);
  },
};
console.log(utilizator.salutArrow());
console.log(utilizator.salutMetoda());
utilizator.salutIntarziat();

Răspuns scurt: salutArrow afișează „Salut, undefined”, salutMetoda „Salut, Ana”, apoi „function: undefined” și „arrow: Ana”. Arrow-ul ia this din scope-ul în care e scris; funcția clasică primește this de la cel care o apelează.

Fiecare caz aplică altă regulă:

  • salutArrow este o arrow function definită într-un obiect literal. Un obiect literal nu creează scope pentru this, deci arrow-ul preia this de la nivelul exterior: undefined într-un modul ES, window într-un script clasic. În ambele cazuri nu e obiectul, iar this?.nume dă undefined, deci rezultatul e „Salut, undefined”.
  • salutMetoda e o metodă apelată ca utilizator.salutMetoda(). Regula apelului cu obiect setează this la utilizator, deci „Salut, Ana”.
  • În salutIntarziat, this este utilizator. Funcția clasică dată lui setTimeout este însă apelată de timer, fără obiect; în browser, this devine window, iar window.nume nu există, deci undefined. Arrow-ul din al doilea timer preia this din salutIntarziat, deci vede utilizator și afișează „Ana”.

Regula de reținut: arrow functions nu au this propriu, îl moștenesc lexical din funcția sau scope-ul în care sunt scrise, iar call, apply sau bind nu îl pot schimba. Funcțiile clasice primesc this la momentul apelului.

Aplicat în practică: folosești metode clasice (sintaxa scurtă metoda() {}) pentru metodele obiectelor și arrow functions pentru callback-urile din interiorul lor. Inversul, arrow ca metodă și funcție clasică drept callback, produce exact bug-urile de mai sus.

Ce urmărește intervievatorul: Intervievatorul verifică dacă aplici regulile pentru this în combinații, nu doar în cazul simplu. Capcana obișnuită este arrow-ul definit direct în obiectul literal.

31 Mid

Scrie o funcție curry(fn) care transformă o funcție cu mai mulți parametri într-una care poate fi apelată parțial: curry(aduna3)(1)(2)(3), dar și curry(aduna3)(1, 2)(3).

Răspuns scurt: Folosești fn.length pentru numărul de parametri: dacă s-au strâns destule argumente, apelezi fn; altfel întorci o funcție care mai acceptă argumente și le adaugă la cele existente.

Currying înseamnă transformarea unei funcții f(a, b, c) într-un șir de funcții care primesc argumentele pe rând. Varianta practică acceptă oricâte argumente la un pas:

JavaScript
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    }
    return function (...urmatoare) {
      return curried.apply(this, [...args, ...urmatoare]);
    };
  };
}

const aduna3 = (a, b, c) => a + b + c;
const c = curry(aduna3);
c(1)(2)(3);   // 6
c(1, 2)(3);   // 6
c(1)(2, 3);   // 6

Cheia este fn.length, numărul de parametri declarați. Fiecare apel parțial creează un closure nou cu argumentele adunate până atunci, deci rezultatele intermediare se pot refolosi fără să interfereze: const plus10 = c(4, 6) poate fi apelat de mai multe ori.

Limitări pe care merită să le spui:

  • fn.length nu numără parametrii cu valoare implicită și nici rest parameters, deci pentru (a, b = 1) => ... lungimea e 1, iar curry apelează funcția prea devreme;
  • funcțiile variadice au nevoie de un număr explicit: curry(fn, aritate);
  • abuzul face codul greu de citit.

Utilizări reale: configurarea treptată a unei funcții (const logEroare = log("eroare")), crearea de funcții specializate pentru map sau filter și combinarea cu pipe. Aplicarea parțială simplă, cu fn.bind(null, a), acoperă des aceeași nevoie.

Ce urmărește intervievatorul: Se verifică stăpânirea closure-urilor, a lui fn.length și a argumentelor variabile. Candidații uită adesea cazul în care se dau mai multe argumente într-un singur apel.

32 Mid

Implementează funcțiile pipe(...fns) și compose(...fns). Folosește-le pentru a transforma un text de forma " Salut Lume " în slug-ul "salut-lume".

Răspuns scurt: pipe aplică funcțiile de la stânga la dreapta, compose de la dreapta la stânga; ambele se scriu cu reduce, rezultatul fiecărei funcții devenind intrarea următoarei.

Compunerea funcțiilor construiește o transformare din pași mici, fiecare pur și testabil separat:

JavaScript
const pipe = (...fns) => (valoare) => fns.reduce((acc, fn) => fn(acc), valoare);
const compose = (...fns) => (valoare) => fns.reduceRight((acc, fn) => fn(acc), valoare);

const trim = (s) => s.trim();
const litereMici = (s) => s.toLowerCase();
const cratime = (s) => s.split(/\s+/).join("-");

const slug = pipe(trim, litereMici, cratime);
slug("  Salut Lume  "); // "salut-lume"

const slug2 = compose(cratime, litereMici, trim); // același rezultat

pipe se citește în ordinea execuției, de aceea e preferat în cod de aplicație. compose urmează notația matematică f(g(x)) și apare în biblioteci funcționale mai vechi.

Detalii de discutat:

  • fiecare funcție primește un singur argument. Funcțiile cu mai mulți parametri se adaptează prin currying sau prin arrow functions: (s) => s.replace(/[^a-z-]/g, "");
  • pentru funcții asincrone ai nevoie de altă variantă, care așteaptă fiecare pas:
JavaScript
const pipeAsync = (...fns) => (x) =>
  fns.reduce((p, fn) => p.then(fn), Promise.resolve(x));
  • depanarea e mai dificilă decât la cod imperativ; un pas ajutător const tap = (fn) => (x) => (fn(x), x) permite inserarea unui console.log fără să schimbi valoarea.

Un slug real pentru texte în română elimină și diacriticele, cu normalize("NFD") și ștergerea semnelor combinate, pas ușor de adăugat în pipeline.

Ce urmărește intervievatorul: Intervievatorul verifică folosirea lui reduce cu funcții ca valori și înțelegerea ordinii de aplicare. Răspunsul bun menționează și varianta asincronă.

33 Mid

Ce afișează codul de mai jos? Explică ordinea de prioritate a regulilor pentru this.

JavaScript
function arata() { return this.x; }
const legat = arata.bind({ x: 1 });
const legatDinNou = legat.bind({ x: 2 });

console.log(legatDinNou());
console.log(legat.call({ x: 3 }));

function Punct(x) { this.x = x; }
const PunctLegat = Punct.bind({ x: 99 });
console.log(new PunctLegat(5).x);

Răspuns scurt: Afișează 1, 1 și 5. O funcție legată cu bind nu mai poate fi relegată nici cu bind, nici cu call; doar new are prioritate peste bind și creează un obiect nou ca this.

bind întoarce o funcție nouă (bound function) care ține minte this și eventualele argumente fixate. La apel, ea cheamă funcția originală cu acel this, ignorând orice this primit. Așadar:

  • legatDinNou este un bind peste o funcție deja legată. Noul this ({ x: 2 }) se aplică funcției legate, care îl ignoră și folosește { x: 1 }. Rezultat: 1;
  • legat.call({ x: 3 }) este ignorat la fel. Rezultat: 1;
  • new PunctLegat(5) este excepția: operatorul new are prioritate peste bind. Se creează un obiect nou, care devine this, iar { x: 99 } e ignorat. Argumentele fixate cu bind se păstrează totuși. Rezultat: 5.

Ordinea de prioritate, de la cea mai puternică:

  • new Fn(): this este obiectul nou creat;
  • funcția legată cu bind: this e cel fixat;
  • apel explicit cu call sau apply;
  • apel ca metodă, obj.fn(): this este obj;
  • apel simplu, fn(): undefined în strict mode, obiectul global altfel.

Arrow functions stau în afara listei: nu au this propriu, deci nici new, nici bind nu le afectează.

Consecința practică: dacă primești o funcție deja legată (de exemplu un handler dintr-o bibliotecă), nu îi poți schimba this din exterior. Trebuie să o înfășori sau să ceri funcția nelegată.

Ce urmărește intervievatorul: Se verifică înțelegerea completă a regulilor pentru this, inclusiv cazurile-limită. Mulți candidați cred că al doilea bind suprascrie primul.

Eroarea, în practică:Bind must be called on a function

34 Senior

O funcție recursivă care parcurge o structură foarte adâncă (de exemplu un arbore de categorii sau un JSON imbricat) aruncă Maximum call stack size exceeded în producție. Cum o rescrii?

Răspuns scurt: Înlocuiești stiva de apeluri cu o stivă explicită (array) într-o buclă, sau folosești un trampolin. Tail call optimization nu este o soluție portabilă: specificația o cere din ES2015, dar doar motorul din Safari o implementează.

Stiva de apeluri are o dimensiune limitată, iar fiecare nivel de recursivitate ocupă un cadru. Datele construite de utilizatori (comentarii imbricate, structuri importate) pot depăși adâncimea pe care ai testat-o.

Soluția cea mai robustă este o stivă explicită pe heap, unde dimensiunea e limitată doar de memorie:

JavaScript
function sumaValori(radacina) {
  let suma = 0;
  const stiva = [radacina];
  while (stiva.length > 0) {
    const nod = stiva.pop();
    suma += nod.valoare;
    for (const copil of nod.copii ?? []) stiva.push(copil);
  }
  return suma;
}

Cu pop obții o parcurgere în adâncime (DFS); folosind o coadă obții una în lățime (BFS). Dacă ordinea contează, pui copiii pe stivă în ordine inversă.

A doua variantă este un trampolin: funcția recursivă întoarce o funcție (următorul pas) în loc să se apeleze direct, iar o buclă le rulează una după alta. Stiva nu crește, dar codul devine mai greu de citit.

Despre tail call optimization: ES2015 cere ca un apel aflat pe ultima poziție (return f(x)) să nu adauge un cadru. În practică, doar JavaScriptCore (Safari) implementează asta; V8 și SpiderMonkey nu o fac, deci nu te poți baza pe ea în Chrome, Firefox sau Node.js.

Ca măsură defensivă, pentru date externe pui o limită de adâncime și raportezi o eroare clară, ceea ce previne și atacurile cu structuri imbricate intenționat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi transforma recursivitatea în iterație și dacă știi statutul real al TCO. Răspunsul slab propune doar mărirea stivei.

Eroarea, în practică:Maximum call stack size exceeded

Obiecte, prototipuri și clase

35 Junior

Ce afișează codul de mai jos? Cum funcționează cheile unui obiect?

JavaScript
const obj = {};
const a = { id: 1 };
const b = { id: 2 };
obj[a] = "primul";
obj[b] = "al doilea";
obj[1] = "unu";
console.log(obj[a]);
console.log(obj["1"]);
console.log(Object.keys(obj));

Răspuns scurt: Afișează "al doilea", "unu" și ["1", "[object Object]"]. Cheile obiectelor sunt string-uri sau simboluri, deci obiectele folosite drept cheie devin "[object Object]" și se suprascriu, iar 1 și "1" sunt aceeași cheie.

Un obiect simplu acceptă doar două tipuri de chei: string și symbol. Orice altă valoare folosită între paranteze drepte este convertită la string:

  • obj[a] devine obj["[object Object]"], iar obj[b] devine aceeași cheie, deci a doua atribuire o suprascrie pe prima. Citirea obj[a] dă "al doilea";
  • obj[1] devine obj["1"], deci cele două forme sunt echivalente;
  • Object.keys întoarce string-uri. Cheile care arată ca numere întregi apar primele, în ordine crescătoare, iar celelalte urmează în ordinea inserării.

Accesul cu punct, obj.nume, merge doar pentru nume valide de identificatori. Parantezele drepte sunt necesare pentru chei dinamice, cu spații sau cratime: obj[camp], obj["data-id"]. Tot ele permit computed property names în obiectele literale:

JavaScript
const camp = "email";
const formular = { [camp]: "ana@exemplu.ro", [`${camp}Valid`]: true };

Dacă ai nevoie de obiecte ca chei, folosești Map, care păstrează referința exactă:

JavaScript
const m = new Map();
m.set(a, "primul").set(b, "al doilea");
m.get(a); // "primul"

Capcana apare des când se construiește un „index” după obiecte sau după date de tip Date, care devin string-uri lungi și pot coincide neașteptat.

Ce urmărește intervievatorul: Se verifică dacă știi că cheile se convertesc la string. Greșeala tipică este folosirea obiectelor drept chei într-un obiect simplu în loc de Map.

36 Junior

Care e diferența dintre for...in, Object.keys, Object.values și Object.entries? De ce poate for...in să afișeze chei la care nu te aștepți?

Răspuns scurt: for...in parcurge cheile enumerabile proprii și moștenite prin prototip; Object.keys, values și entries întorc doar cheile proprii enumerabile, ca array-uri. De aceea for...in poate prinde proprietăți adăugate pe prototip.

Cele patru moduri par echivalente pe un obiect simplu, dar diferă:

  • for (const k in obj) parcurge cheile string enumerabile ale obiectului și ale prototipurilor lui;
  • Object.keys(obj) întoarce un array cu cheile proprii enumerabile;
  • Object.values(obj) întoarce valorile lor;
  • Object.entries(obj) întoarce perechi [cheie, valoare], ideale pentru destructurare.
JavaScript
const baza = { tip: "produs" };
const p = Object.create(baza);
p.nume = "laptop";

for (const k in p) console.log(k); // "nume", "tip"
Object.keys(p);                     // ["nume"]

for (const [cheie, valoare] of Object.entries(p)) {
  console.log(cheie, valoare);
}

Cheile moștenite apar în for...in când lucrezi cu obiecte create prin Object.create, cu instanțe ale unor clase vechi, construite cu funcții constructor, sau când o bibliotecă a adăugat proprietăți pe Object.prototype (practică proastă, dar existentă). De aceea codul vechi arată mereu așa: if (Object.hasOwn(obj, k)).

Alte observații:

  • niciuna dintre metode nu include cheile de tip symbol; pentru ele există Object.getOwnPropertySymbols sau Reflect.ownKeys;
  • for...in pe array-uri e o greșeală: cheile sunt string-uri, iar ordinea și proprietățile suplimentare pot surprinde; pentru array-uri folosești for...of sau metodele de array;
  • Object.fromEntries face operația inversă, util pentru transformări: Object.fromEntries(Object.entries(pret).map(([k, v]) => [k, v * 1.19])).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi de proprietățile moștenite și alegi metoda potrivită. Mulți candidați folosesc for...in pe array-uri.

Eroarea, în practică:Cannot convert undefined or null to objectfor-of loop: Must have a single binding

37 Junior

Ce afișează codul de mai jos? JavaScript transmite argumentele prin valoare sau prin referință?

JavaScript
function schimba(produs, lista) {
  produs.pret = 50;
  lista = ["nou"];
}
const p = { pret: 100 };
const l = ["vechi"];
schimba(p, l);
console.log(p.pret, l);
console.log({ a: 1 } === { a: 1 });

Răspuns scurt: Afișează 50 ["vechi"] și false. JavaScript transmite întotdeauna valoarea, iar pentru obiecte valoarea este o referință: poți modifica obiectul primit, dar reasignarea parametrului nu schimbă variabila apelantului.

Termenul precis este pass by sharing: parametrul primește o copie a valorii argumentului. Pentru primitive, copia este valoarea însăși. Pentru obiecte și array-uri, copia este o referință către același obiect din memorie.

Consecințele se văd în exemplu:

  • produs.pret = 50 modifică obiectul spre care arată ambele referințe (p din exterior și produs din funcție), deci schimbarea e vizibilă în afară;
  • lista = ["nou"] face ca parametrul local să arate spre un array nou. Variabila l din exterior arată în continuare spre array-ul vechi, deci rămâne ["vechi"].

Dacă JavaScript ar transmite prin referință, ca ref din C#, reasignarea ar fi schimbat și l. Nu se întâmplă asta.

Comparația { a: 1 } === { a: 1 } dă false, pentru că === pe obiecte compară referințele, nu conținutul. Două literale creează două obiecte distincte. Pentru egalitate de conținut scrii o comparație explicită sau folosești o funcție de deep equal din bibliotecile de testare.

Implicația practică: o funcție care primește un obiect și îl modifică produce efecte în alte părți ale aplicației, care țin aceeași referință. Dacă funcția trebuie să întoarcă o variantă modificată, creezi un obiect nou:

JavaScript
function cuReducere(produs) {
  return { ...produs, pret: produs.pret * 0.9 };
}

Ce urmărește intervievatorul: Se verifică modelul mental corect pentru parametri. Greșeala clasică este răspunsul „obiectele se transmit prin referință”, contrazis de reasignarea care nu se propagă.

38 Junior

Ce pierde JSON.stringify din obiectul de mai jos? Cum readuci o dată calendaristică la tipul Date după JSON.parse?

JavaScript
const comanda = {
  id: 7,
  nota: undefined,
  calculeaza() { return 1; },
  creata: new Date("2026-10-31T10:00:00Z"),
  etichete: new Set(["urgent"]),
  reducere: NaN,
};
console.log(JSON.stringify(comanda));

Răspuns scurt: Rezultatul e {"id":7,"creata":"2026-10-31T10:00:00.000Z","etichete":{},"reducere":null}: dispar undefined și funcțiile, Date devine string, Set devine obiect gol, NaN devine null. La parse folosești un reviver care transformă string-urile de dată în Date.

JSON are doar string, number, boolean, null, array și obiect. JSON.stringify adaptează tot restul:

  • proprietățile cu undefined, funcții sau simboluri dispar din obiecte; în array-uri devin null;
  • NaN și Infinity devin null;
  • Date are metoda toJSON, care întoarce un string ISO;
  • Map și Set nu au proprietăți enumerabile, deci devin {};
  • BigInt aruncă TypeError;
  • referințele circulare aruncă TypeError: Converting circular structure to JSON.

La JSON.parse, data rămâne string. Un reviver o readuce la tipul corect:

JavaScript
const text = JSON.stringify(comanda);
const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
const inapoi = JSON.parse(text, (cheie, valoare) =>
  typeof valoare === "string" && ISO.test(valoare) ? new Date(valoare) : valoare
);
inapoi.creata instanceof Date; // true

Pentru Set și Map convertești explicit la array înainte: un replacer care întoarce [...valoare] pentru Set, sau Object.fromEntries(map).

Alte opțiuni utile: al doilea argument poate fi un array cu cheile permise (JSON.stringify(user, ["id", "nume"])), bun pentru a nu loga date sensibile, iar al treilea dă indentarea (JSON.stringify(obj, null, 2)).

De aceea, un „deep copy” cu JSON.parse(JSON.stringify(x)) strică datele; pentru copiere există structuredClone.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce date se pierd la serializare, sursă frecventă de bug-uri cu API-uri și localStorage. Mulți candidați nu știu de reviver.

39 Junior

Scrie o clasă ContBancar cu sold inițial, metodele depune și retrage, un getter sold și o metodă statică dinJSON. Retragerea peste sold trebuie să arunce o eroare.

Răspuns scurt: Clasa ține soldul într-un câmp privat, validează sumele în metode și expune soldul doar prin getter. dinJSON este statică pentru că creează o instanță nouă și nu ține de un cont existent.

O implementare care arată folosirea corectă a sintaxei moderne:

JavaScript
class ContBancar {
  #sold;

  constructor(titular, soldInitial = 0) {
    if (soldInitial < 0) throw new RangeError("Soldul inițial nu poate fi negativ");
    this.titular = titular;
    this.#sold = soldInitial;
  }

  get sold() {
    return this.#sold;
  }

  depune(suma) {
    this.#verificaSuma(suma);
    this.#sold += suma;
    return this;
  }

  retrage(suma) {
    this.#verificaSuma(suma);
    if (suma > this.#sold) throw new Error("Fonduri insuficiente");
    this.#sold -= suma;
    return this;
  }

  #verificaSuma(suma) {
    if (!Number.isFinite(suma) || suma <= 0) throw new RangeError("Sumă invalidă");
  }

  static dinJSON({ titular, sold }) {
    return new ContBancar(titular, sold);
  }
}

const cont = new ContBancar("Ana", 100).depune(50).retrage(30);
console.log(cont.sold); // 120

Ce urmărește intervievatorul:

  • încapsularea: #sold nu poate fi modificat din afară; getter-ul fără setter face proprietatea read-only, iar o atribuire cont.sold = 1 e ignorată, sau aruncă TypeError în strict mode;
  • validarea centralizată într-o metodă privată;
  • return this permite înlănțuirea apelurilor;
  • static pentru o metodă de fabricare (factory) care aparține clasei, nu instanței;
  • erori cu tipul potrivit (RangeError pentru valori în afara intervalului).

Pentru bani reali, suma se ține în unități întregi (bani), ca să eviți erorile de virgulă mobilă.

Ce urmărește intervievatorul: Se verifică stăpânirea sintaxei de clase și gândirea despre încapsulare și validare. Răspunsurile slabe lasă soldul public și nu validează intrările.

Eroarea, în practică:Cannot set property which has only a getterGetter must not have any formal parameters

40 Junior

Care e diferența dintre un câmp privat #sold și convenția _sold? Ce afișează codul?

JavaScript
class Cont {
  #sold = 100;
  _istoric = [];
  static esteCont(obj) { return #sold in obj; }
}
const c = new Cont();
console.log(c._istoric);
console.log(Cont.esteCont(c), Cont.esteCont({}));
console.log(Object.keys(c));

Răspuns scurt: #sold este privat la nivel de limbaj: inaccesibil și invizibil în afara clasei. _sold e doar o convenție, o proprietate publică obișnuită. Codul afișează [], apoi true false, apoi ["_istoric"].

Prefixul _ este o convenție veche care înseamnă „nu folosi din afară”, dar nu impune nimic. Proprietatea e publică, apare în Object.keys, în JSON.stringify și poate fi modificată de oricine.

Câmpurile cu # (ES2022) sunt private la nivel de limbaj:

  • accesul c.#sold în afara corpului clasei este SyntaxError, detectat înainte de rulare;
  • nu apar în Object.keys, for...in, JSON.stringify sau Reflect.ownKeys;
  • nu pot fi șterse sau adăugate dinamic; trebuie declarate în corpul clasei;
  • sunt private pentru clasă, nu pentru obiect: o metodă a clasei poate citi alt.#sold al altei instanțe, util la comparații.

Expresia #sold in obj (ES2022) verifică dacă obiectul are câmpul privat, adică dacă a fost construit de această clasă. Este o verificare mai sigură decât instanceof, care poate fi păcălită prin schimbarea prototipului.

Limitări:

  • subclasele nu au acces la câmpurile private ale părintelui; dacă vrei acces „protected”, expui un getter sau păstrezi convenția _;
  • accesul la this.#x pe un obiect care nu are câmpul aruncă TypeError, de exemplu când o metodă e apelată cu alt this;
  • unele unelte vechi și proxy-uri nu le pot intercepta.

Alege # pentru starea internă care trebuie protejată (soldul, token-uri, cache-uri), iar proprietățile publice pentru date pe care codul exterior le folosește legitim.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre convenție și încapsulare reală. Puțini candidați știu de verificarea #x in obj și de lipsa accesului din subclase.

Eroarea, în practică:Private field must be declared in enclosing classCannot read private member #sold from an object

41 Mid

Ce se întâmplă la rularea codului de mai jos? Cum îl repari și cum apelezi metoda părintelui dintr-o metodă suprascrisă?

JavaScript
class Animal {
  constructor(nume) { this.nume = nume; }
  descrie() { return `${this.nume} este un animal`; }
}
class Caine extends Animal {
  constructor(nume, rasa) {
    this.rasa = rasa;
    super(nume);
  }
  descrie() { return `${this.nume} este un câine ${this.rasa}`; }
}
new Caine("Rex", "ciobănesc");

Răspuns scurt: Aruncă ReferenceError, pentru că într-o clasă derivată this nu există până la apelul super(). Muți super(nume) pe prima linie a constructorului; metoda părintelui o apelezi cu super.descrie().

Într-o clasă derivată (extends), obiectul este creat de constructorul părintelui. Până nu apelezi super(...), this nu e inițializat, iar orice acces la el aruncă ReferenceError: Must call super constructor in derived class before accessing 'this'. Aceeași eroare apare dacă un constructor derivat se termină fără să apeleze super și fără să întoarcă un obiect.

Varianta corectă, care refolosește și logica părintelui:

JavaScript
class Caine extends Animal {
  constructor(nume, rasa) {
    super(nume);          // inițializează partea de Animal
    this.rasa = rasa;
  }
  descrie() {
    return `${super.descrie()}, rasa ${this.rasa}`;
  }
}
new Caine("Rex", "ciobănesc").descrie();
// "Rex este un animal, rasa ciobănesc"

Reguli de reținut:

  • dacă subclasa nu are constructor, se generează implicit unul care transmite toate argumentele: constructor(...args) { super(...args); };
  • super.metoda() caută metoda pe prototipul părintelui și o apelează cu this-ul curent; funcționează și în metode statice;
  • câmpurile de clasă ale subclasei (rasa = "necunoscută") se inițializează imediat după super(), deci nu sunt disponibile în constructorul părintelui;
  • dacă părintele apelează în constructor o metodă suprascrisă de subclasă, aceasta rulează înainte ca subclasa să-și fi inițializat câmpurile, sursă de bug-uri cu valori undefined.

Suprascrierea plus super.metoda() e varianta potrivită când extinzi comportamentul. Dacă o înlocuiești complet, merită verificat dacă moștenirea mai are sens.

Ce urmărește intervievatorul: Se verifică ordinea inițializării în clasele derivate. Greșeala tipică este folosirea lui this înainte de super(), mai ales la refactorizări.

Eroarea, în practică:Must call super constructor in derived class'super' keyword unexpected here

42 Mid

Ce face operatorul new pas cu pas? Scrie o funcție creeaza(Constructor, ...args) care îl imită.

Răspuns scurt: new creează un obiect gol cu prototipul Constructor.prototype, apelează constructorul cu acest obiect ca this și întoarce obiectul, cu excepția cazului în care constructorul întoarce explicit alt obiect.

Pentru o funcție constructor sau o clasă, new F(...args) face patru pași:

  • creează un obiect nou;
  • îi setează prototipul la F.prototype, astfel încât metodele definite acolo să fie accesibile;
  • apelează F cu obiectul nou ca this și cu argumentele primite;
  • dacă F întoarce un obiect (inclusiv funcție sau array), acela este rezultatul; dacă întoarce o primitivă sau nimic, rezultatul este obiectul creat.

Implementarea pentru funcții constructor clasice:

JavaScript
function creeaza(Constructor, ...args) {
  const obj = Object.create(Constructor.prototype);
  const rezultat = Constructor.apply(obj, args);
  return rezultat !== null && (typeof rezultat === "object" || typeof rezultat === "function")
    ? rezultat
    : obj;
}

function Produs(nume, pret) {
  this.nume = nume;
  this.pret = pret;
}
Produs.prototype.cuTva = function () { return this.pret * 1.19; };

const p = creeaza(Produs, "carte", 50);
p.cuTva();             // 59.5
p instanceof Produs;   // true

Limitări: imitația nu merge pentru clase ES2015, care aruncă TypeError dacă sunt apelate fără new, și nu setează new.target. Pentru clase, echivalentul fidel este Reflect.construct(Clasa, args).

Exercițiul arată de ce uitarea lui new la o funcție constructor veche e un bug periculos: în modul non-strict, this devine obiectul global, iar this.nume = nume creează variabile globale. Clasele rezolvă asta, deoarece refuză apelul fără new.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea legăturii dintre constructor, prototype și instanță. Mulți candidați uită regula cu obiectul întors explicit.

Eroarea, în practică:Class constructor cannot be invoked without 'new'x is not a constructor

43 Mid

Explică ce afișează codul și cum funcționează căutarea unei proprietăți pe lanțul de prototipuri.

JavaScript
const baza = { salut() { return "salut"; }, tip: "baza" };
const copil = Object.create(baza);
copil.tip = "copil";

console.log(copil.salut());
console.log(copil.tip, baza.tip);
console.log("salut" in copil, Object.hasOwn(copil, "salut"));

const gol = Object.create(null);
console.log(typeof gol.toString);

Răspuns scurt: Afișează "salut", "copil baza", true false și undefined. Proprietatea se caută întâi pe obiect, apoi pe prototip, până la null; atribuirea creează proprietatea pe obiect și o umbrește pe cea moștenită.

Fiecare obiect are o legătură internă [[Prototype]], pe care o citești cu Object.getPrototypeOf(obj). La citirea obj.x, motorul caută x pe obiect; dacă nu o găsește, continuă pe prototip, apoi pe prototipul prototipului, până la null. Dacă nu o găsește nicăieri, rezultatul e undefined.

În exemplu:

  • copil.salut() nu există pe copil, se găsește pe baza și rulează cu this === copil;
  • copil.tip = "copil" nu modifică baza: atribuirea creează o proprietate proprie pe copil care o umbrește pe cea moștenită. Excepție: dacă pe prototip proprietatea e un setter sau e read-only, se aplică regulile acelora;
  • in caută în tot lanțul, deci true; Object.hasOwn (ES2022) verifică doar proprietățile proprii, deci false. Varianta veche, obj.hasOwnProperty(k), eșuează pe obiecte fără prototip;
  • Object.create(null) creează un obiect fără prototip, deci fără toString, hasOwnProperty sau constructor.

Obiectele fără prototip sunt utile ca dicționare: o cheie venită de la utilizator, precum "constructor" sau "__proto__", nu se ciocnește cu proprietăți moștenite. Pentru dicționare, Map este de obicei alegerea mai bună.

Lanțul explică și de ce metodele puse pe prototip sunt partajate de toate instanțele: o singură funcție în memorie, nu câte una per obiect. Un lanț foarte lung încetinește căutările, motiv pentru care ierarhiile adânci de moștenire nu sunt recomandate.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului de lookup și a diferenței dintre citire și atribuire. Candidații confundă des in cu hasOwn.

Eroarea, în practică:Object prototype may only be an Object or nullCyclic __proto__ value

44 Mid

Care e diferența dintre Object.freeze, Object.seal și Object.preventExtensions? Scrie o funcție deepFreeze.

Răspuns scurt: preventExtensions interzice adăugarea de proprietăți; seal interzice și ștergerea; freeze interzice și modificarea valorilor. Toate acționează doar pe primul nivel, deci deepFreeze aplică freeze recursiv pe obiectele imbricate.

Cele trei funcții blochează obiectul în grade diferite:

  • Object.preventExtensions(obj): nu se mai pot adăuga proprietăți noi; cele existente pot fi modificate și șterse;
  • Object.seal(obj): în plus, proprietățile nu mai pot fi șterse sau reconfigurate; valorile se pot schimba;
  • Object.freeze(obj): în plus, valorile nu mai pot fi modificate. Obiectul devine read-only.

Verifici starea cu Object.isExtensible, Object.isSealed, Object.isFrozen. În strict mode, încălcările aruncă TypeError; în modul non-strict sunt ignorate în tăcere, deci bug-ul poate trece neobservat.

Toate sunt superficiale: un obiect imbricat rămâne modificabil.

JavaScript
function deepFreeze(obj) {
  for (const cheie of Reflect.ownKeys(obj)) {
    const valoare = obj[cheie];
    if (valoare && typeof valoare === "object" && !Object.isFrozen(valoare)) {
      deepFreeze(valoare);
    }
  }
  return Object.freeze(obj);
}

const config = deepFreeze({ api: { url: "/v1" }, limite: [10, 20] });
config.api.url = "/v2";   // ignorat sau TypeError în strict mode

Verificarea isFrozen previne bucla infinită la referințe circulare. Reflect.ownKeys include și cheile simbol.

Limitări: Map, Set și Date înghețate pot fi încă modificate prin metodele lor (map.set funcționează), pentru că datele lor interne nu sunt proprietăți. Înghețarea are un cost mic, dar se folosește de obicei pentru constante, configurație sau în modul de dezvoltare, ca să prinzi mutațiile accidentale ale stării.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că freeze e superficial și diferențele dintre cele trei niveluri. Puțini menționează excepția pentru Map și Set.

Eroarea, în practică:Cannot assign to read only propertyCannot add property, object is not extensible

45 Mid

Ce sunt descriptorii de proprietate? Ce afișează codul de mai jos?

JavaScript
const produs = { nume: "carte" };
Object.defineProperty(produs, "id", { value: 42 });
produs.id = 7;
console.log(produs.id);
console.log(Object.keys(produs));
console.log(JSON.stringify(produs));
console.log(Object.getOwnPropertyDescriptor(produs, "nume"));

Răspuns scurt: Afișează 42, ["nume"], {"nume":"carte"} și { value: "carte", writable: true, enumerable: true, configurable: true }. defineProperty pune implicit writable, enumerable și configurable pe false, deci id e ascuns și read-only.

Fiecare proprietate are un descriptor care o descrie complet. Există două forme:

  • data descriptor: value, writable (se poate modifica), enumerable (apare la parcurgere), configurable (se poate șterge sau reconfigura);
  • accessor descriptor: get și set în loc de value și writable, plus enumerable și configurable.

Proprietățile create prin atribuire obișnuită sau în obiecte literale au toate cele trei atribute true. Cele create cu Object.defineProperty au implicit toate atributele false. Asta explică rezultatul:

  • produs.id = 7 e ignorat, pentru că writable e false (în strict mode ar arunca TypeError);
  • id nu apare în Object.keys și nici în JSON, pentru că enumerable e false;
  • nu poate fi șters sau redefinit, pentru că configurable e false.

Un exemplu cu getter calculat:

JavaScript
Object.defineProperty(produs, "pretCuTva", {
  get() { return this.pret * 1.19; },
  enumerable: true,
});

Unde se folosesc descriptorii în practică:

  • metodele claselor sunt definite pe prototip ca ne-enumerabile, de aceea nu apar în for...in;
  • bibliotecile ascund câmpuri tehnice sau creează constante care nu pot fi suprascrise;
  • Object.freeze setează writable și configurable la false pe toate proprietățile;
  • Object.getOwnPropertyDescriptors împreună cu Object.defineProperties permit copierea unui obiect cu tot cu getteri și setteri, pe care spread-ul îi pierde (spread-ul copiază doar valoarea calculată).

Ce urmărește intervievatorul: Se verifică înțelegerea modelului intern al proprietăților și a valorilor implicite ale lui defineProperty. Mulți candidați nu știu de ce o proprietate definită așa nu apare în JSON.

Eroarea, în practică:Cannot assign to read only propertyCannot redefine property: id

46 Senior

Ai o ierarhie de clase Angajat, Manager, Programator, iar acum trebuie adăugate comportamente transversale: unii angajați lucrează remote, unii sunt formatori, unii au ambele roluri. Cum modelezi asta: moștenire sau compoziție?

Răspuns scurt: Compoziție: comportamentele independente devin obiecte sau funcții separate care se combină, în loc de subclase pentru fiecare combinație. Moștenirea rămâne pentru relații stabile de tip „este un”.

Cu moștenire, fiecare combinație cere o clasă nouă: ManagerRemote, ProgramatorFormator, ProgramatorRemoteFormator. Numărul de clase crește combinatoric, iar o schimbare în bază se propagă peste tot (problema clasei de bază fragile). JavaScript are și moștenire simplă: o clasă poate extinde doar una.

Compoziția construiește obiectul din capabilități independente:

JavaScript
const lucruRemote = (o) => ({
  ...o,
  orarFlexibil: true,
  programeazaApel(zi) { return `${o.nume}: apel ${zi}`; },
});

const formator = (o) => ({
  ...o,
  sesiuni: [],
  adaugaSesiune(t) { this.sesiuni.push(t); },
});

const angajat = (nume, rol) => ({ nume, rol });
const ana = formator(lucruRemote(angajat("Ana", "programator")));

O variantă orientată pe clase este injectarea colaboratorilor: new Angajat(nume, { program: new ProgramRemote(), formare: new Formare() }). Clasa delegă către aceste obiecte, care se pot înlocui sau testa separat.

Criterii de decizie:

  • moștenirea e potrivită pentru relații stabile, cu puține niveluri, când subclasa chiar respectă contractul părintelui (principiul substituției Liskov);
  • compoziția e preferată pentru comportamente opționale, combinabile sau care se schimbă în timp;
  • mixin-urile aplicate pe clase (class X extends Remote(Formator(Angajat))) funcționează, dar ascund originea metodelor și pot produce coliziuni de nume.

Atenție la spread în exemplul funcțional: getterii sunt copiați ca valori, iar metodele care folosesc o din closure nu văd modificările ulterioare. Pentru starea partajată e mai sigur obiectul delegat.

Ce urmărește intervievatorul: Intervievatorul verifică judecata de design și argumentarea compromisurilor, nu sintaxa. Răspunsul slab propune o subclasă pentru fiecare combinație.

47 Senior

Desenează lanțul de prototipuri pentru codul de mai jos. Ce afișează fiecare linie?

JavaScript
class Animal {
  static creeaza() { return new this(); }
  vorbeste() { return "..."; }
}
class Pisica extends Animal {}
const tom = new Pisica();

console.log(Object.getPrototypeOf(tom) === Pisica.prototype);
console.log(Object.getPrototypeOf(Pisica.prototype) === Animal.prototype);
console.log(Object.getPrototypeOf(Pisica) === Animal);
console.log(Pisica.creeaza() instanceof Pisica);
console.log(tom.constructor === Pisica);

Răspuns scurt: Toate liniile afișează true. extends leagă două lanțuri: cel al instanțelor (Pisica.prototype moștenește Animal.prototype) și cel al constructorilor (Pisica moștenește Animal), de aceea metodele statice se moștenesc, iar this din creeaza este Pisica.

class Pisica extends Animal setează două legături de prototip:

  • lanțul instanțelor: tom → Pisica.prototype → Animal.prototype → Object.prototype → null. De aici vin metodele de instanță: tom.vorbeste() se găsește pe Animal.prototype;
  • lanțul constructorilor: Pisica → Animal → Function.prototype → Object.prototype → null. De aici se moștenesc metodele statice: Pisica.creeaza există pentru că Pisica are ca prototip pe Animal.

Explicația fiecărei linii:

  • prototipul instanței este Pisica.prototype;
  • Pisica.prototype moștenește Animal.prototype;
  • Object.getPrototypeOf(Pisica) === Animal, legătura statică;
  • în Pisica.creeaza(), this este Pisica (apel ca metodă pe constructor), deci new this() creează o pisică, nu un animal. Modelul e util pentru metode de fabricare moștenite;
  • constructor nu e pe tom, ci pe Pisica.prototype, unde arată spre Pisica.

Terminologia care încurcă des:

  • F.prototype este obiectul care va deveni prototipul instanțelor create cu new F(); există doar pe funcții și clase;
  • [[Prototype]] este legătura internă a oricărui obiect, citită cu Object.getPrototypeOf și setată cu Object.create sau Object.setPrototypeOf;
  • __proto__ este un accesor vechi pentru [[Prototype]], păstrat pentru compatibilitate și nerecomandat în cod nou.

Schimbarea prototipului după creare (setPrototypeOf) e posibilă, dar motoarele dezoptimizează obiectele afectate, deci se evită în cod critic.

Ce urmărește intervievatorul: Se verifică un model complet al claselor ca zahăr sintactic peste prototipuri, inclusiv moștenirea statică. Răspunsul slab confundă prototype cu __proto__.

Array-uri, string-uri, date și colecții

48 Junior

Care metode de array modifică array-ul original și care întorc unul nou? Ce afișează codul?

JavaScript
const note = [7, 10, 5];
const sortate = note.sort((a, b) => a - b);
console.log(note, sortate === note);

const preturi = [30, 10, 20];
const ordonate = preturi.toSorted((a, b) => a - b);
console.log(preturi, ordonate);

Răspuns scurt: sort, reverse, splice, push, pop, shift, unshift și fill modifică array-ul; map, filter, slice, concat și variantele ES2023 toSorted, toReversed, toSpliced, with întorc unul nou. Codul afișează [5, 7, 10] true, apoi [30, 10, 20] [10, 20, 30].

Distincția contează pentru că un array modificat este vizibil în toate locurile care îl referă.

Metode care modifică array-ul (mutating):

  • push, pop, shift, unshift: adaugă sau scot la capete;
  • splice: șterge sau inserează în mijloc;
  • sort, reverse: reordonează pe loc și întorc același array, nu o copie;
  • fill, copyWithin.

Metode care nu modifică și întorc un rezultat nou: map, filter, slice, concat, flat, flatMap, reduce, join, find.

Exemplul arată capcana: note.sort() întoarce chiar note, deci sortate === note e true. Dacă note venea dintr-o stare, dintr-o proprietate a altui obiect sau dintr-un parametru, sortarea a stricat-o pentru toți.

ES2023 a adăugat variante care copiază:

  • toSorted(cmp) în loc de sort;
  • toReversed() în loc de reverse;
  • toSpliced(start, n, ...elem) în loc de splice;
  • with(index, valoare) în loc de arr[index] = valoare.

Sunt disponibile în browserele moderne și în Node.js 20+. Pentru medii mai vechi, varianta clasică este copierea înainte: [...note].sort(cmp) sau note.slice().reverse().

Regula practică: o funcție care primește un array nu ar trebui să-l modifice, decât dacă acesta e scopul ei explicit și numele o spune. Codul de stare (store-uri, componente) folosește aproape exclusiv variantele care întorc array-uri noi.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi care metode au efecte secundare. Greșeala tipică este folosirea lui sort sau reverse pe date primite, crezând că se întoarce o copie.

49 Junior

Ce afișează codul de mai jos? Cum sortezi corect numere, obiecte după o proprietate și nume românești?

JavaScript
console.log([10, 1, 5, 100].sort());
console.log(["Ștefan", "Ana", "ion", "Zoe"].sort());

Răspuns scurt: Afișează [1, 10, 100, 5] și ["Ana", "Zoe", "ion", "Ștefan"]. Fără comparator, sort convertește elementele la string și le compară după codurile UTF-16. Pentru numere folosești (a, b) => a - b, iar pentru texte localeCompare cu limba "ro".

Fără funcție de comparare, sort transformă fiecare element în string și compară codurile caracterelor. "100" vine înaintea lui "5" pentru că "1" < "5". La texte, majusculele au coduri mai mici decât literele mici, iar literele cu diacritice (Ș are codul 536) ajung la final.

Comparatorul primește două elemente și întoarce un număr negativ dacă a trebuie să fie înainte, pozitiv dacă b trebuie să fie înainte, sau 0:

JavaScript
[10, 1, 5, 100].sort((a, b) => a - b);        // crescător
produse.sort((a, b) => b.pret - a.pret);       // descrescător după preț
nume.sort((a, b) => a.localeCompare(b, "ro", { sensitivity: "base" }));
// ["Ana", "ion", "Ștefan", "Zoe"]

Pentru liste mari de texte, un Intl.Collator creat o singură dată e mai rapid decât localeCompare la fiecare comparație:

JavaScript
const colator = new Intl.Collator("ro");
nume.sort(colator.compare);

Sortare după mai multe criterii:

JavaScript
produse.sort((a, b) => a.categorie.localeCompare(b.categorie) || a.pret - b.pret);

Operatorul || trece la al doilea criteriu doar când primul dă 0.

Detalii:

  • din ES2019, sort este garantat stabil: elementele egale își păstrează ordinea relativă, deci sortările succesive sunt sigure;
  • un comparator care întoarce boolean ((a, b) => a > b) e greșit; rezultatele variază după motor;
  • a - b nu merge pentru string-uri sau valori care pot fi undefined.

Ce urmărește intervievatorul: Se verifică dacă știi sortarea implicită ca string și dacă poți scrie comparatori corecți. Mulți candidați nu știu de localeCompare pentru diacritice.

Eroarea, în practică:The comparison function must be a function

50 Junior

Când folosești find, filter, some, every, includes și findIndex? Rezolvă cu metoda potrivită: există vreun produs fără stoc, toate produsele au preț, primul produs din categoria „cărți”.

Răspuns scurt: find întoarce primul element care respectă condiția, filter toate elementele, some și every răspund cu boolean, includes caută o valoare exactă, findIndex dă poziția. Folosești metoda care exprimă exact întrebarea și se oprește cât mai devreme.

Fiecare metodă răspunde la altă întrebare:

  • find(cond): primul element care respectă condiția sau undefined;
  • findIndex(cond): indexul lui sau -1; findLast și findLastIndex (ES2023) caută de la final;
  • filter(cond): un array nou cu toate elementele potrivite, posibil gol;
  • some(cond): true dacă măcar un element respectă condiția;
  • every(cond): true dacă toate o respectă; pe array gol întoarce true;
  • includes(valoare): true dacă array-ul conține exact acea valoare (comparație SameValueZero).
JavaScript
const produse = [
  { nume: "Roman", categorie: "cărți", pret: 40, stoc: 3 },
  { nume: "Cană", categorie: "casă", pret: 25, stoc: 0 },
];

const existaFaraStoc = produse.some((p) => p.stoc === 0);         // true
const toateAuPret = produse.every((p) => Number.isFinite(p.pret)); // true
const primaCarte = produse.find((p) => p.categorie === "cărți");    // Roman

De ce contează alegerea:

  • intenția: some spune clar „există?”, pe când filter(...).length > 0 cere o clipă de interpretare;
  • performanța: find, some, every și includes se opresc la primul rezultat decisiv, iar filter parcurge tot array-ul;
  • tipul rezultatului: find poate întoarce undefined, deci verifici înainte de a accesa proprietăți (primaCarte?.nume).

includes nu acceptă o funcție: pentru obiecte folosești some, pentru că două obiecte diferite nu sunt egale nici dacă au același conținut. Pentru căutări repetate în liste mari, un Set sau un Map după ID e mai eficient decât oricare dintre aceste metode.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi metoda care exprimă intenția și se oprește devreme. Greșeala tipică este filter(...)[0] în loc de find.

51 Junior

Ce afișează codul de mai jos și de ce?

JavaScript
console.log(["1", "2", "3"].map(parseInt));

Răspuns scurt: Afișează [1, NaN, NaN]. map transmite callback-ului (element, index, array), iar parseInt interpretează al doilea argument ca bază de numerație: parseInt("2", 1) și parseInt("3", 2) sunt NaN.

map apelează callback-ul cu trei argumente: elementul, indexul și array-ul. parseInt acceptă doi parametri: textul și baza (radix). Al doilea argument primit de la map, indexul, devine baza. Apelurile reale sunt:

  • parseInt("1", 0): baza 0 înseamnă „detectează automat”, deci baza 10, rezultat 1;
  • parseInt("2", 1): baza 1 nu este validă (bazele acceptate sunt 2–36), rezultat NaN;
  • parseInt("3", 2): în baza 2 sunt permise doar cifrele 0 și 1, deci "3" nu poate fi citit, rezultat NaN.

Reparațiile corecte:

JavaScript
["1", "2", "3"].map(Number);                 // [1, 2, 3]
["1", "2", "3"].map((s) => parseInt(s, 10)); // [1, 2, 3]

Lecția generală este mai importantă decât cazul particular: transmiterea directă a unei funcții ca callback e sigură doar dacă știi ce parametri suplimentari acceptă ea. Alte exemple cu aceeași problemă:

  • ["a", "b"].map(String.prototype.toUpperCase.call) nu funcționează, din cauza lui this;
  • o funcție proprie formateaza(valoare, opțiuni) primește indexul pe post de opțiuni când e dată direct lui map;
  • dacă o bibliotecă adaugă un parametru opțional unei funcții, apelurile de tip .map(fn) se pot strica după actualizare.

Un wrapper explicit, (x) => fn(x), elimină ambiguitatea cu un cost neglijabil. Number e sigur ca callback pentru că ignoră argumentele în plus.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semnătura callback-ului din map și a lui parseInt. Mulți candidați ghicesc [1, 2, 3].

52 Junior

Scrie o funcție estePalindrom(text) care ignoră spațiile, punctuația, majusculele și diacriticele. De exemplu, „Ele fac cafele” trebuie să fie palindrom.

Răspuns scurt: Normalizezi textul: litere mici, descompunere NFD și ștergerea semnelor diacritice, păstrarea doar a literelor și cifrelor; apoi compari caracterele cu doi indici care se apropie de la capete.

Problema are două părți: curățarea textului și verificarea propriu-zisă.

JavaScript
function estePalindrom(text) {
  const curat = text
    .toLowerCase()
    .normalize("NFD")                 // „ș” devine „s” + semn combinat
    .replace(/[̀-ͯ]/g, "")  // elimină semnele diacritice
    .replace(/[^a-z0-9]/g, "");       // păstrează doar litere și cifre

  let st = 0;
  let dr = curat.length - 1;
  while (st < dr) {
    if (curat[st] !== curat[dr]) return false;
    st++;
    dr--;
  }
  return true;
}

estePalindrom("Ele fac cafele");   // true
estePalindrom("Ana are mere");     // false

Explicații pe care merită să le dai:

  • normalize("NFD") descompune caracterele cu diacritice într-o literă de bază și un semn combinat. Semnele pentru ă, â, î, ș, ț se află în intervalul U+0300–U+036F, deci le poți șterge cu regex;
  • compararea cu doi indici (two pointers) nu creează un string inversat și se oprește la prima diferență. Complexitatea e O(n) în timp și O(1) memorie suplimentară, după curățare;
  • varianta scurtă curat === [...curat].reverse().join("") este corectă și ușor de citit, dar alocă un array și un string nou.

Cazuri-limită de menționat: textul gol sau doar cu punctuație (aici întoarce true, decizie care trebuie confirmată cu intervievatorul) și textele în alfabete non-latine, pentru care filtrul [^a-z0-9] ar fi prea agresiv. Pentru ele există /[^\p{L}\p{N}]/gu.

Ce urmărește intervievatorul: Se verifică manipularea string-urilor și atenția la cazuri-limită. Un candidat bun întreabă ce înseamnă „ignoră” înainte să scrie codul.

53 Junior

Scrie o funcție care primește un text și întoarce cele mai frecvente 3 cuvinte, cu numărul de apariții.

Răspuns scurt: Spargi textul în cuvinte cu un regex, numeri aparițiile într-un Map, transformi Map-ul în array de perechi, sortezi descrescător după număr și păstrezi primele 3.

O soluție clară, în pași separați:

JavaScript
function topCuvinte(text, n = 3) {
  const cuvinte = text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
  const frecvente = new Map();
  for (const c of cuvinte) {
    frecvente.set(c, (frecvente.get(c) ?? 0) + 1);
  }
  return [...frecvente]
    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0], "ro"))
    .slice(0, n);
}

topCuvinte("Mere, pere și mere. Pere? Mere!");
// [["mere", 3], ["pere", 2], ["și", 1]]

Decizii pe care le poți justifica:

  • match cu \p{L} și flagul u acceptă litere din orice alfabet, inclusiv cu diacritice; un split(" ") simplu ar păstra punctuația lipită de cuvinte;
  • ?? [] tratează textul fără cuvinte, pentru care match întoarce null;
  • Map evită problemele obiectelor simple cu chei precum "constructor" și păstrează ordinea inserării;
  • al doilea criteriu de sortare face rezultatul determinist când două cuvinte au aceeași frecvență.

Complexitatea este O(n) pentru numărare și O(k log k) pentru sortarea celor k cuvinte distincte. Dacă intervievatorul întreabă de texte uriașe cu foarte multe cuvinte distincte, pentru top n poți păstra un min-heap de dimensiune n, cu O(k log n), dar pentru majoritatea cazurilor sortarea simplă e suficientă și mai lizibilă.

Variante cerute frecvent: ignorarea cuvintelor de legătură (o listă într-un Set), numărarea caracterelor în loc de cuvinte, sau gruparea anagramelor după cheia [...c].sort().join("").

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți combina regex, Map și sortare într-o soluție corectă. Greșeala tipică este split după spațiu, care lasă punctuația în cuvinte.

54 Junior

Când folosești un Map în loc de un obiect simplu? Dă exemple concrete.

Răspuns scurt: Map e potrivit pentru dicționare dinamice: acceptă chei de orice tip, păstrează ordinea inserării, are size și metode clare, nu are chei moștenite și e optimizat pentru adăugări și ștergeri frecvente. Obiectul simplu rămâne bun pentru structuri cu câmpuri fixe și pentru JSON.

Obiectul simplu și Map par interschimbabile, dar sunt făcute pentru lucruri diferite. Obiectul descrie o entitate cu câmpuri cunoscute ({ id, nume, email }), iar Map este un dicționar cu chei arbitrare.

Avantajele lui Map:

  • chei de orice tip: obiecte, elemente DOM, funcții, numere, fără conversie la string;
  • fără chei moștenite: o cheie venită de la utilizator, precum "__proto__" sau "constructor", nu produce comportamente ciudate;
  • dimensiune directă: map.size, față de Object.keys(obj).length;
  • iterabil direct, în ordinea inserării: for (const [k, v] of map);
  • performanță bună la adăugări și ștergeri frecvente; delete obj.x poate dezoptimiza un obiect în unele motoare.
JavaScript
const vizite = new Map();
const buton = document.querySelector("#cumpara");
vizite.set(buton, 0);
vizite.set(buton, vizite.get(buton) + 1);

const cache = new Map();
cache.set(42, { nume: "produs" });   // cheia rămâne numărul 42

Când rămâi la obiect:

  • date care se serializează: JSON.stringify(map) dă {}; convertești cu Object.fromEntries(map);
  • structuri cu câmpuri fixe, unde accesul user.nume e mai lizibil;
  • configurații și opțiuni pentru funcții, cu destructurare.

Alternativa WeakMap se folosește când cheile sunt obiecte și nu vrei ca dicționarul să le împiedice eliberarea din memorie, de exemplu date atașate elementelor DOM.

Ce urmărește intervievatorul: Se verifică dacă știi diferențele practice, nu doar existența lui Map. Răspunsul slab spune doar că Map „e mai modern”.

Eroarea, în practică:Iterator value is not an entry object

55 Junior

Cum elimini duplicatele dintr-un array folosind Set? Ce afișează codul și cum deduplici obiecte după id?

JavaScript
console.log([...new Set([3, 1, 3, "3", NaN, NaN])]);
console.log(new Set([{ id: 1 }, { id: 1 }]).size);

Răspuns scurt: Afișează [3, 1, "3", NaN] și 2. Set păstrează valori unice după SameValueZero, deci 3 și "3" sunt diferite, NaN apare o dată, iar obiectele diferite sunt distincte chiar cu același conținut. Pentru obiecte deduplici după o cheie, cu un Map.

Set reține fiecare valoare o singură dată și păstrează ordinea primei apariții. Deduplicarea unui array de primitive e o linie: [...new Set(arr)] sau Array.from(new Set(arr)).

Comparația folosită este SameValueZero:

  • 3 și "3" au tipuri diferite, deci rămân amândouă;
  • NaN este considerat egal cu NaN, deci apare o dată;
  • obiectele se compară după referință: două literale { id: 1 } sunt obiecte diferite, deci size este 2.

Pentru obiecte, deduplici după o cheie:

JavaScript
function unicDupa(lista, cheie) {
  const vazute = new Map();
  for (const item of lista) {
    if (!vazute.has(item[cheie])) vazute.set(item[cheie], item);
  }
  return [...vazute.values()];
}
unicDupa([{ id: 1, v: "a" }, { id: 1, v: "b" }, { id: 2 }], "id");
// [{ id: 1, v: "a" }, { id: 2 }]

Varianta păstrează prima apariție; new Map(lista.map((x) => [x.id, x])) ar păstra ultima.

Alte utilizări ale lui Set: verificări rapide de apartenență (set.has(x) este în medie O(1), față de includes, care e O(n)), ID-uri selectate într-o listă, etichete. ES2025 a adăugat metode pentru operații pe mulțimi: a.union(b), a.intersection(b), a.difference(b), a.isSubsetOf(b), disponibile în browserele actuale și în Node.js 22+. În medii mai vechi scrii intersecția manual: [...a].filter((x) => b.has(x)).

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi cum compară Set valorile. Greșeala tipică este așteptarea ca Set să deduplice obiecte cu același conținut.

56 Junior

Ai o listă de comenzi { id, client, total }. Scrie o funcție care le grupează după client și calculează totalul pe fiecare client.

Răspuns scurt: Parcurgi lista o singură dată cu reduce sau cu o buclă și acumulezi într-un obiect sau Map: pentru fiecare comandă adaugi la grupul clientului. Din ES2024 există și Object.groupBy și Map.groupBy pentru partea de grupare.

Varianta clasică, cu reduce, care grupează și însumează într-o singură parcurgere:

JavaScript
const comenzi = [
  { id: 1, client: "Ana", total: 120 },
  { id: 2, client: "Ion", total: 80 },
  { id: 3, client: "Ana", total: 50 },
];

const totalPeClient = comenzi.reduce((acc, c) => {
  acc[c.client] = (acc[c.client] ?? 0) + c.total;
  return acc;
}, {});
// { Ana: 170, Ion: 80 }

O funcție generică de grupare, care păstrează elementele:

JavaScript
function groupBy(lista, cheieFn) {
  const grupuri = new Map();
  for (const item of lista) {
    const k = cheieFn(item);
    if (!grupuri.has(k)) grupuri.set(k, []);
    grupuri.get(k).push(item);
  }
  return grupuri;
}

ES2024 a adăugat variantele standard:

JavaScript
const peClient = Object.groupBy(comenzi, (c) => c.client);
// { Ana: [comanda 1, comanda 3], Ion: [comanda 2] }
const peMarime = Map.groupBy(comenzi, (c) => (c.total > 100 ? "mare" : "mică"));

Object.groupBy întoarce un obiect fără prototip, iar Map.groupBy un Map, util când cheia nu e string. Sunt disponibile în browserele actuale și în Node.js 21+.

Puncte de atenție:

  • valoarea inițială a lui reduce ({}) e obligatorie; fără ea, primul element devine acumulator;
  • ?? 0 tratează corect prima apariție;
  • dacă cheile vin de la utilizator, un obiect simplu poate primi chei precum "__proto__"; Map sau Object.create(null) sunt mai sigure;
  • pentru sume de bani, totalurile ar trebui să fie întregi (bani), ca să eviți erorile de virgulă mobilă.

Ce urmărește intervievatorul: Se verifică folosirea fluentă a lui reduce și structurarea datelor. Greșeala frecventă este uitarea valorii inițiale sau a lui return acc.

57 Junior

Ce afișează codul de mai jos? Care sunt capcanele obiectului Date?

JavaScript
const d1 = new Date(2026, 10, 31);
console.log(d1.toDateString());

const d2 = new Date("2026-10-31");
const d3 = new Date("2026-10-31T00:00");
console.log(d2.getTime() === d3.getTime());

console.log(new Date(2026, 9, 31).getDay());

Răspuns scurt: d1 este 1 decembrie 2026: lunile încep de la 0, iar 31 noiembrie se reportează. A doua linie dă false în afara fusului UTC, pentru că data simplă e citită în UTC, iar cea cu oră în ora locală. getDay dă 6 (sâmbătă).

Date este una dintre zonele cu cele mai multe capcane:

  • lunile încep de la 0: new Date(2026, 10, 31) înseamnă luna a 11-a, noiembrie. Noiembrie are 30 de zile, iar Date nu aruncă eroare, ci reportează: 31 noiembrie devine 1 decembrie. Reportarea poate fi folosită intenționat: new Date(an, luna + 1, 0) dă ultima zi a lunii;
  • parsarea string-urilor: o dată fără oră în format ISO ("2026-10-31") e tratată ca miezul nopții în UTC, iar o dată cu oră fără fus ("2026-10-31T00:00") ca ora locală. În România, cele două diferă cu două sau trei ore, în funcție de ora de vară. Afișată local, prima poate arăta ziua anterioară în fusurile orare de la vest de UTC;
  • getDay vs getDate: getDay() întoarce ziua săptămânii (0 = duminică), iar getDate() ziua din lună. 31 octombrie 2026 este sâmbătă, deci 6;
  • mutabilitate: setDate, setMonth modifică obiectul, deci o dată transmisă unei funcții poate fi schimbată fără să știi;
  • formatele nestandard ("31/10/2026") sunt parsate diferit de la un browser la altul sau dau Invalid Date.

Practici sigure:

  • stochezi și transmiți datele ca ISO 8601 cu fus (toISOString(), cu Z) sau ca timestamp;
  • afișezi cu Intl.DateTimeFormat("ro-RO", { dateStyle: "long", timeZone: "Europe/Bucharest" });
  • pentru calcule cu zile, copiezi înainte: new Date(d.getTime()).

Pentru aritmetică serioasă cu fusuri orare se folosește o bibliotecă dedicată sau API-ul Temporal, noul standard pentru date, aflat în curs de adoptare în browsere.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai lucrat real cu date calendaristice. Greșelile tipice sunt luna indexată de la 0 și diferența UTC față de ora locală la parsare.

Eroarea, în practică:Invalid time value

58 Mid

Ce afișează codul de mai jos? Explică diferența dintre Array(3), Array.from și fill.

JavaScript
console.log(new Array(3).map((_, i) => i));
console.log(Array.from({ length: 3 }, (_, i) => i));

const grila = new Array(2).fill([]);
grila[0].push("x");
console.log(grila);

Răspuns scurt: Afișează [ <3 empty items> ], [0, 1, 2] și [["x"], ["x"]]. new Array(3) creează un array cu „găuri”, pe care map le sare; Array.from parcurge length și creează valori; fill pune aceeași referință în toate pozițiile.

new Array(3) creează un array cu length 3, dar fără elemente: un sparse array, cu găuri. Găurile diferă de undefined: indexul nu există deloc (1 in arr este false). Metodele vechi (map, forEach, filter, reduce) sar peste găuri, deci map nu apelează callback-ul și rezultatul păstrează găurile. Metodele mai noi și iterarea (for...of, spread, Array.from) tratează găurile ca undefined.

Array.from({ length: 3 }, fn) primește un obiect array-like (are length) și construiește un array dens, apelând fn(valoare, index) pentru fiecare poziție. Este modul curat de a genera secvențe: Array.from({ length: 5 }, (_, i) => i * 2).

fill(valoare) pune aceeași valoare în toate pozițiile. Pentru primitive nu e o problemă. Pentru obiecte sau array-uri, toate pozițiile arată spre același obiect, deci un push pe un rând modifică toate rândurile. Construcția corectă pentru o grilă:

JavaScript
const grila = Array.from({ length: 2 }, () => []);
grila[0].push("x"); // [["x"], []]

Alte surse de array-uri cu găuri: arr[10] = 1 pe un array scurt, delete arr[0] sau virgule duble în literal ([1, , 3]). Le eviți pentru că se comportă inconsistent între metode, iar motoarele le optimizează mai slab decât array-urile dense.

Array.from convertește și alte structuri: Array.from(document.querySelectorAll("li")), Array.from(new Set(x)), Array.from("text").

Ce urmărește intervievatorul: Se verifică înțelegerea array-urilor sparse și a referințelor partajate. Bug-ul cu fill([]) apare des la construirea matricelor pentru jocuri sau tabele.

Eroarea, în practică:Invalid array length

59 Mid

Scrie o funcție aplatizeaza(arr, adancime = Infinity) care aplatizează un array imbricat, fără Array.prototype.flat.

JavaScript
aplatizeaza([1, [2, [3, [4]]], 5]);      // [1, 2, 3, 4, 5]
aplatizeaza([1, [2, [3, [4]]], 5], 1);   // [1, 2, [3, [4]], 5]

Răspuns scurt: Parcurgi elementele: dacă un element e array și mai ai adâncime, aplici funcția recursiv cu adâncime - 1 și adaugi rezultatele; altfel adaugi elementul. O variantă iterativă cu stivă evită limita stivei de apeluri.

Varianta recursivă, ușor de citit:

JavaScript
function aplatizeaza(arr, adancime = Infinity) {
  const rezultat = [];
  for (const el of arr) {
    if (Array.isArray(el) && adancime > 0) {
      rezultat.push(...aplatizeaza(el, adancime - 1));
    } else {
      rezultat.push(el);
    }
  }
  return rezultat;
}

Detalii care contează:

  • Array.isArray e verificarea corectă; typeof ar da "object" și pentru obiecte simple;
  • adâncimea scade la fiecare nivel, iar Infinity - 1 rămâne Infinity, deci valoarea implicită funcționează fără caz special;
  • push(...rezultatRecursiv) poate depăși limita de argumente pentru sub-array-uri foarte mari (de ordinul sutelor de mii de elemente); o buclă internă de push sau concat evită problema.

Varianta iterativă, fără recursivitate, pentru adâncime nelimitată:

JavaScript
function aplatizeazaIterativ(arr) {
  const stiva = [...arr];
  const rezultat = [];
  while (stiva.length) {
    const el = stiva.pop();
    if (Array.isArray(el)) stiva.push(...el);
    else rezultat.push(el);
  }
  return rezultat.reverse();
}

Elementele sunt scoase de la final, deci rezultatul se inversează la sfârșit pentru a păstra ordinea.

În cod de producție folosești arr.flat(adancime) (ES2019) sau flatMap când transformi și aplatizezi un nivel. Exercițiul verifică însă recursivitatea, parametrii impliciți și atenția la cazuri precum array-urile goale ([1, [], 2] dă [1, 2]).

Ce urmărește intervievatorul: Intervievatorul verifică recursivitatea pe structuri și controlul adâncimii. Candidații buni propun singuri și varianta iterativă.

60 Mid

Ce afișează codul de mai jos? Ce înseamnă length la un string și cum lucrezi corect cu caractere Unicode?

JavaScript
const nume = "Ștefan";
const decompus = nume.normalize("NFD");
console.log(nume.length, decompus.length);
console.log(nume === decompus);

const emoji = "\u{1F600}";
console.log(emoji.length, [...emoji].length);

Răspuns scurt: Afișează 6 7, false, apoi 2 1. length numără unități UTF-16, nu caractere vizibile: Ș poate fi un caracter sau două (literă plus semn), iar emoji-urile ocupă două unități. Normalizezi cu normalize("NFC") înainte de comparații și iterezi cu for...of sau spread.

String-urile JavaScript sunt secvențe de unități de cod UTF-16. Majoritatea caracterelor ocupă o unitate, dar caracterele din afara planului de bază (multe emoji, unele ideograme) ocupă două, o pereche „surogat”. length, indexarea s[i], slice și split("") lucrează pe unități, nu pe caractere vizibile.

Pentru diacritice apare a doua problemă: același text poate avea mai multe reprezentări. „Ș” poate fi un singur caracter (U+0218) sau „S” urmat de semnul combinat virgulă (U+0326). Vizual sunt identice, dar ca string-uri sunt diferite: lungimi diferite, === dă false, iar căutările nu le găsesc. Textele venite de pe macOS, din copy-paste sau din alte sisteme pot folosi oricare formă.

Practici corecte:

  • normalizezi înainte de comparare, căutare sau salvare: s.normalize("NFC") (forma compusă, cea mai răspândită);
  • iterezi pe code points cu for (const ch of s) sau [...s], care nu sparg perechile surogat;
  • pentru „caractere vizibile” (grapheme), inclusiv emoji compuse din mai multe code points, folosești Intl.Segmenter:
JavaScript
const seg = new Intl.Segmenter("ro", { granularity: "grapheme" });
const nrCaractere = [...seg.segment(text)].length;

Implicații practice: limita de caractere a unui câmp poate fi calculată greșit, trunchierea cu slice poate tăia un emoji în două (rezultă un caracter invalid), iar inversarea unui text cu split("").reverse() strică perechile surogat. Pentru comparații fără diacritice combini NFD cu ștergerea semnelor combinate.

Ce urmărește intervievatorul: Se verifică înțelegerea codificării string-urilor, relevantă pentru texte în română. Mulți candidați cred că length numără caracterele vizibile.

Eroarea, în practică:The normalization form should be one of NFC, NFD...Invalid code point

61 Mid

Implementează propria versiune de reduce, ca funcție reduceaza(arr, fn, valoareInitiala), care respectă comportamentul standard, inclusiv lipsa valorii inițiale.

Răspuns scurt: Dacă valoarea inițială lipsește, acumulatorul pornește de la primul element și parcurgerea de la al doilea; pe array gol fără valoare inițială arunci TypeError. Apelezi fn(acc, element, index, arr) și întorci acumulatorul final.

Partea delicată este diferența dintre „valoarea inițială lipsește” și „valoarea inițială este undefined”. O detectezi după numărul de argumente:

JavaScript
function reduceaza(arr, fn, ...rest) {
  if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
  let i = 0;
  let acc;
  if (rest.length > 0) {
    acc = rest[0];
  } else {
    while (i < arr.length && !(i in arr)) i++;  // sare peste găuri
    if (i >= arr.length) {
      throw new TypeError("Reduce of empty array with no initial value");
    }
    acc = arr[i++];
  }
  for (; i < arr.length; i++) {
    if (i in arr) acc = fn(acc, arr[i], i, arr);
  }
  return acc;
}

reduceaza([1, 2, 3], (a, b) => a + b);       // 6
reduceaza([], (a, b) => a + b, 0);           // 0
reduceaza([], (a, b) => a + b);              // TypeError

Ce verifică intervievatorul:

  • cele patru argumente ale callback-ului: acumulator, element, index, array;
  • regula pentru valoarea inițială: fără ea, primul element devine acumulator și nu e transmis callback-ului;
  • eroarea pe array gol fără valoare inițială, identică cu cea standard;
  • găurile din array-urile sparse sunt sărite, la fel ca la metoda nativă (i in arr).

De ce e bine să dai mereu o valoare inițială: fără ea, tipul acumulatorului depinde de date. [{ pret: 5 }].reduce((s, p) => s + p.pret) întoarce obiectul, nu un număr, iar pe array gol aruncă. Cu 0 ca valoare inițială, rezultatul are întotdeauna tipul așteptat.

Un polyfill pe prototip folosește this în loc de arr.

Ce urmărește intervievatorul: Se verifică înțelegerea exactă a contractului lui reduce. Cele mai multe implementări greșite tratează valoarea inițială undefined ca lipsă.

Eroarea, în practică:Reduce of empty array with no initial valueReduce of a done iterator with no initial value

62 Senior

Codul de mai jos procesează două liste de câteva sute de mii de elemente și blochează pagina câteva secunde. Ce optimizezi?

JavaScript
const rezultat = comenzi.filter((c) =>
  clientiActivi.map((cl) => cl.id).includes(c.clientId)
);

Răspuns scurt: Codul reconstruiește lista de ID-uri și o caută liniar pentru fiecare comandă, deci are complexitate O(n·m). Construiești o dată un Set cu ID-urile și folosești has, ajungând la O(n + m). Apoi măsori înainte de alte optimizări.

Problema nu e JavaScript-ul lent, ci algoritmul. Pentru fiecare dintre n comenzi:

  • clientiActivi.map(...) creează un array nou de m elemente;
  • includes îl parcurge liniar.

Rezultatul e O(n·m) operații plus n alocări de array-uri mari, care pun presiune și pe garbage collector. Pentru liste de sute de mii de elemente, înseamnă zeci de miliarde de comparații.

Soluția este o structură cu căutare în timp constant, construită o singură dată:

JavaScript
const idActivi = new Set(clientiActivi.map((cl) => cl.id));
const rezultat = comenzi.filter((c) => idActivi.has(c.clientId));

Complexitatea devine O(n + m). Același tipar rezolvă join-urile între liste: un Map de la ID la obiect în loc de find în buclă.

Alte optimizări, în ordinea impactului:

  • evită lanțurile lungi map().filter().map() pe date foarte mari, care creează array-uri intermediare; o singură buclă sau un reduce le combină. Fă asta doar dacă măsurătorile arată că e nevoie, pentru că lizibilitatea contează;
  • mută filtrarea pe server dacă datele vin de acolo; nu trimite sute de mii de rânduri în browser doar ca să le filtrezi;
  • dacă procesarea trebuie să rămână în browser, mut-o într-un Web Worker sau împarte-o în bucăți, ca interfața să rămână responsivă.

Metoda de lucru contează la fel de mult ca soluția: reproduci cu date realiste, măsori cu performance.now() sau cu panoul Performance din DevTools, schimbi un singur lucru și măsori din nou. Micro-optimizările (de exemplu for clasic în loc de forEach) vin abia după ce complexitatea e corectă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști complexitatea pătratică ascunsă în metode înlănțuite și dacă lucrezi pe bază de măsurători. Răspunsul slab propune doar înlocuirea lui filter cu for.

Promises, async/await și event loop

Exersează capitolul cu exerciții reale: Curs JavaScript pentru începători →
63 Junior

Ce se întâmplă cu timer-ul din codul de mai jos? Garantează setTimeout(fn, 1000) că funcția rulează după exact o secundă?

JavaScript
const start = Date.now();
setTimeout(() => console.log("timer după", Date.now() - start, "ms"), 1000);

while (Date.now() - start < 3000) {
  // calcul sincron care durează 3 secunde
}
console.log("calcul gata");

Răspuns scurt: Nu. Întârzierea e un minim: callback-ul intră în coadă după 1000 ms, dar rulează doar când stiva de apeluri e goală. Aici se afișează „calcul gata”, apoi „timer după ~3000 ms”, iar pagina e blocată 3 secunde.

JavaScript rulează codul paginii pe un singur fir de execuție (main thread). setTimeout nu întrerupe codul care rulează: după expirarea întârzierii, browserul pune callback-ul într-o coadă de sarcini (task queue). Event loop-ul ia următoarea sarcină din coadă doar când codul curent s-a terminat și stiva de apeluri e goală.

În exemplu, bucla while ocupă firul 3 secunde. Timer-ul expiră după 1 secundă, dar callback-ul așteaptă. Ordinea este „calcul gata”, apoi „timer după 3000 ms” (aproximativ). În tot acest timp, pagina nu răspunde la click-uri, nu derulează și nu se redesenează, pentru că și randarea și evenimentele folosesc același fir.

Alte motive pentru care întârzierea nu e exactă:

  • browserele impun un minim de aproximativ 4 ms pentru timere imbricate adânc;
  • în taburile inactive, timerele sunt încetinite (throttling), uneori la o rulare pe secundă sau mai rar;
  • setInterval nu compensează întârzierile; dacă un callback durează mult, intervalele se decalează.

Consecințe practice:

  • pentru un cronometru afișat, calculezi timpul scurs din Date.now() sau performance.now(), nu numeri tick-urile;
  • pentru animații folosești requestAnimationFrame;
  • un calcul lung se mută într-un Web Worker sau se sparge în bucăți, ca firul principal să rămână liber.

Asincron nu înseamnă paralel: callback-urile asincrone rulează tot pe firul principal, doar mai târziu.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului single-thread și a faptului că delay-ul e un minim. Mulți candidați cred că timer-ul întrerupe codul în curs.

64 Junior

Scrie o funcție asteapta(ms) care întoarce o promisiune rezolvată după ms milisecunde. Apoi transformă funcția cu callback de mai jos într-una care întoarce o promisiune.

JavaScript
function citesteSetari(cheie, callback) {
  setTimeout(() => {
    if (!cheie) callback(new Error("Cheie lipsă"));
    else callback(null, { cheie, valoare: "dark" });
  }, 100);
}

Răspuns scurt: Creezi un new Promise în care apelezi setTimeout(resolve, ms). Pentru funcția cu callback, o apelezi în executor și transformi convenția (eroare, rezultat) în reject sau resolve. Node.js are deja util.promisify pentru asta.

new Promise(executor) primește o funcție cu doi parametri, resolve și reject. Executorul rulează imediat și sincron, iar promisiunea se rezolvă când apelezi una dintre funcții.

JavaScript
const asteapta = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

await asteapta(500);
console.log("au trecut 500 ms");

Pentru o funcție în stil Node.js, cu callback-ul (eroare, rezultat) pe ultima poziție, adaptarea e mereu aceeași:

JavaScript
function citesteSetariAsync(cheie) {
  return new Promise((resolve, reject) => {
    citesteSetari(cheie, (err, rezultat) => {
      if (err) reject(err);
      else resolve(rezultat);
    });
  });
}

try {
  const setari = await citesteSetariAsync("tema");
  console.log(setari.valoare);
} catch (e) {
  console.error(e.message);
}

Varianta generică, numită „promisify”:

JavaScript
const promisify = (fn) => (...args) =>
  new Promise((resolve, reject) =>
    fn(...args, (err, val) => (err ? reject(err) : resolve(val)))
  );

În Node.js există util.promisify, iar majoritatea modulelor au deja variante bazate pe promisiuni (fs/promises, timers/promises).

Avantajul conversiei: codul consumator se scrie cu async/await, erorile ajung în try/catch, iar mai multe operații se combină cu Promise.all, fără „callback hell”, adică piramide de callback-uri imbricate cu tratarea erorilor repetată la fiecare nivel. Atenție: new Promise se folosește doar pentru a adapta API-uri bazate pe callback-uri sau evenimente, nu pentru a înveli o promisiune existentă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi construi o promisiune și adapta convenția de callback. Greșeala frecventă: lipsa apelului reject, deci erorile se pierd.

65 Junior

Ce afișează codul de mai jos și de ce?

JavaScript
Promise.resolve(1)
  .then((x) => { x + 1; })
  .then((x) => { console.log("A", x); return Promise.resolve(10); })
  .then((x) => console.log("B", x))
  .then((x) => console.log("C", x));

Răspuns scurt: Afișează „A undefined”, „B 10”, „C undefined”. Fiecare then primește ce a întors callback-ul anterior; fără return, valoarea e undefined, iar o promisiune întoarsă e așteptată și desfăcută automat.

Fiecare .then întoarce o promisiune nouă, rezolvată cu valoarea întoarsă de callback. Lanțul funcționează ca o conductă: ce întoarce un pas devine intrarea pasului următor.

  • primul callback calculează x + 1, dar nu are return. Acoladele fac din el un bloc de cod, nu o expresie, deci întoarce undefined;
  • al doilea afișează A undefined și întoarce o promisiune. Când un callback întoarce o promisiune (sau orice obiect cu metoda then), lanțul o așteaptă și transmite valoarea ei, nu promisiunea. De aceea următorul pas primește 10, nu un obiect Promise;
  • al treilea afișează B 10 și întoarce rezultatul lui console.log, adică undefined;
  • al patrulea afișează C undefined.

Acest comportament de „aplatizare” permite înlănțuirea operațiilor asincrone fără imbricare:

JavaScript
fetch("/api/user")
  .then((r) => r.json())
  .then((user) => fetch(`/api/comenzi?user=${user.id}`))
  .then((r) => r.json());

Cele mai frecvente bug-uri de lanț sunt legate de return:

  • un return uitat într-un callback cu acolade face ca pasul următor să ruleze imediat, fără să aștepte operația, cu undefined;
  • o promisiune creată, dar neîntoarsă, rulează „pe lângă” lanț, iar erorile ei nu mai ajung în .catch-ul final.

Cu async/await problema dispare în mare parte, pentru că fiecare valoare se atribuie explicit unei variabile.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului de înlănțuire și a importanței lui return. Return-ul uitat este una dintre cele mai frecvente cauze de bug-uri asincrone.

66 Junior

Unde e bug-ul în codul de mai jos? Funcția raportează „Salvate: 0” deși trimite toate cererile.

JavaScript
async function salveazaToate(produse) {
  let salvate = 0;
  produse.forEach(async (p) => {
    await fetch("/api/produse", { method: "POST", body: JSON.stringify(p) });
    salvate++;
  });
  console.log("Salvate:", salvate);
}

Răspuns scurt: forEach nu așteaptă callback-urile asincrone: le pornește pe toate și se termină imediat, deci log-ul rulează înainte de orice răspuns. Folosești for...of cu await pentru execuție pe rând, sau Promise.all cu map pentru execuție în paralel.

forEach apelează callback-ul pentru fiecare element și ignoră valoarea întoarsă. Un callback async întoarce o promisiune, pe care forEach o aruncă. Toate cererile pornesc aproape simultan, forEach se termină imediat, iar console.log rulează înainte ca vreun await să se fi încheiat, deci afișează 0. În plus, erorile din callback-uri devin respingeri netratate, iar salveazaToate nu poate raporta un eșec.

Varianta secvențială, când ordinea contează sau vrei să nu încarci serverul:

JavaScript
async function salveazaToate(produse) {
  let salvate = 0;
  for (const p of produse) {
    await salveaza(p);
    salvate++;
  }
  console.log("Salvate:", salvate);
}

Varianta paralelă, când operațiile sunt independente:

JavaScript
async function salveazaToate(produse) {
  const rezultate = await Promise.allSettled(produse.map((p) => salveaza(p)));
  const ok = rezultate.filter((r) => r.status === "fulfilled").length;
  console.log(`Salvate: ${ok} din ${produse.length}`);
}

allSettled raportează și eșecurile individuale, iar Promise.all s-ar opri la prima eroare.

Alegerea între cele două ține de context: zece cereri în paralel sunt de obicei în regulă, zece mii pot supraîncărca serverul sau browserul, caz în care limitezi concurența (de exemplu câte cinci deodată). Aceeași capcană apare la map, filter și reduce cu callback-uri async: filter(async ...) păstrează toate elementele, pentru că o promisiune e mereu truthy.

În fetch trebuie setat și headers: { "Content-Type": "application/json" }, altfel serverul poate să nu interpreteze corpul ca JSON.

Ce urmărește intervievatorul: Intervievatorul verifică un bug foarte frecvent în cod real. Răspunsul bun oferă ambele variante, secvențială și paralelă, și explică alegerea.

67 Junior

Ce afișează codul de mai jos? Cum se propagă erorile într-un lanț de promisiuni?

JavaScript
Promise.resolve()
  .then(() => { throw new Error("pas 1"); })
  .then(() => console.log("pas 2"))
  .catch((e) => { console.log("prins:", e.message); return "recuperat"; })
  .then((v) => console.log("după catch:", v))
  .finally(() => console.log("final"));

Răspuns scurt: Afișează „prins: pas 1”, „după catch: recuperat”, „final”. O eroare sare peste toate then-urile până la primul catch; catch-ul care întoarce o valoare readuce lanțul pe ramura de succes, iar finally rulează indiferent de rezultat.

O excepție aruncată într-un then (sau o promisiune respinsă întoarsă din el) respinge promisiunea creată de acel pas. Respingerea se propagă în jos și sare peste toți pașii then care nu au handler de eroare, până la primul catch. De aceea „pas 2” nu se afișează.

catch este, de fapt, then(undefined, handler). Ce întoarce el devine valoarea de succes a lanțului: aici "recuperat", deci următorul then rulează normal. Dacă vrei ca eroarea să continue să se propage după logare, o arunci din nou:

JavaScript
.catch((e) => {
  raporteaza(e);
  throw e;   // lanțul rămâne respins
})

finally rulează și la succes, și la eșec, nu primește argumente și, de regulă, nu schimbă rezultatul: valoarea sau eroarea trec prin el neschimbate. Excepție: dacă finally aruncă o eroare, aceasta înlocuiește rezultatul. Se folosește pentru curățenie, de exemplu ascunderea unui indicator de încărcare.

Poziția lui catch contează:

  • un catch la final tratează erorile din orice pas;
  • un catch în mijloc permite recuperarea locală (o valoare implicită) și continuarea;
  • then(succes, eroare) cu doi parametri nu prinde erorile aruncate chiar de funcția succes, sursă frecventă de confuzie.

Un lanț fără niciun catch care ajunge respins produce o „unhandled rejection”: eroare în consolă în browser și, implicit, oprirea procesului în Node.js 15+. Echivalentul cu async/await este try/catch/finally, cu aceleași reguli.

Ce urmărește intervievatorul: Se verifică înțelegerea propagării erorilor și a recuperării. Mulți candidați cred că lanțul se oprește complet după catch.

Eroarea, în practică:Uncaught (in promise)

68 Mid

Ce afișează codul de mai jos? Explică ce face await cu restul funcției.

JavaScript
async function incarca() {
  console.log("2. început funcție");
  await null;
  console.log("4. după await");
  return "gata";
}

console.log("1. înainte");
const p = incarca();
console.log("3. după apel", p instanceof Promise);
p.then((v) => console.log("5.", v));

Răspuns scurt: Mesajele apar în ordinea 1, 2, 3 (cu true), 4, 5. O funcție async rulează sincron până la primul await, apoi se suspendă, iar restul ei continuă ca microtask; întoarce mereu o promisiune.

O funcție async nu e asincronă de la început. La apel, corpul ei rulează sincron până la primul await. De aceea „2” apare imediat după „1”, înainte de „3”.

La await valoare, se întâmplă următoarele:

  • valoarea este convertită într-o promisiune (aici null devine o promisiune deja rezolvată);
  • funcția se suspendă și predă controlul apelantului, care primește o promisiune în așteptare;
  • continuarea funcției (codul de după await) este programată ca microtask, după ce promisiunea așteptată se rezolvă.

Apelantul continuă: afișează „3” și true, pentru că o funcție async întoarce întotdeauna o promisiune, chiar dacă scrii return "gata". Valoarea întoarsă devine valoarea promisiunii, iar o excepție aruncată în funcție devine respingerea ei.

După terminarea codului sincron, event loop-ul rulează microtask-urile: continuarea afișează „4” și face return, ceea ce rezolvă p, iar handler-ul then afișează „5. gata”.

Implicații practice:

  • tot ce e înainte de primul await rulează sincron, deci o validare costisitoare acolo blochează apelantul;
  • o eroare aruncată înainte de primul await nu se aruncă sincron, ci respinge promisiunea, deci un try/catch în jurul unui apel fără await nu o prinde;
  • await pe o valoare care nu e promisiune tot suspendă funcția, cel puțin un microtask;
  • async/await este o sintaxă mai comodă peste promisiuni și microtask-uri, nu un mecanism separat.

Ce urmărește intervievatorul: Intervievatorul verifică un model mental precis pentru async/await. Greșeala tipică este credința că tot corpul unei funcții async rulează „mai târziu”.

Eroarea, în practică:await is only valid in async functions

69 Mid

Care e diferența dintre cele două variante? Ce problemă ascunsă are a doua?

JavaScript
// Varianta 1
const user = await getUser(id);
const setari = await getSetari(id);

// Varianta 2
const pUser = getUser(id);
const pSetari = getSetari(id);
const user2 = await pUser;
const setari2 = await pSetari;

Răspuns scurt: Varianta 1 rulează cererile una după alta, varianta 2 le pornește în paralel. Problema celei de-a doua: dacă pSetari e respinsă cât timp aștepți pUser, respingerea nu are încă handler și devine unhandled rejection. Varianta corectă pentru paralel este Promise.all.

În varianta 1, getSetari pornește abia după ce getUser s-a terminat. Dacă fiecare durează 300 ms, totalul este aproximativ 600 ms. E corect când a doua cerere depinde de rezultatul primei, dar aici nu depinde.

În varianta 2, ambele cereri pornesc imediat, iar timpul total este cel al celei mai lente. Problema apare la erori: dacă pSetari e respinsă după 100 ms, în timp ce funcția încă așteaptă pUser, nimeni nu a atașat un handler pe pSetari. Runtime-ul o raportează ca unhandled rejection: avertisment în consola browserului și, în Node.js 15+, oprirea implicită a procesului. Mai mult, dacă pUser e respinsă, funcția aruncă, iar respingerea lui pSetari rămâne netratată.

Varianta corectă pentru paralelism:

JavaScript
const [user, setari] = await Promise.all([getUser(id), getSetari(id)]);

Promise.all atașează imediat handler-e pe toate promisiunile, deci nicio respingere nu rămâne orfană. Prima eroare respinge rezultatul.

Dacă ai nevoie de toate rezultatele, inclusiv de cele eșuate (de exemplu setările sunt opționale), folosești Promise.allSettled și tratezi fiecare rezultat. Dacă o cerere e opțională, o poți face sigură local:

JavaScript
const pSetari = getSetari(id).catch(() => SETARI_IMPLICITE);

Regula practică: dependențele dictează ordinea. Pornești în paralel tot ce e independent, prin Promise.all, și aștepți secvențial doar ce depinde de un rezultat anterior.

Ce urmărește intervievatorul: Se verifică dacă știi diferența de performanță și capcana erorilor orfane. Doar candidații cu experiență reală menționează unhandled rejection în varianta 2.

70 Mid

Implementează de la zero o funcție toate(promisiuni) care se comportă ca Promise.all.

Răspuns scurt: Întorci un new Promise; pentru fiecare element atașezi then, salvezi rezultatul la indexul lui și numeri câte s-au terminat. Când toate sunt gata, rezolvi cu array-ul; la prima respingere apelezi reject. Lista goală se rezolvă imediat cu [].

Comportamentul de reprodus: rezultatul păstrează ordinea intrării, nu ordinea terminării; prima respingere respinge totul; elementele care nu sunt promisiuni sunt tratate ca valori deja rezolvate; un iterabil gol dă imediat [].

JavaScript
function toate(iterabil) {
  return new Promise((resolve, reject) => {
    const elemente = Array.from(iterabil);
    const rezultate = new Array(elemente.length);
    let ramase = elemente.length;

    if (ramase === 0) {
      resolve([]);
      return;
    }

    elemente.forEach((el, i) => {
      Promise.resolve(el).then((valoare) => {
        rezultate[i] = valoare;
        ramase--;
        if (ramase === 0) resolve(rezultate);
      }, reject);
    });
  });
}

toate([asteapta(200).then(() => "a"), "b", Promise.resolve("c")])
  .then(console.log); // ["a", "b", "c"]

Detalii pe care intervievatorul le urmărește:

  • Promise.resolve(el) transformă valorile simple și thenables în promisiuni;
  • rezultatul se scrie la rezultate[i], nu cu push, ca ordinea să fie corectă;
  • se numără elementele rămase, nu se verifică rezultate.length, care e fix de la început;
  • apelurile repetate la reject sau resolve sunt inofensive: o promisiune se stabilește o singură dată;
  • cazul listei goale, fără de care promisiunea nu s-ar rezolva niciodată.

Ca extensie, poți cere variantele: allSettled (în loc de reject salvezi { status: "rejected", reason } și continui numărarea) sau race (primul then sau reject câștigă). Important de spus: Promise.all nu anulează celelalte operații după o eroare; ele continuă să ruleze, doar rezultatele lor sunt ignorate.

Ce urmărește intervievatorul: Se verifică dacă înțelegi contractul exact al lui Promise.all. Greșelile tipice: push în loc de index și uitarea cazului cu lista goală.

71 Mid

Ce se întâmplă cu o promisiune respinsă pe care nu o tratează nimeni? Cum prinzi global aceste erori în browser și în Node.js?

Răspuns scurt: Devine o „unhandled rejection”: browserul afișează o eroare în consolă și emite evenimentul unhandledrejection, iar Node.js 15+ oprește implicit procesul. Le prinzi global pentru raportare, dar le repari local, cu catch sau try/catch.

O promisiune respinsă fără niciun handler de eroare atașat până la terminarea microtask-urilor curente este considerată netratată.

În browser:

  • apare „Uncaught (in promise)” în consolă;
  • se emite evenimentul unhandledrejection pe window, pe care îl poți asculta pentru raportare;
  • dacă un handler se atașează mai târziu, se emite rejectionhandled.
JavaScript
window.addEventListener("unhandledrejection", (event) => {
  trimiteLaMonitorizare(event.reason);
  // event.preventDefault() ascunde mesajul din consolă
});

În Node.js:

  • de la versiunea 15, comportamentul implicit este --unhandled-rejections=throw: eroarea devine excepție neprinsă și procesul se oprește cu cod de ieșire nenul;
  • poți asculta process.on("unhandledRejection", (reason, promise) => { ... }), în primul rând pentru logare, apoi pentru o oprire controlată.

Handler-ele globale sunt plasa de siguranță, nu soluția. Erorile se tratează acolo unde poți lua o decizie: afișezi un mesaj, reîncerci, folosești o valoare implicită. Surse comune de respingeri netratate:

  • un apel async fără await și fără .catch („fire and forget”);
  • callback-uri async în forEach sau în event listeners;
  • promisiuni pornite în paralel și așteptate pe rând;
  • un .catch care aruncă din nou fără să existe alt handler mai sus.

Pentru operațiile lansate intenționat fără așteptare, atașezi explicit un handler: trimiteAnalytics().catch(logheaza). Regula ESLint @typescript-eslint/no-floating-promises le detectează automat în proiectele cu TypeScript, iar no-async-promise-executor prinde o variantă înrudită.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce se întâmplă în producție cu erorile pierdute. Mulți candidați nu știu că Node.js modern oprește procesul.

Eroarea, în practică:Uncaught (in promise)

72 Mid

Ce afișează codul de mai jos? Ce greșeli vezi în a doua funcție?

JavaScript
const p = new Promise((resolve, reject) => {
  resolve("primul");
  resolve("al doilea");
  reject(new Error("eroare"));
  console.log("executor terminat");
});
p.then(console.log, (e) => console.log("respins", e.message));

function getUser(id) {
  return new Promise(async (resolve, reject) => {
    const r = await fetch(`/api/users/${id}`);
    resolve(await r.json());
  });
}

Răspuns scurt: Afișează „executor terminat”, apoi „primul”: o promisiune se stabilește o singură dată, apelurile ulterioare sunt ignorate, dar codul executorului continuă. getUser e un anti-pattern: învelește inutil o promisiune, iar erorile din executorul async nu ajung la reject, deci promisiunea rămâne în așteptare.

Partea întâi ilustrează două reguli:

  • o promisiune trece o singură dată din pending în fulfilled sau rejected. Primul resolve câștigă, iar celelalte apeluri sunt ignorate fără eroare;
  • resolve nu oprește execuția executorului, deci console.log rulează. Rezultatul e afișat sincron, înainte de handler-ul then, care rulează ca microtask. Dacă vrei să te oprești, scrii return resolve(...).

Funcția getUser are două probleme.

Prima este anti-pattern-ul constructorului explicit: fetch întoarce deja o promisiune, deci nu e nevoie de new Promise. Codul e mai lung și mai fragil fără niciun câștig.

A doua e gravă: executorul este async. Dacă fetch eșuează sau r.json() aruncă (de exemplu răspunsul nu e JSON), excepția respinge promisiunea întoarsă de executor, pe care constructorul Promise o ignoră. reject nu e apelat niciodată, iar promisiunea exterioară rămâne în așteptare la nesfârșit. Apelantul nu primește nici rezultat, nici eroare. Regula ESLint no-async-promise-executor semnalează exact acest caz.

Varianta corectă:

JavaScript
async function getUser(id) {
  const r = await fetch(`/api/users/${id}`);
  if (!r.ok) throw new Error(`HTTP ${r.status}`);
  return r.json();
}

Erorile se propagă natural, iar verificarea lui r.ok tratează și răspunsurile HTTP de eroare. Excepțiile aruncate sincron într-un executor obișnuit (non-async) sunt prinse și transformate automat în respingere.

Ce urmărește intervievatorul: Se verifică înțelegerea stărilor unei promisiuni și recunoașterea unui anti-pattern frecvent. Executorul async care pierde erori e un bug greu de depistat.

Eroarea, în practică:Promise resolver undefined is not a functionPromise constructor cannot be invoked without 'new'

73 Mid

Un API întoarce produsele paginat, cu un câmp urmatoarea (URL-ul paginii următoare sau null). Scrie un generator asincron care parcurge toate produsele, pentru a putea fi consumat cu for await...of.

Răspuns scurt: Scrii o funcție async function* care cere pagina curentă, face yield pentru fiecare produs și trece la URL-ul următor până la null. Consumatorul iterează cu for await și se poate opri devreme cu break, moment în care nu se mai cer alte pagini.

Un generator asincron (async function*) combină await cu yield: produce valori pe rând, iar între ele poate aștepta operații asincrone. Este potrivit pentru date care vin în bucăți: paginare, stream-uri, mesaje.

JavaScript
async function* toateProdusele(url) {
  while (url) {
    const r = await fetch(url);
    if (!r.ok) throw new Error(`HTTP ${r.status} la ${url}`);
    const pagina = await r.json();
    yield* pagina.produse;      // câte un produs pe rând
    url = pagina.urmatoarea;
  }
}

for await (const produs of toateProdusele("/api/produse?page=1")) {
  afiseaza(produs);
  if (produs.id === cautat) break;  // nu se mai cer alte pagini
}

Avantaje față de o funcție care adună totul într-un array:

  • leneș: pagina următoare se cere doar când consumatorul ajunge la ea;
  • memorie constantă: nu ții toate produsele deodată;
  • oprire curată: la break, return sau la o excepție în corpul buclei, se apelează automat return() pe generator, iar un bloc finally din generator poate elibera resurse;
  • logica de paginare e separată de logica de procesare.

yield* delegă către un alt iterabil, aici array-ul de produse. Erorile din generator se propagă în bucla for await și pot fi prinse cu try/catch în jurul ei.

Pentru a obține totuși un array, colectezi manual sau, în mediile care îl suportă, cu Array.fromAsync (ES2024). Același protocol e implementat de stream-urile din Node.js și de ReadableStream din browserele moderne, deci pot fi parcurse tot cu for await.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi iterarea asincronă, utilă pentru date mari sau paginate. Puțini candidați menționează oprirea devreme cu break.

Eroarea, în practică:is not async iterable

74 Senior

Ai 500 de URL-uri de descărcat, dar serverul acceptă cel mult 5 cereri simultane. Scrie o funcție cuLimita(sarcini, limita) care rulează sarcinile asincrone cu concurență limitată și întoarce rezultatele în ordine.

Răspuns scurt: Pornești limita de „lucrători” care iau, pe rând, următorul index dintr-un contor comun și așteaptă sarcina; fiecare rezultat se salvează la indexul lui. Când toți lucrătorii termină, întorci array-ul.

Promise.all cu 500 de cereri le pornește pe toate deodată; for...of cu await le rulează câte una. Soluția intermediară este un pool de lucrători:

JavaScript
async function cuLimita(sarcini, limita) {
  const rezultate = new Array(sarcini.length);
  let urmatorul = 0;

  async function lucrator() {
    while (urmatorul < sarcini.length) {
      const i = urmatorul++;
      rezultate[i] = await sarcini[i]();
    }
  }

  const lucratori = Array.from(
    { length: Math.min(limita, sarcini.length) },
    lucrator
  );
  await Promise.all(lucratori);
  return rezultate;
}

const sarcini = urls.map((u) => () => fetch(u).then((r) => r.json()));
const date = await cuLimita(sarcini, 5);

De ce funcționează:

  • sarcinile sunt funcții care creează promisiunea, nu promisiuni deja pornite; altfel toate cererile ar începe imediat;
  • urmatorul++ e sigur fără blocări: codul JavaScript rulează pe un singur fir, iar între citire și incrementare nu există niciun await;
  • fiecare lucrător ia o sarcină nouă imediat ce o termină pe cea curentă, deci concurența rămâne mereu la limită, fără să aștepte terminarea unui lot întreg (cum ar face împărțirea în loturi de câte 5).

Decizii de discutat cu intervievatorul:

  • la o eroare, varianta de mai sus respinge totul, dar lucrătorii rămași continuă; pentru rezultate parțiale, prinzi eroarea per sarcină și salvezi { ok: false, eroare };
  • anularea se face cu un AbortSignal transmis sarcinilor și verificat în buclă;
  • reîncercarea cu backoff se adaugă în jurul fiecărei sarcini, nu în pool.

În producție se folosesc des biblioteci mici precum p-limit, dar implementarea arată stăpânirea promisiunilor.

Ce urmărește intervievatorul: Se verifică abilitatea de a controla concurența, o problemă reală la importuri și scrapere. Greșeala tipică este transmiterea promisiunilor deja pornite în loc de funcții.

75 Senior

Ce afișează codul de mai jos, în ordine?

JavaScript
console.log("A");
setTimeout(() => console.log("B"), 0);
queueMicrotask(() => console.log("C"));
(async () => {
  console.log("D");
  await undefined;
  console.log("E");
})();
Promise.resolve()
  .then(() => console.log("F"))
  .then(() => console.log("G"));
console.log("H");

Răspuns scurt: A, D, H, C, E, F, G, B. Întâi rulează tot codul sincron, apoi coada de microtask-uri, în ordinea programării și inclusiv microtask-urile adăugate între timp, și abia apoi următorul macrotask, timer-ul.

Raționamentul pas cu pas:

Codul sincron, de sus în jos:

  • „A” se afișează;
  • setTimeout programează B ca macrotask (task queue);
  • queueMicrotask pune C în coada de microtask-uri;
  • funcția async rulează sincron până la await: se afișează „D”; await undefined suspendă funcția și pune continuarea (E) în coada de microtask-uri;
  • Promise.resolve().then(F) pune F în coada de microtask-uri; G nu e încă programat, pentru că depinde de promisiunea creată de primul then;
  • „H” se afișează.

Microtask-urile, după golirea stivei: coada conține C, E, F, în ordinea programării. Rulează C, apoi E, apoi F. Terminarea lui F rezolvă promisiunea următoare, deci G intră la finalul cozii. Event loop-ul golește coada complet, inclusiv elementele adăugate în timpul golirii, deci rulează și G.

Macrotask-ul: abia acum rulează B.

Rezultat: A, D, H, C, E, F, G, B.

Reguli generale:

  • după fiecare macrotask (script, timer, eveniment), event loop-ul golește integral coada de microtask-uri înainte de orice altceva, inclusiv înainte de randare;
  • microtask-uri: handler-e de promisiuni, continuări după await, queueMicrotask, callback-uri MutationObserver;
  • macrotask-uri: setTimeout, setInterval, evenimente de interfață, mesaje.

Detaliu de versiune: await pe o promisiune nativă costă un singur microtask din ES2019; înainte costa trei, iar ordinea în puzzle-uri asemănătoare era diferită. Un return al unei promisiuni dintr-o funcție async adaugă încă două microtask-uri. Un lanț infinit de microtask-uri blochează pagina, la fel ca o buclă infinită.

Ce urmărește intervievatorul: Intervievatorul verifică un model precis al cozilor din event loop, inclusiv microtask-urile adăugate în timpul golirii. Greșeala tipică: B pus înaintea lui G.

76 Senior

Pe o pagină de produs, trei componente independente apelează la încărcare getProdus(id), iar serverul primește trei cereri identice. Cum previi asta? De ce un cache simplu cu rezultatul nu e suficient?

JavaScript
const cache = new Map();
async function getProdus(id) {
  if (cache.has(id)) return cache.get(id);
  const r = await fetch(`/api/produse/${id}`);
  const produs = await r.json();
  cache.set(id, produs);
  return produs;
}

Răspuns scurt: Cache-ul se completează abia după răspuns, deci apelurile pornite înainte îl găsesc gol și fac cereri proprii. Salvezi în cache promisiunea, imediat, nu rezultatul; apelurile simultane o împart, iar la eroare o ștergi din cache.

Codul are o condiție de cursă (race condition), chiar dacă JavaScript rulează pe un singur fir. Verificarea cache.has(id) și scrierea cache.set sunt separate de două await-uri. Între ele, alte apeluri rulează, găsesc cache-ul gol și pornesc propriile cereri. Tiparul „verifică, apoi acționează” peste un await este sursa majorității condițiilor de cursă din cod asincron.

Soluția este să salvezi promisiunea, sincron, înainte de primul await:

JavaScript
const inZbor = new Map();

function getProdus(id) {
  if (!inZbor.has(id)) {
    const p = fetch(`/api/produse/${id}`)
      .then((r) => {
        if (!r.ok) throw new Error(`HTTP ${r.status}`);
        return r.json();
      })
      .catch((err) => {
        inZbor.delete(id);   // permite reîncercarea
        throw err;
      });
    inZbor.set(id, p);
  }
  return inZbor.get(id);
}

Toate apelurile simultane primesc aceeași promisiune, deci pleacă o singură cerere.

Decizii de discutat:

  • eșecurile se scot din cache, altfel o eroare temporară rămâne „memorată” definitiv;
  • expirarea: datele se învechesc; păstrezi un timestamp și reîncarci după un interval, sau ștergi intrarea după ce cererea se termină, dacă vrei doar deduplicare, nu cache;
  • memoria: un cache fără limită crește odată cu numărul de ID-uri vizitate;
  • anularea: dacă o componentă anulează cererea comună cu AbortController, le afectează și pe celelalte, deci anularea se face per consumator, nu pe cererea partajată.

Același tipar se aplică la reîmprospătarea unui token de autentificare: zece cereri care primesc 401 simultan trebuie să aștepte o singură reîmprospătare, nu să pornească zece. Bibliotecile de server state implementează exact această deduplicare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști condițiile de cursă într-un mediu single-thread. Răspunsul slab propune un flag boolean, care nu le dă rezultatul celorlalte apeluri.

DOM, evenimente și API-uri din browser

77 Junior

Care e diferența dintre textContent, innerText și innerHTML? Pe care îl folosești pentru a afișa un nume introdus de utilizator?

Răspuns scurt: textContent citește sau scrie tot textul nodului, fără să țină cont de CSS; innerText întoarce doar textul vizibil și declanșează calculul layout-ului; innerHTML lucrează cu HTML parsat. Pentru date de la utilizator folosești textContent.

Cele trei proprietăți par asemănătoare, dar lucrează diferit:

  • textContent întoarce textul tuturor nodurilor descendente, inclusiv al celor ascunse cu CSS și conținutul tag-urilor <script> sau <style>. La scriere, înlocuiește tot conținutul cu un singur nod text. Valoarea nu e interpretată ca HTML;
  • innerText întoarce textul așa cum apare pe ecran: ignoră elementele cu display: none, aplică transformări CSS precum text-transform și transformă <br> sau blocurile în rânduri noi. Pentru asta, browserul trebuie să calculeze stilurile și layout-ul, deci citirea lui într-o buclă poate forța recalculări costisitoare;
  • innerHTML întoarce sau setează marcajul HTML. La scriere, browserul parsează string-ul și creează elemente.

Pentru un nume introdus de utilizator:

JavaScript
const el = document.querySelector("#salut");
el.textContent = `Bine ai venit, ${nume}!`;

Dacă numele conține <img src=x onerror=...>, cu textContent apare literal pe ecran, ca text. Cu innerHTML, aceeași valoare ar crea un element și ar executa cod.

Când folosești fiecare:

  • textContent pentru afișarea și citirea de text, implicit;
  • innerText când ai nevoie de textul exact vizibil, de exemplu la copierea conținutului afișat;
  • innerHTML doar cu marcaj controlat de tine (șabloane statice) sau trecut printr-un sanitizer; pentru structuri dinamice, createElement și append sunt mai sigure.

Scrierea în innerHTML distruge și recreează toți copiii, deci pierzi listener-ele atașate pe ei și starea câmpurilor de formular.

Ce urmărește intervievatorul: Se verifică diferențele practice și reflexul de securitate. Greșeala frecventă: innerHTML folosit implicit pentru orice text.

78 Junior

De ce codul de mai jos elimină doar o parte dintre elemente? Care e diferența dintre un HTMLCollection live și un NodeList static?

JavaScript
const active = document.getElementsByClassName("activ");
for (let i = 0; i < active.length; i++) {
  active[i].classList.remove("activ");
}

Răspuns scurt: getElementsByClassName întoarce o colecție live, care se actualizează când DOM-ul se schimbă. La eliminarea clasei, elementul dispare din colecție, indicii se decalează și bucla sare peste fiecare al doilea element. querySelectorAll întoarce un NodeList static, sigur pentru astfel de bucle.

Metodele de selecție întorc două feluri de colecții:

  • getElementsByClassName, getElementsByTagName și element.children întorc un HTMLCollection live: o vedere asupra DOM-ului care reflectă imediat orice schimbare;
  • querySelectorAll întoarce un NodeList static: o listă fixă de elemente, din momentul apelului.

În exemplu, presupunem trei elemente active. La i = 0, primul pierde clasa și iese din colecție. Colecția are acum două elemente, iar fostul element de pe poziția 1 e acum pe 0. Bucla trece la i = 1 și îl tratează pe al treilea. Al doilea rămâne activ, iar length scade în timpul buclei.

Reparații:

JavaScript
document.querySelectorAll(".activ").forEach((el) => el.classList.remove("activ"));

// sau, dacă ai deja o colecție live
for (const el of Array.from(active)) el.classList.remove("activ");

Alte diferențe utile:

  • NodeList are forEach, dar nu map sau filter; convertești cu Array.from sau spread;
  • HTMLCollection nu are nici forEach;
  • childNodes este un NodeList live și include și nodurile text, inclusiv spațiile dintre tag-uri, pe când children conține doar elemente.

Colecțiile live au un avantaj: nu trebuie să interoghezi din nou DOM-ul pentru a vedea starea curentă. În majoritatea codului, querySelector și querySelectorAll sunt preferate pentru că acceptă orice selector CSS și au un comportament previzibil. Dacă ștergi elemente într-o buclă, iterează pe o copie statică sau de la final spre început.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi distincția live/static, sursă de bug-uri greu de înțeles. Mulți candidați nu știu ce întoarce fiecare metodă.

79 Junior

Care e diferența dintre onclick și addEventListener? De ce codul de mai jos nu elimină listener-ul și ce fac opțiunile once și passive?

JavaScript
buton.addEventListener("click", () => salveaza());
buton.removeEventListener("click", () => salveaza());

Răspuns scurt: onclick permite un singur handler, suprascris la fiecare atribuire; addEventListener permite oricâte și are opțiuni. removeEventListener cere exact aceeași referință de funcție, iar două arrow-uri identice sunt funcții diferite. once elimină automat listener-ul după primul apel; passive promite că nu apelezi preventDefault.

element.onclick = fn este o proprietate: o atribuire nouă înlocuiește handler-ul anterior, deci două scripturi care setează onclick se calcă reciproc. addEventListener adaugă handler-e într-o listă, le rulează în ordinea înregistrării și acceptă opțiuni.

removeEventListener identifică listener-ul după tipul evenimentului, referința funcției și opțiunea capture. Două arrow functions cu același corp sunt obiecte diferite, deci al doilea apel nu găsește nimic de eliminat. Corect este să păstrezi referința:

JavaScript
const laClick = () => salveaza();
buton.addEventListener("click", laClick);
buton.removeEventListener("click", laClick);

Opțiuni utile:

  • { once: true }: listener-ul se elimină automat după primul apel;
  • { passive: true }: îi spui browserului că nu vei apela preventDefault(). Pentru touchstart, touchmove și wheel, browserul poate derula imediat, fără să aștepte handler-ul, deci derularea e mai fluidă. Un preventDefault() într-un listener pasiv este ignorat, cu avertisment în consolă;
  • { capture: true }: listener-ul rulează în faza de capturare, nu în cea de bubbling;
  • { signal }: listener-ul se elimină când semnalul unui AbortController este anulat.

Opțiunea signal simplifică curățenia când ai mai multe listener-e:

JavaScript
const ac = new AbortController();
window.addEventListener("resize", recalculeaza, { signal: ac.signal });
document.addEventListener("keydown", scurtaturi, { signal: ac.signal });
ac.abort(); // le elimină pe amândouă

Listener-ele uitate pe window sau document țin în memorie closure-urile lor și rulează în continuare după ce partea de interfață a dispărut.

Ce urmărește intervievatorul: Se verifică dacă știi cum se elimină corect un listener și ce opțiuni există. Greșeala clasică este încercarea de a elimina o funcție anonimă.

80 Junior

Care e diferența dintre event.target și event.currentTarget? Ce afișează codul la un click pe textul „Șterge” din buton?

HTML
<ul id="lista">
  <li data-id="7"><button><span>Șterge</span></button></li>
</ul>
JavaScript
document.querySelector("#lista").addEventListener("click", (e) => {
  console.log(e.target.tagName, e.currentTarget.id);
});

Răspuns scurt: Afișează „SPAN lista”. target este elementul pe care s-a dat efectiv click, cel mai adânc, iar currentTarget este elementul care are listener-ul atașat. Pentru a găsi butonul sau rândul, folosești e.target.closest(...).

Când dai click, evenimentul are o singură țintă reală, elementul cel mai adânc de sub cursor, aici <span>. Evenimentul urcă apoi prin strămoși (bubbling), iar fiecare listener întâlnit pe drum rulează.

  • e.target rămâne mereu elementul de origine: SPAN;
  • e.currentTarget este elementul al cărui listener rulează în acel moment: <ul id="lista">. Într-o funcție clasică (nu arrow), this are aceeași valoare ca currentTarget.

Bug-ul frecvent apare când codul presupune că target este butonul. Dacă butonul conține o iconiță sau un <span>, e.target.dataset.id sau e.target.matches("button") dau rezultate greșite, în funcție de punctul exact al click-ului. Soluția robustă este closest, care urcă de la țintă până la primul strămoș potrivit:

JavaScript
lista.addEventListener("click", (e) => {
  const buton = e.target.closest("button");
  if (!buton || !lista.contains(buton)) return;
  const id = buton.closest("li").dataset.id;
  stergeProdus(id);
});

Verificarea lista.contains(buton) evită cazurile în care closest găsește un element din afara containerului.

Alte detalii:

  • currentTarget este null după terminarea handler-ului; dacă îl folosești într-un callback asincron, îl salvezi întâi într-o variabilă;
  • e.composedPath() întoarce tot drumul evenimentului, util la depanare și cu Shadow DOM;
  • pentru elemente cu pointer-events: none, click-ul trece la elementul de dedesubt, care devine target.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența și folosești closest pentru elemente imbricate. Mulți candidați scriu cod care funcționează doar când click-ul nimerește chiar butonul.

81 Junior

Scrie codul care tratează trimiterea unui formular de contact fără reîncărcarea paginii: citește valorile, validează emailul și trimite datele ca JSON. Ce diferență e între evenimentele input și change?

Răspuns scurt: Asculți evenimentul submit pe formular, apelezi preventDefault, citești valorile cu FormData, validezi și trimiți cu fetch. input se declanșează la fiecare modificare a valorii, change abia când valoarea e confirmată, de obicei la pierderea focusului.

Listener-ul se pune pe evenimentul submit al formularului, nu pe click-ul butonului, pentru că formularul se poate trimite și cu Enter dintr-un câmp:

JavaScript
const form = document.querySelector("#contact");

form.addEventListener("submit", async (e) => {
  e.preventDefault();                       // oprește reîncărcarea paginii
  const date = Object.fromEntries(new FormData(form));
  const eroare = form.querySelector(".eroare");

  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(date.email ?? "")) {
    eroare.textContent = "Adresa de email nu pare validă.";
    return;
  }

  const buton = form.querySelector("button[type=submit]");
  buton.disabled = true;
  try {
    const r = await fetch("/api/contact", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(date),
    });
    if (!r.ok) throw new Error(`HTTP ${r.status}`);
    form.reset();
    eroare.textContent = "";
  } catch {
    eroare.textContent = "Mesajul nu a putut fi trimis. Încearcă din nou.";
  } finally {
    buton.disabled = false;
  }
});

Puncte urmărite:

  • FormData citește automat câmpurile după atributul name; Object.fromEntries îl transformă în obiect. Pentru câmpuri cu valori multiple (checkbox-uri cu același nume) folosești getAll;
  • butonul dezactivat previne trimiterile duble;
  • mesajele de eroare se afișează cu textContent;
  • validarea din browser e pentru experiența utilizatorului; serverul validează din nou.

Despre evenimente: input se declanșează la fiecare tastă, lipire sau ștergere, potrivit pentru validare live sau căutare. change se declanșează când valoarea e confirmată: la pierderea focusului pentru text, imediat pentru checkbox-uri și select-uri.

Ce urmărește intervievatorul: Se verifică un flux complet de formular, cu atenție la detaliile care contează în producție. Greșeala tipică este listener-ul pe click-ul butonului.

82 Junior

Ce afișează codul după ce utilizatorul a scris „Maria” în câmp? Care e diferența dintre un atribut HTML și o proprietate DOM?

HTML
<input id="nume" value="Ana" data-max-lungime="20">
JavaScript
const input = document.querySelector("#nume");
// utilizatorul scrie „Maria”
console.log(input.value);
console.log(input.getAttribute("value"));
console.log(input.dataset.maxLungime, typeof input.dataset.maxLungime);

Răspuns scurt: Afișează „Maria”, „Ana” și „20 string”. Atributul value reprezintă valoarea inițială din HTML, iar proprietatea value valoarea curentă. Atributele data-* ajung în dataset, cu numele în camelCase și valori mereu de tip string.

HTML-ul definește atribute, iar browserul creează din el obiecte DOM cu proprietăți. Multe atribute au proprietăți corespondente, dar relația nu e mereu o simplă oglindă.

  • pentru <input>, atributul value este valoarea implicită (input.defaultValue). Proprietatea value este starea curentă, schimbată de utilizator. După ce scrie „Maria”, proprietatea e „Maria”, iar atributul rămâne „Ana”. form.reset() revine la valoarea atributului;
  • la fel, checked (atribut) și input.checked (proprietate) diferă după ce utilizatorul bifează;
  • proprietățile pot normaliza valoarea: a.href întoarce URL-ul absolut, iar a.getAttribute("href") exact textul din HTML.

Atributele data-* sunt destinate datelor proprii ale aplicației. Le citești prin dataset, cu conversie automată din kebab-case în camelCase: data-max-lungime devine dataset.maxLungime. Valorile sunt întotdeauna string-uri, deci convertești explicit: Number(input.dataset.maxLungime). Atribuirea el.dataset.stare = "activ" creează atributul data-stare="activ", vizibil în HTML și utilizabil în selectori CSS ([data-stare="activ"]).

Când folosești fiecare:

  • proprietăți pentru starea curentă a elementelor (value, checked, disabled);
  • getAttribute și setAttribute pentru atribute fără proprietate echivalentă, pentru atribute ARIA sau când ai nevoie de valoarea exactă din marcaj;
  • dataset pentru informații mici legate de element, precum un ID de produs pe un buton, nu pentru obiecte mari, care trebuie serializate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că atributul value nu reflectă ce a scris utilizatorul. Mulți candidați uită că dataset întoarce mereu string-uri.

83 Mid

Trebuie să afișezi 1.000 de rânduri primite de la un API într-un tabel. Ce e greșit în codul de mai jos și cum îl rescrii eficient?

JavaScript
for (const p of produse) {
  tabel.innerHTML += `<tr><td>${p.nume}</td><td>${p.pret}</td></tr>`;
}

Răspuns scurt: Fiecare += reparsează tot conținutul tabelului și recreează toate rândurile, deci costul crește pătratic, iar datele neescapate deschid calea spre XSS. Construiești rândurile cu createElement și textContent într-un DocumentFragment și le inserezi o singură dată.

innerHTML += x înseamnă: citește HTML-ul existent, concatenează, parsează totul din nou, distruge nodurile vechi și creează noduri noi. La rândul 1.000, browserul reconstruiește 1.000 de rânduri. Totalul crește pătratic cu numărul de rânduri. În plus, listener-ele și starea elementelor existente se pierd la fiecare pas, iar valorile din API sunt inserate ca HTML, deci un nume de produs care conține marcaj se execută.

Varianta eficientă și sigură:

JavaScript
function randeazaProduse(tbody, produse) {
  const fragment = document.createDocumentFragment();
  for (const p of produse) {
    const tr = document.createElement("tr");
    const nume = document.createElement("td");
    nume.textContent = p.nume;
    const pret = document.createElement("td");
    pret.textContent = new Intl.NumberFormat("ro-RO", {
      style: "currency", currency: "RON",
    }).format(p.pret);
    tr.append(nume, pret);
    fragment.append(tr);
  }
  tbody.replaceChildren(fragment);
}

De ce funcționează:

  • DocumentFragment este un container care nu face parte din pagină; modificările din el nu declanșează layout. La inserare, copiii lui sunt mutați în DOM într-o singură operație;
  • replaceChildren (disponibil în browserele moderne) golește și umple elementul într-un singur pas;
  • textContent elimină riscul de injecție.

O variantă acceptabilă este construirea unui singur string HTML, cu valorile escapate, și o singură atribuire innerHTML. Pentru zeci de mii de rânduri, nici asta nu mai e suficient: se folosește paginarea sau virtualizarea, adică randarea doar a rândurilor vizibile. Formatatorul Intl.NumberFormat merită creat o singură dată, în afara buclei.

Ce urmărește intervievatorul: Se verifică înțelegerea costului operațiilor DOM și reflexul de securitate. Greșeala tipică este innerHTML += în buclă.

84 Mid

Cum creezi și emiți un eveniment propriu? Scrie o componentă „coș” care anunță restul paginii când se adaugă un produs, fără ca celelalte părți să cunoască coșul direct.

Răspuns scurt: Creezi un CustomEvent cu nume propriu, date în detail și, dacă vrei să urce prin DOM, bubbles: true, apoi îl emiți cu dispatchEvent. Ascultătorii folosesc addEventListener ca pentru orice eveniment. Pentru logică fără DOM, o clasă poate extinde EventTarget.

Evenimentele proprii decuplează părțile unei pagini: cine emite nu știe cine ascultă. Un coș care anunță schimbările:

JavaScript
class Cos extends EventTarget {
  #produse = [];

  adauga(produs) {
    this.#produse.push(produs);
    this.dispatchEvent(
      new CustomEvent("cos:schimbat", {
        detail: { produse: [...this.#produse], adaugat: produs },
      })
    );
  }
}

const cos = new Cos();

cos.addEventListener("cos:schimbat", (e) => {
  document.querySelector("#numar-cos").textContent = e.detail.produse.length;
});
cos.addEventListener("cos:schimbat", (e) => {
  arataNotificare(`${e.detail.adaugat.nume} a fost adăugat în coș`);
});

cos.adauga({ id: 7, nume: "Carte" });

EventTarget poate fi extins direct în browserele moderne și în Node.js, deci nu ai nevoie de un emitter propriu. Varianta legată de DOM emite pe un element:

JavaScript
buton.dispatchEvent(new CustomEvent("produs:ales", {
  bubbles: true,          // urcă până la document
  detail: { id: 7 },
}));
document.addEventListener("produs:ales", (e) => console.log(e.detail.id));

Detalii importante:

  • dispatchEvent este sincron: listener-ele rulează imediat, înainte ca dispatchEvent să se întoarcă, nu într-un task ulterior;
  • o excepție într-un listener nu oprește celelalte listener-e și nu ajunge la cel care a emis evenimentul; e raportată ca eroare globală;
  • detail e transmis prin referință; un listener îl poate modifica, deci trimiți copii sau date imutabile;
  • un prefix în nume (cos:) previne coliziunile cu evenimente native.

Abuzul de evenimente globale face fluxul greu de urmărit, deci le folosești pentru notificări între module, nu pentru orice apel de funcție.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi tiparul observer cu API-uri native. Puțini candidați știu că dispatchEvent este sincron.

85 Mid

Cum construiești corect un URL cu parametri de căutare introduși de utilizator? Ce e greșit aici?

JavaScript
const url = "/api/cauta?q=" + termen + "&categorie=" + categorie;

Răspuns scurt: Valorile nu sunt codificate, deci caractere ca &, =, # sau spațiu strică structura URL-ului sau injectează parametri. Folosești URL și URLSearchParams, care codifică automat; manual, encodeURIComponent pentru fiecare valoare.

Dacă utilizatorul caută „pâine & lapte”, URL-ul devine /api/cauta?q=pâine & lapte&categorie=.... Serverul vede parametrul q cu valoarea „pâine ” și un parametru nou, „ lapte”. Un # taie restul URL-ului, fiind interpretat ca fragment. Un termen precum x&admin=true adaugă parametri arbitrari.

API-urile URL și URLSearchParams rezolvă codificarea:

JavaScript
const url = new URL("/api/cauta", window.location.origin);
url.searchParams.set("q", termen);
url.searchParams.set("categorie", categorie);
url.searchParams.append("tag", "nou");
url.searchParams.append("tag", "reducere");

const r = await fetch(url);
// /api/cauta?q=p%C3%A2ine+%26+lapte&categorie=...&tag=nou&tag=reducere

Și citirea e simplă:

JavaScript
const params = new URLSearchParams(window.location.search);
const pagina = Number(params.get("pagina") ?? 1);
const taguri = params.getAll("tag");

Diferența dintre funcțiile vechi:

  • encodeURIComponent(valoare) codifică tot ce are sens special într-un URL (&, =, ?, /, #), potrivit pentru o singură valoare;
  • encodeURI(url) lasă neatinse caracterele de structură, potrivit doar pentru un URL întreg, deja bine construit.

Detalii: URLSearchParams codifică spațiul ca +, iar encodeURIComponent ca %20; serverele acceptă de obicei ambele forme în query string, dar nu și în cale. Valorile citite sunt mereu string-uri, iar get întoarce null pentru un parametru lipsă.

Pentru actualizarea URL-ului fără reîncărcare (filtre care pot fi distribuite printr-un link) folosești history.replaceState(null, "", url).

Ce urmărește intervievatorul: Se verifică reflexul de a nu construi URL-uri prin concatenare. Mulți candidați nu știu diferența dintre encodeURI și encodeURIComponent.

Eroarea, în practică:URIError: URI malformed

86 Mid

Ce este un Web Worker și când îl folosești? Ce nu poate face un worker și cum comunici cu el?

Răspuns scurt: Un Web Worker rulează JavaScript pe un fir separat, deci un calcul greu nu blochează interfața. Nu are acces la DOM sau la window; comunici prin postMessage și evenimentul message, iar datele sunt copiate prin structured clone sau transferate.

Codul paginii, randarea și evenimentele împart același fir. Un calcul de câteva sute de milisecunde (parsarea unui fișier CSV mare, procesarea unei imagini, căutare fuzzy în zeci de mii de elemente) îngheață pagina. Un Web Worker mută calculul pe alt fir de execuție.

JavaScript
// main.js
const worker = new Worker(new URL("./analiza.js", import.meta.url), { type: "module" });
worker.postMessage({ randuri: textCsv });
worker.addEventListener("message", (e) => afiseazaStatistici(e.data));
worker.addEventListener("error", (e) => console.error(e.message));

// analiza.js
self.addEventListener("message", (e) => {
  const rezultat = calculeazaStatistici(e.data.randuri);
  self.postMessage(rezultat);
});

Ce nu poate face un worker:

  • nu accesează DOM-ul, window sau document; trimite rezultatul înapoi, iar pagina actualizează interfața;
  • nu împarte variabile cu pagina; fiecare are propriul scope global (self).

Ce poate face: fetch, timere, IndexedDB, WebSocket, OffscreenCanvas și import de module.

Comunicarea:

  • postMessage copiază datele prin algoritmul structured clone, care acceptă obiecte, array-uri, Map, Set, Date, dar nu funcții sau elemente DOM. Copierea unor date foarte mari are un cost;
  • obiectele transferabile, precum ArrayBuffer, se pot muta fără copiere: worker.postMessage(buffer, [buffer]). După transfer, bufferul nu mai e utilizabil în pagină.

Worker-ul are un cost de pornire și de serializare, deci nu merită pentru operații scurte. Pentru mai multe sarcini, păstrezi un worker pornit și îi trimiți mesaje. Peste postMessage se poate construi o interfață bazată pe promisiuni, cu un ID per cerere.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi opțiunile pentru calcule grele în browser și limitele lor. Greșeala tipică este încercarea de a modifica DOM-ul din worker.

Eroarea, în practică:DataCloneError: could not be clonedCannot perform ... on a detached ArrayBuffer

87 Senior

La un click pe „Exportă”, pagina procesează 200.000 de rânduri și îngheață câteva secunde: butoanele nu răspund, iar indicatorul de încărcare nu apare. Cum restructurezi codul fără să muți totul pe server?

Răspuns scurt: Spargi procesarea în bucăți mici și cedezi controlul browserului între ele (setTimeout, scheduler.yield unde există), ca să poată randa și trata evenimente; afișezi progresul. Dacă procesarea e pur computațională, o muți într-un Web Worker. Măsori cu panoul Performance înainte și după.

Indicatorul nu apare pentru că browserul randează doar între sarcini. Dacă handler-ul de click rulează cinci secunde fără pauză, modificarea DOM-ului care afișează indicatorul se vede abia la final. În panoul Performance din DevTools apare ca un singur „long task”, adică o sarcină de peste 50 ms, iar metrica INP (cât durează până la următoarea actualizare vizuală după o interacțiune) devine foarte slabă.

Prima opțiune este împărțirea lucrului în bucăți, cu cedarea controlului între ele:

JavaScript
const cedeaza = () =>
  globalThis.scheduler?.yield
    ? scheduler.yield()
    : new Promise((r) => setTimeout(r, 0));

async function proceseaza(randuri, laProgres) {
  const rezultat = [];
  let ultimaPauza = performance.now();
  for (let i = 0; i < randuri.length; i++) {
    rezultat.push(transforma(randuri[i]));
    if (performance.now() - ultimaPauza > 40) {
      laProgres(i / randuri.length);
      await cedeaza();
      ultimaPauza = performance.now();
    }
  }
  return rezultat;
}

Bucla verifică timpul scurs, nu un număr fix de rânduri, deci se adaptează la dispozitive lente. scheduler.yield() există în browserele bazate pe Chromium și păstrează prioritatea sarcinii; setTimeout e varianta universală.

A doua opțiune este un Web Worker, când procesarea nu are nevoie de DOM: firul principal rămâne complet liber, dar plătești serializarea datelor.

Contează și ce rămâne în firul principal:

  • afișezi indicatorul, apoi cedezi o dată înainte de începerea lucrului;
  • dezactivezi butonul ca să previi exporturi paralele;
  • permiți anularea, cu un flag verificat la fiecare pauză sau cu un AbortSignal;
  • verifici dacă algoritmul nu e, de fapt, pătratic; o complexitate corectă rezolvă uneori totul.

Ce urmărește intervievatorul: Se verifică înțelegerea legăturii dintre event loop, randare și responsivitate, plus metoda de măsurare. Răspunsul slab propune doar un setTimeout în jurul întregului calcul.

Erori, module, iteratori și metaprogramare

88 Junior

Ce afișează codul de mai jos? De ce try/catch nu prinde eroarea din a doua funcție?

JavaScript
function citeste() {
  try {
    return "din try";
  } finally {
    console.log("finally rulează");
  }
}
console.log(citeste());

function programeaza() {
  try {
    setTimeout(() => { throw new Error("din timer"); }, 0);
  } catch (e) {
    console.log("prins:", e.message);
  }
}
programeaza();

Răspuns scurt: Afișează „finally rulează”, apoi „din try”; eroarea din timer nu e prinsă și apare ca „Uncaught Error”. finally rulează chiar și după return, iar try/catch prinde doar erorile din codul care rulează sincron în blocul lui; callback-ul timer-ului rulează mai târziu, pe altă stivă.

finally rulează întotdeauna: după try normal, după catch, după return, break sau o excepție. Valoarea de return se calculează întâi și se păstrează, apoi rulează finally, apoi funcția se întoarce. De aceea log-ul din finally apare înaintea rezultatului.

O capcană: dacă finally conține propriul return, acesta înlocuiește rezultatul și chiar înghite excepțiile:

JavaScript
function f() {
  try { throw new Error("pierdută"); }
  finally { return "ok"; }
}
f(); // "ok", eroarea dispare

De aceea, în finally pui doar curățenie (închiderea unei resurse, ascunderea unui indicator), fără return.

De ce nu e prinsă eroarea din timer: try/catch acționează doar asupra codului care rulează pe stivă cât timp blocul try e activ. setTimeout doar programează callback-ul și se întoarce imediat; blocul try se termină fără erori. Callback-ul rulează mai târziu, ca sarcină separată, când programeaza nu mai e pe stivă. Excepția devine eroare globală (evenimentul error pe window, „Uncaught Error” în consolă).

Soluțiile:

  • pui try/catch în interiorul callback-ului;
  • transformi operația într-o promisiune și o aștepți cu await într-un try, caz în care eroarea ajunge în catch:
JavaScript
try {
  await new Promise((_, reject) => setTimeout(() => reject(new Error("din timer")), 0));
} catch (e) {
  console.log("prins:", e.message);
}

Aceeași regulă se aplică event listener-elor și callback-urilor de tip Node.js.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi legătura dintre excepții și stiva de apeluri. Mulți candidați cred că try/catch prinde orice eroare din codul scris în interior.

Eroarea, în practică:Missing catch or finally after try

89 Junior

Scrie o clasă de eroare proprie EroareValidare care reține câmpul invalid. Cum o deosebești de alte erori în catch și cum păstrezi eroarea originală când o învelești?

Răspuns scurt: Extinzi Error, apelezi super(mesaj), setezi name și adaugi câmpurile proprii. În catch verifici cu instanceof sau după name, iar eroarea originală o transmiți prin opțiunea cause, din ES2022.

O eroare proprie face ca tratarea să depindă de tip, nu de textul mesajului:

JavaScript
class EroareValidare extends Error {
  constructor(camp, mesaj, options) {
    super(mesaj, options);           // options poate conține { cause }
    this.name = "EroareValidare";
    this.camp = camp;
  }
}

function valideazaVarsta(valoare) {
  const n = Number(valoare);
  if (!Number.isInteger(n) || n < 0) {
    throw new EroareValidare("varsta", "Vârsta trebuie să fie un număr întreg pozitiv");
  }
  return n;
}

try {
  valideazaVarsta("abc");
} catch (e) {
  if (e instanceof EroareValidare) {
    arataEroareLangaCamp(e.camp, e.message);
  } else {
    throw e;                          // nu înghiți erorile neașteptate
  }
}

Elemente de reținut:

  • super(mesaj) setează message și stack; fără name propriu, eroarea apare în loguri ca simplu „Error”;
  • catch prinde orice, inclusiv bug-uri (TypeError din cod greșit). De aceea tratezi doar tipurile pe care le cunoști și arunci din nou restul;
  • în JavaScript poți arunca orice valoare (throw "text"), dar fără stack și fără tip. Aruncă mereu instanțe de Error.

Opțiunea cause (ES2022) păstrează lanțul de erori când învelești o eroare de nivel jos într-una cu sens pentru aplicație:

JavaScript
try {
  await salveazaInBaza(date);
} catch (err) {
  throw new Error("Comanda nu a putut fi salvată", { cause: err });
}

Eroarea originală rămâne disponibilă în e.cause, iar consolele moderne și instrumentele de monitorizare o afișează. Pentru erori venite din alt realm sau după serializare, instanceof nu mai funcționează, deci verifici e.name.

Ce urmărește intervievatorul: Se verifică practicile de tratare a erorilor într-o aplicație. Greșeala tipică este un catch care înghite toate erorile, inclusiv bug-urile.

90 Mid

Fă clasa Interval de mai jos iterabilă, astfel încât să funcționeze cu for...of, spread și destructurare.

JavaScript
class Interval {
  constructor(start, sfarsit, pas = 1) {
    this.start = start;
    this.sfarsit = sfarsit;
    this.pas = pas;
  }
}
console.log([...new Interval(1, 10, 3)]); // [1, 4, 7, 10]

Răspuns scurt: Implementezi metoda [Symbol.iterator], care întoarce un iterator: un obiect cu metoda next() ce dă { value, done }. Cel mai simplu o scrii ca generator, cu *[Symbol.iterator]() și yield.

Un obiect este iterabil dacă are metoda [Symbol.iterator](), care întoarce un iterator: un obiect cu metoda next(), ce întoarce { value, done }. for...of, spread, destructurarea, Array.from, new Set(x) și Promise.all folosesc toate acest protocol.

Varianta explicită, ca să se vadă mecanismul:

JavaScript
class Interval {
  constructor(start, sfarsit, pas = 1) {
    this.start = start;
    this.sfarsit = sfarsit;
    this.pas = pas;
  }

  [Symbol.iterator]() {
    let curent = this.start;
    const { sfarsit, pas } = this;
    return {
      next() {
        if (curent <= sfarsit) {
          const value = curent;
          curent += pas;
          return { value, done: false };
        }
        return { value: undefined, done: true };
      },
    };
  }
}

Varianta cu generator, echivalentă și mai scurtă:

JavaScript
*[Symbol.iterator]() {
  for (let x = this.start; x <= this.sfarsit; x += this.pas) yield x;
}

Utilizare:

JavaScript
for (const n of new Interval(0, 4)) console.log(n);  // 0 1 2 3 4
const [primul, alDoilea] = new Interval(5, 100);    // 5, 6

Observații:

  • fiecare apel la [Symbol.iterator]() creează un iterator nou, cu stare proprie, deci obiectul poate fi parcurs de mai multe ori. Un generator apelat direct produce un iterator care poate fi parcurs o singură dată;
  • destructurarea se oprește după elementele de care are nevoie, deci iterabilul poate fi chiar infinit;
  • un iterator poate avea și return(), apelat la break, pentru eliberarea resurselor.

Același protocol îl implementează Array, String, Map, Set, NodeList și arguments; obiectele simple nu sunt iterabile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi protocolul pe care se bazează for...of și spread. Mulți candidați cunosc generatoarele, dar nu și Symbol.iterator.

Eroarea, în practică:x is not iterableResult of Symbol.iterator method is not an object

91 Mid

Ce afișează codul de mai jos? Explică cum funcționează un generator și unde e util.

JavaScript
function* numere() {
  let n = 1;
  while (true) {
    const reset = yield n++;
    if (reset) n = 1;
  }
}
const g = numere();
console.log(g.next().value, g.next().value, g.next().value);
console.log(g.next(true).value);
console.log(g.return(99));
console.log(g.next());

Răspuns scurt: Afișează 1 2 3, apoi 1, apoi { value: 99, done: true } și { value: undefined, done: true }. Un generator se oprește la fiecare yield și continuă la următorul next; valoarea dată lui next devine rezultatul expresiei yield, iar return îl termină.

O funcție function* nu rulează la apel, ci întoarce un obiect generator. Fiecare next() rulează corpul până la următorul yield, întoarce { value, done: false } și suspendă funcția, cu toate variabilele locale păstrate.

Pas cu pas:

  • primele trei next() dau 1, 2 și 3; după fiecare, n a crescut;
  • next(true) reia execuția: expresia yield n++ aflată în așteptare primește valoarea true, deci reset e true, iar n devine 1. Bucla continuă la următorul yield, care dă 1;
  • return(99) termină generatorul ca și cum ar fi apărut un return 99 în locul unde era suspendat; un bloc finally din generator ar rula acum;
  • orice next() ulterior întoarce done: true.

Argumentul primului next() se pierde, pentru că nu există încă un yield în așteptare care să-l primească.

Unde sunt utile generatoarele:

  • secvențe leneșe sau infinite: ID-uri, paginare, combinări, calculate doar la cerere;
  • iteratori personalizați, scriși mult mai simplu decât un obiect cu next();
  • pipeline-uri care procesează date fără array-uri intermediare:
JavaScript
function* ia(n, iterabil) {
  for (const x of iterabil) {
    if (n-- <= 0) return;
    yield x;
  }
}
[...ia(3, numere())]; // [1, 2, 3]
  • mașini de stare și protocoale în pași.

Bibliotecile mai vechi foloseau generatoare pentru a simula async/await, iar unele biblioteci de efecte încă le folosesc. Pentru cod asincron nou, async/await și generatoarele asincrone sunt alegerea directă.

Ce urmărește intervievatorul: Se verifică înțelegerea execuției suspendate și a comunicării bidirecționale prin next. Puțini candidați știu ce se întâmplă cu valoarea transmisă la next.

Eroarea, în practică:Iterator result is not an objectGenerator is already running

92 Mid

Când folosești WeakMap și WeakSet în loc de Map și Set? De ce nu le poți parcurge sau afla dimensiunea?

Răspuns scurt: WeakMap ține cheile obiect „slab”: dacă obiectul nu mai e referit în altă parte, intrarea poate fi eliminată de garbage collector. E potrivit pentru date atașate unor obiecte pe care nu le controlezi. Nu poate fi iterat, pentru că conținutul depinde de momentul colectării.

Un Map care folosește un obiect drept cheie îl ține în viață: cât timp există intrarea, obiectul nu poate fi eliberat, chiar dacă restul aplicației a renunțat la el. Un WeakMap ține cheile slab: referința din WeakMap nu contează pentru garbage collector. Când cheia nu mai e accesibilă din altă parte, intrarea dispare împreună cu valoarea ei.

Restricții care decurg din asta:

  • cheile trebuie să fie obiecte (sau simboluri neînregistrate, din ES2023), nu primitive;
  • nu există size, keys(), forEach sau iterare, deoarece conținutul s-ar schimba în funcție de momentul imprevizibil al colectării. Ai doar get, set, has, delete.

Cazuri de utilizare:

JavaScript
// date asociate elementelor DOM, fără scurgeri de memorie
const stareElement = new WeakMap();
function initTooltip(el) {
  stareElement.set(el, { deschis: false, timer: null });
}
// când elementul e eliminat din pagină și nu mai e referit, starea dispare

// cache per obiect
const cacheCalcul = new WeakMap();
function statistici(raport) {
  if (!cacheCalcul.has(raport)) cacheCalcul.set(raport, calculeazaGreu(raport));
  return cacheCalcul.get(raport);
}

WeakSet marchează obiecte fără să le rețină: „acest obiect a fost deja procesat”, util și pentru detectarea referințelor circulare la parcurgeri recursive.

Înainte de câmpurile #private, WeakMap era modul standard de a ține date private pentru instanțe. Pentru cazuri mai avansate există WeakRef și FinalizationRegistry, dar momentul colectării nu e garantat, deci nu construiești logică de business pe ele.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi legătura cu garbage collection și cazurile reale de folosire. Răspunsul slab spune doar că WeakMap „e mai rapid” sau „consumă mai puțină memorie”.

Eroarea, în practică:Invalid value used as weak map keyWeakRef: invalid target

93 Mid

Scrie un regex care extrage din linii de log de forma 2026-10-31 14:02:11 ERROR [plata] Timeout la procesator data, nivelul și modulul. Ce e greșit în codul de mai jos?

JavaScript
const eroare = /ERROR/g;
const linii = ["ERROR a", "ERROR b", "ERROR c"];
console.log(linii.filter((l) => eroare.test(l)).length);

Răspuns scurt: Folosești grupuri numite: /^(?<data>\d{4}-\d{2}-\d{2}) (?<ora>[\d:]{8}) (?<nivel>[A-Z]+) \[(?<modul>[^\]]+)\] (?<mesaj>.*)$/. Codul afișează 2, nu 3: un regex cu flagul g păstrează lastIndex între apeluri test, deci al doilea test începe căutarea de la poziția greșită.

Grupurile numite (ES2018) fac extragerea lizibilă:

JavaScript
const LOG = /^(?<data>\d{4}-\d{2}-\d{2}) (?<ora>\d{2}:\d{2}:\d{2}) (?<nivel>[A-Z]+) \[(?<modul>[^\]]+)\] (?<mesaj>.*)$/;

const linie = "2026-10-31 14:02:11 ERROR [plata] Timeout la procesator";
const { data, nivel, modul, mesaj } = linie.match(LOG)?.groups ?? {};
// data "2026-10-31", nivel "ERROR", modul "plata"

Elemente de explicat:

  • ^ și $ ancorează la începutul și sfârșitul liniei;
  • \[ escapează paranteza dreaptă, iar [^\]]+ înseamnă „orice în afară de ]”, mai sigur decât .*, care e lacom și poate înghiți prea mult;
  • ?.groups ?? {} tratează liniile care nu se potrivesc, pentru care match întoarce null.

Pentru un text cu multe linii, matchAll cu flagurile g și m întoarce toate potrivirile:

JavaScript
for (const m of text.matchAll(/^(?<nivel>ERROR|WARN) \[(?<modul>[^\]]+)\]/gm)) {
  console.log(m.groups.modul);
}

Bug-ul cu lastIndex: un regex cu flagul g sau y ține minte poziția de unde continuă căutarea. Primul test găsește „ERROR” și setează lastIndex la 5. Al doilea test, pe alt string, începe căutarea de la poziția 5, nu găsește nimic, întoarce false și resetează lastIndex la 0. Al treilea găsește din nou. Rezultatul alternează: 2 în loc de 3.

Soluția: nu folosi g cu test sau cu un regex refolosit; pentru verificări simple, /ERROR/.test(l) sau l.includes("ERROR"). Același efect apare cu exec într-o buclă.

Ce urmărește intervievatorul: Se verifică abilitatea de a scrie un regex practic și cunoașterea capcanei cu lastIndex. Bug-ul cu flagul g apare des în validări refolosite.

Eroarea, în practică:replaceAll called with a non-global RegExpmatchAll called with a non-global RegExp

94 Senior

Ce sunt Proxy și Reflect? Scrie un obiect de configurare care aruncă eroare la citirea unei chei inexistente și validează tipul la scriere.

Răspuns scurt: Proxy învelește un obiect și interceptează operațiile asupra lui (get, set, has, deleteProperty) prin funcții „trap”. Reflect oferă metode care execută comportamentul implicit al acestor operații, folosite în trap-uri ca să nu reimplementezi semantica.

Un Proxy primește un obiect țintă și un handler cu „trap-uri”, funcții care interceptează operații fundamentale: citire (get), scriere (set), in (has), ștergere, enumerarea cheilor, apeluri de funcție.

JavaScript
function configStricta(tinta, tipuri) {
  return new Proxy(tinta, {
    get(t, cheie, receiver) {
      if (typeof cheie === "string" && !(cheie in t)) {
        throw new Error(`Cheie de configurare necunoscută: ${cheie}`);
      }
      return Reflect.get(t, cheie, receiver);
    },
    set(t, cheie, valoare, receiver) {
      const asteptat = tipuri[cheie];
      if (asteptat && typeof valoare !== asteptat) {
        throw new TypeError(`${cheie} trebuie să fie ${asteptat}`);
      }
      return Reflect.set(t, cheie, valoare, receiver);
    },
  });
}

const config = configStricta({ timeout: 5000, debug: false }, { timeout: "number", debug: "boolean" });
config.timeout = 3000;   // ok
config.timout;           // Error: cheie necunoscută (greșeală de scriere prinsă)
config.debug = "da";     // TypeError

Reflect are câte o metodă pentru fiecare trap, cu aceeași semnătură, care face operația implicită. Folosirea lui Reflect.get(t, cheie, receiver) în loc de t[cheie] păstrează corect getterii și moștenirea. set trebuie să întoarcă true; un false aruncă TypeError în strict mode.

Verificarea typeof cheie === "string" lasă să treacă simbolurile, pe care le citesc intern unelte precum console.log sau conversiile (Symbol.toPrimitive).

Utilizări reale: reactivitate (Vue 3 detectează citirile și scrierile prin Proxy), validare, logging, obiecte de tip mock în teste, API-uri „fluente”. Costuri: fiecare operație trece prin trap, deci e mai lent; identitatea diferă (proxy !== tinta), iar obiectele cu sloturi interne (Map, Date, câmpuri #private) nu funcționează direct prin proxy, deoarece metodele lor verifică obiectul real.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea metaprogramării și a costurilor ei. Candidații de nivel senior trebuie să știe de ce se folosește Reflect în trap-uri.

Eroarea, în practică:'set' on proxy: trap returned falsishCannot create proxy with a non-object

95 Senior

Ce afișează codul de mai jos? Explică live bindings, evaluarea unică a modulelor și ce se întâmplă la importuri circulare.

JavaScript
// contor.js
export let valoare = 0;
export function creste() { valoare++; }
export default { nume: "contor" };

// main.js
import config, { valoare, creste } from "./contor.js";
console.log(valoare);
creste();
console.log(valoare);
console.log(config.nume);

Răspuns scurt: Afișează 0, 1 și „contor”. Importurile ES sunt legături vii către variabilele modulului, nu copii; fiecare modul se evaluează o singură dată și e partajat de toți importatorii. La importuri circulare, o variabilă accesată înainte de evaluarea modulului ei aruncă ReferenceError.

Live bindings: import { valoare } nu copiază valoarea, ci creează o legătură read-only către variabila exportată. Când creste() modifică variabila în modul, main.js vede imediat 1. Atribuirea din importator, valoare = 5, aruncă TypeError, pentru că legăturile importate sunt read-only. CommonJS se comportă diferit: const { valoare } = require(...) copiază valoarea din momentul importului.

Named și default: export default exportă o singură valoare sub numele default, importată fără acolade și cu orice nume. Exporturile cu nume se importă cu acolade și numele exact, ceea ce ajută la refactorizări, la autocompletare și la tree shaking. Multe echipe preferă exclusiv exporturi cu nume, pentru consecvență.

Evaluare unică: un modul se încarcă și se execută o singură dată per realm, oricâte fișiere îl importă. Toți importatorii primesc aceeași instanță, deci un modul care exportă un obiect este, practic, un singleton. Starea globală dintr-un modul este partajată, un aspect de luat în calcul la teste.

Faze: modulele ES sunt analizate static. Importurile sunt ridicate și rezolvate înainte de execuția oricărui cod, deci nu pot apărea într-un if. Pentru încărcare condiționată sau leneșă există import(), care întoarce o promisiune și permite bundlerelor să creeze fișiere separate (code splitting). Top-level await (ES2022) face ca modulele care îl importă să aștepte.

Importuri circulare: dacă a.js importă b.js, iar b.js importă a.js, unul dintre ele se evaluează primul și vede legăturile celuilalt încă neinițializate. Accesarea unui let, const sau class neinițializat aruncă ReferenceError (TDZ); declarațiile de funcție, ridicate, funcționează. Soluția durabilă este extragerea codului comun într-un al treilea modul.

Ce urmărește intervievatorul: Se verifică un model aprofundat al modulelor ES, dincolo de sintaxă. Diferența de live bindings față de CommonJS și importurile circulare separă candidații seniori.

Eroarea, în practică:Class extends value undefined is not a constructor

Situații din lucrul de zi cu zi

Exersează capitolul cu exerciții reale: Curs JavaScript pentru începători →
96 Junior

În consolă apare „TypeError: Cannot read properties of undefined (reading 'nume')”, iar pagina nu mai funcționează. Cum depanezi, pas cu pas?

Răspuns scurt: Citești mesajul și stack trace-ul ca să afli linia și lanțul de apeluri, pui un breakpoint acolo, inspectezi valorile și urmărești de unde vine undefined. Repari cauza (date lipsă, ordinea operațiilor, un await uitat), nu doar simptomul, și adaugi un test sau o verificare.

Un răspuns structurat urmează pașii pe care îi faci efectiv:

  • citești eroarea complet: mesajul spune că încerci să citești nume dintr-o valoare undefined. Deci problema nu e nume, ci obiectul din fața lui, de exemplu user în user.nume;
  • mergi la sursă: click pe fișierul și linia din consolă. În proiectele cu bundler, source maps te duc la codul original. Stack trace-ul arată ce funcții au dus acolo;
  • reproduci și oprești execuția: pui un breakpoint pe linie sau activezi „Pause on exceptions” în panoul Sources. Inspectezi variabilele locale, scope-ul și call stack-ul;
  • urmărești valoarea înapoi: de unde trebuia să vină obiectul? Din răspunsul API-ului (verifici în panoul Network ce a venit efectiv), dintr-un find care nu a găsit nimic, dintr-un await uitat, dintr-un index greșit sau dintr-un cod care rulează înainte ca datele să fie încărcate;
  • repari cauza: dacă lipsa datelor e un caz legitim (utilizator neautentificat, listă goală), îl tratezi explicit, cu o stare de interfață; dacă e un bug (cheie greșită în răspuns, ordine greșită), îl corectezi la sursă;
  • previi repetarea: un test pentru cazul respectiv, validarea răspunsului de la API la intrare, iar în proiectele care îl folosesc, TypeScript cu verificări stricte de null.

Ce evit: să pun user?.nume peste tot fără să înțeleg de ce lipsește user. Optional chaining ascunde simptomul, iar bug-ul reapare mai departe, sub altă formă.

La interviu ajută un exemplu concret: o dată când ai găsit cauza reală a unei astfel de erori și ce ai învățat din ea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai o metodă de depanare și știi uneltele din DevTools. Răspunsul slab sare direct la optional chaining.

Eroarea, în practică:Cannot read properties of undefined

97 Junior

Un coleg nou nu înțelege de ce în codul lui produse este gol la console.log, deși datele apar mai târziu pe pagină. Cum îi explici?

JavaScript
let produse = [];
fetch("/api/produse").then((r) => r.json()).then((d) => { produse = d; });
console.log(produse.length);

Răspuns scurt: Îi explic că fetch doar pornește cererea și programează callback-urile pentru mai târziu; log-ul rulează imediat, înainte ca răspunsul să sosească. Apoi îi arăt pe cod ordinea reală și varianta cu async/await, în care codul care are nevoie de date stă după await.

Un răspuns bun arată și cum explici, nu doar ce explici:

  • pornesc de la ce vede: îi cer să pună un console.log cu numere (1, 2, 3) în fiecare pas și să ruleze. Ordinea afișată îi arată singur că log-ul de la final rulează înaintea celui din then;
  • folosesc o analogie scurtă: comanzi o pizza; telefonul (fetch) se termină imediat, dar pizza vine mai târziu. Dacă deschizi cutia imediat după ce închizi telefonul, e goală. Codul din then este „ce faci când sună curierul”;
  • leg analogia de concepte: JavaScript nu așteaptă rețeaua; înregistrează callback-ul și continuă. Callback-ul rulează când răspunsul a sosit și firul e liber;
  • arăt soluția: codul care are nevoie de date trebuie să ruleze după ce ele există:
JavaScript
async function incarcaProduse() {
  const r = await fetch("/api/produse");
  if (!r.ok) throw new Error(`HTTP ${r.status}`);
  const produse = await r.json();
  console.log(produse.length);
  afiseaza(produse);
}
  • verific înțelegerea: îi dau o mică variantă de exercițiu (de exemplu două cereri, una după alta) și îl las să o scrie, în loc să o scriu eu.

Evit să încep cu termeni precum event loop sau microtask: sunt corecți, dar nu ajută pe cineva blocat pe un bug concret. Îi trimit apoi un material bun pentru aprofundare și îi spun că e o confuzie întâlnită la aproape toți cei care învață JavaScript, ca să nu se simtă judecat.

Intervievatorul urmărește răbdarea, claritatea și capacitatea de a adapta explicația la nivelul celuilalt.

Ce urmărește intervievatorul: Se verifică abilitatea de a explica un concept fundamental unui începător, importantă în echipe cu juniori. Răspunsul slab recită definiția event loop-ului.

98 Mid

Ai moștenit un fișier JavaScript de 2.000 de linii, fără teste, cu funcții lungi și variabile globale, iar trebuie să adaugi o funcționalitate nouă. Cum procedezi?

Răspuns scurt: Nu rescriu totul. Întâi înțeleg fluxul și scriu teste de caracterizare pentru comportamentul existent în zona pe care o ating, apoi refactorizez în pași mici și verificabili (extrag funcții pure, înlocuiesc globalele cu parametri), iar funcționalitatea nouă o adaug în cod curat, testat.

Un răspuns structurat:

  • înțeleg înainte să schimb: rulez aplicația, identific fluxul atins de funcționalitate, notez punctele de intrare (handler-e, apeluri de API) și dependențele de variabile globale. Folosesc „Find references” din editor și breakpoint-uri;
  • plasă de siguranță: scriu teste de caracterizare, care fixează comportamentul actual, chiar dacă pare ciudat, pentru zona pe care o modific. Pentru codul legat de DOM, încep cu teste la nivel înalt sau cu un set de verificări manuale scris;
  • pregătesc terenul: activez ESLint și Prettier fără să reformatez tot fișierul (un commit separat, dacă echipa e de acord), ca diff-urile să rămână lizibile;
  • refactorizez în pași mici, fiecare urmat de rularea testelor și de un commit separat:
  • extrag logica de calcul în funcții pure, cu parametri în loc de globale;
  • separ accesul la DOM și la rețea de logică;
  • mut părțile coerente în module ES separate;
  • redenumesc variabilele neclare;
  • adaug funcționalitatea în structura nouă, cu teste unitare;
  • comunic: explic în pull request ce s-a refactorizat și ce s-a adăugat, ideal în pull request-uri separate, ca review-ul să fie ușor.

Ce evit: rescrierea completă „de la zero”, care aduce riscuri mari și blochează livrarea, și amestecarea refactorizării cu schimbări de comportament în același commit.

Principiul de bază: lași codul puțin mai bun decât l-ai găsit în zona în care lucrezi, fără să promiți o curățenie generală pe care nu ți-a cerut-o nimeni și pe care nu o poți testa.

Ce urmărește intervievatorul: Intervievatorul verifică maturitatea în lucrul cu cod existent și disciplina pașilor mici. Răspunsul slab propune rescrierea completă.

99 Mid

Utilizatorii raportează o eroare care apare doar în producție, iar codul este minificat. Local nu o poți reproduce. Cum o investighezi?

Răspuns scurt: Strâng date: mesajul, stack trace-ul, browserul, pașii și momentul apariției, idealmente dintr-un instrument de monitorizare. Decodific stack trace-ul cu source maps, compar mediile (date, configurare, versiune, extensii) și reproduc cu datele și condițiile din producție, apoi repar și adaug un test.

Structura răspunsului:

  • colectez informații: mesajul exact și stack trace-ul, browserul și versiunea, dispozitivul, URL-ul, pașii utilizatorului, ora și dacă problema a apărut după un deploy. Ideal vin dintr-un instrument de monitorizare a erorilor care înregistrează automat erorile globale (window.onerror, unhandledrejection) și pașii anteriori;
  • decodific stack trace-ul: codul minificat are nume de o literă și o singură linie. Source maps, încărcate în instrumentul de monitorizare (nu neapărat publice), traduc pozițiile în fișierele și liniile originale;
  • caut tiparul: apare doar într-un browser sau pe o versiune veche (o metodă nouă, precum Array.prototype.at sau structuredClone, nesuportată acolo)? Doar pentru anumiți utilizatori (date specifice, roluri, limbă, fus orar)? Doar după un anumit deploy?
  • compar mediile: diferențe de date (câmpuri lipsă, valori null, texte foarte lungi), de configurare (variabile de mediu, chei de API), de rețea (latență mare, care scoate la iveală condiții de cursă), de CDN sau cache (fișiere vechi amestecate cu noi după deploy), extensii de browser care modifică DOM-ul;
  • reproduc: folosesc aceeași versiune de browser, încetinesc rețeaua din DevTools, folosesc date copiate (anonimizate) din producție sau un build de producție local;
  • repar și previn: scriu un test care reproduce cazul, adaug logare suplimentară în punctul sensibil dacă nu am găsit cauza, și urmăresc după deploy dacă eroarea a dispărut din monitorizare.

Dacă impactul e mare, discut întâi o soluție de oprire rapidă (revenirea la versiunea anterioară sau dezactivarea funcționalității cu un feature flag), apoi caut cauza fără presiune.

Ce urmărește intervievatorul: Se verifică metoda de investigare sistematică și cunoașterea uneltelor de producție. Răspunsul slab rămâne la „încerc să reproduc local”.

100 Senior

Echipa ta discută dacă să adopte o bibliotecă mare de utilitare (pentru date, colecții, validări) sau să scrie funcțiile necesare în proiect. Cum iei decizia și cum o comunici?

Răspuns scurt: Pornesc de la nevoi concrete: ce funcții folosim, ce oferă deja limbajul modern, cât costă biblioteca în dimensiunea bundle-ului, întreținere și securitate și cât costă codul propriu în testare. Decid pe date, documentez decizia și o revizuim dacă se schimbă contextul.

Un răspuns bun arată un proces, nu o preferință:

  • inventarul nevoilor: ce funcții vrem concret? Multe utilitare clasice au devenit inutile prin limbaj: structuredClone pentru copiere profundă, Object.groupBy, Array.prototype.flat, toSorted, Intl pentru formatare de numere și date, Set cu operații pe mulțimi. Verific ce suportă mediile țintă ale proiectului;
  • costul bibliotecii: impactul în bundle (măsurat, de exemplu cu un analizor de bundle, și verificat dacă suportă tree shaking prin module ES), calitatea întreținerii (activitatea recentă, problemele deschise, numărul de dependențe tranzitive), istoricul de vulnerabilități, licența, efortul de actualizare la versiuni majore;
  • costul codului propriu: timpul de scriere și testare, cazurile-limită pe care o bibliotecă matură le-a rezolvat deja (date calendaristice, fusuri orare, Unicode), întreținerea pe termen lung;
  • regula practică: funcțiile mici și clare (debounce, groupBy, chunk) se scriu ușor în proiect, cu teste; domeniile grele și pline de cazuri-limită (date cu fusuri orare, validarea schemelor, sanitizarea HTML) se lasă unei biblioteci dedicate și bine întreținute, nu unei biblioteci generale;
  • experiment: fac un spike scurt pe un caz real și compar rezultatul măsurat, nu impresiile;
  • comunicare: scriu decizia într-un document scurt de tip ADR (Architecture Decision Record), cu contextul, opțiunile, argumentele și condițiile în care o revizuim. Ascult obiecțiile colegilor înainte de decizie, nu după.

Dacă rămân în minoritate, susțin decizia echipei și propun un moment concret de reevaluare, pe baza datelor strânse între timp.

Ce urmărește intervievatorul: Intervievatorul verifică judecata tehnică, măsurarea și capacitatea de a conduce o decizie în echipă. Răspunsul slab este o opinie absolută, pentru sau împotriva bibliotecilor.

Î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 JavaScript, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață JavaScript scriind cod, nu doar citind

Curs JavaScript: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.