...
Pregătire interviuri

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

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

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

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 131 minde citit
Întrebări de interviu React cu răspunsuri

La un interviu în care se verifică React, primele întrebări sunt de obicei despre fundamente: cum se transformă JSX, diferența dintre props și state, cum funcționează useState și useEffect, de ce contează cheile în liste. Urmează aproape mereu cod: ți se arată o componentă mică și ți se cere să spui ce afișează sau unde e bug-ul, ori scrii live o componentă (o listă de sarcini, un formular, o căutare cu API). Multe firme dau și o temă pentru acasă, o mică aplicație React care consumă un API, pe care o discutați apoi împreună.

Diferența dintre junior și mid se vede în detalii. De la un junior se așteaptă să scrie corect componente, formulare controlate și liste, să actualizeze state-ul imutabil și să folosească efectele cu curățare. De la un mid se așteaptă să explice de ce se re-randează o componentă, să recunoască stale closures și race conditions, să aleagă între Context, Redux Toolkit, Zustand și TanStack Query și să scrie teste cu React Testing Library. Întrebările senior ating arhitectura: randarea concurentă, React Compiler, Server Components, loader-e și refactorizarea codului mare.

Întrebările sunt grupate pe teme și ordonate de la junior la senior. Citește întâi răspunsul scurt și încearcă să-l spui cu voce tare, apoi compară cu explicația detaliată. Pentru întrebările cu cod, rulează exemplele într-un proiect Vite și modifică-le: un bug pe care l-ai reprodus singur îl recunoști mult mai ușor la interviu. Exemplele folosesc React 19 și menționează explicit unde comportamentul diferă între versiuni.

JSX și componente

1 Junior

De ce numele unei componente React trebuie să înceapă cu literă mare? Ce se întâmplă dacă scrii <buton /> în loc de <Buton />?

Răspuns scurt: JSX tratează tagurile cu literă mică drept elemente HTML (șiruri de caractere) și pe cele cu literă mare drept referințe la variabile JavaScript. <buton /> devine un element DOM necunoscut, nu componenta ta.

La compilare, JSX se transformă în apeluri de funcție. Compilatorul (Babel, SWC, esbuild) decide tipul elementului după prima literă:

JSX
<div />      // jsx("div")    -> șir, element HTML
<Buton />    // jsx(Buton)    -> referință la funcția Buton
<buton />    // jsx("buton")  -> șir, element HTML inexistent

Dacă ai definit function buton() {...} și o folosești ca <buton />, React creează în DOM un tag <buton> gol, iar în consolă apare un avertisment de tipul „The tag <buton> is unrecognized in this browser”. Funcția ta nu este apelată deloc.

Regula se aplică și la componente primite dinamic. Dacă alegi componenta dintr-un obiect, pune-o întâi într-o variabilă cu literă mare:

JSX
const iconite = { info: InfoIcon, eroare: ErrorIcon };
function Mesaj({ tip }) {
  const Icon = iconite[tip];
  return <Icon />;
}

Notația cu punct funcționează și ea (<Form.Input />), pentru că Form.Input este o expresie de membru, nu un tag HTML. Convenția PascalCase ajută și la citire: vezi imediat ce e componentă și ce e HTML.

Ce urmărește intervievatorul: Verifică dacă știi că JSX este doar sintaxă peste apeluri de funcție. Candidații spun adesea „așa e convenția”, fără să explice mecanismul.

Eroarea, în practică:The tag <produs> is unrecognized in this browserHook called in function that is neither ...

2 Junior

De ce o componentă nu poate returna două elemente alăturate fără un părinte? Ce este un Fragment și când ai nevoie de forma lui lungă?

Răspuns scurt: Pentru că JSX se compilează într-un singur apel de funcție, iar o funcție returnează o singură valoare. Fragmentul (<>...</>) grupează elemente fără să adauge un nod în DOM; forma <Fragment key> e necesară când ai nevoie de key într-o listă.

Codul de mai jos nu compilează:

JSX
return (
  <h1>Titlu</h1>
  <p>Text</p>
);

Fiecare tag devine o expresie jsx(...), iar două expresii alăturate fără operator nu sunt JavaScript valid. Soluția clasică era un <div> în jur, dar asta adaugă noduri inutile în DOM și poate strica layout-uri cu Flexbox sau Grid, ori structura unui tabel (un <div> în interiorul unui <tr> e HTML invalid).

Fragmentul rezolvă problema fără nod suplimentar:

JSX
return (
  <>
    <h1>Titlu</h1>
    <p>Text</p>
  </>
);

Forma scurtă <> nu acceptă atribute. Când randezi o listă în care fiecare element produce mai multe noduri, ai nevoie de key, deci de forma lungă:

JSX
import { Fragment } from "react";

{termeni.map(t => (
  <Fragment key={t.id}>
    <dt>{t.nume}</dt>
    <dd>{t.definitie}</dd>
  </Fragment>
))}

Alternativ, poți returna un tablou de elemente, dar fiecare are nevoie de key, iar Fragmentul e mai lizibil.

Ce urmărește intervievatorul: Verifică înțelegerea legăturii dintre JSX și JavaScript și grija pentru HTML valid. Mulți candidați nu știu că <> nu poate primi key.

Eroarea, în practică:Adjacent JSX elements must be wrappedInvalid prop supplied to `React.Fragment`

3 Junior

Care sunt diferențele practice dintre JSX și HTML pe care trebuie să le știi când copiezi un șablon HTML într-o componentă?

Răspuns scurt: JSX folosește className și htmlFor, atribute și evenimente în camelCase, style ca obiect, taguri închise obligatoriu și acolade pentru expresii JavaScript. Comentariile se scriu {/* ... */}.

JSX arată ca HTML, dar este JavaScript, deci unele cuvinte rezervate și convenții se schimbă:

  • class devine className, iar for (la label) devine htmlFor, pentru că class și for sunt cuvinte rezervate în JavaScript;
  • evenimentele sunt în camelCase și primesc funcții, nu șiruri: onClick={salveaza}, nu onclick="salveaza()";
  • majoritatea atributelor sunt camelCase: tabIndex, maxLength, readOnly; excepții: aria-* și data-* rămân cu cratimă;
  • style primește un obiect cu proprietăți camelCase: style={{ backgroundColor: "red", marginTop: 8 }} (numerele fără unitate devin px pentru majoritatea proprietăților);
  • toate tagurile trebuie închise: <img />, <br />, <input />;
  • comentariile sunt {/* comentariu */}, nu <!-- -->;
  • expresiile JavaScript stau între acolade, iar în acolade poți pune doar expresii, nu instrucțiuni (if, for).
JSX
<label htmlFor="email" className="eticheta">Email</label>
<input id="email" type="email" readOnly={!editabil}
       style={{ borderColor: eroare ? "red" : "gray" }} />

Un lucru util de știut: atributele HTML scrise greșit (class, onclick) produc avertismente în consola de development. Pentru conversii mari există unelte care transformă automat HTML în JSX, dar trebuie să înțelegi regulile ca să repari ce rămâne.

Ce urmărește intervievatorul: Verifică experiența practică cu JSX. Greșeala tipică este style="color: red" sau uitarea faptului că în acolade nu poți pune un if.

Eroarea, în practică:Invalid DOM property `class`Invalid DOM property `for`

4 Junior

Ce afișează componenta de mai jos când lista e goală și cum o repari?

JSX
function Notificari({ items }) {
  return (
    <div>
      {items.length && <span>Ai {items.length} notificări</span>}
    </div>
  );
}

Răspuns scurt: Afișează cifra 0 pe ecran. items.length && ... returnează 0 când lista e goală, iar React randează numerele, chiar și 0. Soluția: o condiție booleană explicită, items.length > 0 && ..., sau operatorul ternar.

Operatorul && din JavaScript nu returnează true sau false, ci primul operand fals sau ultimul operand. Când items.length este 0, expresia întreagă valorează 0.

React tratează valorile din JSX astfel:

  • null, undefined, true, false nu afișează nimic;
  • numerele și șirurile se afișează, inclusiv 0 și NaN;
  • șirul gol "" nu afișează nimic vizibil.

Deci în DOM ajunge <div>0</div>. Pe web e doar urât; în React Native, un număr în afara unui <Text> produce chiar eroare.

Variante corecte:

JSX
{items.length > 0 && <span>Ai {items.length} notificări</span>}

{!!items.length && <span>...</span>}

{items.length ? <span>...</span> : <p>Nu ai notificări</p>}

Varianta cu ternar e preferabilă când vrei și un mesaj pentru lista goală, ceea ce e bine pentru utilizator. Aceeași capcană apare cu orice valoare numerică: {pret && <Pret />} ascunde prețul... și afișează 0 la produsele gratuite. Regula de lucru: în stânga lui && pune doar valori booleene.

Ce urmărește intervievatorul: Este o capcană clasică de interviu, care verifică dacă știi ce întoarce && și ce randează React. Mulți candidați presupun că nu se afișează nimic.

5 Junior

Ce variante ai pentru afișarea condiționată în React și când o alegi pe fiecare? Ce înseamnă când o componentă returnează null?

Răspuns scurt: Ai operatorul ternar pentru două variante, && pentru „afișează sau nimic”, if înainte de return pentru cazuri complete diferite și un obiect de mapare pentru mai multe stări. return null înseamnă că componenta nu afișează nimic, dar rămâne montată.

Alegerea ține de lizibilitate:

  • ternar când ai exact două ramuri în același loc din JSX: {logat ? <Profil /> : <Login />};
  • && când afișezi ceva sau nimic, cu o condiție booleană în stânga;
  • if cu return devreme când ramurile diferă complet, de exemplu încărcare și eroare:
JSX
function Produs({ status, produs }) {
  if (status === "loading") return <Spinner />;
  if (status === "error") return <Eroare />;
  return <Detalii produs={produs} />;
}
  • obiect de mapare când ai mai multe stări și vrei să eviți ternare imbricate:
JSX
const ecrane = { pas1: <Adresa />, pas2: <Plata />, pas3: <Confirmare /> };
return ecrane[pas];

Ternarele imbricate pe trei niveluri sunt un semnal de refactorizare: extrage logica într-o funcție sau o componentă separată.

O componentă care returnează null nu produce nimic în DOM, dar este în continuare în arbore: hook-urile ei rulează, state-ul se păstrează, efectele rămân active. Asta diferă de situația în care părintele nu o randează deloc ({arata && <Modal />}), caz în care componenta este demontată și state-ul ei se pierde. Diferența contează când vrei să păstrezi, de exemplu, textul scris într-un formular ascuns.

Ce urmărește intervievatorul: Verifică stilul de cod și înțelegerea diferenței dintre „ascuns” și „demontat”. Răspunsurile slabe se opresc la ternar.

Eroarea, în practică:Unexpected token (if sau for în JSX)

6 Junior

Unde e problema în componenta de mai jos?

JSX
function CardUtilizator({ user }) {
  if (!user.nume) {
    user.nume = "Anonim";
  }
  return <h2>{user.nume}</h2>;
}

Răspuns scurt: Componenta modifică un prop. Props sunt doar pentru citire: obiectul aparține părintelui, iar modificarea lui schimbă datele părintelui fără ca React să știe, ceea ce duce la afișări inconsistente. Folosește o variabilă locală: const nume = user.nume || "Anonim".

Obiectul user e același obiect pe care îl ține părintele (în state, într-un store sau într-un cache). Scriind user.nume = "Anonim":

  • modifici datele părintelui fără un setState, deci React nu programează nicio randare; alte componente care citesc același obiect pot afișa valori diferite până la următoarea randare;
  • încalci regula ca randarea să fie o funcție pură: aceleași props trebuie să producă același rezultat, fără efecte secundare;
  • dacă obiectul vine dintr-un store imutabil (Redux Toolkit îngheață state-ul în development), primești chiar eroare „Cannot assign to read only property”.

Varianta corectă calculează o valoare nouă:

JSX
function CardUtilizator({ user }) {
  const nume = user.nume || "Anonim";
  return <h2>{nume}</h2>;
}

Dacă valoarea implicită trebuie salvată efectiv în date, părintele e cel care o face, prin funcția lui de actualizare primită de copil ca prop (onChange).

Același principiu se aplică la tablouri: props.items.sort() sortează pe loc tabloul părintelui. Folosește o copie: [...items].sort() sau items.toSorted() (ES2023). Regula din documentația React: tratează props, state și contextul ca fiind imutabile în timpul randării.

Ce urmărește intervievatorul: Verifică dacă înțelegi fluxul de date de sus în jos și puritatea randării. Greșeala apare des la cei veniți din jQuery sau din cod imperativ.

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

7 Junior

Ce este prop-ul children? Scrie o componentă Card care primește un titlu și orice conținut în interior.

Răspuns scurt: children este prop-ul special care conține tot ce pui între tagul de deschidere și cel de închidere al unei componente. Permite componente de layout reutilizabile, care nu știu dinainte ce conțin.

Când scrii <Card titlu="Profil"><p>Text</p></Card>, React pune elementul <p> în props.children. Componenta decide unde îl afișează:

JSX
function Card({ titlu, children, footer }) {
  return (
    <section className="card">
      <h3 className="card__titlu">{titlu}</h3>
      <div className="card__continut">{children}</div>
      {footer && <div className="card__footer">{footer}</div>}
    </section>
  );
}

<Card titlu="Comanda #124" footer={<button>Plătește</button>}>
  <p>3 produse</p>
  <p>Total: 240 lei</p>
</Card>

children poate fi orice se poate randa: text, un element, mai multe elemente, null sau chiar o funcție (pattern-ul render props). Nu presupune o anumită formă; dacă trebuie să-l numeri sau să-l parcurgi, API-ul Children există, dar documentația React îl consideră o soluție rar potrivită.

Exemplul arată și pattern-ul de sloturi: pe lângă children, poți primi alte elemente prin props obișnuite (footer, header, actiuni). E compoziția recomandată de React în locul moștenirii. Avantaj în plus: elementele trimise prin children sunt create de părinte, așa că o re-randare a lui Card din cauza state-ului propriu nu le re-randează, ceea ce ajută și la performanță.

Ce urmărește intervievatorul: Verifică dacă știi să construiești componente reutilizabile prin compoziție. Un candidat bun pomenește și sloturile prin props.

Eroarea, în practică:Do not pass children as props

8 Junior

Cum dai valori implicite pentru props într-o componentă funcție? Ce s-a întâmplat cu defaultProps în React 19?

Răspuns scurt: Valorile implicite se dau prin destructurare: function Buton({ marime = "mediu" }). defaultProps pentru componente funcție a fost marcat învechit în React 18.3 și eliminat în React 19; rămâne doar pentru componente clasă.

Varianta modernă folosește valorile implicite din JavaScript:

JSX
function Buton({ varianta = "primar", marime = "mediu", disabled = false, children }) {
  return (
    <button className={`btn btn--${varianta} btn--${marime}`} disabled={disabled}>
      {children}
    </button>
  );
}

Un detaliu important: valoarea implicită se aplică doar când prop-ul este undefined (lipsește sau e trimis explicit undefined). Dacă părintele trimite null, valoarea rămâne null. Același lucru e valabil și pentru 0 sau "", care sunt păstrate.

Capcană de performanță: o valoare implicită de tip obiect sau tablou se creează din nou la fiecare randare.

JSX
function Lista({ items = [] }) {
  useEffect(() => { /* ... */ }, [items]); // rulează la fiecare randare dacă items lipsește
}

Soluția e o constantă definită în afara componentei: const GOL = []; și items = GOL.

Componenta.defaultProps = {...} era vechea metodă. React 18.3 a început să afișeze avertismente pentru componentele funcție, iar React 19 a eliminat suportul pentru ele; componentele clasă îl păstrează. La migrarea unui proiect vechi la React 19, mutarea valorilor din defaultProps în destructurare e unul dintre pașii obligatorii.

Ce urmărește intervievatorul: Verifică dacă ești la zi cu React modern și dacă știi detaliul undefined vs null. Candidații care au învățat din tutoriale vechi folosesc încă defaultProps.

Eroarea, în practică:Support for defaultProps will be removed

9 Junior

Care e diferența dintre exportul implicit și exportul cu nume pentru componente? Ce înseamnă eroarea „Element type is invalid: expected a string... but got: undefined”?

Răspuns scurt: Exportul implicit (export default) se importă fără acolade și cu orice nume; exportul cu nume se importă cu acolade și numele exact. Eroarea apare aproape mereu când imporți greșit: cu acolade un export implicit sau fără acolade un export cu nume, deci componenta e undefined.

Cele două forme:

JSX
// Buton.jsx
export default function Buton() { ... }
export function ButonMic() { ... }

// App.jsx
import Buton from "./Buton";          // corect, export implicit
import { ButonMic } from "./Buton";   // corect, export cu nume
import { Buton } from "./Buton";      // greșit: undefined

Când randezi <Buton /> și Buton este undefined, React nu are ce tip de element să creeze și aruncă eroarea „Element type is invalid... but got: undefined. You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports”. Mesajul spune chiar cauza, iar dedesubt indică metoda render a componentei în care s-a produs.

Cauze frecvente:

  • import cu sau fără acolade greșit;
  • componenta nu e exportată deloc;
  • import circular între două fișiere, care face ca valoarea să fie încă undefined la momentul folosirii;
  • o bibliotecă și-a schimbat exporturile între versiuni.

Multe echipe preferă exporturile cu nume pentru componente: numele e consistent în tot proiectul, căutarea și refactorizarea în editor funcționează mai bine, iar greșelile de import apar la compilare în TypeScript. React.lazy cere însă un export implicit (sau un mic adaptor then(m => ({ default: m.Nume }))).

Ce urmărește intervievatorul: Verifică dacă poți depana o eroare foarte frecventă citind mesajul. Răspunsul bun leagă eroarea de modul în care funcționează modulele ES.

Eroarea, în practică:Element type is invalid ... but got: undefinedOnly one default export allowed per module

10 Junior

Întâlnești într-un proiect vechi componente clasă. Cum corespund componentDidMount, componentDidUpdate, componentWillUnmount și this.setState cu hook-urile?

Răspuns scurt: componentDidMount + componentDidUpdate + componentWillUnmount corespund aproximativ unui useEffect cu funcție de curățare și dependențe; this.state și this.setState corespund lui useState. Corespondența nu e exactă: efectele se gândesc ca sincronizare, nu ca momente din viața componentei.

O componentă clasă care se abonează la ceva:

JSX
class Ceas extends React.Component {
  state = { ora: new Date() };
  componentDidMount() {
    this.id = setInterval(() => this.setState({ ora: new Date() }), 1000);
  }
  componentWillUnmount() {
    clearInterval(this.id);
  }
  render() {
    return <p>{this.state.ora.toLocaleTimeString()}</p>;
  }
}

Echivalentul cu hook-uri:

JSX
function Ceas() {
  const [ora, setOra] = useState(() => new Date());
  useEffect(() => {
    const id = setInterval(() => setOra(new Date()), 1000);
    return () => clearInterval(id);
  }, []);
  return <p>{ora.toLocaleTimeString()}</p>;
}

Diferențe de reținut:

  • this.setState({...}) combină obiectul nou cu state-ul existent; setter-ul din useState îl înlocuiește;
  • logica împrăștiată în clasă în mai multe metode (abonare în didMount, re-abonare în didUpdate, dezabonare în willUnmount) se adună într-un singur efect, cu dependențele potrivite;
  • this în clase cerea bind pentru handleri sau funcții săgeată; în funcții nu există problema;
  • shouldComponentUpdate/PureComponent corespund lui React.memo;
  • error boundaries se scriu încă doar cu clase (componentDidCatch, getDerivedStateFromError).

Clasele nu sunt eliminate din React, dar codul nou se scrie cu funcții și hook-uri.

Ce urmărește intervievatorul: Verifică dacă poți lucra într-un proiect moștenit. Greșeala tipică: „useEffect cu [] este exact componentDidMount”, fără să menționezi curățarea și dependențele.

Eroarea, în practică:undefined (reading 'setState') în claseuseState() doesn't support the second callback

11 Mid

Ce problemă are codul de mai jos? Utilizatorii se plâng că inputul își pierde focusul după fiecare literă.

JSX
function Formular() {
  const [nume, setNume] = useState("");

  function Camp() {
    return <input value={nume} onChange={e => setNume(e.target.value)} />;
  }

  return <Camp />;
}

Răspuns scurt: Camp este definit în interiorul lui Formular, deci la fiecare randare se creează o funcție nouă, adică un tip nou de componentă. React vede alt tip, demontează inputul vechi și montează unul nou, care nu are focus. Componentele se definesc la nivelul modulului.

React decide dacă păstrează un element comparând tipul lui cu cel din randarea anterioară. Pentru componente, tipul este referința la funcție. Fiecare tastă apelează setNume, Formular se randează din nou și declarația function Camp() creează o funcție nouă, diferită de cea veche (CampVechi !== CampNou).

Consecințe:

  • React demontează tot subarborele vechi și montează unul nou, deci inputul din DOM e înlocuit și pierde focusul;
  • orice state intern al lui Camp s-ar reseta la fiecare randare;
  • efectele lui ar rula de la zero de fiecare dată;
  • performanța scade, pentru că se recreează noduri DOM.

Soluția: muți componenta în afară și îi dai datele prin props.

JSX
function Camp({ value, onChange }) {
  return <input value={value} onChange={e => onChange(e.target.value)} />;
}

function Formular() {
  const [nume, setNume] = useState("");
  return <Camp value={nume} onChange={setNume} />;
}

Dacă nu ai nevoie de o componentă separată, poți apela o funcție care returnează JSX ({randeazaCamp()}), pentru că atunci nu se creează un tip nou de componentă, dar o componentă separată la nivelul modulului e mai clară. Linterul eslint-plugin-react are regula no-unstable-nested-components pentru exact acest bug.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care React identifică componentele la reconciliere. E un bug real, greu de găsit dacă nu cunoști mecanismul.

Eroarea, în practică:Do not define components during render

12 Mid

Ce avantaje și ce capcane are transmiterea props cu spread, de exemplu <input {...props} />?

Răspuns scurt: Spread-ul transmite automat toate atributele (inclusiv aria-*, evenimente) către elementul de bază, util la componente-wrapper. Capcanele: ordinea decide cine câștigă, atributele necunoscute ajung în DOM și devine greu de văzut ce primește componenta.

Pattern-ul e comun la componentele care învelesc un element HTML:

JSX
function Input({ eticheta, eroare, className = "", ...rest }) {
  const id = useId();
  return (
    <div>
      <label htmlFor={id}>{eticheta}</label>
      <input id={id} className={`input ${className}`} aria-invalid={!!eroare} {...rest} />
      {eroare && <p role="alert">{eroare}</p>}
    </div>
  );
}

Avantajul: cine folosește Input poate trimite type, placeholder, onBlur, autoComplete fără să le declari pe toate.

Capcane:

  • ordinea contează: ce vine după spread suprascrie, ce vine înainte poate fi suprascris. Mai sus, un id din rest ar înlocui id-ul generat și ar rupe legătura cu eticheta. Decide conștient ce lași să fie suprascris și pune acele atribute înaintea spread-ului;
  • atribute necunoscute în DOM: dacă faci {...props} fără să scoți props proprii (eticheta, eroare), React le pune pe <input> și afișează avertismente de atribute invalide;
  • className și style se înlocuiesc, nu se combină; trebuie combinate manual, ca în exemplu;
  • lizibilitate: <Componenta {...props} /> transmis prin trei niveluri ascunde ce date circulă și face refactorizarea riscantă.

Regula practică: destructurează explicit ce folosești, apoi transmite restul doar elementului de bază.

Ce urmărește intervievatorul: Verifică experiența la construirea componentelor reutilizabile. Candidații slabi folosesc spread peste tot fără să se gândească la ordine.

Eroarea, în practică:React does not recognize the `esteActiv` propInvalid value for prop on <div> tag

State și evenimente

13 Junior

Ce se întâmplă în codul de mai jos și cum îl repari?

JSX
function Lista({ items, onSterge }) {
  return items.map(item => (
    <li key={item.id}>
      {item.nume}
      <button onClick={onSterge(item.id)}>Șterge</button>
    </li>
  ));
}

Răspuns scurt: onSterge(item.id) se execută imediat, în timpul randării, pentru fiecare element, iar rezultatul lui (de obicei undefined) ajunge în onClick. Toate elementele se șterg la prima randare. Trebuie transmisă o funcție: onClick={() => onSterge(item.id)}.

onClick așteaptă o funcție pe care React o apelează la click. Parantezele onSterge(item.id) apelează funcția pe loc, în timp ce React construiește JSX-ul.

Ce se întâmplă efectiv:

  • la prima randare, onSterge rulează pentru fiecare element;
  • dacă onSterge modifică state-ul părintelui, se declanșează o nouă randare, care rulează din nou toate apelurile; în cazuri ca onClick={setCount(count + 1)} ajungi la eroarea „Too many re-renders”;
  • butoanele nu fac nimic la click, pentru că primesc undefined.

Variante corecte:

JSX
<button onClick={() => onSterge(item.id)}>Șterge</button>

Funcția săgeată e creată la fiecare randare, ceea ce e în regulă în aproape toate cazurile. Dacă li devine o componentă memorizată și vrei să eviți funcții noi, mută argumentul în componenta copil:

JSX
const Rand = memo(function Rand({ item, onSterge }) {
  return <li>{item.nume} <button onClick={() => onSterge(item.id)}>Șterge</button></li>;
});

Cu onSterge stabil (de exemplu creat cu useCallback în părinte), Rand nu se mai re-randează inutil. Diferența de reținut: onClick={f} transmite funcția, onClick={f()} transmite rezultatul ei.

Ce urmărește intervievatorul: Este cea mai frecventă greșeală de începător cu evenimentele. Intervievatorul vrea să vezi imediat problema și să explici de ce.

Eroarea, în practică:Too many re-rendersCannot update a component while rendering another

14 Junior

Utilizatorul apasă „+1” de două ori, apoi „Arată”, apoi încă o dată „+1” în următoarele 3 secunde. Ce afișează alerta și de ce?

JSX
function Contor() {
  const [count, setCount] = useState(0);
  function arata() {
    setTimeout(() => alert(count), 3000);
  }
  return (
    <>
      <button onClick={() => setCount(count + 1)}>+1</button>
      <button onClick={arata}>Arată</button>
    </>
  );
}

Răspuns scurt: Alerta afișează 2, deși pe ecran apare deja 3. Fiecare randare are propriul count, constant; funcția din setTimeout a fost creată în randarea în care count era 2 și păstrează acea valoare prin closure.

State-ul într-o componentă funcție se comportă ca un instantaneu (snapshot). La fiecare randare, React apelează funcția Contor, iar count este o constantă locală acelei randări. Handler-ele create în randarea respectivă văd doar valorile ei.

Pașii:

  • randarea cu count = 2: se creează funcția arata, care închide în closure valoarea 2;
  • click pe „Arată”: se programează alerta cu acea funcție;
  • click pe „+1”: React randează din nou cu count = 3 și creează funcții noi, dar timerul deja programat o folosește pe cea veche;
  • după 3 secunde: alert(2).

Acest comportament e intenționat: dacă trimiți un mesaj și schimbi destinatarul între timp, vrei ca mesajul să plece la destinatarul ales la click.

Dacă ai nevoie de cea mai recentă valoare, ții o copie într-un ref:

JSX
const countRef = useRef(count);
countRef.current = count; // sau într-un efect

function arata() {
  setTimeout(() => alert(countRef.current), 3000);
}

Actualizarea ref-ului direct în randare e acceptată în practică pentru astfel de cazuri, dar documentația recomandă un efect. Pentru logica din efecte, React 19.2 oferă useEffectEvent, care rezolvă aceeași problemă mai curat.

Ce urmărește intervievatorul: Verifică dacă înțelegi closure-urile și modelul de snapshot. Majoritatea candidaților răspund 3, gândind state-ul ca pe o variabilă mutabilă.

15 Junior

De ce nu se actualizează ecranul după click?

JSX
function Profil() {
  const [user, setUser] = useState({ nume: "Ana", oras: "Iași" });
  function mutaLaCluj() {
    user.oras = "Cluj";
    setUser(user);
  }
  return <p onClick={mutaLaCluj}>{user.nume}, {user.oras}</p>;
}

Răspuns scurt: Obiectul e modificat pe loc, iar setUser primește aceeași referință. React compară state-ul vechi și cel nou cu Object.is, vede același obiect și sare peste randare. Trebuie creat un obiect nou: setUser({ ...user, oras: "Cluj" }).

React nu urmărește proprietățile obiectelor din state. Când apelezi setter-ul, compară valoarea nouă cu cea veche prin Object.is. Pentru obiecte, asta înseamnă comparație de referință. Codul de mai sus modifică obiectul existent și îl trimite înapoi; referința e aceeași, deci React consideră că nu s-a schimbat nimic.

Mai rău, obiectul a fost totuși modificat. La următoarea randare declanșată de altceva, noul oraș apare brusc, ceea ce face bug-ul greu de reprodus.

Varianta corectă creează un obiect nou:

JSX
function mutaLaCluj() {
  setUser(prev => ({ ...prev, oras: "Cluj" }));
}

Pentru obiecte imbricate, copiezi fiecare nivel pe care îl schimbi:

JSX
setUser(prev => ({
  ...prev,
  adresa: { ...prev.adresa, oras: "Cluj" },
}));

Spread-ul face o copie superficială: nivelurile neschimbate rămân aceleași referințe, ceea ce e bine, pentru că memo și selectoarele pot detecta ce s-a schimbat.

De ce insistă React pe imutabilitate: comparația de referință e rapidă, permite optimizări (memo, useMemo), face posibile funcții ca undo și face codul previzibil. Când copierea devine greoaie, biblioteca Immer permite să scrii cod „mutabil” care produce de fapt obiecte noi.

Ce urmărește intervievatorul: Verifică înțelegerea imutabilității și a comparației prin referință. Greșeala vine des de la cei obișnuiți cu framework-uri reactive bazate pe mutație.

Eroarea, în practică:Do not mutate state directly. Use setState().

16 Junior

Ai în state o listă de sarcini { id, text, gata }. Scrie funcțiile care adaugă o sarcină, o șterg după id și comută gata, fără să modifici tabloul existent.

Răspuns scurt: Adăugarea folosește spread ([...lista, nou]), ștergerea filter, iar actualizarea map cu un obiect nou doar pentru elementul schimbat. Metodele care modifică pe loc (push, splice, atribuirea directă) nu se folosesc pe state.

JSX
function Sarcini() {
  const [lista, setLista] = useState([]);

  function adauga(text) {
    setLista(prev => [...prev, { id: crypto.randomUUID(), text, gata: false }]);
  }

  function sterge(id) {
    setLista(prev => prev.filter(s => s.id !== id));
  }

  function comuta(id) {
    setLista(prev =>
      prev.map(s => (s.id === id ? { ...s, gata: !s.gata } : s))
    );
  }
  // ...
}

De ce așa:

  • push, splice, sort, reverse și lista[i] = ... modifică tabloul existent, deci referința rămâne aceeași și React poate să nu randeze;
  • map returnează un tablou nou și păstrează referințele elementelor neschimbate, ceea ce permite componentelor memorizate (memo) să nu se re-randeze;
  • în comuta se creează un obiect nou doar pentru sarcina schimbată; s.gata = !s.gata în interiorul lui map ar fi tot o mutație, chiar dacă tabloul e nou;
  • forma funcțională prev => ... evită problemele când funcțiile sunt apelate de mai multe ori rapid sau din callback-uri vechi.

Alte operații utile: inserare la o poziție cu [...prev.slice(0, i), nou, ...prev.slice(i)], sortare cu [...prev].sort(...) sau prev.toSorted(...). Id-ul se generează la creare, nu la randare; crypto.randomUUID() e disponibil în browserele moderne în context securizat (HTTPS sau localhost).

Ce urmărește intervievatorul: Este exercițiul de bază la orice live coding cu React. Intervievatorul urmărește dacă folosești reflex metode imutabile și forma funcțională.

17 Junior

Ce este starea derivată și de ce e o greșeală să ții în state și lista de produse, și lista filtrată?

Răspuns scurt: Starea derivată se poate calcula din alte date (state sau props), deci nu trebuie stocată. Dacă ții și lista, și varianta filtrată în state, trebuie să le sincronizezi manual, iar orice uitare produce date inconsistente. Calculeaz-o în timpul randării.

Varianta problematică:

JSX
const [produse, setProduse] = useState([]);
const [filtru, setFiltru] = useState("");
const [filtrate, setFiltrate] = useState([]);

useEffect(() => {
  setFiltrate(produse.filter(p => p.nume.includes(filtru)));
}, [produse, filtru]);

Probleme:

  • două surse de adevăr: dacă adaugi un produs și uiți să actualizezi filtrate (sau efectul are o dependență lipsă), ecranul arată date vechi;
  • randare dublă: întâi cu filtrate vechi, apoi efectul îl setează și urmează încă o randare;
  • cod mai lung și mai greu de citit.

Varianta corectă:

JSX
const [produse, setProduse] = useState([]);
const [filtru, setFiltru] = useState("");
const filtrate = produse.filter(p => p.nume.includes(filtru));

Valoarea e mereu corectă, pentru că se recalculează la fiecare randare. Dacă filtrarea e scumpă (zeci de mii de elemente) și măsurarea arată o problemă, o învelești în useMemo(() => ..., [produse, filtru]).

Exemple tipice de stare derivată: numărul de elemente, totalul unui coș, numeComplet din prenume și nume, „formular valid”, elementul selectat (ține selectedId în state, nu obiectul copiat, și găsește-l în listă). Întrebarea de verificare: „pot calcula valoarea din ce am deja?” Dacă da, nu e state.

Ce urmărește intervievatorul: Verifică gândirea despre surse unice de adevăr. Mulți juniori folosesc useEffect pentru a sincroniza state cu state, o greșeală pe care documentația React o numește explicit.

18 Junior

Când folosești mai multe apeluri useState și când un singur obiect în state?

Răspuns scurt: Folosește variabile separate pentru valori independente și un obiect când valorile se schimbă mereu împreună (coordonate, câmpurile unui formular). Dacă logica de actualizare devine complicată, treci la useReducer.

Ambele variante funcționează; criteriul e cum se schimbă datele.

Variabile separate, pentru valori independente:

JSX
const [deschis, setDeschis] = useState(false);
const [cautare, setCautare] = useState("");
const [pagina, setPagina] = useState(1);

Fiecare setter e simplu și nu există riscul să ștergi accidental alt câmp.

Un obiect, pentru valori care se schimbă împreună:

JSX
const [pozitie, setPozitie] = useState({ x: 0, y: 0 });
setPozitie({ x: e.clientX, y: e.clientY });

Sau pentru un formular cu multe câmpuri, unde un singur handler actualizează orice câmp.

Capcana obiectului: setter-ul din useState înlocuiește valoarea, nu o combină ca vechiul this.setState. Dacă scrii setForm({ email }), pierzi celelalte câmpuri. Trebuie setForm(prev => ({ ...prev, email })).

Semnale că structura nu e bună:

  • două variabile care trebuie mereu actualizate împreună (isLoading și error): grupează-le sau folosește un status unic;
  • state redundant sau derivat: elimină-l;
  • multe actualizări care depind una de alta și reguli de tranziție: useReducer.

Din punct de vedere al performanței, diferența e neglijabilă; contează claritatea și evitarea stărilor imposibile.

Ce urmărește intervievatorul: Verifică judecata la structurarea state-ului. Răspunsul slab este „mereu un obiect, ca în clase”, fără să știi că setter-ul nu combină.

19 Junior

Care e diferența dintre e.target și e.currentTarget într-un handler React? Ce este un SyntheticEvent?

Răspuns scurt: e.target este elementul pe care a avut loc evenimentul (poate fi un copil), iar e.currentTarget este elementul pe care e atașat handler-ul. SyntheticEvent este învelișul React peste evenimentul nativ, cu aceeași interfață în toate browserele.

Exemplu în care diferența contează:

JSX
function Card({ id, onSelect }) {
  return (
    <div data-id={id} onClick={e => onSelect(e.currentTarget.dataset.id)}>
      <img src="..." alt="" />
      <h3>Titlu</h3>
    </div>
  );
}

Dacă utilizatorul dă click pe imagine, e.target este <img>, care nu are data-id. e.currentTarget este mereu <div>-ul cu handler-ul, deci citirea e sigură. La inputuri, e.target.value funcționează pentru că evenimentul are loc chiar pe input.

SyntheticEvent este obiectul pe care React îl dă handler-elor. Are metodele obișnuite (preventDefault, stopPropagation), proprietăți normalizate între browsere și acces la evenimentul original prin e.nativeEvent.

Detalii utile:

  • din React 17, evenimentele sunt atașate la containerul rădăcină (elementul în care montezi aplicația), nu la document; asta permite mai multe versiuni de React pe aceeași pagină;
  • tot din React 17 s-a eliminat event pooling, deci poți citi e și după await sau în setTimeout (în React 16 primeai valori null);
  • onChange în React se declanșează la fiecare tastă, ca evenimentul nativ input, nu doar la pierderea focusului, cum face change nativ;
  • onScroll nu face bubbling în React 17+.

Ce urmărește intervievatorul: Verifică experiența practică cu evenimente. Bug-ul cu e.target pe elemente cu copii apare frecvent în cod real.

20 Junior

Ai un card pe care se poate da click și, în interiorul lui, un buton „Favorit”. La click pe buton se deschide și cardul. Cum repari? Și de ce un formular reîncarcă pagina la trimitere?

Răspuns scurt: Evenimentul de click urcă de la buton la card (bubbling). Oprești propagarea cu e.stopPropagation() în handler-ul butonului. Formularul reîncarcă pagina pentru că acesta e comportamentul implicit al browserului la submit; îl oprești cu e.preventDefault().

Evenimentele în React se propagă la fel ca în DOM: de la elementul pe care s-a produs, în sus prin părinți.

JSX
function CardProdus({ produs, onDeschide, onFavorit }) {
  return (
    <div className="card" onClick={() => onDeschide(produs.id)}>
      <h3>{produs.nume}</h3>
      <button
        onClick={e => {
          e.stopPropagation();
          onFavorit(produs.id);
        }}
      >
        Favorit
      </button>
    </div>
  );
}

Cele două metode fac lucruri diferite:

  • stopPropagation() oprește urcarea evenimentului către părinți;
  • preventDefault() oprește acțiunea implicită a browserului: trimiterea formularului, navigarea unui link, bifarea unui checkbox.
JSX
function Cautare({ onCauta }) {
  const [q, setQ] = useState("");
  return (
    <form onSubmit={e => { e.preventDefault(); onCauta(q); }}>
      <input value={q} onChange={e => setQ(e.target.value)} />
      <button>Caută</button>
    </form>
  );
}

Un <button> fără type într-un formular are implicit type="submit", deci butoanele care nu trimit (de exemplu „Anulează”) trebuie să aibă type="button".

Atenție cu stopPropagation: dacă ai cod care ascultă click-uri la nivel superior (închiderea unui meniu la click în afară, analytics), oprirea propagării îl poate strica. O alternativă e ca părintele să verifice e.target.closest("button") înainte să acționeze. Și, pentru accesibilitate, un card clicabil ar trebui să fie un link sau un buton real, nu un div.

Ce urmărește intervievatorul: Verifică înțelegerea propagării și a comportamentului implicit. Candidații confundă des cele două metode.

Eroarea, în practică:Missing an explicit type attribute for button

21 Junior

Scrie o componentă SelectorCulori care trimite părintelui culoarea aleasă, iar părintele afișează un pătrat în culoarea respectivă.

Răspuns scurt: Părintele ține state-ul culoare și îi dă copilului o funcție (onAlege). Copilul apelează funcția cu valoarea aleasă. Datele circulă în jos prin props, iar evenimentele urcă prin callback-uri.

JSX
const CULORI = ["#e63946", "#2a9d8f", "#e9c46a", "#264653"];

function SelectorCulori({ selectata, onAlege }) {
  return (
    <div role="radiogroup" aria-label="Culoare">
      {CULORI.map(c => (
        <button
          key={c}
          type="button"
          role="radio"
          aria-checked={c === selectata}
          aria-label={c}
          style={{ background: c, outline: c === selectata ? "3px solid black" : "none" }}
          onClick={() => onAlege(c)}
        />
      ))}
    </div>
  );
}

function Editor() {
  const [culoare, setCuloare] = useState(CULORI[0]);
  return (
    <>
      <SelectorCulori selectata={culoare} onAlege={setCuloare} />
      <div style={{ width: 80, height: 80, background: culoare }} />
    </>
  );
}

Punctele pe care le urmărește intervievatorul:

  • state-ul stă în cel mai apropiat părinte comun al componentelor care au nevoie de el (aici Editor, pentru că și pătratul are nevoie de culoare);
  • copilul e controlat: nu are state propriu pentru culoare, primește selectata și anunță schimbarea; așa nu există două surse de adevăr;
  • numele callback-urilor urmează convenția onCeva pentru prop și handleCeva pentru funcția din părinte;
  • onAlege={setCuloare} e suficient; nu e nevoie de (c) => setCuloare(c);
  • lista de culori e o constantă în afara componentei, ca să nu fie recreată la fiecare randare.

Bonus de accesibilitate: rolurile radiogroup/radio și aria-checked fac selectorul utilizabil cu cititoare de ecran.

Ce urmărește intervievatorul: Verifică fluxul de date de bază: date în jos, evenimente în sus. Greșeala tipică e un state duplicat în copil, sincronizat cu un efect.

22 Junior

Ce diferență este între useState(calculeazaInitial()) și useState(() => calculeazaInitial())?

Răspuns scurt: Prima formă apelează funcția la fiecare randare, chiar dacă rezultatul e folosit doar la prima. A doua (inițializare leneșă) primește funcția și React o apelează o singură dată, la montare. Contează când calculul e scump, de exemplu citirea din localStorage sau parsarea unui JSON mare.

Argumentul lui useState e folosit doar la prima randare. Dar JavaScript evaluează argumentele înainte de apelul funcției, deci în varianta de mai jos JSON.parse rulează la fiecare tastă:

JSX
function Notite() {
  const [notite, setNotite] = useState(
    JSON.parse(localStorage.getItem("notite") ?? "[]")
  );
  // ...
}

Cu inițializare leneșă, React primește o funcție și o apelează doar când are nevoie de valoarea inițială:

JSX
const [notite, setNotite] = useState(() =>
  JSON.parse(localStorage.getItem("notite") ?? "[]")
);

Detalii:

  • transmiți funcția, nu rezultatul apelului: useState(calculeazaInitial) e corect, useState(calculeazaInitial()) e varianta neleneșă;
  • funcția de inițializare trebuie să fie pură și fără argumente; în modul Strict, în development, React o apelează de două ori ca să detecteze impurități;
  • dacă vrei să stochezi chiar o funcție în state, trebuie s-o împachetezi: useState(() => functiaMea), altfel React o apelează;
  • același mecanism există la useReducer(reducer, arg, init), unde al treilea argument e funcția de inițializare.

Pentru valori ieftine (useState(0), useState("")) diferența nu contează. Merită când inițializarea citește din storage, creează obiecte mari sau face calcule.

Ce urmărește intervievatorul: Verifică dacă știi detaliul de evaluare a argumentelor în JavaScript și optimizarea oferită de React. E o întrebare frecventă după un exercițiu cu localStorage.

23 Mid

Ce afișează componenta după ce bifezi „Mod avansat”? Textul scris în input se păstrează sau se pierde?

JSX
function Pagina() {
  const [avansat, setAvansat] = useState(false);
  return (
    <div>
      <label><input type="checkbox" checked={avansat}
        onChange={e => setAvansat(e.target.checked)} /> Mod avansat</label>
      {avansat ? <Camp eticheta="Avansat" /> : <Camp eticheta="Simplu" />}
    </div>
  );
}

function Camp({ eticheta }) {
  const [text, setText] = useState("");
  return <label>{eticheta}<input value={text} onChange={e => setText(e.target.value)} /></label>;
}

Răspuns scurt: Textul se păstrează. Ambele ramuri pun o componentă Camp în aceeași poziție din arbore, așa că React o consideră aceeași instanță și îi păstrează state-ul; se schimbă doar eticheta. Dacă vrei resetare, dai fiecărei ramuri un key diferit.

React nu asociază state-ul cu variabila din JSX, ci cu poziția componentei în arbore și cu tipul ei. La comutare, în poziția a doua din <div> rămâne un element de tip Camp. Tipul e același, poziția e aceeași, deci React actualizează props (eticheta) și păstrează state-ul text.

Regulile:

  • același tip în aceeași poziție: state păstrat;
  • alt tip în acea poziție (de exemplu Camp devine div sau altă componentă): subarborele vechi e demontat, state-ul se pierde;
  • key diferit: React îl tratează ca pe o componentă nouă, chiar dacă tipul și poziția sunt aceleași.

Pentru două câmpuri independente:

JSX
{avansat
  ? <Camp key="avansat" eticheta="Avansat" />
  : <Camp key="simplu" eticheta="Simplu" />}

Atenție: cu key, la întoarcere state-ul vechi nu revine, pentru că instanța a fost demontată. Dacă vrei să păstrezi ambele valori, ridică state-ul în părinte sau randează ambele componente și ascunde-o pe cea inactivă cu CSS. React 19.2 a adăugat și componenta <Activity mode="hidden">, care ascunde un subarbore păstrându-i state-ul.

Varianta {avansat && <Camp .../>}{!avansat && <Camp .../>} ar produce două poziții diferite și deci state separat, ceea ce surprinde des.

Ce urmărește intervievatorul: Verifică înțelegerea identității componentelor în arbore. E un bug real în formulare cu ramuri și o întrebare preferată la nivel mid.

24 Mid

După ce adaugi un mesaj într-o listă de chat, vrei să derulezi până la el. Codul de mai jos derulează mereu la penultimul mesaj. De ce și cum ajută flushSync?

JSX
function trimite(text) {
  setMesaje(prev => [...prev, { id: Date.now(), text }]);
  listaRef.current.lastElementChild.scrollIntoView();
}

Răspuns scurt: setMesaje doar programează actualizarea; DOM-ul se schimbă după ce handler-ul se termină, deci ultimul element din DOM e încă mesajul anterior. flushSync din react-dom forțează React să aplice actualizarea sincron, înainte de linia următoare.

React grupează actualizările de state (batching) și randează după ce codul din handler s-a terminat. Asta e bine pentru performanță, dar înseamnă că imediat după setMesaje DOM-ul e neschimbat.

Soluția cu flushSync:

JSX
import { flushSync } from "react-dom";

function trimite(text) {
  flushSync(() => {
    setMesaje(prev => [...prev, { id: crypto.randomUUID(), text }]);
  });
  listaRef.current.lastElementChild.scrollIntoView({ behavior: "smooth" });
}

Când funcția dată lui flushSync se termină, React a randat și a actualizat DOM-ul, deci noul mesaj există.

Alternative și precauții:

  • poți muta derularea într-un efect care rulează când se schimbă lista (useEffect(() => ..., [mesaje.length])); e mai declarativ, dar derulează și la mesajele primite, ceea ce poate fi sau nu dorit;
  • flushSync e o „trapă de urgență”: anulează batching-ul și poate afecta performanța, deci se folosește punctual, doar când ai nevoie de DOM actualizat imediat (derulare, focus, măsurare);
  • nu îl apela în timpul randării sau în interiorul unui efect, React avertizează;
  • Date.now() ca id poate produce duplicate la două mesaje în aceeași milisecundă, de aceea am folosit crypto.randomUUID().

Același tipar apare la focusul pe un câmp care abia a apărut.

Ce urmărește intervievatorul: Verifică înțelegerea momentului în care React aplică schimbările în DOM. Puțini candidați cunosc flushSync, dar mulți au întâlnit bug-ul.

Eroarea, în practică:flushSync was called from inside a lifecycle method

25 Mid

Refactorizează starea de mai jos. Ce stări imposibile permite?

JSX
const [isLoading, setIsLoading] = useState(false);
const [isError, setIsError] = useState(false);
const [data, setData] = useState(null);

Răspuns scurt: Trei variabile booleene independente permit combinații fără sens, de exemplu isLoading și isError adevărate simultan sau date vechi afișate lângă o eroare. Un status explicit ("idle" | "loading" | "success" | "error") face stările imposibile imposibil de reprezentat.

Cu trei variabile ai 2 x 2 x 2 combinații, dintre care multe nu au sens:

  • isLoading: true, isError: true;
  • isError: true, data: {...} (date vechi lângă eroare);
  • uiți să pui isLoading pe false în ramura de eroare și spinner-ul rămâne permanent.

Fiecare loc din cod care schimbă starea trebuie să actualizeze corect toate cele trei variabile, iar greșelile apar exact în ramurile rar testate.

Varianta cu status explicit:

JSX
const [stare, setStare] = useState({ status: "idle" });

async function incarca() {
  setStare({ status: "loading" });
  try {
    const res = await fetch("/api/comenzi");
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    setStare({ status: "success", data: await res.json() });
  } catch (err) {
    setStare({ status: "error", error: err.message });
  }
}

if (stare.status === "loading") return <Spinner />;
if (stare.status === "error") return <Eroare mesaj={stare.error} />;

Fiecare tranziție setează toată starea dintr-o dată, deci nu poți uita un câmp. În TypeScript, o uniune discriminată ({ status: "success"; data: Comanda[] } | { status: "error"; error: string }) obligă compilatorul să verifice că citești data doar în starea de succes.

Pentru mai multe tranziții (reîncercare, anulare), pasul următor e useReducer. Pentru date de server, biblioteci ca TanStack Query oferă direct status, data, error.

Ce urmărește intervievatorul: Verifică gândirea despre modelarea stării. Intervievatorii apreciază candidații care vorbesc despre „stări imposibile” în loc de flag-uri.

26 Senior

Ai o stare imbricată pe mai multe niveluri (proiecte cu liste de sarcini cu comentarii) și actualizările devin greu de scris. Cum o restructurezi?

Răspuns scurt: Normalizezi datele: le ții plat, în obiecte indexate după id (proiecte, sarcini, comentarii), cu referințe prin id-uri. Pentru actualizări imbricate rămase, folosești Immer (produce sau useImmer), care îți permite să scrii cod „mutabil” și produce obiecte noi.

Structura imbricată:

JavaScript
{ proiecte: [{ id: 1, sarcini: [{ id: 7, comentarii: [{ id: 30, text }] }] }] }

Ca să modifici un comentariu, copiezi proiectul, lista de sarcini, sarcina, lista de comentarii și comentariul: cinci niveluri de spread. Cod lung, ușor de greșit, iar o sarcină mutată între proiecte trebuie căutată peste tot.

Normalizarea, ca într-o bază de date:

JavaScript
{
  proiecte:   { byId: { 1: { id: 1, sarcinaIds: [7] } }, allIds: [1] },
  sarcini:    { byId: { 7: { id: 7, comentariuIds: [30] } } },
  comentarii: { byId: { 30: { id: 30, text: "..." } } },
}

Avantaje: o actualizare atinge un singur nivel (comentarii.byId[30]), fiecare entitate există într-un singur loc, căutarea după id e O(1), iar componentele pot primi doar id-ul și citi exact entitatea de care au nevoie, ceea ce reduce re-randările. Redux Toolkit oferă createEntityAdapter pentru exact acest tipar.

Immer pentru cazurile rămase:

JavaScript
import { produce } from "immer";
setStare(produce(draft => {
  draft.comentarii.byId[30].text = "nou";
}));

Immer folosește un Proxy, înregistrează modificările pe draft și produce un obiect nou cu partajare structurală. Redux Toolkit îl folosește intern în createSlice.

Compromisuri: normalizarea cere selectoare pentru a reconstrui vederile imbricate, iar pentru date de server un cache ca TanStack Query poate fi mai potrivit decât un store normalizat scris manual.

Ce urmărește intervievatorul: Verifică experiența cu aplicații cu date complexe. Răspunsul senior discută compromisuri, nu doar sintaxa.

useEffect și sincronizare

Exersează capitolul cu exerciții reale: Curs React online →
27 Junior

În development, efectul tău rulează de două ori la montare și vezi două cereri în tab-ul Network. E un bug? Ce face StrictMode?

Răspuns scurt: Nu e un bug: în modul Strict, în development, React montează componenta, o demontează și o montează din nou, ca să verifice că efectele au curățare corectă. În producție efectul rulează o singură dată. Soluția nu e dezactivarea StrictMode, ci un efect cu cleanup.

<StrictMode> activează verificări suplimentare doar în development:

  • apelează de două ori funcția componentei, inițializatorii de state și reducerii, ca să descopere randări impure;
  • rulează efectele de două ori (montare, demontare simulată, montare), ca să descopere efectele fără curățare;
  • avertizează despre API-uri învechite.

De ce e util: în aplicații reale, o componentă se montează de mai multe ori (navighezi și te întorci, Fast Refresh, viitoare funcționalități care păstrează state-ul componentelor ascunse). Un efect care se abonează fără să se dezaboneze produce scurgeri de memorie sau ascultători dubli. StrictMode face problema vizibilă imediat.

Pentru o cerere, efectul corect ignoră sau anulează răspunsul când e curățat:

JSX
useEffect(() => {
  const ctrl = new AbortController();
  fetch(`/api/produse/${id}`, { signal: ctrl.signal })
    .then(r => r.json())
    .then(setProdus)
    .catch(err => { if (err.name !== "AbortError") setEroare(err); });
  return () => ctrl.abort();
}, [id]);

În development vei vedea o cerere anulată și una reușită, ceea ce e normal.

Ce nu faci: un ref de tip „am rulat deja” ca să sari peste a doua rulare; ascunde problema în loc s-o rezolve. Pentru cereri, o bibliotecă de date (TanStack Query, loaderele routerului) elimină complet discuția, pentru că deduplică cererile.

Ce urmărește intervievatorul: Verifică dacă știi de ce React face asta și nu cauți „cum dezactivez”. E o întrebare foarte frecventă după apariția React 18.

28 Junior

De ce nu poți scrie useEffect(async () => { ... }, [])? Cum încarci corect date cu async/await într-un efect?

Răspuns scurt: O funcție async returnează mereu o promisiune, iar React așteaptă ca efectul să returneze fie nimic, fie o funcție de curățare. Definești o funcție async în interiorul efectului și o apelezi, iar curățarea rămâne o funcție sincronă.

React tratează valoarea returnată de efect ca funcție de cleanup. O promisiune nu e funcție, așa că React afișează un avertisment și nu poate curăța nimic.

Varianta corectă:

JSX
useEffect(() => {
  let anulat = false;

  async function incarca() {
    try {
      setStatus("loading");
      const res = await fetch(`/api/utilizatori/${id}`);
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      const date = await res.json();
      if (!anulat) {
        setUser(date);
        setStatus("success");
      }
    } catch (e) {
      if (!anulat) setStatus("error");
    }
  }

  incarca();
  return () => { anulat = true; };
}, [id]);

Puncte importante:

  • fetch nu aruncă eroare la răspunsuri 404 sau 500, doar la erori de rețea; verifici res.ok explicit;
  • flag-ul anulat împiedică actualizarea state-ului cu un răspuns care a sosit după ce id-ul s-a schimbat sau componenta a fost demontată;
  • AbortController e o alternativă care oprește și cererea, nu doar ignoră răspunsul;
  • poți folosi și un IIFE: (async () => { ... })();, cu aceleași reguli.

În React 19, pentru componente care citesc o promisiune există use(promise) împreună cu Suspense, dar promisiunea trebuie creată în afara randării (de un framework, un loader sau un cache), nu în componentă.

Ce urmărește intervievatorul: Verifică înțelegerea contractului lui useEffect. Un răspuns bun pomenește și verificarea res.ok, pe care mulți o uită.

Eroarea, în practică:useEffect must not return anything (efect async)Unexpected reserved word 'await'

29 Junior

Scrie un efect care afișează lățimea ferestrei și se actualizează la redimensionare. Ce se întâmplă dacă uiți funcția de curățare?

Răspuns scurt: Efectul adaugă un ascultător resize pe window la montare și îl elimină în funcția de curățare. Fără curățare, fiecare montare adaugă încă un ascultător care rămâne activ și după demontare: scurgere de memorie și avertismente sau erori la setarea state-ului.

JSX
function LatimeFereastra() {
  const [latime, setLatime] = useState(() => window.innerWidth);

  useEffect(() => {
    function laRedimensionare() {
      setLatime(window.innerWidth);
    }
    window.addEventListener("resize", laRedimensionare);
    return () => window.removeEventListener("resize", laRedimensionare);
  }, []);

  return <p>Lățime: {latime}px</p>;
}

Detalii care contează:

  • removeEventListener trebuie să primească aceeași referință de funcție ca addEventListener; de aceea funcția e definită în efect și folosită în ambele locuri. O funcție anonimă scrisă de două ori nu se elimină;
  • dependențele sunt [] pentru că efectul nu folosește props sau state; setLatime e stabil;
  • inițializarea leneșă citește lățimea o singură dată; dacă aplicația are randare pe server, window nu există acolo, iar valoarea inițială trebuie setată în efect.

Fără cleanup, fiecare montare (inclusiv dubla montare din StrictMode, navigarea între pagini) adaugă un ascultător nou. Ascultătorii vechi țin în viață closure-urile componentei demontate, deci memoria crește, iar handler-ele rulează inutil la fiecare redimensionare.

Pentru performanță, evenimentul resize se declanșează des; poți limita actualizările cu throttle sau poți folosi matchMedia când te interesează doar un prag (mobil sau desktop). Pentru a refolosi logica, o extragi într-un hook useLatimeFereastra(); pentru surse externe de acest tip, useSyncExternalStore e varianta recomandată de React.

Ce urmărește intervievatorul: Verifică dacă scrii reflex funcția de curățare și dacă știi de ce trebuie aceeași referință. E un exercițiu frecvent la live coding.

Eroarea, în practică:State update on an unmounted component

30 Mid

Ai un câmp de căutare care face o cerere la API la fiecare tastă. Scrie varianta cu debounce de 400 ms folosind un efect.

Răspuns scurt: Efectul pornește un setTimeout la fiecare schimbare a textului și îl anulează în funcția de curățare. Cererea pleacă doar când utilizatorul nu a mai tastat 400 ms. Adaugi și anularea cererii anterioare, ca un răspuns vechi să nu suprascrie unul nou.

JSX
function Cautare() {
  const [q, setQ] = useState("");
  const [rezultate, setRezultate] = useState([]);

  useEffect(() => {
    if (q.trim().length < 2) {
      setRezultate([]);
      return;
    }
    const ctrl = new AbortController();
    const timer = setTimeout(async () => {
      try {
        const res = await fetch(`/api/cauta?q=${encodeURIComponent(q)}`, { signal: ctrl.signal });
        setRezultate(await res.json());
      } catch (e) {
        if (e.name !== "AbortError") console.error(e);
      }
    }, 400);
    return () => {
      clearTimeout(timer);
      ctrl.abort();
    };
  }, [q]);

  return (
    <>
      <input value={q} onChange={e => setQ(e.target.value)} />
      <ul>{rezultate.map(r => <li key={r.id}>{r.nume}</li>)}</ul>
    </>
  );
}

Cum funcționează: la fiecare tastă, q se schimbă, React rulează curățarea efectului anterior (oprește timerul care nu a apucat să pornească și anulează cererea în curs), apoi programează un timer nou. Inputul rămâne fluid, pentru că q se actualizează imediat; doar cererea e întârziată.

Detalii:

  • encodeURIComponent evită probleme cu spații și caractere speciale;
  • pragul minim de caractere reduce cererile inutile;
  • logica se poate extrage într-un hook useDebounce(valoare, ms), iar cu TanStack Query valoarea întârziată devine parte din queryKey, cu cache inclus.

Ce urmărește intervievatorul: Verifică dacă folosești cleanup-ul ca mecanism de anulare, nu doar pentru dezabonare. Mulți scriu debounce-ul cu o variabilă globală care nu funcționează între randări.

31 Mid

Contorul de mai jos ajunge la 1 și rămâne acolo. De ce?

JSX
function Cronometru() {
  const [secunde, setSecunde] = useState(0);
  useEffect(() => {
    const id = setInterval(() => {
      setSecunde(secunde + 1);
    }, 1000);
    return () => clearInterval(id);
  }, []);
  return <p>{secunde}s</p>;
}

Răspuns scurt: Callback-ul din setInterval a fost creat la prima randare și vede mereu secunde = 0 (closure învechit, stale closure). La fiecare secundă setează 0 + 1 = 1. Soluția: actualizarea funcțională setSecunde(s => s + 1).

Efectul are dependențe goale, deci rulează o singură dată, cu valorile din prima randare. Funcția dată lui setInterval închide în closure variabila secunde din acea randare, adică 0. Componenta se randează din nou cu secunde = 1, dar intervalul folosește în continuare funcția veche. Rezultatul: setSecunde(1) la nesfârșit, iar React nu mai randează, pentru că valoarea nu se schimbă.

Linterul react-hooks/exhaustive-deps semnalează problema: efectul folosește secunde, dar nu îl declară. Dacă adaugi secunde în dependențe, codul funcționează, dar intervalul este oprit și repornit la fiecare secundă, ceea ce poate produce derivă de timp.

Soluția corectă e să nu mai citești state-ul în efect:

JSX
useEffect(() => {
  const id = setInterval(() => {
    setSecunde(s => s + 1);
  }, 1000);
  return () => clearInterval(id);
}, []);

Forma funcțională primește valoarea curentă din coada lui React, deci nu depinde de closure.

Dacă intervalul trebuie să citească și alte valori care se schimbă (de exemplu un pas configurabil), opțiunile sunt un ref actualizat la fiecare randare, useReducer (dispatch-ul e stabil, iar reducerul vede mereu state-ul curent) sau, din React 19.2, useEffectEvent. Pentru un cronometru precis, calculează timpul scurs din Date.now() față de momentul de start, nu prin numărarea tick-urilor.

Ce urmărește intervievatorul: Este întrebarea clasică despre stale closures. Verifică dacă înțelegi legătura dintre closure, dependențe și forma funcțională.

Eroarea, în practică:Use callback in setState (previous state)

32 Mid

Utilizatorul dă click rapid pe mai mulți utilizatori într-o listă, iar panoul de detalii afișează uneori alt utilizator decât cel selectat. Unde e problema?

JSX
useEffect(() => {
  fetch(`/api/users/${userId}`)
    .then(r => r.json())
    .then(setUser);
}, [userId]);

Răspuns scurt: Este o condiție de cursă (race condition): cererile pleacă în ordine, dar răspunsurile pot sosi în altă ordine, iar ultimul răspuns sosit suprascrie state-ul, chiar dacă e pentru un utilizator vechi. Repari în cleanup: ignori răspunsul cu un flag sau anulezi cererea cu AbortController.

Scenariu: click pe utilizatorul 1, apoi imediat pe 2. Pleacă cererea A (id 1), apoi B (id 2). Dacă serverul răspunde mai încet la A, ordinea sosirii e B, apoi A. Efectul nu verifică nimic, așa că setUser(A) vine ultimul și ecranul arată utilizatorul 1, deși selecția e 2.

Varianta cu anulare:

JSX
useEffect(() => {
  const ctrl = new AbortController();
  setStatus("loading");
  fetch(`/api/users/${userId}`, { signal: ctrl.signal })
    .then(r => {
      if (!r.ok) throw new Error(r.status);
      return r.json();
    })
    .then(u => { setUser(u); setStatus("success"); })
    .catch(e => { if (e.name !== "AbortError") setStatus("error"); });
  return () => ctrl.abort();
}, [userId]);

Când userId se schimbă, React rulează întâi curățarea efectului vechi, care anulează cererea A. Promisiunea ei e respinsă cu AbortError, pe care o ignorăm. Doar răspunsul pentru id-ul curent ajunge în state.

Varianta cu flag (let ignora = false; return () => { ignora = true; }) e echivalentă pentru UI, dar cererea veche continuă în rețea.

Bug-ul e greu de prins local, unde rețeaua e rapidă; îl reproduci cu throttling în DevTools. E unul dintre motivele pentru care, în aplicații reale, se preferă biblioteci ca TanStack Query sau SWR: ele leagă răspunsul de cheia cererii și elimină complet problema.

Ce urmărește intervievatorul: Verifică experiența cu fetch în efecte în condiții reale. Candidații care nu au întâlnit bug-ul în producție rareori îl recunosc din cod.

Eroarea, în practică:State update on an unmounted componentAbortError: signal is aborted without reason

33 Mid

De ce efectul de mai jos se conectează din nou la fiecare randare, deși camera nu se schimbă?

JSX
function Chat({ camera }) {
  const optiuni = { server: "wss://chat.exemplu.ro", camera };
  useEffect(() => {
    const conn = conecteaza(optiuni);
    return () => conn.close();
  }, [optiuni]);
}

Răspuns scurt: optiuni e un obiect nou la fiecare randare, iar React compară dependențele cu Object.is, deci le vede mereu diferite. Soluția: creezi obiectul în interiorul efectului și depinzi doar de valorile primitive (camera).

Dependențele se compară element cu element prin Object.is. Pentru obiecte, funcții și tablouri create în corpul componentei, fiecare randare produce o referință nouă: {...} !== {...}. Deci orice randare a lui Chat, chiar declanșată de altceva (un mesaj nou, un input), închide conexiunea și deschide alta.

Soluția preferată e mutarea obiectului în efect:

JSX
function Chat({ camera }) {
  useEffect(() => {
    const conn = conecteaza({ server: "wss://chat.exemplu.ro", camera });
    return () => conn.close();
  }, [camera]);
}

Acum efectul depinde doar de camera, un șir comparat după valoare.

Alte variante, în ordinea preferinței:

  • valorile constante (serverul) se mută în afara componentei;
  • dacă obiectul vine din props, destructurezi câmpurile primitive înainte de efect și depinzi de ele;
  • dacă ai nevoie de obiect și în altă parte, useMemo(() => ({ ... }), [camera]);
  • pentru funcții, le muți în efect sau le stabilizezi cu useCallback.

Ce nu faci: să ștergi dependența din listă sau să dezactivezi linterul. Efectul ar folosi valori vechi și ai înlocui un bug cu altul. Regula din documentația React: nu alegi dependențele, ele rezultă din codul efectului; ca să le schimbi, schimbi codul. Din React 19 cu React Compiler, multe astfel de valori sunt memorizate automat, dar principiul rămâne același.

Ce urmărește intervievatorul: Verifică dacă înțelegi comparația dependențelor prin referință. Răspunsul slab este „scot optiuni din dependențe”.

Eroarea, în practică:Maximum update depth exceededReact Hook useEffect has a missing dependency

34 Mid

Ce efecte din componenta de mai jos nu sunt necesare și cum ar arăta codul fără ele?

JSX
function Cos({ produse }) {
  const [total, setTotal] = useState(0);
  const [cantitate, setCantitate] = useState(1);
  useEffect(() => {
    setTotal(produse.reduce((s, p) => s + p.pret * p.qty, 0));
  }, [produse]);
  useEffect(() => {
    if (cantitate > 10) alert("Maxim 10 bucăți");
  }, [cantitate]);
}

Răspuns scurt: Ambele. Totalul e stare derivată și se calculează direct în randare. Alerta e reacția la o acțiune a utilizatorului, deci aparține handler-ului de eveniment, nu unui efect. Efectele sunt pentru sincronizarea cu sisteme externe.

Documentația React are o pagină întreagă, „You Might Not Need an Effect”. Regula: un efect e potrivit când componenta trebuie să se sincronizeze cu ceva din afara React (rețea, DOM imperativ, timere, abonamente, biblioteci terțe). Nu e potrivit pentru a transforma date sau a reacționa la evenimente.

Varianta corectată:

JSX
function Cos({ produse }) {
  const [cantitate, setCantitate] = useState(1);
  const total = produse.reduce((s, p) => s + p.pret * p.qty, 0);

  function schimbaCantitate(n) {
    if (n > 10) {
      alert("Maxim 10 bucăți");
      return;
    }
    setCantitate(n);
  }
}

De ce sunt greșite efectele originale:

  • primul produce o randare cu totalul vechi, apoi încă una cu cel nou; în plus, total poate fi inconsistent cu produse pentru un moment;
  • al doilea rulează și când cantitate se schimbă din alt motiv (restaurare din storage, o resetare), nu doar la acțiunea utilizatorului; în StrictMode alerta ar apărea chiar de două ori la montare dacă valoarea inițială ar depăși limita.

Alte cazuri frecvente fără efect:

  • resetarea state-ului când se schimbă un prop: folosești key pe componentă;
  • notificarea părintelui după o schimbare: apelezi onChange în același handler;
  • trimiterea unui formular: în onSubmit, nu într-un efect care urmărește un flag trimis.

Întrebarea de control: „de ce rulează codul acesta?” Dacă răspunsul e „pentru că utilizatorul a făcut ceva”, locul lui e în handler.

Ce urmărește intervievatorul: Verifică maturitatea în folosirea efectelor. Abuzul de useEffect e cea mai frecventă problemă de calitate în codul React scris de juniori.

Eroarea, în practică:Maximum update depth exceeded

35 Mid

Care e diferența dintre useEffect și useLayoutEffect? Dă un exemplu în care alegerea contează.

Răspuns scurt: useEffect rulează după ce browserul a desenat ecranul, fără să-l blocheze. useLayoutEffect rulează sincron după actualizarea DOM-ului, dar înainte de desenare, deci poți măsura și corecta layout-ul fără ca utilizatorul să vadă o pâlpâire. Costul: blochează desenarea.

Ordinea pentru o actualizare: React randează, aplică modificările în DOM (commit), rulează efectele de layout, browserul desenează, apoi rulează efectele normale.

Exemplu tipic: un tooltip care se poziționează deasupra elementului, dar coboară dedesubt dacă nu are loc.

JSX
function Tooltip({ tinta, children }) {
  const ref = useRef(null);
  const [sus, setSus] = useState(true);

  useLayoutEffect(() => {
    const { height } = ref.current.getBoundingClientRect();
    const spatiuSus = tinta.getBoundingClientRect().top;
    setSus(spatiuSus > height);
  }, [tinta]);

  return <div ref={ref} className={sus ? "tip tip--sus" : "tip tip--jos"}>{children}</div>;
}

Cu useEffect, utilizatorul ar putea vedea un cadru cu tooltip-ul sus, apoi un salt jos. Cu useLayoutEffect, React aplică actualizarea din efect înainte ca browserul să deseneze, deci se vede doar poziția finală.

Când folosești useLayoutEffect:

  • măsurători ale DOM-ului care influențează randarea (dimensiuni, poziții);
  • restaurarea poziției de scroll înainte de afișare;
  • sincronizări cu biblioteci care manipulează DOM-ul și trebuie să vadă starea finală.

Când nu: cereri de rețea, abonamente, logging. Acolo useEffect e corect, pentru că nu blochează afișarea.

La randarea pe server, useLayoutEffect nu rulează (nu există layout); în versiunile React mai vechi de 19 afișa și un avertisment. useInsertionEffect există pentru bibliotecile CSS-in-JS, nu pentru codul de aplicație.

Ce urmărește intervievatorul: Verifică înțelegerea fazelor de randare și a desenării. Majoritatea candidaților știu că există, puțini pot da un exemplu concret.

36 Mid

Linterul react-hooks/exhaustive-deps îți cere să adaugi onSave în dependențele efectului, dar atunci efectul rulează la fiecare randare a părintelui. Ce faci?

Răspuns scurt: Nu ignori avertismentul. Cauza e că onSave e o funcție nouă la fiecare randare a părintelui. Opțiunile: stabilizezi funcția în părinte cu useCallback, muți logica astfel încât efectul să nu depindă de ea sau, din React 19.2, o citești printr-un useEffectEvent.

Situația tipică, un autosave:

JSX
function Editor({ text, onSave }) {
  useEffect(() => {
    const id = setTimeout(() => onSave(text), 1000);
    return () => clearTimeout(id);
  }, [text, onSave]);
}

// în părinte:
<Editor text={text} onSave={t => api.salveaza(docId, t)} />

Funcția săgeată din părinte e nouă la fiecare randare, deci timerul repornește chiar dacă textul nu s-a schimbat.

Variante, de la cea mai simplă:

  • stabilizarea în părinte: const onSave = useCallback(t => api.salveaza(docId, t), [docId]); funcționează dacă ai control asupra părintelui și toți părinții respectă convenția;
  • mutarea logicii: dacă efectul are nevoie doar de date, nu de funcție, părintele poate face salvarea pe baza unui eveniment, iar efectul dispare;
  • useEffectEvent (stabil din React 19.2): marchezi funcția ca logică non-reactivă, care citește mereu ultimele props, dar nu e dependență:
JSX
const salveaza = useEffectEvent(t => onSave(t));
useEffect(() => {
  const id = setTimeout(() => salveaza(text), 1000);
  return () => clearTimeout(id);
}, [text]);
  • în versiunile anterioare, echivalentul era un ref actualizat cu ultima funcție.

Ce nu faci: // eslint-disable-next-line. Ascunzi o dependență reală și efectul va folosi la un moment dat un onSave vechi, cu un docId greșit, ceea ce poate salva textul în alt document.

Ce urmărește intervievatorul: Verifică dacă tratezi linterul ca pe un ajutor și cunoști soluțiile corecte. Dezactivarea regulii e un semnal negativ pentru intervievator.

Eroarea, în practică:React Hook useEffect has a missing dependency

37 Senior

Ce problemă rezolvă useEffectEvent (React 19.2)? Dă un exemplu cu o conexiune de chat care trebuie să citească tema curentă fără să se reconecteze.

Răspuns scurt: useEffectEvent separă logica non-reactivă dintr-un efect: o funcție care citește mereu cele mai noi props și state, dar nu face parte din dependențe. Astfel, efectul se resincronizează doar când se schimbă ce contează (camera), nu și la schimbarea temei.

Un efect are două feluri de cod: partea reactivă, care trebuie să ruleze din nou când se schimbă anumite valori, și partea non-reactivă, care doar citește valorile la un moment dat. Înainte de useEffectEvent, linterul te obliga să pui toate valorile citite în dependențe.

JSX
function Chat({ camera, tema }) {
  useEffect(() => {
    const conn = conecteaza(camera);
    conn.on("conectat", () => arataNotificare("Conectat", tema));
    return () => conn.close();
  }, [camera, tema]); // schimbarea temei reconectează chat-ul
}

Cu useEffectEvent:

JSX
import { useEffect, useEffectEvent } from "react";

function Chat({ camera, tema }) {
  const laConectare = useEffectEvent(() => {
    arataNotificare("Conectat", tema); // citește tema curentă
  });

  useEffect(() => {
    const conn = conecteaza(camera);
    conn.on("conectat", () => laConectare());
    return () => conn.close();
  }, [camera]);
}

Reguli:

  • funcția returnată nu se pune în dependențe; versiunile recente ale pluginului eslint-plugin-react-hooks înțeleg asta;
  • se apelează doar din efecte (sau din alte Effect Events), nu în timpul randării și nu se transmite altor componente ca prop;
  • nu e un înlocuitor general pentru useCallback; e pentru cazul strict „vreau ultima valoare, dar nu vreau să resincronizez”.

Înainte de 19.2, același rezultat se obținea cu un ref actualizat la fiecare randare, cu mai mult cod și mai ușor de greșit.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu API-urile recente și înțelegi distincția reactiv/non-reactiv. Un senior trebuie să explice de ce, nu doar sintaxa.

useRef, useReducer și hooks avansate

38 Junior

Pe lângă accesul la elemente DOM, la ce folosește useRef? De ce schimbarea lui ref.current nu re-randează componenta?

Răspuns scurt: useRef ține o valoare păstrată între randări care nu se afișează: id-ul unui timer, o valoare anterioară, instanța unei biblioteci. E un obiect simplu { current } pe care React nu îl urmărește, deci modificarea lui nu programează randări.

useRef(initial) returnează același obiect la fiecare randare. Poți modifica current oricând, iar React nu află, pentru că nu trece printr-un setter.

Exemplu: un buton care pornește și oprește un timer.

JSX
function Metronom() {
  const [activ, setActiv] = useState(false);
  const timerRef = useRef(null);

  function comuta() {
    if (activ) {
      clearInterval(timerRef.current);
      timerRef.current = null;
    } else {
      timerRef.current = setInterval(() => playClick(), 500);
    }
    setActiv(!activ);
  }

  useEffect(() => () => clearInterval(timerRef.current), []);
  return <button onClick={comuta}>{activ ? "Stop" : "Start"}</button>;
}

Id-ul timerului nu apare pe ecran, deci nu are sens să fie state (ar provoca o randare inutilă). O variabilă locală nu merge, pentru că se pierde la fiecare randare. O variabilă la nivelul modulului ar fi partajată de toate instanțele componentei.

Alte utilizări: instanța unui grafic sau a unei hărți create de o bibliotecă externă, un AbortController curent, un flag „s-a trimis deja”, ultima valoare a unui prop pentru comparație.

Regula importantă: nu citi și nu scrie ref.current în timpul randării (cu excepția inițializării leneșe), pentru că rezultatul randării ar depinde de ceva ce React nu știe. Citirea în handler-e și efecte e corectă. Dacă valoarea trebuie afișată, e state, nu ref.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre state și ref ca instrumente. Candidații slabi pomenesc doar „ref pentru input”.

Eroarea, în practică:Cannot read properties of null (reading 'focus')Function components cannot have string refs

39 Junior

Scrie o componentă care pune automat focusul pe un câmp de căutare când se deschide un panou și îl pune din nou la apăsarea tastei /.

Răspuns scurt: Creezi un ref cu useRef(null), îl atașezi la input prin prop-ul ref, apoi apelezi ref.current.focus() într-un efect la montare și într-un ascultător de tastatură pe document, eliminat la curățare.

JSX
function PanouCautare() {
  const inputRef = useRef(null);

  useEffect(() => {
    inputRef.current?.focus();

    function laTasta(e) {
      const tag = document.activeElement?.tagName;
      if (e.key === "/" && tag !== "INPUT" && tag !== "TEXTAREA") {
        e.preventDefault();
        inputRef.current?.focus();
      }
    }
    document.addEventListener("keydown", laTasta);
    return () => document.removeEventListener("keydown", laTasta);
  }, []);

  return <input ref={inputRef} type="search" placeholder="Caută (apasă /)" />;
}

Explicații:

  • React completează inputRef.current cu nodul DOM după commit, deci în efect elementul există; în timpul randării current e încă null la prima montare;
  • ?. protejează cazul în care inputul nu e randat (condiționat);
  • verificarea activeElement împiedică furtul tastei / când utilizatorul scrie în alt câmp;
  • preventDefault oprește scrierea caracterului / în input în momentul focusului.

Pentru focusul simplu la montare există și atributul autoFocus, pe care React îl tratează apelând focus() la montare. E suficient pentru cazuri simple, dar nu te ajută la a doua parte. Din punct de vedere al accesibilității, mutarea automată a focusului trebuie folosită cu grijă: e potrivită la deschiderea unui dialog sau panou, nu la încărcarea unei pagini obișnuite, unde poate dezorienta utilizatorii de cititoare de ecran.

Ce urmărește intervievatorul: Verifică folosirea practică a ref-urilor și a evenimentelor globale cu curățare. Detaliile de accesibilitate diferențiază un răspuns bun.

Eroarea, în practică:Cannot read properties of null (reading 'focus')

40 Junior

Când alegi useReducer în loc de useState?

Răspuns scurt: Când starea are mai multe câmpuri legate între ele, când tranzițiile urmează reguli (de exemplu pași într-un wizard) sau când aceeași actualizare se face din mai multe locuri. Reducerul adună logica într-o funcție pură, ușor de testat, iar componentele doar trimit acțiuni.

useState e potrivit pentru valori independente cu actualizări simple. useReducer devine mai bun când:

  • mai multe valori se schimbă împreună: un formular cu valori, erori, trimis, status;
  • tranzițiile au reguli: nu poți trece la pasul 3 dacă pasul 2 nu e valid, nu poți adăuga în coș mai mult decât stocul;
  • multe handler-e modifică aceeași stare: logica e împrăștiată prin componentă, iar reducerul o centralizează;
  • vrei să testezi logica separat: reducerul e o funcție pură (state, action) => newState, testată fără React;
  • vrei să transmiți actualizarea în jos: dispatch e stabil (aceeași referință mereu), deci îl poți da copiilor sau într-un context fără useCallback.
JSX
function reducer(state, action) {
  switch (action.type) {
    case "next":
      return state.pas < 3 && state.valid[state.pas] ? { ...state, pas: state.pas + 1 } : state;
    case "prev":
      return { ...state, pas: Math.max(1, state.pas - 1) };
    default:
      throw new Error(`Acțiune necunoscută: ${action.type}`);
  }
}
const [state, dispatch] = useReducer(reducer, { pas: 1, valid: {} });

Costul: mai mult cod pentru cazuri simple. Pentru un toggle sau un contor, useState e mai clar. Un semn util că ai nevoie de reducer: te trezești scriind trei setX consecutive în fiecare handler.

Ambele hook-uri pot fi folosite împreună în aceeași componentă, iar useState e implementat intern în React tot ca un reducer.

Ce urmărește intervievatorul: Verifică judecata, nu doar sintaxa. Un răspuns bun menționează testabilitatea și stabilitatea lui dispatch.

41 Junior

Coșul nu se actualizează pe ecran după „Adaugă”, deși în consolă reducerul se apelează. Unde e bug-ul?

JSX
function reducer(state, action) {
  switch (action.type) {
    case "adauga":
      state.items.push(action.produs);
      return state;
    default:
      return state;
  }
}

Răspuns scurt: Reducerul modifică state-ul pe loc și returnează aceeași referință. React compară state-ul nou cu cel vechi prin Object.is, vede același obiect și nu randează. Reducerul trebuie să returneze un obiect nou: { ...state, items: [...state.items, action.produs] }.

Un reducer trebuie să fie o funcție pură: primește state-ul și acțiunea și returnează un state nou, fără să le modifice pe cele primite.

Problemele codului:

  • push modifică tabloul existent, iar return state returnează același obiect, deci React sare peste randare;
  • chiar dacă altceva provoacă o randare și coșul apare actualizat, ai pierdut posibilitatea de a compara versiunile (pentru memo, undo, devtools);
  • în StrictMode, React apelează reducerul de două ori în development, iar un push adaugă produsul de două ori, ceea ce face bug-ul vizibil.

Varianta corectă:

JSX
function reducer(state, action) {
  switch (action.type) {
    case "adauga": {
      const exista = state.items.find(i => i.id === action.produs.id);
      const items = exista
        ? state.items.map(i => (i.id === action.produs.id ? { ...i, qty: i.qty + 1 } : i))
        : [...state.items, { ...action.produs, qty: 1 }];
      return { ...state, items };
    }
    default:
      throw new Error(`Acțiune necunoscută: ${action.type}`);
  }
}

Observă și ramura default: aruncarea unei erori la acțiuni necunoscute prinde imediat greșelile de tastare în type, pe când return state le ascunde.

Dacă preferi sintaxa mutabilă, useImmerReducer din pachetul use-immer sau createSlice din Redux Toolkit îți permit state.items.push(...), pentru că lucrezi pe un draft, iar Immer produce obiectul nou.

Ce urmărește intervievatorul: Verifică înțelegerea imutabilității în reduceri. Detaliul cu dubla apelare în StrictMode arată experiență reală.

42 Junior

Două componente folosesc același custom hook useContor(). Dacă una crește contorul, se schimbă și în cealaltă?

Răspuns scurt: Nu. Un custom hook reutilizează logica, nu starea. Fiecare componentă care îl apelează primește propriul useState, independent. Pentru stare comună, ridici state-ul într-un părinte comun sau folosești un context sau un store.

Un custom hook este o funcție care apelează alte hook-uri. Când ComponentaA și ComponentaB apelează useContor(), fiecare apel de useState din hook se leagă de componenta care l-a apelat, exact ca și cum ai fi scris useState direct în ea.

JSX
function useContor(initial = 0) {
  const [valoare, setValoare] = useState(initial);
  const creste = () => setValoare(v => v + 1);
  const reseteaza = () => setValoare(initial);
  return { valoare, creste, reseteaza };
}

function A() { const c = useContor(); return <button onClick={c.creste}>A: {c.valoare}</button>; }
function B() { const c = useContor(); return <button onClick={c.creste}>B: {c.valoare}</button>; }

Click pe A schimbă doar A.

Dacă vrei aceeași valoare în ambele, ai opțiuni:

  • state în părinte și props;
  • un context cu provider deasupra ambelor, iar hook-ul citește din context (useCos() care apelează useContext(CosContext));
  • un store extern (Zustand, Redux, un store propriu cu useSyncExternalStore), la care hook-ul se abonează.

Reguli pentru custom hooks:

  • numele începe cu use, ca linterul să aplice regulile hook-urilor în interior;
  • poate returna orice: o valoare, un tablou (ca useState) sau un obiect cu nume;
  • nu e nevoie să fie hook dacă nu folosește alte hook-uri; o funcție obișnuită e mai potrivită.

Ce urmărește intervievatorul: Verifică o confuzie frecventă între reutilizarea logicii și partajarea stării. Mulți juniori cred că hook-ul e un „store”.

43 Mid

Scrie un reducer pentru un coș de cumpărături cu acțiunile: adăugare, schimbare cantitate, ștergere și golire. Cum expui totalul?

Răspuns scurt: Reducerul tratează fiecare acțiune printr-un case care returnează un state nou, iar cantitatea 0 elimină produsul. Totalul nu stă în state: îl calculezi din items la randare sau într-un selector, ca să nu se desincronizeze.

JSX
const initial = { items: [] };

function cosReducer(state, action) {
  switch (action.type) {
    case "adauga": {
      const { produs } = action;
      const exista = state.items.some(i => i.id === produs.id);
      return {
        items: exista
          ? state.items.map(i => (i.id === produs.id ? { ...i, qty: i.qty + 1 } : i))
          : [...state.items, { id: produs.id, nume: produs.nume, pret: produs.pret, qty: 1 }],
      };
    }
    case "cantitate": {
      const qty = Math.max(0, Math.floor(action.qty));
      return {
        items: qty === 0
          ? state.items.filter(i => i.id !== action.id)
          : state.items.map(i => (i.id === action.id ? { ...i, qty } : i)),
      };
    }
    case "sterge":
      return { items: state.items.filter(i => i.id !== action.id) };
    case "goleste":
      return initial;
    default:
      throw new Error(`Acțiune necunoscută: ${action.type}`);
  }
}

export const totalCos = state =>
  state.items.reduce((s, i) => s + i.pret * i.qty, 0);

Folosire:

JSX
const [cos, dispatch] = useReducer(cosReducer, initial);
const total = totalCos(cos);
<button onClick={() => dispatch({ type: "adauga", produs })}>Adaugă</button>

Decizii pe care merită să le explici:

  • în coș salvezi doar datele necesare, nu tot obiectul produsului;
  • validarea cantității stă în reducer, deci nicio componentă nu poate pune o valoare negativă;
  • totalul e derivat; dacă prețurile sunt în lei cu zecimale, la sume reale e mai sigur să lucrezi în bani (întregi) ca să eviți erorile de virgulă mobilă;
  • reducerul se testează ușor, fără React: expect(cosReducer(s, { type: "sterge", id: 1 }).items).toHaveLength(0).

Ce urmărește intervievatorul: Este un exercițiu tipic de live coding. Intervievatorul urmărește imutabilitatea, cazurile limită și dacă evită să stocheze totalul.

44 Mid

Scrie un hook useDebounce(valoare, intarziere) care returnează valoarea doar după ce nu s-a mai schimbat un anumit timp. Cum îl folosești cu un filtru de listă?

Răspuns scurt: Hook-ul ține o copie întârziată a valorii în state și o actualizează dintr-un setTimeout pornit într-un efect, pe care îl anulezi la curățare. Componenta folosește valoarea originală pentru input și pe cea întârziată pentru operația scumpă.

JSX
import { useEffect, useState } from "react";

export function useDebounce(valoare, intarziere = 300) {
  const [intarziata, setIntarziata] = useState(valoare);

  useEffect(() => {
    const id = setTimeout(() => setIntarziata(valoare), intarziere);
    return () => clearTimeout(id);
  }, [valoare, intarziere]);

  return intarziata;
}

Folosire:

JSX
function Catalog({ produse }) {
  const [q, setQ] = useState("");
  const qIntarziat = useDebounce(q, 300);

  const filtrate = useMemo(
    () => produse.filter(p => p.nume.toLowerCase().includes(qIntarziat.toLowerCase())),
    [produse, qIntarziat]
  );

  return (
    <>
      <input value={q} onChange={e => setQ(e.target.value)} />
      {q !== qIntarziat && <small>Se caută...</small>}
      <Lista items={filtrate} />
    </>
  );
}

De ce funcționează: la fiecare schimbare, curățarea anulează timerul anterior, deci doar ultimul ajunge să ruleze. Inputul rămâne controlat de q, care se actualizează imediat, așa că tastarea nu are întârzieri.

Observații:

  • hook-ul funcționează pentru orice tip, dar pentru obiecte valoarea trebuie să fie stabilă, altfel timerul repornește la fiecare randare;
  • debounce pe valoare e diferit de debounce pe funcție (de exemplu un onChange care trimite la server); pentru funcție ai nevoie de un ref la timer;
  • pentru filtrare locală, useDeferredValue din React 18 e o alternativă fără timp fix, care lasă React să decidă când randează lista; pentru cereri de rețea, debounce-ul real rămâne mai potrivit, pentru că reduce numărul de cereri.

Ce urmărește intervievatorul: Verifică dacă știi să scrii un hook reutilizabil corect și să alegi între debounce și useDeferredValue.

45 Mid

Cum transmiți un ref către un element din interiorul componentei tale? Ce s-a schimbat în React 19 față de forwardRef?

Răspuns scurt: Până la React 18, componenta trebuia învelită în forwardRef ca să primească ref ca al doilea argument. Din React 19, componentele funcție primesc ref ca prop obișnuit, iar forwardRef nu mai e necesar (rămâne funcțional, urmând să fie marcat învechit).

Problema: o componentă de bibliotecă, de exemplu Input, învelește un <input>. Părintele vrea să pună focus pe el: <Input ref={inputRef} />. În React 18, ref nu era un prop obișnuit; era interceptat de React și nu ajungea în componentă.

React 18:

JSX
const Input = forwardRef(function Input({ eticheta, ...rest }, ref) {
  return (
    <label>{eticheta}<input ref={ref} {...rest} /></label>
  );
});

React 19:

JSX
function Input({ eticheta, ref, ...rest }) {
  return (
    <label>{eticheta}<input ref={ref} {...rest} /></label>
  );
}

Alte noutăți legate de ref-uri în React 19:

  • un callback ref poate returna o funcție de curățare, apelată la demontare, similar cu efectele:
JSX
<div ref={nod => {
  const obs = new ResizeObserver(() => {});
  obs.observe(nod);
  return () => obs.disconnect();
}} />
  • în TypeScript, useRef cere acum un argument (useRef<HTMLInputElement>(null)).

Când expui un ref, gândește-te ce primește părintele: tot nodul DOM îi dă acces la orice. Dacă vrei să limitezi la câteva metode (focus, scrollIntoView), folosești useImperativeHandle. La componentele clasă, ref continuă să indice instanța clasei. Pentru bibliotecile care trebuie să suporte și React 18, forwardRef rămâne încă necesar.

Ce urmărește intervievatorul: Verifică dacă ești la zi cu React 19 și înțelegi de ce ref era special. Un candidat mid trebuie să cunoască ambele variante, pentru că proiectele reale le amestecă.

Eroarea, în practică:Function components cannot be given refsforwardRef render functions accept two parameters

46 Mid

Ce face useImperativeHandle și când e justificat să-l folosești?

Răspuns scurt: useImperativeHandle definește ce obiect primește părintele prin ref, în loc de nodul DOM: de exemplu doar metodele focus() și reset(). E justificat pentru acțiuni imperative greu de exprimat prin props: focus, derulare, pornirea unei animații sau a unui player video.

Implicit, un ref către componenta ta ajunge la un nod DOM, iar părintele poate face orice cu el (schimba stiluri, șterge copii). useImperativeHandle îți permite să expui un API restrâns și stabil:

JSX
function PlayerVideo({ src, ref }) {
  const videoRef = useRef(null);

  useImperativeHandle(ref, () => ({
    play: () => videoRef.current.play(),
    pause: () => videoRef.current.pause(),
    sari: secunde => { videoRef.current.currentTime = secunde; },
  }), []);

  return <video ref={videoRef} src={src} />;
}

function Lectie() {
  const player = useRef(null);
  return (
    <>
      <PlayerVideo ref={player} src="/lectie.mp4" />
      <button onClick={() => player.current.sari(120)}>Sari la exercițiu</button>
    </>
  );
}

În React 19 ref vine ca prop; în versiunile anterioare componenta trebuie învelită în forwardRef.

Când e justificat:

  • acțiuni de tip „fă ceva acum”, nu stări: focus, scroll, play/pause, deschiderea unui selector de fișiere, reset pe un formular complex;
  • componente de bibliotecă unde vrei să ascunzi structura internă.

Când nu e justificat: dacă poți exprima același lucru prin props, fă-o. Un modal se deschide cu isOpen, nu cu modalRef.current.open(). Dacă API-ul imperativ crește, e un semn că fluxul de date e întors invers. Al treilea argument e lista de dependențe; dacă funcțiile expuse folosesc props, ele trebuie trecute acolo.

Ce urmărește intervievatorul: Verifică dacă știi să alegi între abordarea declarativă și cea imperativă. Abuzul de ref-uri imperative e un miros de cod pe care intervievatorul vrea să-l recunoști.

47 Mid

Ce rezolvă useId? De ce nu folosești Math.random() sau un contor global pentru id-urile care leagă label de input?

Răspuns scurt: useId generează un id unic și stabil pentru fiecare instanță de componentă, identic pe server și în client. Math.random() dă alt id la fiecare randare și altul pe server față de client, ceea ce strică hidratarea; un contor global depinde de ordinea randării.

Atributele htmlFor, aria-describedby și aria-labelledby au nevoie de id-uri unice în pagină. O componentă reutilizabilă nu poate avea un id fix, pentru că două instanțe ar produce duplicate.

JSX
function CampParola() {
  const id = useId();
  return (
    <>
      <label htmlFor={id}>Parolă</label>
      <input id={id} type="password" aria-describedby={`${id}-ajutor`} />
      <p id={`${id}-ajutor`}>Minim 12 caractere.</p>
    </>
  );
}

De ce nu alternativele:

  • Math.random() sau crypto.randomUUID() în randare: id nou la fiecare randare, deci React actualizează atributele inutil, iar la randare pe server HTML-ul generat pe server are alt id decât cel calculat în browser, ceea ce produce erori de hidratare (hydration mismatch);
  • un contor global (let n = 0; id = n++): depinde de ordinea în care se randează componentele, care poate diferi între server și client, mai ales cu streaming și Suspense, plus crește la fiecare randare;
  • useRef(Math.random()): stabil între randări, dar tot diferit între server și client.

useId se bazează pe poziția componentei în arbore, care e aceeași pe server și în client. Formatul exact al id-ului s-a schimbat între versiunile 19.x, deci nu te baza pe forma lui și nu-l folosi în selectoare CSS.

Ce nu face: nu e pentru key în liste. Cheile vin din date.

Ce urmărește intervievatorul: Verifică atenția la accesibilitate și înțelegerea hidratării. Mulți candidați nu știu că Math.random în randare strică SSR-ul.

Eroarea, în practică:Hydration failed: UI does not match the serverA form label must be associated with a control

48 Senior

Ai o listă care se filtrează la fiecare literă tastată, iar inputul devine greoi. Cum te ajută useTransition și useDeferredValue și care e diferența dintre ele?

Răspuns scurt: Ambele marchează o actualizare ca mai puțin urgentă, deci React poate întrerupe randarea listei ca să răspundă la tastare. useTransition învelește un setState pe care îl controlezi; useDeferredValue primește o valoare și îți dă o versiune care rămâne în urmă.

React 18 a introdus randarea concurentă: o actualizare marcată ca tranziție poate fi întreruptă dacă apare una urgentă (tastare, click). Inputul se actualizează imediat, iar lista se randează „în fundal”.

Cu useTransition, când tu faci actualizarea:

JSX
function Catalog({ produse }) {
  const [text, setText] = useState("");
  const [filtru, setFiltru] = useState("");
  const [isPending, startTransition] = useTransition();

  function laSchimbare(e) {
    setText(e.target.value);                 // urgent
    startTransition(() => setFiltru(e.target.value)); // poate aștepta
  }

  return (
    <>
      <input value={text} onChange={laSchimbare} />
      <div style={{ opacity: isPending ? 0.6 : 1 }}>
        <ListaGrea produse={produse} filtru={filtru} />
      </div>
    </>
  );
}

Cu useDeferredValue, când primești valoarea și nu controlezi setter-ul:

JSX
function Rezultate({ query }) {
  const queryAmanat = useDeferredValue(query);
  const vechi = query !== queryAmanat;
  return <ListaGrea filtru={queryAmanat} stale={vechi} />;
}

Condiție importantă: ListaGrea trebuie învelită în memo, altfel se randează oricum și cu valoarea urgentă, iar beneficiul dispare.

Limite:

  • nu fac calculul mai rapid; doar îl fac întreruptibil. Dacă lista are 50.000 de rânduri în DOM, ai nevoie de virtualizare;
  • nu sunt debounce: nu reduc numărul de cereri de rețea;
  • setText nu poate fi pus într-o tranziție, pentru că inputurile controlate au nevoie de actualizări sincrone.

În React 19, startTransition acceptă și funcții async, folosite de Actions.

Ce urmărește intervievatorul: Verifică înțelegerea randării concurente și a limitelor ei. Un senior știe că fără memo și fără virtualizare beneficiul e minim.

49 Senior

Ce este useSyncExternalStore? Scrie un hook useOnline() care spune dacă browserul are conexiune la internet.

Răspuns scurt: useSyncExternalStore abonează o componentă la o sursă de date din afara React (un store, un API al browserului) într-un mod sigur pentru randarea concurentă. Primește o funcție de abonare, una care citește valoarea curentă și opțional una pentru valoarea de pe server.

Cu un useEffect care se abonează și copiază valoarea în state, randarea concurentă poate produce tearing: în timpul unei randări întrerupte, o parte din arbore vede valoarea veche a store-ului și alta pe cea nouă. useSyncExternalStore garantează că toată randarea vede aceeași valoare.

JSX
import { useSyncExternalStore } from "react";

function subscribe(callback) {
  window.addEventListener("online", callback);
  window.addEventListener("offline", callback);
  return () => {
    window.removeEventListener("online", callback);
    window.removeEventListener("offline", callback);
  };
}

export function useOnline() {
  return useSyncExternalStore(
    subscribe,
    () => navigator.onLine,  // getSnapshot în browser
    () => true               // getServerSnapshot la SSR
  );
}

Reguli:

  • subscribe trebuie să fie stabil (definit în afara componentei); o funcție nouă la fiecare randare înseamnă reabonare la fiecare randare;
  • getSnapshot trebuie să returneze aceeași valoare dacă store-ul nu s-a schimbat. Dacă returnează un obiect nou la fiecare apel (() => ({ ...store })), React intră în buclă și avertizează. Pentru date compuse, store-ul trebuie să păstreze referința până la o schimbare reală;
  • fără getServerSnapshot, componenta aruncă eroare la randare pe server.

Este fundația pe care biblioteci ca Zustand, Redux (react-redux v8+) și altele își construiesc hook-urile. În codul de aplicație îl folosești rar, de obicei pentru API-uri ale browserului (matchMedia, online, visibilitychange) sau pentru un store propriu.

Ce urmărește intervievatorul: Verifică înțelegerea integrării React cu surse externe și a problemelor concurente. E o întrebare care separă seniorii de cei care doar folosesc biblioteci.

Liste și formulare

50 Junior

Ce se întâmplă cu inputurile din listă dacă folosești key={Math.random()}?

JSX
{sarcini.map(s => (
  <li key={Math.random()}>
    <input defaultValue={s.text} />
  </li>
))}

Răspuns scurt: La fiecare randare, fiecare element primește o cheie nouă, deci React consideră că toate elementele sunt noi: le demontează și le montează din nou. Inputurile își pierd textul scris și focusul, iar performanța scade. Cheia trebuie să fie stabilă și să vină din date.

React folosește key ca să potrivească elementele dintr-o listă între două randări. Dacă o cheie din randarea nouă există și în cea veche, elementul e păstrat și actualizat; dacă nu, cel vechi e demontat și se creează unul nou.

Cu Math.random(), nicio cheie nu se repetă între randări. Consecințe:

  • orice tastă într-un input care provoacă o randare a listei distruge toate inputurile; cel în care scrii pierde focusul după fiecare literă;
  • inputurile necontrolate (defaultValue) revin la valoarea inițială, pierzând textul;
  • orice state intern al componentelor din listă se resetează, efectele lor rulează de la zero;
  • React recreează nodurile DOM, ceea ce costă mult la liste mari.

Varianta corectă:

JSX
{sarcini.map(s => (
  <li key={s.id}>
    <input defaultValue={s.text} />
  </li>
))}

De unde iei cheia:

  • id-ul din baza de date sau de la API;
  • un id generat la crearea elementului (crypto.randomUUID() în funcția de adăugare), nu la randare;
  • o combinație unică de câmpuri, dacă datele nu au id.

Cheile trebuie să fie unice doar între frații din aceeași listă, nu global. Indexul e acceptabil doar pentru liste statice, care nu se reordonează, nu se filtrează și nu au state în elemente. Cheile duplicate produc avertismente și comportamente imprevizibile, de exemplu un element care dispare sau apare de două ori.

Ce urmărește intervievatorul: Verifică înțelegerea rolului cheilor dintr-un unghi practic. Cheile generate la randare apar des la cei care vor doar să scape de avertisment.

Eroarea, în practică:Each child in a list should have a unique "key" propEncountered two children with the same key

51 Junior

Ce bug are componenta de mai jos? După ce un utilizator vede tabelul sortat, alte componente care folosesc aceeași listă o afișează și ele sortată.

JSX
function Clasament({ jucatori }) {
  const sortati = jucatori.sort((a, b) => b.puncte - a.puncte);
  return sortati.map(j => <Rand key={j.id} jucator={j} />);
}

Răspuns scurt: Array.prototype.sort sortează pe loc și returnează același tablou, deci componenta modifică tabloul primit prin props, care aparține părintelui. Folosește o copie: [...jucatori].sort(...) sau jucatori.toSorted(...).

Metodele sort, reverse și splice modifică tabloul pe care sunt apelate. sortati și jucatori sunt de fapt aceeași referință, iar datele părintelui (sau din store, sau din cache-ul unei biblioteci de date) au fost reordonate fără setState.

Efecte:

  • alte componente care primesc aceeași listă o văd sortată, deși nu au cerut asta;
  • React nu știe de schimbare, deci acele componente nu se actualizează până la o randare ulterioară, ceea ce produce un comportament care pare aleator;
  • dacă lista vine dintr-un store care o îngheață (Redux Toolkit în development), primești o eroare de tip „Cannot assign to read only property”;
  • randarea nu mai e pură: aceeași componentă randată de două ori poate produce rezultate diferite.

Variante corecte:

JSX
const sortati = [...jucatori].sort((a, b) => b.puncte - a.puncte);
// sau, ES2023:
const sortati = jucatori.toSorted((a, b) => b.puncte - a.puncte);

toSorted, toReversed și toSpliced sunt versiuni care returnează tablouri noi și sunt disponibile în browserele moderne.

Pentru sortarea după text în română, folosește localeCompare cu locale, ca diacriticele să fie sortate corect:

JSX
[...orase].sort((a, b) => a.nume.localeCompare(b.nume, "ro"));

Dacă lista e mare și sortarea apare în profiler, o pui în useMemo cu dependențele [jucatori].

Ce urmărește intervievatorul: Verifică atenția la metodele care modifică tablouri. E un bug real și subtil, pe care codul de review îl prinde des.

52 Junior

Ai o listă de cheltuieli { id, categorie, suma }. Scrie codul care afișează cheltuielile grupate pe categorii, cu totalul fiecărei categorii și totalul general.

Răspuns scurt: Calculezi grupurile în timpul randării cu reduce (sau Object.groupBy), apoi randezi cu map peste Object.entries. Nu stochezi grupurile sau totalurile în state, pentru că sunt derivate din listă.

JSX
function Raport({ cheltuieli }) {
  const grupuri = cheltuieli.reduce((acc, c) => {
    (acc[c.categorie] ??= []).push(c);
    return acc;
  }, {});

  const totalGeneral = cheltuieli.reduce((s, c) => s + c.suma, 0);
  const lei = new Intl.NumberFormat("ro-RO", { style: "currency", currency: "RON" });

  if (cheltuieli.length === 0) return <p>Nu ai cheltuieli în această lună.</p>;

  return (
    <section>
      {Object.entries(grupuri).map(([categorie, items]) => (
        <div key={categorie}>
          <h3>{categorie} ({lei.format(items.reduce((s, c) => s + c.suma, 0))})</h3>
          <ul>
            {items.map(c => <li key={c.id}>{lei.format(c.suma)}</li>)}
          </ul>
        </div>
      ))}
      <p><strong>Total: {lei.format(totalGeneral)}</strong></p>
    </section>
  );
}

Puncte de discutat:

  • push în reduce e acceptabil aici, pentru că modifici acumulatorul creat chiar în această funcție, nu state-ul;
  • Object.groupBy(cheltuieli, c => c.categorie) (ES2024) face același lucru, dar verifică suportul browserelor țintă;
  • cheile vin din date: numele categoriei pentru grupuri, id pentru cheltuieli;
  • formatarea monedei cu Intl.NumberFormat afișează corect separatorii românești, în loc de concatenări manuale;
  • tratarea listei goale e un detaliu pe care intervievatorii îl caută;
  • dacă lista are mii de elemente și randarea e frecventă, calculul se poate pune în useMemo; pentru câteva sute nu e nevoie.

Ce urmărește intervievatorul: Verifică dacă poți transforma date în interfață fără state inutil. Este un exercițiu tipic din temele de acasă cu dashboard-uri.

53 Junior

Ce înseamnă avertismentele „You provided a value prop to a form field without an onChange handler” și „A component is changing an uncontrolled input to be controlled”? Cum le repari?

Răspuns scurt: Primul apare când dai value fără onChange: inputul devine doar pentru citire. Al doilea apare când value pornește ca undefined (necontrolat) și apoi primește un șir (controlat). Repari adăugând onChange (sau readOnly) și inițializând mereu valoarea cu un șir, de exemplu "".

Un input e controlat când React îi dictează valoarea prin value (sau checked), și necontrolat când DOM-ul își ține singur valoarea, eventual pornind de la defaultValue.

Primul avertisment:

JSX
<input value={nume} />  // utilizatorul nu poate scrie

React readuce inputul la nume la fiecare randare, iar fără onChange valoarea nu se schimbă niciodată. Soluții: adaugi onChange={e => setNume(e.target.value)}, folosești defaultValue dacă vrei necontrolat sau pui readOnly dacă e intenționat.

Al doilea avertisment:

JSX
const [user, setUser] = useState({});
<input value={user.email} onChange={...} />

La prima randare user.email e undefined, deci React consideră inputul necontrolat. După ce datele sosesc, devine controlat. Comutarea între moduri produce comportamente greu de prevăzut, de aceea React avertizează. Soluții:

JSX
<input value={user.email ?? ""} onChange={...} />

sau inițializezi state-ul complet: useState({ email: "", nume: "" }).

Același lucru la checkbox-uri: checked={!!user.abonat}. Valoarea null produce un avertisment asemănător.

Regula: alege un mod pentru fiecare câmp și păstrează-l pe toată durata vieții componentei.

Ce urmărește intervievatorul: Verifică dacă înțelegi avertismentele din consolă, nu doar le ignori. E o situație foarte frecventă când datele formularului vin de la API.

Eroarea, în practică:You provided a `value` prop without an `onChange`Changing an uncontrolled input to be controlled

54 Junior

Scrie un formular de înregistrare cu nume, email și parolă care folosește un singur handler onChange pentru toate câmpurile.

Răspuns scurt: Ții valorile într-un obiect în state, dai fiecărui input un atribut name egal cu cheia din obiect și folosești în handler o proprietate calculată: setForm(f => ({ ...f, [e.target.name]: e.target.value })).

JSX
const initial = { nume: "", email: "", parola: "", termeni: false };

function Inregistrare({ onTrimite }) {
  const [form, setForm] = useState(initial);

  function handleChange(e) {
    const { name, type, value, checked } = e.target;
    setForm(f => ({ ...f, [name]: type === "checkbox" ? checked : value }));
  }

  function handleSubmit(e) {
    e.preventDefault();
    onTrimite(form);
    setForm(initial);
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>Nume <input name="nume" value={form.nume} onChange={handleChange} /></label>
      <label>Email <input name="email" type="email" value={form.email} onChange={handleChange} /></label>
      <label>Parolă <input name="parola" type="password" value={form.parola}
        onChange={handleChange} autoComplete="new-password" /></label>
      <label><input name="termeni" type="checkbox" checked={form.termeni}
        onChange={handleChange} /> Accept termenii</label>
      <button disabled={!form.termeni}>Creează cont</button>
    </form>
  );
}

Ce merită explicat:

  • [name] este o proprietate calculată din JavaScript; cheia obiectului e valoarea variabilei;
  • valorile se citesc din eveniment înainte de setForm, pentru că funcția de actualizare poate rula mai târziu (din React 17 evenimentul nu mai e reutilizat, dar codul rămâne mai clar așa);
  • checkbox-urile folosesc checked, nu value;
  • forma funcțională f => ... evită pierderea unor modificări;
  • etichetele învelesc inputurile, deci sunt legate fără id-uri;
  • autoComplete="new-password" ajută managerii de parole.

Pentru formulare cu multe câmpuri, validare și erori de la server, o bibliotecă precum React Hook Form scade mult codul repetitiv.

Ce urmărește intervievatorul: Verifică stăpânirea formularelor controlate și a sintaxei JavaScript moderne. Este un exercițiu standard la live coding.

55 Junior

Cum lucrezi în React cu checkbox-uri, butoane radio și select? Ce diferă față de un input text?

Răspuns scurt: Checkbox-ul folosește checked și e.target.checked. Grupul de radio-uri folosește același name și checked={valoare === optiune}. select primește value direct pe <select>, nu selected pe opțiuni; cu multiple, valoarea e un tablou.

Checkbox simplu și listă de checkbox-uri:

JSX
const [newsletter, setNewsletter] = useState(false);
<input type="checkbox" checked={newsletter} onChange={e => setNewsletter(e.target.checked)} />

const [interese, setInterese] = useState([]);
function comutaInteres(x) {
  setInterese(prev => prev.includes(x) ? prev.filter(i => i !== x) : [...prev, x]);
}
{["React", "Node", "SQL"].map(x => (
  <label key={x}>
    <input type="checkbox" checked={interese.includes(x)} onChange={() => comutaInteres(x)} /> {x}
  </label>
))}

Radio:

JSX
const [livrare, setLivrare] = useState("curier");
{["curier", "easybox", "ridicare"].map(opt => (
  <label key={opt}>
    <input type="radio" name="livrare" value={opt}
      checked={livrare === opt} onChange={e => setLivrare(e.target.value)} /> {opt}
  </label>
))}

Select:

JSX
<select value={oras} onChange={e => setOras(e.target.value)}>
  <option value="">Alege orașul</option>
  <option value="iasi">Iași</option>
  <option value="cluj">Cluj-Napoca</option>
</select>

Diferențe de reținut:

  • e.target.value e mereu un șir, inclusiv la select cu valori numerice; convertești cu Number(...);
  • în React nu pui selected pe <option>, ci value pe <select>; React avertizează la selected;
  • select multiple cere value de tip tablou, iar valorile alese se citesc cu Array.from(e.target.selectedOptions, o => o.value);
  • textarea primește value, nu conținut între taguri;
  • o opțiune goală cu text explicativ evită ca prima opțiune să pară aleasă din greșeală.

Ce urmărește intervievatorul: Verifică experiența practică cu formulare, dincolo de inputul text. Greșelile cu selected și cu valorile string sunt frecvente.

Eroarea, în practică:Use `defaultValue` or `value` on <select>`value` supplied to <select> must be an array

56 Junior

După ce trimiți formularul, pagina se reîncarcă și datele se pierd, iar după o trimitere reușită câmpurile ar trebui golite. Cum scrii corect onSubmit, inclusiv starea de trimitere?

Răspuns scurt: Oprești comportamentul implicit cu e.preventDefault(), setezi un status „se trimite” ca să blochezi dublele trimiteri, aștepți răspunsul și, doar la succes, resetezi state-ul la valorile inițiale. La eroare păstrezi datele și afișezi mesajul.

JSX
const gol = { email: "", mesaj: "" };

function Contact() {
  const [form, setForm] = useState(gol);
  const [status, setStatus] = useState("idle"); // idle | sending | sent | error

  async function handleSubmit(e) {
    e.preventDefault();
    if (status === "sending") return;
    setStatus("sending");
    try {
      const res = await fetch("/api/contact", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(form),
      });
      if (!res.ok) throw new Error();
      setForm(gol);
      setStatus("sent");
    } catch {
      setStatus("error");
    }
  }

  return (
    <form onSubmit={handleSubmit}>
      {/* câmpuri controlate */}
      <button disabled={status === "sending"}>
        {status === "sending" ? "Se trimite..." : "Trimite"}
      </button>
      {status === "sent" && <p role="status">Mesaj trimis.</p>}
      {status === "error" && <p role="alert">Nu am putut trimite. Încearcă din nou.</p>}
    </form>
  );
}

De ce așa:

  • fără preventDefault, browserul face o navigare GET sau POST către action, care reîncarcă pagina;
  • onSubmit pe <form>, nu onClick pe buton, prinde și trimiterea cu Enter;
  • butonul dezactivat și verificarea din handler opresc dublul click;
  • resetarea se face doar după succes; la eroare utilizatorul nu pierde textul;
  • role="status" și role="alert" anunță mesajele cititoarelor de ecran.

Pentru formulare necontrolate, e.currentTarget.reset() golește câmpurile. În React 19, cu <form action={fn}>, formularele necontrolate se resetează automat după o acțiune reușită.

Ce urmărește intervievatorul: Verifică dacă scrii un formular complet, nu doar fericit. Intervievatorii urmăresc dublele trimiteri și păstrarea datelor la eroare.

Eroarea, în practică:undefined (reading 'preventDefault')Missing an explicit type attribute for button

57 Mid

Ai un tabel cu sarcini și vrei editare inline: click pe „Editează” transformă rândul în input, cu „Salvează” și „Renunță”. Unde ții starea?

Răspuns scurt: În părinte ții lista și id-ul rândului editat (editId), nu un flag editing pe fiecare obiect din date. Textul temporar stă în componenta rândului care se editează, ca „Renunță” să nu modifice lista, iar „Salvează” trimite valoarea nouă printr-un callback.

JSX
function TabelSarcini({ sarcini, onActualizeaza }) {
  const [editId, setEditId] = useState(null);
  return (
    <ul>
      {sarcini.map(s =>
        s.id === editId ? (
          <RandEditare key={s.id} sarcina={s}
            onSalveaza={text => { onActualizeaza(s.id, text); setEditId(null); }}
            onRenunta={() => setEditId(null)} />
        ) : (
          <li key={s.id}>{s.text} <button onClick={() => setEditId(s.id)}>Editează</button></li>
        )
      )}
    </ul>
  );
}

function RandEditare({ sarcina, onSalveaza, onRenunta }) {
  const [text, setText] = useState(sarcina.text);
  return (
    <li>
      <input autoFocus value={text} onChange={e => setText(e.target.value)}
        onKeyDown={e => { if (e.key === "Escape") onRenunta(); if (e.key === "Enter") onSalveaza(text.trim()); }} />
      <button onClick={() => onSalveaza(text.trim())} disabled={!text.trim()}>Salvează</button>
      <button onClick={onRenunta}>Renunță</button>
    </li>
  );
}

Decizii argumentate:

  • un singur editId garantează că se editează un singur rând; un flag editing în fiecare obiect amestecă starea interfeței cu datele și permite mai multe rânduri în editare simultan;
  • draftul local (text) separă modificarea neconfirmată de date; „Renunță” doar închide editarea;
  • useState(sarcina.text) folosește prop-ul doar ca valoare inițială, ceea ce aici e intenționat, pentru că RandEditare se montează din nou la fiecare intrare în editare;
  • tastele Enter și Escape sunt așteptări firești ale utilizatorilor.

Ce urmărește intervievatorul: Verifică unde plasezi state-ul și dacă separi datele de starea interfeței. Este un exercițiu frecvent de live coding.

58 Mid

Implementează validarea unui câmp de email astfel încât eroarea să apară doar după ce utilizatorul a părăsit câmpul, apoi să se actualizeze în timp ce scrie.

Răspuns scurt: Ții separat valorile, erorile calculate și câmpurile atinse (touched). Eroarea se calculează la fiecare randare din valoare, dar se afișează doar dacă câmpul a fost atins (setat la onBlur) sau dacă s-a încercat trimiterea.

JSX
function valideaza(v) {
  const e = {};
  if (!v.email) e.email = "Emailul e obligatoriu.";
  else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v.email)) e.email = "Emailul nu pare valid.";
  if (v.parola.length < 12) e.parola = "Parola are nevoie de minim 12 caractere.";
  return e;
}

function Formular() {
  const [valori, setValori] = useState({ email: "", parola: "" });
  const [atinse, setAtinse] = useState({});
  const [trimis, setTrimis] = useState(false);
  const erori = valideaza(valori);              // derivat
  const arata = camp => (atinse[camp] || trimis) && erori[camp];

  function onBlur(e) { setAtinse(a => ({ ...a, [e.target.name]: true })); }
  function onSubmit(e) {
    e.preventDefault();
    setTrimis(true);
    if (Object.keys(erori).length === 0) trimite(valori);
  }

  return (
    <form onSubmit={onSubmit} noValidate>
      <input name="email" value={valori.email} onBlur={onBlur}
        onChange={e => setValori(v => ({ ...v, email: e.target.value }))}
        aria-invalid={!!arata("email")} aria-describedby="err-email" />
      {arata("email") && <p id="err-email" role="alert">{erori.email}</p>}
    </form>
  );
}

De ce acest tipar:

  • eroarea afișată din prima literă e frustrantă; cea afișată abia la trimitere e prea târzie. Combinația „după blur, apoi live” e standardul în UX;
  • erorile sunt stare derivată, nu se țin în state, deci nu se pot desincroniza de valori;
  • noValidate dezactivează bulele native ale browserului ca să ai mesaje consistente, dar păstrezi type="email" pentru tastatura mobilă;
  • aria-invalid și aria-describedby leagă eroarea de câmp pentru cititoarele de ecran;
  • validarea din client e doar pentru confort; serverul validează oricum.

În proiecte mari, React Hook Form oferă exact aceste moduri (mode: "onTouched") împreună cu o schemă Zod.

Ce urmărește intervievatorul: Verifică gândirea despre experiența utilizatorului, nu doar regex-ul. Răspunsurile bune păstrează erorile ca stare derivată.

59 Mid

De ce ai folosi React Hook Form cu o schemă Zod în loc de useState pentru un formular cu 20 de câmpuri?

Răspuns scurt: React Hook Form folosește inputuri necontrolate și ref-uri, deci tastarea nu re-randează tot formularul, iar validarea, erorile, câmpurile atinse și starea de trimitere vin gata făcute. Zod definește regulile o singură dată, ca schemă, din care obții și tipurile TypeScript.

Cu useState pentru 20 de câmpuri, fiecare tastă re-randează toată componenta și scrii manual: handler-e, touched, erori, isSubmitting, resetare, focus pe primul câmp invalid. Codul devine lung și greu de întreținut.

TSX
import { useForm } from "react-hook-form";
import { z } from "zod";
import { zodResolver } from "@hookform/resolvers/zod";

const schema = z.object({
  email: z.string().email("Email invalid"),
  varsta: z.coerce.number().int().min(18, "Minim 18 ani"),
});
type Date = z.infer<typeof schema>;

function Profil() {
  const { register, handleSubmit, formState: { errors, isSubmitting } } =
    useForm<Date>({ resolver: zodResolver(schema), mode: "onTouched" });

  return (
    <form onSubmit={handleSubmit(async d => await api.salveaza(d))}>
      <input {...register("email")} />
      {errors.email && <p role="alert">{errors.email.message}</p>}
      <input type="number" {...register("varsta")} />
      {errors.varsta && <p role="alert">{errors.varsta.message}</p>}
      <button disabled={isSubmitting}>Salvează</button>
    </form>
  );
}

Avantaje:

  • register atașează un ref și handler-e; valoarea stă în DOM, deci re-randările sunt limitate la câmpurile cu erori;
  • schema Zod poate fi refolosită pe server pentru validarea aceleiași cereri, iar z.infer dă tipul datelor fără duplicare;
  • pentru componente controlate (selectoare de dată, componente UI) există Controller.

Compromisuri: o dependență în plus și un model mental diferit (necontrolat). Pentru 2–3 câmpuri, useState sau acțiunile din React 19 sunt suficiente. Detaliile de API diferă între versiunile majore ale Zod, deci verifici documentația versiunii din proiect.

Ce urmărește intervievatorul: Verifică dacă știi uneltele folosite în proiecte reale și motivele de performanță. Un răspuns bun discută și când nu merită biblioteca.

60 Senior

Trebuie să afișezi un tabel cu 20.000 de rânduri, iar pagina se blochează la încărcare și la derulare. Ce opțiuni ai?

Răspuns scurt: Problema e numărul de noduri DOM, nu React în sine. Opțiunile sunt paginarea (pe server sau client), „încarcă mai mult” sau derularea infinită și virtualizarea, adică randarea doar a rândurilor vizibile (TanStack Virtual, react-window). Alegi după nevoile utilizatorului.

20.000 de rânduri cu câteva celule fiecare înseamnă sute de mii de noduri DOM. Browserul consumă mult la layout, desenare și memorie, iar fiecare re-randare a listei costă. memo și useMemo nu rezolvă asta, pentru că nodurile există oricum.

Opțiuni:

  • paginare pe server: cea mai bună când utilizatorul caută ceva anume; serverul trimite 50 de rânduri, iar filtrarea și sortarea se fac în baza de date. Reduce și transferul de date;
  • încarcă mai mult / derulare infinită: potrivită pentru fluxuri (feed, notificări), mai puțin pentru tabele în care utilizatorul vrea să sară la o anumită poziție;
  • virtualizare: randezi doar rândurile din zona vizibilă plus o marjă, iar un container cu înălțimea totală simulează bara de derulare. Utilizatorul are impresia că toate rândurile există.
TSX
import { useVirtualizer } from "@tanstack/react-virtual";

function Tabel({ randuri }) {
  const parentRef = useRef(null);
  const v = useVirtualizer({ count: randuri.length, getScrollElement: () => parentRef.current, estimateSize: () => 36 });
  return (
    <div ref={parentRef} style={{ height: 600, overflow: "auto" }}>
      <div style={{ height: v.getTotalSize(), position: "relative" }}>
        {v.getVirtualItems().map(item => (
          <div key={item.key} style={{ position: "absolute", top: 0, transform: `translateY(${item.start}px)`, height: item.size }}>
            {randuri[item.index].nume}
          </div>
        ))}
      </div>
    </div>
  );
}

Compromisuri ale virtualizării: căutarea cu Ctrl+F din browser nu găsește rândurile nerandate, înălțimile variabile cer măsurare, accesibilitatea tabelului cere atenție (aria-rowcount, aria-rowindex), iar printarea are nevoie de altă soluție. De aceea, dacă e posibil, paginarea pe server rămâne prima opțiune.

Ce urmărește intervievatorul: Verifică dacă abordezi performanța de la cauza reală. Un senior discută compromisurile și nu sare direct la o bibliotecă.

Randare și performanță

Exersează capitolul cu exerciții reale: Curs React online →
61 Junior

Ce declanșează o nouă randare a unei componente React? Se re-randează un copil dacă props-urile lui nu s-au schimbat?

Răspuns scurt: O componentă se re-randează când își schimbă propriul state, când se re-randează părintele sau când se schimbă un context pe care îl citește. Da, implicit copilul se re-randează odată cu părintele, chiar dacă props-urile sunt identice; doar memo schimbă asta.

Un mit frecvent: „componenta se re-randează când i se schimbă props”. De fapt, schimbarea props-urilor nu e un declanșator în sine. Declanșatorii sunt:

  • state propriu: setState, dispatch cu o valoare diferită (comparată cu Object.is);
  • re-randarea părintelui: când un părinte randează, React randează recursiv toți copiii lui, indiferent de props;
  • context: o componentă care apelează useContext(X) se re-randează când value al celui mai apropiat X.Provider se schimbă;
  • store extern: abonamentele prin useSyncExternalStore (Redux, Zustand) când selectorul returnează altă valoare.
JSX
function Parinte() {
  const [n, setN] = useState(0);
  return (
    <>
      <button onClick={() => setN(n + 1)}>{n}</button>
      <Antet />  {/* se randează la fiecare click, deși nu are props */}
    </>
  );
}

Antet se randează la fiecare click. De obicei nu e o problemă: randarea înseamnă apelarea funcției și compararea rezultatului, iar dacă JSX-ul e același, React nu atinge DOM-ul.

Ce poți face când costul devine vizibil:

  • învelești copilul în memo, ca să sară peste randare la props egale;
  • muți state-ul mai jos, în componenta care chiar îl folosește;
  • transmiți copilul prin children, creat de un strămoș care nu se re-randează.

Instrumentul de verificare e React DevTools, cu opțiunea „Highlight updates when components render” și Profiler-ul.

Ce urmărește intervievatorul: Verifică un model mental corect al randării. Majoritatea candidaților cred greșit că doar props schimbate declanșează randarea.

62 Junior

De ce componenta de mai jos afișează numere diferite în development față de producție? Ce înseamnă că randarea trebuie să fie pură?

JSX
let vizitatori = 0;

function Salut({ nume }) {
  vizitatori = vizitatori + 1;
  return <p>Salut, {nume}! Ești vizitatorul {vizitatori}.</p>;
}

Răspuns scurt: Componenta modifică o variabilă din afara ei în timpul randării. În development, StrictMode randează de două ori, deci numărul crește cu 2. Randarea trebuie să fie pură: aceleași props și state dau același JSX, fără să modifici nimic în afară.

React presupune că funcția unei componente e pură:

  • nu modifică variabile, obiecte sau DOM care existau înainte de randare;
  • pentru aceleași intrări (props, state, context) returnează același rezultat.

Pe această presupunere se bazează funcționalități importante: React poate apela o componentă de mai multe ori, poate întrerupe o randare și o poate relua (randare concurentă), poate sări peste randare cu memo și poate randa pe server. Codul de mai sus încalcă regula, deci rezultatul depinde de câte ori și în ce ordine a decis React să randeze.

În development, StrictMode apelează intenționat componentele de două ori ca să scoată la iveală astfel de probleme. De aceea numerele cresc din doi în doi.

Variante corecte, după ce vrei de fapt:

  • dacă e un contor al vizitelor, vine de la server și stă în state sau într-un cache;
  • dacă vrei să numeri randările pentru depanare, folosești un ref modificat într-un efect, nu în randare;
  • dacă vrei un număr de ordine pentru fiecare element din listă, îl primești ca prop (indexul din map).
JSX
function Salut({ nume, numar }) {
  return <p>Salut, {nume}! Ești vizitatorul {numar}.</p>;
}

Variabilele locale create în timpul randării pot fi modificate liber (de exemplu un tablou construit cu push în aceeași funcție); impuritatea înseamnă modificarea a ceva ce exista înainte. Efectele secundare (cereri, abonamente, logging) aparțin handler-elor de evenimente sau efectelor.

Ce urmărește intervievatorul: Verifică înțelegerea unui principiu de bază pe care se sprijină restul React. Mulți candidați nu știu de ce StrictMode dublează randările.

63 Junior

Cum împarți codul unei aplicații React ca să nu descarce utilizatorul tot JavaScript-ul la prima vizită? Scrie un exemplu cu lazy și Suspense pe rute.

Răspuns scurt: React.lazy încarcă o componentă printr-un import() dinamic, iar bundler-ul (Vite, webpack) creează un fișier separat pentru ea. Suspense afișează un fallback până se descarcă. Cel mai bun punct de împărțire sunt rutele, apoi componentele grele (editoare, grafice).

JSX
import { lazy, Suspense } from "react";
import { BrowserRouter, Routes, Route } from "react-router";

const Acasa = lazy(() => import("./pagini/Acasa"));
const Dashboard = lazy(() => import("./pagini/Dashboard"));
const Setari = lazy(() => import("./pagini/Setari"));

export default function App() {
  return (
    <BrowserRouter>
      <Suspense fallback={<p>Se încarcă pagina...</p>}>
        <Routes>
          <Route path="/" element={<Acasa />} />
          <Route path="/dashboard" element={<Dashboard />} />
          <Route path="/setari" element={<Setari />} />
        </Routes>
      </Suspense>
    </BrowserRouter>
  );
}

Cum funcționează: la prima randare a lui Dashboard, React apelează funcția din lazy, care pornește descărcarea fișierului. Componenta „suspendă”, iar cel mai apropiat Suspense afișează fallback-ul. Când modulul sosește, React randează componenta reală.

Reguli și detalii:

  • lazy cere un modul cu export implicit;
  • lazy(...) se apelează la nivelul modulului, nu în interiorul unei componente, altfel se recreează și starea se pierde;
  • poziția lui Suspense decide ce dispare în timpul încărcării; un Suspense în jurul conținutului, nu al întregii aplicații, păstrează meniul vizibil;
  • dacă descărcarea eșuează (o versiune nouă a fost publicată și fișierul vechi nu mai există), eroarea ajunge la un error boundary, deci ai nevoie de unul care oferă reîncărcarea;
  • poți preîncărca la hover: apelezi import("./pagini/Dashboard") când utilizatorul trece cu mouse-ul peste link.

În React Router cu data router, proprietatea lazy pe rută descarcă și componenta, și loader-ul în paralel.

Ce urmărește intervievatorul: Verifică dacă știi cum se reduce dimensiunea bundle-ului inițial. Un răspuns bun menționează error boundary-ul pentru descărcări eșuate.

64 Mid

Ce înseamnă „randare” în React? Explică fazele render și commit și de ce o randare nu înseamnă neapărat modificarea DOM-ului.

Răspuns scurt: Randarea înseamnă că React apelează componentele ca să afle cum ar trebui să arate interfața. În faza de commit, React compară rezultatul cu cel anterior și aplică în DOM doar diferențele. Dacă JSX-ul rezultat e identic, DOM-ul nu se atinge deloc.

O actualizare trece prin trei etape:

  • declanșare (trigger): montarea inițială sau o actualizare de state;
  • render: React apelează funcția componentei afectate și, recursiv, pe cele ale copiilor. Rezultatul e un arbore de elemente (obiecte JavaScript). În această fază nu se modifică nimic vizibil, motiv pentru care randarea trebuie să fie pură și poate fi întreruptă, reluată sau aruncată (în modul concurent);
  • commit: React compară noul arbore cu cel precedent (reconciliere) și aplică în DOM minimul de operații: creează, mută sau șterge noduri, schimbă atribute și text. Apoi atașează ref-urile, rulează useLayoutEffect, browserul desenează, iar după aceea rulează useEffect.

Exemplu:

JSX
function Ceas({ ora }) {
  return (
    <div>
      <h1>Ora curentă</h1>
      <p>{ora}</p>
    </div>
  );
}

La fiecare secundă, Ceas se randează din nou, dar la commit React modifică doar textul din <p>. Titlul și <div>-ul rămân aceleași noduri DOM, deci un input din interior și-ar păstra focusul și textul.

Consecințe practice:

  • „componenta se re-randează des” nu înseamnă automat o problemă de performanță; contează costul randării și al commit-ului;
  • codul cu efecte secundare din corpul componentei rulează la fiecare randare, inclusiv la cele care nu schimbă nimic pe ecran;
  • măsurătorile din Profiler arată separat timpul de randare pentru fiecare commit.

Ce urmărește intervievatorul: Verifică un model mental precis, care diferă de „virtual DOM e mai rapid”. Distincția render/commit apare la toate discuțiile de performanță.

65 Mid

În ce ordine apar mesajele în consolă la montare (fără StrictMode)?

JSX
function Copil() {
  console.log("render copil");
  useEffect(() => { console.log("efect copil"); });
  return null;
}
function Parinte() {
  console.log("render părinte");
  useEffect(() => { console.log("efect părinte"); });
  return <Copil />;
}

Răspuns scurt: Ordinea este: „render părinte”, „render copil”, „efect copil”, „efect părinte”. Randarea merge de sus în jos, iar efectele rulează după commit, de jos în sus: copiii își termină efectele înaintea părintelui.

Randarea e un apel recursiv: React apelează Parinte, primește <Copil />, apoi apelează Copil. De aici primele două mesaje, de sus în jos.

Efectele rulează după ce tot arborele a fost aplicat în DOM. React le execută în ordinea în care componentele își termină montarea, adică întâi copiii, apoi părinții. Logica: când rulează efectul părintelui, copiii lui sunt deja complet montați, cu ref-urile atașate și efectele lor gata. Un părinte poate deci să măsoare sau să folosească în siguranță nodurile copiilor.

La o actualizare ulterioară:

  • „render părinte”, „render copil”;
  • curățarea efectelor vechi (copil, apoi părinte);
  • efectele noi (copil, apoi părinte).

Cu StrictMode în development, vei vedea fiecare render de două ori și secvența montare, curățare, montare pentru efecte, ceea ce poate confunda la interviu dacă nu menționezi condiția.

Ordinea contează practic când un părinte depinde de ceva ce copilul face într-un efect: de exemplu, copilul se înregistrează într-un registru, iar părintele citește registrul. Funcționează, dar e fragil; e mai sigur ca datele să curgă prin props sau context.

Ce urmărește intervievatorul: Verifică înțelegerea ciclului de randare și efecte. Răspunsul greșit tipic este „efect părinte” înaintea „efect copil”.

66 Mid

Ai învelit ListaProduse în memo, dar Profiler-ul arată că se re-randează la fiecare tastă din căutare. De ce?

JSX
const ListaProduse = memo(function ListaProduse({ produse, optiuni, onSelect }) { /* ... */ });

function Pagina({ produse }) {
  const [q, setQ] = useState("");
  return (
    <>
      <input value={q} onChange={e => setQ(e.target.value)} />
      <ListaProduse produse={produse} optiuni={{ compact: true }}
        onSelect={id => console.log(id)} />
    </>
  );
}

Răspuns scurt: memo compară props superficial, prin referință. optiuni și onSelect sunt create din nou la fiecare randare a lui Pagina, deci par mereu schimbate. Stabilizează-le: obiectul constant mutat în afara componentei, funcția cu useCallback.

memo(Componenta) sare peste randare doar dacă fiecare prop e egal cu cel anterior prin Object.is. Un literal de obiect { compact: true } și o funcție săgeată sunt valori noi la fiecare execuție a lui Pagina, deci comparația eșuează mereu, iar memo doar adaugă costul comparației.

Varianta corectată:

JSX
const OPTIUNI = { compact: true }; // nu depinde de nimic, deci în afara componentei

function Pagina({ produse }) {
  const [q, setQ] = useState("");
  const onSelect = useCallback(id => {
    console.log(id);
  }, []);

  return (
    <>
      <input value={q} onChange={e => setQ(e.target.value)} />
      <ListaProduse produse={produse} optiuni={OPTIUNI} onSelect={onSelect} />
    </>
  );
}

Alte surse frecvente care strică memo:

  • children dat ca JSX (<Card><p>x</p></Card>): elementele sunt obiecte noi la fiecare randare;
  • tablouri derivate în randare (produse.filter(...)) trimise ca prop, care cer useMemo;
  • un context citit în interiorul componentei memorizate, care o re-randează oricum la schimbare;
  • useCallback cu dependențe care se schimbă la fiecare randare.

Alternativă fără memorizare: mută q și inputul într-o componentă separată Cautare. Atunci tastarea re-randează doar Cautare, iar Pagina și lista nu mai sunt afectate.

Cu React Compiler activat, aceste stabilizări se fac automat la build, dar înțelegerea mecanismului rămâne necesară pentru depanare.

Ce urmărește intervievatorul: Verifică înțelegerea comparației superficiale din memo în cod concret. E motivul principal pentru care memorizarea „nu funcționează” în proiecte reale.

67 Mid

Ai o pagină de editare a profilului care primește userId din rută. Când navighezi de la un utilizator la altul, formularul păstrează datele celui vechi. Cum repari fără useEffect?

Răspuns scurt: Pui key={userId} pe componenta formularului. Când cheia se schimbă, React o tratează ca pe o componentă nouă: o demontează și o montează din nou, cu state-ul inițializat din datele noului utilizator.

Bug-ul apare pentru că formularul își ține draftul în state inițializat din props:

JSX
function FormularProfil({ user }) {
  const [nume, setNume] = useState(user.nume); // folosit doar la montare
  // ...
}

<FormularProfil user={user} />

La navigarea de la /profil/1 la /profil/2, ruta randează aceeași componentă în aceeași poziție, deci React o păstrează, inclusiv state-ul. useState(user.nume) nu se reaplică, pentru că valoarea inițială e folosită doar la prima montare.

Soluția recomandată de documentația React:

JSX
<FormularProfil key={user.id} user={user} />

Cheia diferită spune lui React că e o altă instanță. Tot state-ul din formular și din copiii lui se resetează, iar efectele pornesc de la zero.

Varianta cu efect, des întâlnită:

JSX
useEffect(() => { setNume(user.nume); }, [user.id]);

are dezavantaje: o randare intermediară cu numele vechi, trebuie repetată pentru fiecare câmp și pentru fiecare copil cu state, iar orice câmp nou adăugat poate fi uitat.

Când nu vrei resetarea completă (de exemplu păstrezi o parte din state), alternativa e stocarea „pentru ce utilizator e draftul” și ajustarea în timpul randării, dar e mai greu de citit. Același truc cu key resetează și alte componente: un player când se schimbă lecția, un chat când se schimbă conversația.

Ce urmărește intervievatorul: Verifică dacă știi folosirea key ca instrument de resetare, nu doar la liste. E o soluție pe care puțini candidați o propun spontan.

Eroarea, în practică:componentWillReceiveProps has been renamed

68 Mid

Utilizatorii spun că aplicația „e lentă”. Cum măsori concret unde e problema de performanță într-o aplicație React, înainte să adaugi memo peste tot?

Răspuns scurt: Reproduci problema în build de producție, apoi folosești React DevTools Profiler ca să vezi ce componente se randează, de ce și cât durează, și tab-ul Performance din Chrome pentru JavaScript, layout și desenare. Optimizezi doar ce apare în măsurători, apoi măsori din nou.

Pașii, în ordine:

  • definești simptomul: încărcare inițială lentă, tastare greoaie, derulare sacadată, tranziție lentă între pagini. Fiecare are alte cauze;
  • reproduci în producție sau într-un build de producție: modul development e mult mai lent (verificări, StrictMode), deci măsurătorile de acolo înșală. Folosește CPU throttling în Chrome ca să simulezi un telefon obișnuit;
  • React DevTools Profiler: înregistrezi interacțiunea, vezi fiecare commit, ce componente s-au randat și cât a durat fiecare. Opțiunea „Record why each component rendered” arată motivul (props schimbate, state, context, părinte);
  • „Highlight updates when components render” din setări arată vizual ce se re-randează la o tastă;
  • tab-ul Performance din Chrome: arată dacă timpul se duce în JavaScript, în layout, în desenare sau în rețea; long tasks peste 50 ms blochează interacțiunea;
  • Lighthouse și Web Vitals (LCP, INP, CLS) pentru încărcare și pentru întârzierea reacției la interacțiuni, plus analiza bundle-ului (de exemplu rollup-plugin-visualizer la Vite).

Cauze frecvente pe care le găsești astfel:

  • un context cu valoare nouă la fiecare randare, care re-randează tot arborele;
  • state ținut prea sus (un input în rădăcina aplicației);
  • liste mari fără virtualizare;
  • calcule grele în randare;
  • biblioteci mari descărcate la prima vizită.

Optimizezi o singură cauză, măsori din nou și compari. memo peste tot adaugă cost și complexitate fără garanții.

Ce urmărește intervievatorul: Verifică o abordare bazată pe măsurare, nu pe ghicit. Intervievatorii penalizează răspunsul „pun useMemo peste tot”.

69 Senior

Ai o pagină cu un input de culoare în vârf și un arbore mare de componente dedesubt, toate re-randate la fiecare schimbare de culoare. Cum o optimizezi fără memo?

Răspuns scurt: Muți state-ul în jos, în componenta mică ce îl folosește (colocare). Dacă un părinte care ține state-ul trebuie să învelească arborele mare, primește arborele prin children: elementele create de un strămoș nu se re-randează când se schimbă state-ul părintelui.

Situația de pornire:

JSX
function Pagina() {
  const [culoare, setCuloare] = useState("#ff0000");
  return (
    <div style={{ borderColor: culoare }}>
      <input type="color" value={culoare} onChange={e => setCuloare(e.target.value)} />
      <ArboreScump />
    </div>
  );
}

Fiecare schimbare de culoare re-randează Pagina și, implicit, ArboreScump.

Pasul 1: colocarea stării. Dacă doar inputul folosește culoarea, mută state-ul într-o componentă SelectorCuloare. Pagina nu se mai re-randează.

Pasul 2: conținutul ca children. Aici culoarea e folosită și de div-ul care învelește tot. Extragi învelișul:

JSX
function CadruColorat({ children }) {
  const [culoare, setCuloare] = useState("#ff0000");
  return (
    <div style={{ borderColor: culoare }}>
      <input type="color" value={culoare} onChange={e => setCuloare(e.target.value)} />
      {children}
    </div>
  );
}

function Pagina() {
  return (
    <CadruColorat>
      <ArboreScump />
    </CadruColorat>
  );
}

<ArboreScump /> este creat de Pagina, care nu se re-randează. Când CadruColorat își schimbă state-ul, prop-ul children e același obiect ca înainte, deci React sare peste randarea lui.

De ce e preferabil lui memo: nu depinde de stabilitatea props-urilor, nu are cost de comparație și face structura mai clară. Același principiu stă la baza recomandării de a împărți contextele și de a ține state-ul cât mai aproape de locul în care e folosit.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de randare la nivel de arhitectură. Tehnica children e un semn clar de experiență.

70 Senior

Ce este React Fiber și ce a făcut posibil? Explică randarea concurentă în cuvinte simple.

Răspuns scurt: Fiber este motorul de reconciliere din React 16, care împarte randarea în unități mici ce pot fi întrerupte, prioritizate și reluate. Pe el se bazează randarea concurentă din React 18: o actualizare neurgentă se pregătește fără să blocheze interacțiunile.

Înainte de Fiber, reconcilierea era recursivă și sincronă: odată pornită o actualizare a unui arbore mare, React parcurgea tot arborele dintr-o singură bucată. Dacă dura 200 ms, browserul nu putea răspunde la tastare în acest timp.

Fiber reprezintă fiecare componentă ca un obiect („fiber”) într-o structură legată, cu legături spre părinte, primul copil și fratele următor. Avantajul acestei structuri este că parcurgerea se poate opri după orice nod și relua de acolo. Fiecare fiber conține tipul, props, state-ul (lista de hook-uri), efectele de aplicat și o legătură spre versiunea alternativă (arborele curent și cel în lucru, double buffering).

Ce permite:

  • priorități: tastarea și click-urile sunt urgente, o tranziție sau o listă amânată nu;
  • întrerupere: React lucrează în bucăți scurte și cedează controlul browserului, verificând dacă a apărut ceva mai urgent;
  • abandonare: o randare începută cu date vechi poate fi aruncată dacă au sosit date noi;
  • Suspense: o componentă poate „suspenda” în timp ce așteaptă cod sau date, iar React afișează fallback-ul.

Faza de commit rămâne sincronă și neîntreruptă, ca DOM-ul să nu ajungă într-o stare incompletă. De aceea randarea trebuie să fie pură: poate rula de mai multe ori înainte de un commit.

Concurența e activată doar pentru actualizările marcate (startTransition, useDeferredValue, Suspense). Actualizările obișnuite se comportă ca înainte, deci migrarea la React 18 nu a schimbat comportamentul codului existent.

Ce urmărește intervievatorul: Verifică înțelegerea arhitecturii interne la nivel conceptual. Un senior trebuie să lege Fiber de cerința de puritate și de API-urile concurente.

71 Senior

Ce este React Compiler și cum schimbă modul în care folosești useMemo, useCallback și memo?

Răspuns scurt: React Compiler este un plugin de build care adaugă automat memorizare pentru valori și JSX; versiunea stabilă 1.0 a apărut în octombrie 2025. Cu el, majoritatea apelurilor manuale de useMemo, useCallback și memo devin inutile, dacă respecți regulile React.

Memorizarea manuală are probleme cunoscute: e ușor de uitat, dependențele greșite produc bug-uri, iar codul devine mai greu de citit. Compilatorul rezolvă asta la build: analizează fluxul de date din fiecare componentă și hook și memorizează automat valorile și elementele JSX care depind de aceleași intrări.

JSX
function Lista({ produse, filtru, onSelect }) {
  const vizibile = produse.filter(p => p.categorie === filtru);
  return vizibile.map(p => <Card key={p.id} produs={p} onClick={() => onSelect(p.id)} />);
}

Cu compilatorul, vizibile se recalculează doar când se schimbă produse sau filtru, iar elementele Card rămân aceleași dacă intrările lor nu s-au schimbat, fără niciun useMemo scris de mână.

Ce trebuie să știi:

  • se instalează ca plugin pentru Babel, cu integrări pentru Vite și Next.js; funcționează cu React 19 și, cu un pachet de runtime, și cu React 17 și 18;
  • presupune că respecți regulile React: randare pură, fără mutații ale props și state, fără citirea ref-urilor în randare. Componentele care încalcă regulile sunt sărite;
  • regulile din eslint-plugin-react-hooks (în versiunile recente) semnalează codul pe care compilatorul nu îl poate optimiza;
  • useMemo și useCallback existente nu trebuie șterse imediat; rămân utile ca „trapă de urgență” când ai nevoie de o referință garantat stabilă, de exemplu ca dependență de efect;
  • adoptarea într-un proiect mare se face treptat, pe directoare, cu teste, pentru că expune codul care se baza pe impurități.

Pentru interviu, important e că memorizarea devine un detaliu de build, iar accentul cade pe cod corect, nu pe optimizări manuale.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu direcția ecosistemului. Un senior știe și ce condiții impune compilatorul codului.

Stare globală, date de la API și routing

72 Junior

Cum creezi și folosești un context pentru tema aplicației (luminos/întunecat)? Ce primește o componentă care citește contextul fără un Provider deasupra?

Răspuns scurt: Creezi contextul cu createContext(valoareImplicita), învelești arborele într-un Provider care primește value și citești cu useContext. Fără Provider, componenta primește valoarea implicită dată la createContext, fără eroare, ceea ce poate ascunde bug-uri.

JSX
import { createContext, useContext, useState } from "react";

const TemaContext = createContext("luminos");

function App() {
  const [tema, setTema] = useState("luminos");
  return (
    <TemaContext value={tema}>
      <button onClick={() => setTema(t => (t === "luminos" ? "intunecat" : "luminos"))}>
        Schimbă tema
      </button>
      <Pagina />
    </TemaContext>
  );
}

function Buton({ children }) {
  const tema = useContext(TemaContext);
  return <button className={`btn btn--${tema}`}>{children}</button>;
}

În React 19 poți folosi direct contextul ca provider (<TemaContext value={...}>); în versiunile anterioare scrii <TemaContext.Provider value={...}>, sintaxă care funcționează încă.

Ce trebuie reținut:

  • useContext caută cel mai apropiat Provider deasupra în arbore; poți suprascrie valoarea pentru o secțiune cu un Provider imbricat;
  • fără niciun Provider, primești valoarea implicită. Dacă implicitul e un obiect fals sau undefined, bug-ul apare abia la runtime, departe de cauză. De aceea, pentru contexte care trebuie să aibă Provider, se folosește un hook care aruncă eroare;
  • toate componentele care citesc contextul se re-randează când value se schimbă (comparat cu Object.is); memo pe componentă nu oprește asta;
  • contextul transportă date, nu e un store: nu are selectoare și nu face nimic singur.

Pentru o temă, valoarea se schimbă rar, deci contextul e alegerea potrivită. Tema se aplică de obicei și prin variabile CSS pe document.documentElement, ca stilurile să nu depindă de re-randări.

Ce urmărește intervievatorul: Verifică dacă știi folosirea de bază a contextului și capcana valorii implicite. Detaliul despre sintaxa React 19 arată că ești la zi.

Eroarea, în practică:Cannot destructure property of 'useContext(...)'`value` prop is required for <Context.Provider>

73 Junior

Scrie un CosProvider cu un hook useCos() care aruncă o eroare clară dacă e folosit în afara providerului.

Răspuns scurt: Creezi contextul cu valoarea implicită null, providerul ține state-ul (de exemplu cu useReducer) și expune o valoare memorizată, iar useCos citește contextul și aruncă eroare dacă primește null. Componentele nu mai importă direct contextul.

JSX
import { createContext, useContext, useMemo, useReducer } from "react";

const CosContext = createContext(null);

function cosReducer(state, action) {
  switch (action.type) {
    case "adauga":
      return state.some(i => i.id === action.produs.id)
        ? state.map(i => (i.id === action.produs.id ? { ...i, qty: i.qty + 1 } : i))
        : [...state, { ...action.produs, qty: 1 }];
    case "sterge":
      return state.filter(i => i.id !== action.id);
    default:
      throw new Error(`Acțiune necunoscută: ${action.type}`);
  }
}

export function CosProvider({ children }) {
  const [items, dispatch] = useReducer(cosReducer, []);
  const value = useMemo(() => ({
    items,
    numar: items.reduce((s, i) => s + i.qty, 0),
    adauga: produs => dispatch({ type: "adauga", produs }),
    sterge: id => dispatch({ type: "sterge", id }),
  }), [items]);
  return <CosContext value={value}>{children}</CosContext>;
}

export function useCos() {
  const ctx = useContext(CosContext);
  if (ctx === null) {
    throw new Error("useCos trebuie folosit în interiorul <CosProvider>.");
  }
  return ctx;
}

Ce câștigi:

  • eroarea apare imediat, cu un mesaj clar, nu un „cannot read properties of null” într-o componentă oarecare;
  • componentele depind de un API (items, adauga, sterge), nu de forma internă a state-ului; poți înlocui reducerul cu un store fără să le schimbi;
  • useMemo pe value evită re-randarea tuturor consumatorilor când providerul se re-randează din alt motiv.

Dacă unele componente au nevoie doar de acțiuni (butonul „Adaugă” de pe fiecare produs), poți separa două contexte: unul pentru date, unul pentru acțiuni, ca butoanele să nu se re-randeze la fiecare schimbare a coșului.

Ce urmărește intervievatorul: Verifică un tipar folosit în aproape orice aplicație React. Intervievatorul urmărește verificarea providerului și memorizarea valorii.

Eroarea, în practică:Cannot destructure property of 'useContext(...)'Cannot read properties of undefined ('Provider')

74 Junior

Ce câștigi folosind TanStack Query (React Query) în loc de useEffect + useState pentru datele de la API? Ce este queryKey?

Răspuns scurt: TanStack Query gestionează cache-ul, deduplicarea cererilor, reîncercările, reîmprospătarea în fundal și stările de încărcare și eroare. queryKey identifică datele în cache: aceeași cheie înseamnă aceleași date, partajate între componente, iar o cheie nouă (de exemplu alt id) declanșează altă cerere.

Cu useEffect scrii la fiecare cerere: stări de încărcare și eroare, anularea răspunsurilor vechi, și nu ai cache. Două componente care cer același produs fac două cereri, iar la întoarcerea pe o pagină vezi din nou spinner-ul.

JSX
import { useQuery } from "@tanstack/react-query";

function Produs({ id }) {
  const { data, isPending, isError, error } = useQuery({
    queryKey: ["produs", id],
    queryFn: async ({ signal }) => {
      const res = await fetch(`/api/produse/${id}`, { signal });
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json();
    },
  });

  if (isPending) return <Spinner />;
  if (isError) return <p>Eroare: {error.message}</p>;
  return <h1>{data.nume}</h1>;
}

Ce primești gratuit:

  • cache după queryKey: navighezi înapoi și datele apar imediat;
  • deduplicare: zece componente cu aceeași cheie produc o singură cerere;
  • fără race conditions: răspunsul e legat de cheie, iar signal permite anularea;
  • reîncercări automate la eșec (3 implicit, cu întârziere crescătoare);
  • reîmprospătare când fereastra primește din nou focus sau la reconectare;
  • paginare și infinite scroll cu useInfiniteQuery.

Cheia trebuie să conțină toate variabilele de care depinde cererea (id, filtre, pagină). Dacă uiți un filtru, două seturi de date diferite ajung sub aceeași cheie. Aplicația se învelește în QueryClientProvider cu un QueryClient.

Exemplul folosește API-ul din versiunea 5 (isPending în loc de isLoading pentru starea fără date).

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre server state și client state la nivel practic. Candidații buni explică ce probleme dispar, nu doar sintaxa.

75 Junior

De ce în React Router folosești <Link> și nu <a href>? La ce folosește <NavLink>?

Răspuns scurt: <Link> schimbă URL-ul prin History API și randează ruta nouă fără reîncărcarea paginii, deci păstrezi state-ul aplicației și nu descarci din nou resursele. <a href> face o navigare completă. <NavLink> știe dacă ruta lui e activă și îți permite să stilizezi linkul curent din meniu.

Într-o aplicație cu o singură pagină (SPA), routerul ascultă schimbările de URL și randează componenta potrivită. Un <a href="/produse"> obișnuit cere browserului o navigare: pagina se descarcă din nou, JavaScript-ul pornește de la zero, iar tot state-ul (coș, formulare, cache) se pierde.

<Link> randează tot un <a> cu href corect (deci funcționează click dreapta, deschidere în tab nou, accesibilitate), dar interceptează click-ul obișnuit și apelează history.pushState:

JSX
import { Link, NavLink } from "react-router";

function Meniu() {
  return (
    <nav>
      <Link to="/">Acasă</Link>
      <NavLink to="/cursuri" className={({ isActive }) => (isActive ? "activ" : undefined)}>
        Cursuri
      </NavLink>
      <NavLink to="/" end>Prima pagină</NavLink>
    </nav>
  );
}

NavLink:

  • primește isActive (și isPending la data router) în funcțiile pentru className, style și children;
  • adaugă automat aria-current="page" pe linkul activ, util pentru cititoare de ecran;
  • implicit e activ și pentru sub-rute (/cursuri/react activează /cursuri); end limitează la potrivire exactă, necesar mai ales pentru /.

Când folosești totuși <a>: linkuri externe, descărcări de fișiere, rute servite de altă aplicație. Pentru navigare din cod (după login, după salvare) folosești useNavigate.

Din React Router v7, pachetul principal este react-router; importurile din react-router-dom funcționează în continuare pentru compatibilitate.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care funcționează un SPA. Detaliile despre end și aria-current arată experiență practică.

76 Junior

Scrie configurația de rute pentru o aplicație cu un layout comun (antet și meniu), o pagină de start, o listă de cursuri, pagina unui curs și o pagină 404.

Răspuns scurt: Pui layout-ul pe o rută părinte cu <Outlet /> în locul în care apar paginile copil, pagina de start ca rută index, ruta dinamică cu parametru (cursuri/:slug) și o rută * pentru orice URL necunoscut.

Varianta cu createBrowserRouter (data router):

JSX
import { createBrowserRouter, RouterProvider, Outlet, Link } from "react-router";

function Layout() {
  return (
    <>
      <header><Link to="/">Academia</Link></header>
      <main>
        <Outlet />
      </main>
    </>
  );
}

const router = createBrowserRouter([
  {
    path: "/",
    element: <Layout />,
    errorElement: <EroareGenerala />,
    children: [
      { index: true, element: <Acasa /> },
      { path: "cursuri", element: <ListaCursuri /> },
      { path: "cursuri/:slug", element: <PaginaCurs /> },
      { path: "*", element: <NuExista /> },
    ],
  },
]);

export default function App() {
  return <RouterProvider router={router} />;
}

Explicații:

  • rutele imbricate randează părintele, iar copilul potrivit apare în locul lui <Outlet />; antetul nu se re-montează la navigare;
  • index: true e ruta afișată când URL-ul e exact al părintelui (/); nu are path propriu;
  • căile copil sunt relative (cursuri, nu /cursuri);
  • ***** prinde orice cale nepotrivită, iar pentru că e în interiorul layout-ului, pagina 404 păstrează meniul;
  • errorElement prinde erorile aruncate în randare sau în loader-ele rutelor copil.

Varianta declarativă, echivalentă pentru cazurile simple:

JSX
<Routes>
  <Route path="/" element={<Layout />}>
    <Route index element={<Acasa />} />
    <Route path="cursuri" element={<ListaCursuri />} />
    <Route path="cursuri/:slug" element={<PaginaCurs />} />
    <Route path="*" element={<NuExista />} />
  </Route>
</Routes>

Varianta cu obiecte deblochează loader-ele, acțiunile și încărcarea leneșă la nivel de rută.

Ce urmărește intervievatorul: Verifică dacă poți structura routing-ul unei aplicații reale. Greșelile frecvente sunt căile absolute la copii și uitarea lui Outlet.

Eroarea, în practică:useNavigate() may be used only in a <Router>A <Route> is only ever to be used in <Routes>

77 Junior

Pe pagina /produse/:categorie vrei filtre pentru preț și sortare care să se păstreze când utilizatorul copiază linkul. Cum citești și actualizezi parametrii?

Răspuns scurt: Categoria vine din calea URL-ului prin useParams, iar filtrele din query string prin useSearchParams. Filtrele stau în URL, nu în useState, deci linkul copiat, butonul Înapoi și reîncărcarea paginii păstrează exact aceeași vedere.

JSX
import { useParams, useSearchParams } from "react-router";

function Produse() {
  const { categorie } = useParams();               // /produse/laptopuri
  const [params, setParams] = useSearchParams();   // ?max=3000&sort=pret

  const max = Number(params.get("max") ?? 0) || undefined;
  const sort = params.get("sort") ?? "relevanta";

  function schimba(cheie, valoare) {
    setParams(prev => {
      const p = new URLSearchParams(prev);
      if (valoare) p.set(cheie, valoare);
      else p.delete(cheie);
      return p;
    }, { replace: true });
  }

  const { data } = useQuery({
    queryKey: ["produse", categorie, max, sort],
    queryFn: () => getProduse({ categorie, max, sort }),
  });

  return (
    <>
      <select value={sort} onChange={e => schimba("sort", e.target.value)}>
        <option value="relevanta">Relevanță</option>
        <option value="pret">Preț crescător</option>
      </select>
      {/* listă */}
    </>
  );
}

Detalii:

  • parametrii din URL sunt mereu șiruri sau null; îi convertești și validezi, pentru că utilizatorul poate scrie orice în bara de adrese;
  • setParams cu funcție păstrează ceilalți parametri; un obiect nou i-ar înlocui pe toți;
  • replace: true evită umplerea istoricului cu fiecare mișcare de slider; pentru schimbări pe care utilizatorul ar vrea să le anuleze cu Înapoi, lași navigarea normală;
  • URL-ul devine sursa de adevăr; nu copia parametrii și într-un useState, ar fi două surse care se desincronizează;
  • useParams returnează parametrii rutei potrivite, iar componenta rămâne montată când doar parametrul se schimbă, deci datele se reîncarcă prin dependențe (aici prin queryKey).

Ce urmărește intervievatorul: Verifică dacă știi că URL-ul e un loc bun pentru stare. Intervievatorii apreciază argumentul despre linkuri care se pot partaja.

Eroarea, în practică:undefined (reading 'params')

78 Junior

Pagina de profil încarcă utilizatorul, apoi comenzile lui, apoi recenziile, iar cererile pleacă una după alta. Cum o faci mai rapidă?

Răspuns scurt: Cererile care nu depind una de alta pornesc în paralel cu Promise.all (sau prin interogări separate care rulează simultan). Lanțul secvențial (waterfall) apare când fiecare cerere așteaptă răspunsul celei anterioare sau când componentele copil încep să încarce abia după ce părintele a terminat.

Varianta lentă:

JSX
useEffect(() => {
  async function incarca() {
    const user = await getUser(id);
    const comenzi = await getComenzi(id);
    const recenzii = await getRecenzii(id);
    setDate({ user, comenzi, recenzii });
  }
  incarca();
}, [id]);

Toate cele trei cereri depind doar de id, dar fiecare await o așteaptă pe precedenta. Timpul total e suma celor trei.

Varianta paralelă:

JSX
const [user, comenzi, recenzii] = await Promise.all([
  getUser(id),
  getComenzi(id),
  getRecenzii(id),
]);

Timpul total devine cel al celei mai lente cereri.

Alegerea metodei:

  • Promise.all respinge la prima eroare; dacă recenziile pot lipsi fără să strice pagina, folosești Promise.allSettled și tratezi fiecare rezultat separat;
  • cu TanStack Query, trei useQuery în aceeași componentă rulează automat în paralel, fiecare cu propria stare de încărcare, deci poți afișa profilul înainte de recenzii;
  • waterfall între componente: dacă Profil afișează un spinner până vine utilizatorul și abia apoi randează <Comenzi />, care își pornește propria cerere, tot ai cereri secvențiale. Soluții: pornești cererile mai sus (în părinte sau în loader-ul rutei) ori folosești prefetchQuery;
  • dependențele reale (de exemplu ai nevoie de user.companieId pentru a doua cerere) rămân secvențiale; acolo poți cere backend-ului un endpoint care returnează datele combinate.

Verificarea se face în tab-ul Network, unde lanțul secvențial se vede ca o „scară”.

Ce urmărește intervievatorul: Verifică înțelegerea concurenței cererilor și a impactului asupra timpului de încărcare. Mulți nu observă waterfall-ul creat de componentele imbricate.

79 Mid

Scrie un slice Redux Toolkit pentru notificări (adăugare, marcare ca citită, ștergerea celor citite) și arată cum îl folosești într-o componentă.

Răspuns scurt: Cu createSlice definești state-ul inițial și reducerii, iar RTK generează automat action creators. Store-ul se creează cu configureStore, aplicația se învelește în <Provider store>, iar componentele folosesc useSelector pentru citire și useDispatch pentru acțiuni.

JavaScript
// notificariSlice.js
import { createSlice, nanoid } from "@reduxjs/toolkit";

const notificariSlice = createSlice({
  name: "notificari",
  initialState: { items: [] },
  reducers: {
    adauga: {
      reducer(state, action) {
        state.items.push(action.payload);
      },
      prepare(text) {
        return { payload: { id: nanoid(), text, citita: false } };
      },
    },
    marcheazaCitita(state, action) {
      const n = state.items.find(i => i.id === action.payload);
      if (n) n.citita = true;
    },
    stergeCitite(state) {
      state.items = state.items.filter(i => !i.citita);
    },
  },
});

export const { adauga, marcheazaCitita, stergeCitite } = notificariSlice.actions;
export const selectNecitite = state => state.notificari.items.filter(i => !i.citita).length;
export default notificariSlice.reducer;
JSX
// store.js
export const store = configureStore({ reducer: { notificari: notificariReducer } });

// Clopotel.jsx
function Clopotel() {
  const necitite = useSelector(selectNecitite);
  const dispatch = useDispatch();
  return <button onClick={() => dispatch(stergeCitite())}>Notificări ({necitite})</button>;
}

De explicat:

  • state.items.push pare mutație, dar createSlice folosește Immer, deci se produce un state nou. Nu amesteca: fie modifici draftul, fie returnezi un obiect nou;
  • prepare generează id-ul în afara reducerului, care trebuie să rămână pur;
  • selectorul returnează un număr, deci componenta se re-randează doar când numărul se schimbă;
  • configureStore adaugă automat Redux DevTools și verificări în development pentru mutații și valori neserializabile.

Pentru date de la server, RTK Query (inclus în Redux Toolkit) e preferabil reducerilor scriși manual.

Ce urmărește intervievatorul: Verifică experiența cu Redux modern, nu cu varianta veche cu switch și constante. Detaliul despre Immer și prepare arată înțelegere.

80 Mid

Componenta de mai jos se re-randează la orice acțiune din store, chiar și la cele care nu au legătură cu utilizatorul. De ce?

JSX
function Antet() {
  const { nume, avatar } = useSelector(state => ({
    nume: state.user.nume,
    avatar: state.user.avatar,
  }));
  return <Avatar nume={nume} src={avatar} />;
}

Răspuns scurt: useSelector compară rezultatul selectorului cu cel anterior prin referință (===). Selectorul construiește un obiect nou la fiecare apel, deci după fiecare acțiune rezultatul pare schimbat. Selectezi valori separate, folosești shallowEqual sau un selector memorizat cu createSelector.

După fiecare dispatch, react-redux rulează selectoarele tuturor componentelor abonate și compară rezultatul nou cu cel vechi. Dacă diferă, componenta se re-randează. Un literal de obiect e mereu o referință nouă, deci componenta se re-randează la orice acțiune, inclusiv la cele din alte slice-uri. În development, react-redux afișează și un avertisment că selectorul returnează alt rezultat pentru aceleași intrări.

Variante corecte:

JSX
// 1. selectoare separate pentru valori primitive
const nume = useSelector(state => state.user.nume);
const avatar = useSelector(state => state.user.avatar);

// 2. selectezi obiectul existent din store, dacă e suficient
const user = useSelector(state => state.user);

// 3. comparație superficială
import { shallowEqual } from "react-redux";
const { nume, avatar } = useSelector(
  state => ({ nume: state.user.nume, avatar: state.user.avatar }),
  shallowEqual
);

Același lucru apare cu tablouri derivate:

JSX
const active = useSelector(state => state.sarcini.filter(s => !s.gata)); // tablou nou mereu

Aici soluția e un selector memorizat:

JavaScript
import { createSelector } from "@reduxjs/toolkit";
const selectActive = createSelector([state => state.sarcini], sarcini => sarcini.filter(s => !s.gata));

createSelector (din Reselect, reexportat de RTK) recalculează doar când intrarea se schimbă și returnează aceeași referință altfel. Zustand are aceeași problemă și aceeași soluție, cu useShallow.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de abonare din Redux. Este o cauză foarte frecventă de probleme de performanță în aplicații mari.

81 Mid

În TanStack Query v5, care e diferența dintre staleTime și gcTime? De ce vezi o cerere nouă de fiecare dată când revii pe o pagină, deși datele sunt în cache?

Răspuns scurt: staleTime spune cât timp datele sunt proaspete și nu se cer din nou (implicit 0). gcTime, fostul cacheTime, spune cât rămân în memorie datele nefolosite (implicit 5 minute). Cu staleTime 0, cache-ul se afișează imediat, dar se reîmprospătează la montare.

Ciclul unei interogări:

  • datele sosesc și sunt fresh;
  • după staleTime devin stale (învechite). Datele stale se afișează în continuare, dar la anumite evenimente se cer din nou: montarea unei componente noi cu aceeași cheie, focus pe fereastră, reconectare;
  • când nicio componentă nu mai folosește cheia, interogarea devine inactivă; după gcTime, este ștearsă din memorie.

Cu valorile implicite (staleTime: 0, gcTime: 5 minute), la revenirea pe pagină vezi datele vechi instant, fără spinner, iar în Network apare o cerere de reîmprospătare. E un comportament intenționat: preferă date corecte. isFetching e true în timpul reîmprospătării, iar isPending rămâne false, pentru că ai deja date.

Configurare după natura datelor:

JavaScript
const queryClient = new QueryClient({
  defaultOptions: { queries: { staleTime: 60_000 } }, // 1 minut implicit
});

useQuery({ queryKey: ["categorii"], queryFn: getCategorii, staleTime: Infinity }); // rar se schimbă
useQuery({ queryKey: ["stoc", id], queryFn: () => getStoc(id), staleTime: 0 });  // se schimbă des

Greșeli frecvente:

  • confuzia celor două: mărirea lui gcTime nu oprește cererile; doar staleTime face asta;
  • gcTime mai mic decât staleTime nu are sens practic, pentru că datele dispar înainte să devină stale;
  • dezactivarea refetchOnWindowFocus peste tot, în loc de un staleTime potrivit.

În v4 opțiunea se numea cacheTime; redenumirea în v5 a fost făcută tocmai pentru că numele inducea în eroare.

Ce urmărește intervievatorul: Verifică înțelegerea cache-ului, nu doar folosirea bibliotecii. Confuzia dintre cele două opțiuni e foarte frecventă.

82 Mid

Utilizatorul neautentificat deschide /comenzi/123, este trimis la login, iar după autentificare ajunge pe pagina de start. Cum îl duci înapoi la pagina cerută?

Răspuns scurt: Când redirecționezi la login, salvezi locația curentă în state (<Navigate to="/login" state={{ from: location }} replace />). După autentificare, citești location.state?.from și navighezi acolo cu navigate(dest, { replace: true }), cu pagina de start ca rezervă.

JSX
import { Navigate, Outlet, useLocation, useNavigate } from "react-router";

function RutaProtejata() {
  const { user, seIncarca } = useAuth();
  const location = useLocation();
  if (seIncarca) return <Spinner />;
  if (!user) {
    return <Navigate to="/login" replace state={{ from: location }} />;
  }
  return <Outlet />;
}

function Login() {
  const navigate = useNavigate();
  const location = useLocation();
  const dest = location.state?.from?.pathname
    ? location.state.from.pathname + (location.state.from.search ?? "")
    : "/";

  async function onSubmit(date) {
    await login(date);
    navigate(dest, { replace: true });
  }
  // formular...
}

Detalii care contează:

  • replace la redirecționare înlocuiește intrarea din istoric, deci butonul Înapoi de pe login nu te trimite într-o buclă către pagina protejată;
  • salvezi și search, nu doar pathname, ca filtrele sau parametrii să nu se piardă;
  • seIncarca evită redirecționarea greșită la reîncărcarea paginii, cât timp sesiunea încă se verifică;
  • location.state se pierde dacă utilizatorul deschide linkul de login direct sau într-un tab nou. Dacă ai nevoie de robustețe, pui destinația în query (/login?next=/comenzi/123), dar o validezi: acceptă doar căi relative interne, altfel creezi o vulnerabilitate de tip open redirect;
  • <Navigate> se folosește în randare, useNavigate în handler-e și după operații asincrone.

Protecția din client e doar pentru experiența utilizatorului; API-ul verifică oricum autorizarea la fiecare cerere.

Ce urmărește intervievatorul: Verifică experiența cu fluxuri reale de autentificare. Validarea parametrului next și folosirea lui replace diferențiază un răspuns bun.

83 Senior

Echipa ta discută dacă un proiect nou ar trebui să folosească Redux Toolkit sau Zustand. Ce argumente aduci?

Răspuns scurt: Zustand e minimal: un store creat ca hook, fără provider și boilerplate, bun pentru stare de client mică sau medie. Redux Toolkit aduce convenții, devtools și middleware, utile în echipe mari cu multă logică. Datele de server merg oricum în TanStack Query sau RTK Query.

Întâi clarifici ce stare ai. Dacă majoritatea e stare de server (liste, detalii, cache), o bibliotecă de server state rezolvă partea cea mai mare. Store-ul global rămâne pentru stare de client: sesiune, preferințe, coș, filtre, stări ale interfeței partajate.

Zustand:

JavaScript
import { create } from "zustand";
export const useCos = create(set => ({
  items: [],
  adauga: p => set(s => ({ items: [...s.items, p] })),
}));
// în componentă:
const numar = useCos(s => s.items.length);
  • foarte puțin cod, fără provider, curba de învățare mică;
  • abonare cu selectoare, re-randări doar când se schimbă bucata selectată;
  • middleware pentru persistență și devtools;
  • libertate mare, deci fiecare dezvoltator poate structura altfel.

Redux Toolkit:

  • convenții clare (slice-uri, acțiuni, reduceri puri), ușor de urmat de o echipă mare;
  • Redux DevTools cu istoric de acțiuni și time travel, util la depanarea logicii complexe;
  • middleware și listeneri pentru fluxuri asincrone;
  • RTK Query integrat pentru date de server;
  • mai mult cod și concepte de învățat.

Criterii de decizie: mărimea echipei și cât de importantă e uniformitatea, complexitatea logicii (multe interacțiuni între părți ale state-ului favorizează Redux), experiența existentă în echipă, nevoia de depanare cu istoric. Pentru o echipă mică și state modest, Zustand. Pentru un produs mare, cu mulți dezvoltatori și logică de business în client, Redux Toolkit.

Indiferent de alegere: ține în store doar ce e cu adevărat global, nu tot state-ul.

Ce urmărește intervievatorul: Verifică judecata arhitecturală, nu preferința personală. Răspunsul senior pornește de la tipul de stare și de la echipă.

84 Senior

Implementează cu TanStack Query o acțiune „Marchează ca favorit” cu actualizare optimistă: interfața se schimbă imediat, iar dacă serverul răspunde cu eroare, revine la starea anterioară.

Răspuns scurt: Folosești useMutation cu onMutate (anulezi cererile în curs, salvezi datele vechi, scrii valoarea nouă în cache), onError (restaurezi copia) și onSettled (invalidezi cheia ca să sincronizezi cu serverul).

JSX
import { useMutation, useQueryClient } from "@tanstack/react-query";

function useFavorit() {
  const qc = useQueryClient();
  const key = ["produse"];

  return useMutation({
    mutationFn: ({ id, favorit }) =>
      fetch(`/api/produse/${id}/favorit`, {
        method: favorit ? "PUT" : "DELETE",
      }).then(r => { if (!r.ok) throw new Error("Eșec"); }),

    onMutate: async ({ id, favorit }) => {
      await qc.cancelQueries({ queryKey: key });
      const anterior = qc.getQueryData(key);
      qc.setQueryData(key, old =>
        old?.map(p => (p.id === id ? { ...p, favorit } : p))
      );
      return { anterior };
    },

    onError: (_err, _vars, context) => {
      qc.setQueryData(key, context.anterior);
      toast.error("Nu am putut salva favoritul.");
    },

    onSettled: () => qc.invalidateQueries({ queryKey: key }),
  });
}

De ce fiecare pas:

  • cancelQueries oprește o reîmprospătare în curs care, sosind după actualizarea optimistă, ar suprascrie-o cu date vechi;
  • copia anterior returnată din onMutate ajunge ca context în onError; e mecanismul de rollback;
  • actualizarea în cache e imutabilă, ca orice componentă care citește cheia să se re-randeze;
  • onSettled rulează și la succes, și la eroare; invalidarea aduce adevărul de pe server (de exemplu un contor de favorite calculat acolo).

Când e potrivită abordarea optimistă: acțiuni frecvente, cu șanse mari de succes și ușor de anulat (like, favorit, bifare). Nu e potrivită pentru plăți sau operații ireversibile, unde utilizatorul trebuie să vadă confirmarea reală. Alternativă mai simplă în v5: afișezi optimist din variables ale mutației în timp ce isPending, fără să modifici cache-ul. În React 19 există și useOptimistic pentru același scop, legat de Actions.

Ce urmărește intervievatorul: Verifică stăpânirea cache-ului și a cazurilor de eroare. Un senior explică și când nu e potrivită actualizarea optimistă.

85 Senior

Ce sunt loader-ele din React Router (data router) și ce problemă rezolvă față de încărcarea datelor în useEffect din componente?

Răspuns scurt: Un loader este o funcție asociată rutei, apelată de router înainte de randare, în paralel pentru toate rutele imbricate potrivite. Elimină lanțul „randează, apoi pornește cererea”, iar codul și datele se descarcă simultan, cu starea navigării gestionată de router.

Cu useEffect, ordinea este: se descarcă codul paginii, componenta se randează, efectul pornește cererea, componenta afișează spinner-ul, iar dacă un copil are propriul efect, încă o rundă. Fiecare nivel de rute imbricate adaugă o etapă (fetch-on-render).

Cu loader-e (render-as-you-fetch):

JSX
const router = createBrowserRouter([
  {
    path: "/cursuri/:slug",
    loader: async ({ params, request }) => {
      const res = await fetch(`/api/cursuri/${params.slug}`, { signal: request.signal });
      if (res.status === 404) throw new Response("Nu există", { status: 404 });
      return res.json();
    },
    lazy: () => import("./PaginaCurs"),  // codul paginii, în paralel cu datele
    errorElement: <EroareCurs />,
  },
]);

function PaginaCurs() {
  const curs = useLoaderData();
  return <h1>{curs.titlu}</h1>;
}

Ce câștigi:

  • datele pentru toate rutele potrivite (layout, pagină, sub-pagină) se cer în paralel;
  • cererea pornește la click, nu după randare; poți porni chiar la hover cu <Link prefetch="intent"> în modul framework;
  • useNavigation().state îți spune global dacă o navigare e în curs, pentru un indicator de progres;
  • erorile aruncate în loader ajung la errorElement, cu useRouteError;
  • request.signal anulează cererea dacă utilizatorul pleacă înainte de final;
  • acțiunile (action) pentru formulare revalidează automat loader-ele după o modificare.

Compromisuri: datele sunt legate de rute, deci componentele reutilizabile din interiorul paginilor au nevoie de alt mecanism, iar cache-ul e minim. Multe echipe combină loader-ele cu TanStack Query: loader-ul apelează queryClient.ensureQueryData, iar componenta citește cu useQuery, obținând și pornirea timpurie, și cache-ul.

Ce urmărește intervievatorul: Verifică înțelegerea problemelor de arhitectură a încărcării datelor. E o discuție tipic senior, legată de performanța percepută.

Testare, TypeScript, pattern-uri și React 19

86 Junior

În React Testing Library, care e diferența dintre getBy, queryBy și findBy? Când îl folosești pe fiecare?

Răspuns scurt: getBy returnează elementul sau aruncă eroare imediat dacă nu există. queryBy returnează null dacă nu există, util pentru a verifica absența. findBy returnează o promisiune care așteaptă apariția elementului, util pentru conținut asincron. Variantele All lucrează cu liste.

JSX
import { render, screen } from "@testing-library/react";

test("afișează produsele după încărcare", async () => {
  render(<ListaProduse />);

  // există sincron, imediat după randare
  expect(screen.getByRole("heading", { name: "Produse" })).toBeInTheDocument();

  // apare după ce se rezolvă cererea
  expect(await screen.findByText("Laptop")).toBeInTheDocument();

  // verificăm că spinner-ul a dispărut
  expect(screen.queryByRole("progressbar")).not.toBeInTheDocument();
});

Reguli:

  • getBy pentru elementele care trebuie să existe acum. Mesajul de eroare include DOM-ul curent, ceea ce ajută la depanare;
  • queryBy doar pentru aserțiuni de absență. Folosit pentru existență, un test care eșuează dă mesaje mai puțin clare;
  • findBy pentru ce apare după o operație asincronă: o cerere, un timer, o tranziție. Implicit așteaptă până la 1000 ms; e echivalentul lui waitFor + getBy;
  • getAllBy / queryAllBy / findAllBy returnează tablouri; getAllBy aruncă dacă nu găsește niciunul.

Greșeli frecvente:

  • expect(screen.getByText("x")).toBeNull(), care nu poate trece niciodată, pentru că getBy aruncă înainte;
  • waitFor cu efecte secundare în interior (de exemplu un click), care se poate executa de mai multe ori;
  • uitarea lui await la findBy, care face testul să treacă fals.

Matcher-ele ca toBeInTheDocument vin din @testing-library/jest-dom, care se configurează în fișierul de setup al testelor, pentru Jest sau Vitest.

Ce urmărește intervievatorul: Verifică experiența reală cu testarea componentelor. Folosirea greșită a lui queryBy și uitarea lui await sunt foarte frecvente.

87 Junior

Scrie un test cu React Testing Library pentru un contor: la încărcare arată 0, iar după două click-uri pe „Adaugă” arată 2.

Răspuns scurt: Randezi componenta, găsești butonul după rol și nume, simulezi click-urile cu userEvent (cu await) și verifici textul afișat. Testul descrie ce vede și ce face utilizatorul, nu state-ul intern.

Componenta:

JSX
export function Contor() {
  const [n, setN] = useState(0);
  return (
    <div>
      <p aria-live="polite">Valoare: {n}</p>
      <button onClick={() => setN(v => v + 1)}>Adaugă</button>
    </div>
  );
}

Testul:

JSX
import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { Contor } from "./Contor";

test("crește valoarea la fiecare click", async () => {
  const user = userEvent.setup();
  render(<Contor />);

  expect(screen.getByText("Valoare: 0")).toBeInTheDocument();

  const buton = screen.getByRole("button", { name: "Adaugă" });
  await user.click(buton);
  await user.click(buton);

  expect(screen.getByText("Valoare: 2")).toBeInTheDocument();
});

De ce așa:

  • userEvent simulează interacțiunea completă (pointer, focus, evenimentele de mouse, tastatura), mai aproape de realitate decât fireEvent.click, care trimite un singur eveniment;
  • userEvent.setup() creat la începutul testului este forma recomandată din versiunea 14, iar metodele sunt asincrone, deci au nevoie de await;
  • getByRole("button", { name }) verifică și accesibilitatea: dacă butonul ar fi un div fără rol, testul ar eșua;
  • testul nu știe că există useState; poți refactoriza componenta în useReducer sau Zustand fără să schimbi testul.

Testul rulează la fel în Jest sau Vitest, cu un mediu DOM (jsdom sau happy-dom) configurat. RTL face automat curățarea după fiecare test când framework-ul de test expune afterEach global.

Ce urmărește intervievatorul: Este exercițiul standard de testare la interviu. Intervievatorul urmărește interogările după rol, userEvent și lipsa testării detaliilor interne.

88 Junior

Ce ar trebui să testezi la o componentă React și ce nu? De ce React Testing Library recomandă getByRole în locul selectoarelor CSS sau al data-testid?

Răspuns scurt: Testezi comportamentul vizibil: ce se afișează, ce fac interacțiunile, stările de încărcare și eroare, nu state-ul intern sau structura DOM. getByRole caută elementele cum le găsește un utilizator, inclusiv cu cititor de ecran, deci verifică și accesibilitatea.

Principiul RTL: cu cât testele seamănă mai mult cu felul în care e folosită aplicația, cu atât îți dau mai multă încredere.

Ce merită testat:

  • afișarea corectă pentru date diferite: listă goală, un element, multe;
  • interacțiunile: click, tastare, trimiterea formularului și efectul lor vizibil;
  • stările asincrone: încărcare, succes, eroare de la server;
  • cazuri limită: validări, butoane dezactivate, permisiuni;
  • callback-urile publice: componenta apelează onSubmit cu datele corecte.

Ce nu merită testat:

  • valoarea unui useState sau numărul de randări;
  • clasele CSS interne sau structura exactă a DOM-ului;
  • comportamentul React sau al bibliotecilor (că useState funcționează);
  • snapshot-uri uriașe care se schimbă la orice modificare și sunt actualizate fără să fie citite.

Ordinea recomandată a interogărilor:

  • getByRole (cu name): butoane, linkuri, câmpuri, titluri;
  • getByLabelText pentru câmpuri de formular;
  • getByPlaceholderText, getByText, getByDisplayValue;
  • getByAltText, getByTitle;
  • getByTestId ca ultimă soluție, când nu există altă cale semantică.
JSX
screen.getByRole("textbox", { name: "Email" });       // legat de <label>
screen.getByRole("button", { name: /trimite/i });

Un selector .btn-primary se strică la o schimbare de stil; getByRole se strică doar când comportamentul pentru utilizator se schimbă. Bonus: dacă nu poți găsi un câmp după etichetă, probabil nici un utilizator cu cititor de ecran nu îl poate identifica.

Ce urmărește intervievatorul: Verifică filozofia de testare, nu doar sintaxa. Testele legate de implementare sunt o problemă majoră în proiectele reale.

89 Junior

Cum tipizezi în TypeScript props-urile unei componente, inclusiv children, un callback și un handler de eveniment pentru un input?

Răspuns scurt: Definești un type sau interface pentru props și îl folosești la parametrul funcției. Pentru conținut folosești React.ReactNode, pentru callback-uri semnătura funcției, iar pentru evenimente tipurile React, de exemplu React.ChangeEvent<HTMLInputElement>.

TSX
import type { ReactNode, ChangeEvent, ComponentProps } from "react";

type Produs = { id: string; nume: string; pret: number };

type CardProps = {
  produs: Produs;
  variant?: "compact" | "complet";        // opțional, uniune de literale
  onAdauga: (id: string, qty: number) => void;
  children?: ReactNode;
};

export function CardProdus({ produs, variant = "complet", onAdauga, children }: CardProps) {
  return (
    <article className={variant}>
      <h3>{produs.nume}</h3>
      {children}
      <button onClick={() => onAdauga(produs.id, 1)}>Adaugă</button>
    </article>
  );
}

function Cautare() {
  const [q, setQ] = useState("");                 // tip dedus: string
  const [user, setUser] = useState<Produs | null>(null);

  function onChange(e: ChangeEvent<HTMLInputElement>) {
    setQ(e.target.value);
  }
  return <input value={q} onChange={onChange} />;
}

// componentă care extinde un element HTML
type ButonProps = ComponentProps<"button"> & { varianta?: "primar" | "secundar" };
function Buton({ varianta = "primar", ...rest }: ButonProps) {
  return <button className={varianta} {...rest} />;
}

Observații:

  • ReactNode acceptă tot ce se poate randa (text, elemente, null, liste); ReactElement acceptă doar elemente JSX;
  • uniunile de literale ("compact" | "complet") prind greșelile de scriere la compilare;
  • useState deduce tipul din valoarea inițială; dai tipul explicit când pornești cu null sau un tablou gol;
  • ComponentProps<"button"> aduce toate atributele native (type, disabled, aria-*);
  • React.FC nu mai e necesar și e evitat de multe echipe; funcția simplă cu props tipizate e suficientă;
  • evenimentele React au tipuri proprii (MouseEvent din react, nu cel global din DOM).

Ce urmărește intervievatorul: Verifică experiența cu TypeScript în React, care e cerută în majoritatea anunțurilor. Greșeala tipică e any la evenimente sau JSX.Element pentru children.

90 Mid

Cum testezi o componentă care încarcă date de la API, ca să verifici starea de încărcare, afișarea datelor și mesajul de eroare?

Răspuns scurt: Înlocuiești rețeaua cu mock-uri, de preferat la nivel HTTP cu Mock Service Worker (MSW), care interceptează cererile și returnează răspunsuri controlate. Testul randează componenta, verifică spinner-ul, apoi așteaptă datele cu findBy; pentru eroare, suprascrii handler-ul în acel test.

Opțiuni de mock, de la cea mai apropiată de realitate:

  • MSW: interceptează cererile la nivel de rețea, deci componenta folosește fetch, axios sau TanStack Query neschimbat;
  • vi.mock / jest.mock pe modulul de servicii (api.getProduse): simplu, dar testezi mai puțin;
  • înlocuirea lui globalThis.fetch: fragil, trebuie să imiți obiectul Response.

Cu MSW (API-ul din versiunea 2):

JavaScript
// test/server.js
import { setupServer } from "msw/node";
import { http, HttpResponse } from "msw";

export const server = setupServer(
  http.get("/api/produse", () => HttpResponse.json([{ id: 1, nume: "Laptop" }]))
);
// în setup: beforeAll(() => server.listen()); afterEach(() => server.resetHandlers()); afterAll(() => server.close());
JSX
test("afișează produsele", async () => {
  render(<ListaProduse />, { wrapper: Providers });
  expect(screen.getByRole("progressbar")).toBeInTheDocument();
  expect(await screen.findByText("Laptop")).toBeInTheDocument();
});

test("afișează eroarea când serverul cade", async () => {
  server.use(http.get("/api/produse", () => new HttpResponse(null, { status: 500 })));
  render(<ListaProduse />, { wrapper: Providers });
  expect(await screen.findByRole("alert")).toHaveTextContent(/nu am putut încărca/i);
});

Detalii practice:

  • wrapper furnizează providerii necesari (QueryClient, router, tema). Pentru TanStack Query, creezi un QueryClient nou per test, cu retry: false, altfel testul de eroare așteaptă reîncercările și cache-ul se scurge între teste;
  • resetHandlers după fiecare test anulează suprascrierile;
  • onUnhandledRequest: "error" la server.listen prinde cererile pe care ai uitat să le simulezi;
  • aceleași handlere MSW pot rula și în browser, în development, pentru a lucra fără backend.

Ce urmărește intervievatorul: Verifică dacă poți testa cod asincron real, nu doar componente statice. Intervievatorii apreciază testarea explicită a cazului de eroare.

91 Mid

Ce este un error boundary? Ce erori prinde și ce erori nu prinde?

Răspuns scurt: Un error boundary prinde erorile aruncate la randarea copiilor săi (și în lifecycle-ul lor) și afișează o interfață de rezervă în locul ecranului alb. Nu prinde erori din handler-e de evenimente, din cod asincron (timere, fetch în efecte) sau din el însuși.

Fără error boundary, o eroare în randare demontează întregul arbore React, iar utilizatorul vede un ecran alb. Un boundary izolează eroarea la o secțiune:

JSX
class ErrorBoundary extends React.Component {
  state = { eroare: null };

  static getDerivedStateFromError(eroare) {
    return { eroare };                  // schimbă UI-ul
  }

  componentDidCatch(eroare, info) {
    raporteaza(eroare, info.componentStack); // de exemplu către Sentry
  }

  render() {
    if (this.state.eroare) return this.props.fallback;
    return this.props.children;
  }
}

<ErrorBoundary fallback={<p>Graficul nu poate fi afișat.</p>}>
  <GraficVanzari />
</ErrorBoundary>

Se scrie încă doar cu clase; în practică se folosește pachetul react-error-boundary, care oferă <ErrorBoundary FallbackComponent onReset resetKeys> și hook-ul useErrorBoundary.

Ce nu prinde și cum tratezi:

  • erori în handler-e (onClick): try/catch în handler și state de eroare; sau showBoundary(err) din useErrorBoundary;
  • cod asincron (setTimeout, fetch în efecte): catch și state de eroare;
  • erori în randarea pe server, tratate de framework;
  • erori în boundary-ul însuși: sunt propagate la boundary-ul de deasupra.

Unde le pui: unul la rădăcină, ca plasă de siguranță, și altele în jurul secțiunilor independente (widget-uri, rute, grafice), ca o eroare locală să nu ascundă restul paginii. Oferă și o cale de recuperare, de exemplu un buton „Încearcă din nou” care resetează boundary-ul.

În React 19, createRoot acceptă opțiunile onCaughtError și onUncaughtError pentru raportarea centralizată a erorilor.

Ce urmărește intervievatorul: Verifică înțelegerea limitelor mecanismului. Mulți candidați cred că un boundary prinde orice eroare, inclusiv cele din onClick.

92 Mid

De ce ai randa o fereastră modală cu createPortal? Ce trebuie să ai în vedere la evenimente și accesibilitate?

Răspuns scurt: Portalul randează copiii în alt nod DOM, de obicei în body, ca modalul să nu fie tăiat de overflow: hidden sau prins sub z-index-ul părinților. Pentru React rămâne în același arbore: contextul merge, iar evenimentele urcă prin părinții din React.

JSX
import { createPortal } from "react-dom";

function Modal({ deschis, onInchide, titlu, children }) {
  const dialogRef = useRef(null);

  useEffect(() => {
    if (!deschis) return;
    const anterior = document.activeElement;
    dialogRef.current?.focus();
    function laTasta(e) { if (e.key === "Escape") onInchide(); }
    document.addEventListener("keydown", laTasta);
    return () => {
      document.removeEventListener("keydown", laTasta);
      anterior?.focus();                       // focusul revine pe butonul care a deschis
    };
  }, [deschis, onInchide]);

  if (!deschis) return null;
  return createPortal(
    <div className="fundal" onClick={onInchide}>
      <div role="dialog" aria-modal="true" aria-labelledby="titlu-modal"
        ref={dialogRef} tabIndex={-1} onClick={e => e.stopPropagation()}>
        <h2 id="titlu-modal">{titlu}</h2>
        {children}
        <button onClick={onInchide}>Închide</button>
      </div>
    </div>,
    document.body
  );
}

De ce portal: un modal randat în interiorul unui card cu overflow: hidden sau transform ar fi tăiat sau poziționat greșit, iar un z-index mare nu ajută dacă un strămoș creează un context de stivuire.

Particularități:

  • evenimentele React urcă pe arborele React: un click în modal ajunge la onClick al componentei care l-a randat, chiar dacă în DOM modalul e în body. De aici stopPropagation pe conținut;
  • contextul (tema, autentificarea) funcționează normal în interiorul portalului;
  • accesibilitate: role="dialog", aria-modal, titlu legat, focus mutat în dialog și readus la închidere, închidere cu Escape, focusul păstrat în interior (focus trap) și conținutul de dedesubt inert.

Elementul nativ <dialog> cu showModal() rezolvă o mare parte din acestea (straturi superioare, Escape, fundal inert) și merită luat în calcul înainte de o soluție scrisă manual.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre arborele React și cel DOM. Detaliile de accesibilitate și elementul <dialog> arată maturitate.

93 Mid

Construiește o componentă Tabs folosind pattern-ul de componente compuse (<Tabs>, <Tabs.List>, <Tabs.Tab>, <Tabs.Panel>). Când alegi acest pattern în locul props-urilor de configurare?

Răspuns scurt: Componenta părinte ține starea comună într-un context, iar sub-componentele o citesc. Cine folosește componenta compune liber structura, ca la <select> și <option>. E potrivit când componenta are mai multe părți pe care utilizatorul vrea să le aranjeze sau personalizeze; pentru componente simple, props-urile sunt suficiente.

JSX
const TabsCtx = createContext(null);
const useTabs = () => {
  const c = useContext(TabsCtx);
  if (!c) throw new Error("Componentele Tabs trebuie folosite în <Tabs>.");
  return c;
};

function Tabs({ implicit, children }) {
  const [activ, setActiv] = useState(implicit);
  const id = useId();
  return <TabsCtx value={{ activ, setActiv, id }}>{children}</TabsCtx>;
}

Tabs.List = function List({ children }) {
  return <div role="tablist">{children}</div>;
};

Tabs.Tab = function Tab({ valoare, children }) {
  const { activ, setActiv, id } = useTabs();
  const selectat = activ === valoare;
  return (
    <button role="tab" id={`${id}-t-${valoare}`} aria-selected={selectat}
      aria-controls={`${id}-p-${valoare}`} tabIndex={selectat ? 0 : -1}
      onClick={() => setActiv(valoare)}>
      {children}
    </button>
  );
};

Tabs.Panel = function Panel({ valoare, children }) {
  const { activ, id } = useTabs();
  if (activ !== valoare) return null;
  return <div role="tabpanel" id={`${id}-p-${valoare}`} aria-labelledby={`${id}-t-${valoare}`}>{children}</div>;
};

<Tabs implicit="descriere">
  <Tabs.List>
    <Tabs.Tab valoare="descriere">Descriere</Tabs.Tab>
    <Tabs.Tab valoare="recenzii">Recenzii <Badge>12</Badge></Tabs.Tab>
  </Tabs.List>
  <Tabs.Panel valoare="descriere">...</Tabs.Panel>
  <Tabs.Panel valoare="recenzii">...</Tabs.Panel>
</Tabs>

Comparat cu <Tabs items={[{ titlu, continut }]} />: varianta cu configurare e mai scurtă, dar orice personalizare (un badge în titlu, o iconiță, panouri într-un alt loc din layout) cere props noi, iar componenta crește continuu.

Alte pattern-uri pentru reutilizarea logicii: render props (<Mouse>{pos => ...}</Mouse>) și HOC-uri (withAuth(Pagina)). Ambele au fost în mare parte înlocuite de custom hooks, dar le vei întâlni în cod existent. Pentru tab-uri complete lipsește navigarea cu săgețile, cerută de pattern-ul WAI-ARIA.

Ce urmărește intervievatorul: Verifică experiența în proiectarea API-urilor de componente. Un candidat bun discută compromisul flexibilitate versus simplitate.

94 Senior

Ce sunt Actions în React 19? Explică pe scurt useActionState, useFormStatus și useOptimistic pe un formular de adăugare a unui comentariu.

Răspuns scurt: Actions sunt funcții, posibil async, date la <form action> sau pornite în startTransition; React gestionează pending, erorile și resetarea. useActionState ține rezultatul acțiunii, useFormStatus dă starea formularului unui buton din el, useOptimistic afișează rezultatul așteptat până la confirmare.

JSX
import { useActionState, useOptimistic } from "react";
import { useFormStatus } from "react-dom";

function ButonTrimite() {
  const { pending } = useFormStatus();          // starea <form>-ului părinte
  return <button disabled={pending}>{pending ? "Se trimite..." : "Comentează"}</button>;
}

function Comentarii({ initiale, trimiteComentariu }) {
  const [comentarii, setComentarii] = useState(initiale);
  const [optimiste, adaugaOptimist] = useOptimistic(
    comentarii,
    (lista, text) => [...lista, { id: "temp", text, inAsteptare: true }]
  );

  const [stare, actiune] = useActionState(async (anterior, formData) => {
    const text = formData.get("text").trim();
    if (!text) return { eroare: "Comentariul e gol." };
    adaugaOptimist(text);
    try {
      const nou = await trimiteComentariu(text);
      setComentarii(c => [...c, nou]);
      return { eroare: null };
    } catch {
      return { eroare: "Nu am putut salva comentariul." };
    }
  }, { eroare: null });

  return (
    <>
      <ul>{optimiste.map(c => <li key={c.id} style={{ opacity: c.inAsteptare ? 0.5 : 1 }}>{c.text}</li>)}</ul>
      <form action={actiune}>
        <textarea name="text" />
        <ButonTrimite />
        {stare.eroare && <p role="alert">{stare.eroare}</p>}
      </form>
    </>
  );
}

Ce aduce modelul:

  • nu mai scrii manual isSubmitting, preventDefault și resetarea: formularele necontrolate se golesc automat după o acțiune reușită;
  • valoarea optimistă dispare automat când acțiunea se termină; dacă a eșuat și state-ul real nu s-a schimbat, interfața revine singură;
  • useFormStatus evită transmiterea lui pending prin props, dar funcționează doar în componente aflate în interiorul unui <form>;
  • în framework-uri cu Server Components, funcția poate fi o Server Function ("use server"), iar formularul funcționează și înainte de încărcarea JavaScript-ului.

Pentru formulare complexe, cu validare pe câmp în timp real, bibliotecile dedicate rămân utile; Actions acoperă bine formularele simple și medii.

Ce urmărește intervievatorul: Verifică dacă ești la zi cu React 19 și înțelegi problema pe care o rezolvă. Un senior explică și limitele, nu doar API-ul.

95 Senior

Un coleg scrie într-o aplicație Next.js (App Router) componenta de mai jos și primește o eroare la build. De ce și cum ar trebui împărțită?

JSX
// app/produse/page.jsx
import { db } from "@/lib/db";
import { useState } from "react";

export default async function Pagina() {
  const produse = await db.produs.findMany();
  const [filtru, setFiltru] = useState("");
  return (
    <>
      <input value={filtru} onChange={e => setFiltru(e.target.value)} />
      {produse.filter(p => p.nume.includes(filtru)).map(p => <p key={p.id}>{p.nume}</p>)}
    </>
  );
}

Răspuns scurt: În App Router, componentele sunt implicit Server Components: rulează pe server, pot fi async și pot citi baza de date, dar nu pot folosi state, efecte sau handler-e. Partea interactivă se mută într-o componentă cu "use client", care primește datele ca props.

React Server Components (RSC) se execută pe server (la build sau la cerere) și trimit browserului rezultatul randării, nu codul lor. Ce pot: async/await direct în componentă, acces la baza de date și la secrete, dependențe grele care nu ajung în bundle. Ce nu pot: useState, useEffect, onClick, API-uri ale browserului. Componenta de mai sus amestecă cele două lumi.

Împărțirea corectă:

JSX
// app/produse/page.jsx  (Server Component)
import { db } from "@/lib/db";
import ListaFiltrabila from "./ListaFiltrabila";

export default async function Pagina() {
  const produse = await db.produs.findMany({ select: { id: true, nume: true } });
  return <ListaFiltrabila produse={produse} />;
}
JSX
// app/produse/ListaFiltrabila.jsx
"use client";
import { useState } from "react";

export default function ListaFiltrabila({ produse }) {
  const [filtru, setFiltru] = useState("");
  return (
    <>
      <input value={filtru} onChange={e => setFiltru(e.target.value)} />
      {produse.filter(p => p.nume.includes(filtru)).map(p => <p key={p.id}>{p.nume}</p>)}
    </>
  );
}

Reguli de la granița server-client:

  • "use client" marchează un punct de intrare: componenta și tot ce importă ea ajung în bundle-ul din browser. Pune granița cât mai jos, pe bucățile interactive;
  • props trecute de la server la client trebuie să fie serializabile: date simple, obiecte, tablouri, Date, promisiuni, dar nu funcții obișnuite sau instanțe de clase;
  • selectezi doar câmpurile necesare, pentru că tot ce trimiți ca props ajunge vizibil în browser;
  • "use server" marchează Server Functions, apelabile din client (de exemplu ca action la formular), nu Server Components.

Componentele client sunt randate și ele pe server pentru HTML-ul inițial, apoi hidratate, deci „client” nu înseamnă „randat doar în browser”.

Ce urmărește intervievatorul: Verifică înțelegerea conceptuală a modelului RSC la nivel de cod. Confuzia dintre "use client" și „randat doar în browser” e foarte frecventă.

Situații practice și live coding

Exersează capitolul cu exerciții reale: Curs React online →
96 Junior

La live coding ți se cere o listă de sarcini în React (adăugare, bifare, ștergere, filtru „toate/active/terminate”) în 20 de minute. Cum procedezi?

Răspuns scurt: Clarifici cerințele în primul minut, construiești întâi varianta minimă care funcționează (adăugare și afișare), apoi adaugi pe rând bifarea, ștergerea și filtrul, testând după fiecare pas. Vorbești cu voce tare despre decizii și lași finisările (stil, persistență) pentru final, dacă rămâne timp.

Un model de răspuns structurat:

1. Clarificare (1–2 minute). Întrebi ce contează: e nevoie de persistență, de editare, de stil? Ce se întâmplă cu un text gol? Arăți că nu începi să scrii fără să înțelegi problema.

2. Modelul de date (1 minut). Spui cu voce tare: „țin o listă de { id, text, gata } și un filtru; lista filtrată o calculez, nu o stochez.”

3. Varianta minimă (5–7 minute).

JSX
function App() {
  const [sarcini, setSarcini] = useState([]);
  const [text, setText] = useState("");
  const [filtru, setFiltru] = useState("toate");

  function adauga(e) {
    e.preventDefault();
    if (!text.trim()) return;
    setSarcini(s => [...s, { id: crypto.randomUUID(), text: text.trim(), gata: false }]);
    setText("");
  }
  const vizibile = sarcini.filter(s =>
    filtru === "active" ? !s.gata : filtru === "terminate" ? s.gata : true);
  // formular + listă
}

Rulezi și verifici în browser înainte să continui.

4. Funcționalitățile, pe rând (8 minute). Bifare cu map, ștergere cu filter, butoanele de filtru. După fiecare, verifici.

5. Finisare (restul). Mesaj pentru lista goală, contor de sarcini active, eventual extragerea unei componente Sarcina, localStorage dacă e timp.

Ce urmărește intervievatorul: comunicarea, pașii mici care funcționează, imutabilitatea, cheile corecte, starea derivată. Dacă te blochezi, spui ce încerci și de ce; o soluție incompletă, dar corectă și explicată, cântărește mai mult decât una completă scrisă în tăcere și plină de bug-uri.

Ce urmărește intervievatorul: Verifică procesul de lucru sub presiune, nu doar rezultatul. Greșeala tipică e să scrii totul dintr-o dată și să rulezi abia la final.

97 Mid

În producție, monitorizarea arată eroarea „TypeError: Cannot read properties of undefined (reading 'map')” pe pagina de comenzi, dar local nu o poți reproduce. Cum procedezi?

Răspuns scurt: Găsești linia exactă din stack trace cu source maps, aduni contextul (utilizatori, browser, răspunsul API), reproduci cu acele date și repari cauza (date lipsă, altă formă a răspunsului). Apoi adaugi protecții: stare inițială corectă, validarea răspunsului, un error boundary local.

Un model de răspuns structurat:

1. Evaluarea impactului. Câți utilizatori sunt afectați și de când? Coincide cu o publicare recentă (frontend sau backend)? Dacă impactul e mare și cauza e o publicare, revenirea la versiunea anterioară e o opțiune rapidă cât timp investighez.

2. Localizarea. Uneltele de monitorizare (de exemplu Sentry) cu source maps încărcate arată fișierul, componenta și linia din codul sursă, plus breadcrumbs: ce a făcut utilizatorul înainte, ce cereri au plecat. Fără source maps, primul pas e să le configurez.

3. Ipoteze. x.map pe undefined înseamnă că o listă lipsește. Cauze frecvente:

  • componenta randează înainte să sosească datele, iar state-ul inițial e undefined în loc de [];
  • API-ul returnează altă formă pentru anumiți utilizatori ({ comenzi: null } pentru un cont fără comenzi, o eroare 200 cu alt corp, un câmp redenumit);
  • un răspuns de eroare (401, 500) e tratat ca succes pentru că lipsește verificarea res.ok;
  • date vechi din localStorage cu o structură anterioară.

4. Reproducere. Mă autentific cu un cont de test în situația descrisă sau simulez răspunsul cu MSW, local.

5. Corecția. Repar cauza, nu doar simptomul: verific res.ok, tratez explicit „fără comenzi”, validez răspunsul (de exemplu cu o schemă Zod) la granița cu API-ul. Doar optional chaining (comenzi?.map) ar ascunde problema, nu ar rezolva-o.

6. Prevenire. Un test pentru cazul găsit, un error boundary în jurul secțiunii ca o eroare locală să nu dărâme pagina, și o discuție cu echipa de backend dacă contractul API s-a schimbat.

Ce urmărește intervievatorul: Verifică metoda de depanare în producție și seriozitatea față de cauza reală. Răspunsul slab este „pun ?. și gata”.

Eroarea, în practică:Cannot read properties of null (reading 'nume')

98 Mid

Faci code review pe un pull request cu o funcționalitate nouă în React. La ce te uiți, în ce ordine, și cum formulezi comentariile?

Răspuns scurt: Începi cu scopul și comportamentul (face ce trebuie, cazurile limită, stările de eroare), apoi corectitudinea specifică React (chei, efecte, dependențe, mutații, stare derivată), apoi structura, accesibilitatea, testele și performanța. Comentariile sunt concrete, explică motivul și separă problemele blocante de sugestii.

Un model de răspuns structurat:

1. Context. Citesc descrierea PR-ului și tichetul. Dacă e o interfață, rulez ramura sau mă uit la capturi. Fără context, review-ul devine doar despre stil.

2. Comportament. Face ce cere tichetul? Ce se întâmplă cu lista goală, cu eroarea de la server, cu dublul click, cu un text foarte lung, pe mobil?

3. Corectitudine React, unde apar cele mai multe bug-uri:

  • chei stabile în liste, nu indexul sau valori aleatoare;
  • efecte cu dependențe complete și curățare; efecte care ar putea fi calcule sau handler-e;
  • mutații de state sau props (push, sort, atribuiri);
  • stare duplicată sau derivată ținută în state;
  • race conditions la cereri;
  • componente definite în interiorul altor componente.

4. Structură. Componente cu o singură responsabilitate, logică reutilizabilă în hook-uri, nume clare, fără cod duplicat cu ce există deja în proiect.

5. Accesibilitate și UX. Butoane reale în loc de div-uri clicabile, etichete la câmpuri, focus gestionat la modale, mesaje de eroare anunțate.

6. Teste. Acoperă comportamentul nou și cazurile de eroare? Testele interoghează după rol, nu după clase?

7. Performanță. Doar unde e cazul: liste mari, contexte cu valori noi la fiecare randare, biblioteci mari importate integral.

Formularea comentariilor: concret și cu motiv („sort modifică props-ul primit, ceea ce schimbă ordinea și în sidebar; propun toSorted”), cu prefixe clare pentru ce e blocant și ce e sugestie, întrebări în loc de verdicte când nu sunt sigur, și aprecieri pentru soluțiile bune. Regulile de stil le las linterului și formatter-ului, nu oamenilor.

Ce urmărește intervievatorul: Verifică dacă știi ce să cauți specific în codul React și cum colaborezi. Intervievatorul urmărește și tonul, nu doar lista de verificări.

99 Senior

Utilizatorii raportează că tastarea în câmpul de căutare al unui dashboard „se blochează” câteva sute de milisecunde la fiecare literă. Descrie cum ai investiga și rezolva problema.

Răspuns scurt: Reproduci în build de producție cu CPU încetinit, înregistrezi cu React Profiler și Chrome Performance ce se randează la fiecare tastă și cât durează, identifici cauza (state prea sus, context, listă mare, calcul greu), aplici o corecție și măsori din nou.

Un model de răspuns structurat:

1. Reproducere. Construiesc aplicația pentru producție local și activez CPU throttling (4x) în Chrome, ca să simulez un laptop sau telefon obișnuit. Verific dacă problema apare cu datele reale (câte rânduri are dashboard-ul în contul utilizatorului care a raportat).

2. Măsurare.

  • React DevTools Profiler: înregistrez câteva taste. Văd ce componente se randează la fiecare commit și de ce („Why did this render?”). Dacă se randează tot dashboard-ul, cauza e structurală;
  • Chrome Performance: văd dacă timpul e în JavaScript (randare, calcule), în layout sau în desenare. Long tasks de sute de milisecunde confirmă blocarea.

3. Cauze tipice și corecții.

  • state-ul căutării e în componenta rădăcină: îl mut lângă input sau separ inputul, ca doar ce depinde de text să se randeze;
  • valoarea căutării e într-un context citit de multe componente: separ contextul sau folosesc un store cu selectoare;
  • filtrarea a zeci de mii de elemente la fiecare tastă: useDeferredValue pentru listă (plus memo pe ea) sau mut filtrarea pe server cu debounce;
  • prea multe noduri DOM: virtualizare;
  • grafice care se redesenează la fiecare tastă: memo cu props stabile sau date memorizate.

4. Verificare. După fiecare schimbare, măsor din nou aceeași interacțiune și compar. Păstrez doar optimizările care au efect.

5. Prevenire. Adaug un test de performanță sau un buget (de exemplu prag pentru INP în monitorizarea reală) și explic echipei cauza, ca tiparul să nu reapară.

Ce evit: să adaug useMemo și memo peste tot fără măsurare.

Ce urmărește intervievatorul: Verifică metoda sistematică de depanare a performanței. Un senior măsoară întâi și explică relația dintre cauză și corecție.

100 Senior

Primești în grijă o componentă PaginaComanda.jsx de 800 de linii, cu 15 useState, 6 useEffect și fără teste. Cum o refactorizezi fără să strici funcționalitatea?

Răspuns scurt: Întâi o protejezi cu teste de comportament la nivelul paginii, apoi refactorizezi în pași mici, fiecare într-un PR separat: extragi componente de prezentare, grupezi state-ul legat în reduceri sau hook-uri de domeniu, elimini efectele inutile și stările derivate, muți apelurile API într-un strat de servicii.

Un model de răspuns structurat:

1. Înțelegere. Citesc componenta și notez responsabilitățile: încărcarea comenzii, formularul de adresă, calculul totalului, plata, notificările. Identific ce efecte există și de ce. Vorbesc cu cine a scris-o sau cu produsul, pentru comportamentele neclare.

2. Plasă de siguranță. Scriu teste cu React Testing Library și MSW pentru fluxurile principale: comanda se încarcă, adresa se poate modifica, totalul e corect, plata reușește și eșuează. Testele nu depind de structura internă, deci rămân valabile pe tot parcursul refactorizării.

3. Pași mici, fiecare verificat.

  • extrag componente de prezentare fără state (RezumatComanda, ListaProduse), primite prin props;
  • elimin starea derivată (totaluri, „formular valid”) și efectele care o sincronizau;
  • grupez state-ul legat: formularul de adresă devine un reducer sau un hook useFormularAdresa;
  • mut cererile într-un modul de servicii și în hook-uri de domeniu (useComanda(id)), eventual cu TanStack Query;
  • pentru fiecare efect rămas, verific dependențele și curățarea.

4. Livrare. PR-uri mici, ușor de revizuit, fiecare cu testele trecute și verificat manual în mediul de test. Nu amestec refactorizarea cu funcționalități noi în același PR, ca un bug să poată fi legat clar de o schimbare.

5. Rezultat. O pagină-container subțire care compune hook-uri și componente, fiecare cu o singură responsabilitate și testabilă separat.

Ce evit: rescrierea completă dintr-o dată. Pierde comportamente nedocumentate pe care utilizatorii se bazează și blochează echipa săptămâni întregi.

Ce urmărește intervievatorul: Verifică maturitatea în lucrul cu cod moștenit și gestionarea riscului. Un senior insistă pe teste înainte de modificări și pe pași mici.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de React, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață React scriind cod, nu doar citind

Curs React: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.