...
Pregătire interviuri

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

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

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

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

La un interviu în care se verifică PHP, întrebările merg de obicei pe trei direcții: cât de bine cunoști limbajul în sine (tipuri, comparații, array-uri, OOP), dacă știi să scrii cod web corect și sigur (formulare, sesiuni, PDO, escaparea datelor) și dacă ești la zi cu PHP 8.x. Pe lângă teorie, apar aproape mereu fragmente de cod de tipul „ce afișează” sau „unde e bug-ul”, un exercițiu de live coding și, uneori, o temă de casă: un mic CRUD, un import de date sau un endpoint JSON.

Pentru un post de junior se verifică fundamentele și capcanele clasice ale limbajului: == față de ===, stringurile cu diacritice, cheile array-urilor, validarea inputului, password_hash și prepared statements. La mid, întrebările trec la design și la ce se întâmplă în producție: tipuri și varianță, obiecte imutabile, erori fatale, sesiuni blocate, volume mari de date, analiză statică. Întrebările de senior verifică dacă înțelegi ce se întâmplă în interiorul motorului și dacă poți conduce o echipă printr-o migrare.

Întrebările sunt grupate pe teme și ordonate de la junior la senior. Citește întâi răspunsul scurt și încearcă să-l explici cu voce tare, apoi compară cu răspunsul detaliat. Rulează exemplele de cod pe PHP 8.4 sau 8.5 și schimbă-le până înțelegi de ce se comportă așa: la interviu contează mai mult explicația decât rezultatul memorat. Întrebările despre Laravel, Symfony, WordPress și arhitectura aplicațiilor sunt pe pagina dedicată meseriei de PHP Web Developer.

Tipuri, conversii și comparații

1 Junior

Ce afișează codul următor în PHP 8 și de ce s-ar fi schimbat rezultatul pe PHP 7?

PHP
var_dump(0 == "a", "1" == "01", "10" == "1e1", 100 == "1e2", "abc" == 0);

Răspuns scurt: În PHP 8 afișează false, true, true, true, false. Pe PHP 7, 0 == "a" și "abc" == 0 dădeau true, pentru că stringul nenumeric era convertit la 0.

Din PHP 8.0 (RFC „Saner string to number comparisons”) regula este: dacă un operand e număr și celălalt e un numeric string (un string care arată ca un număr, de exemplu "42", "1e2", " 7"), comparația se face numeric. Dacă stringul nu e numeric, numărul este convertit în string și se compară ca stringuri.

  • 0 == "a": "a" nu e numeric, deci se compară "0" cu "a", rezultă false.
  • "1" == "01": ambele sunt stringuri numerice, deci PHP le compară ca numere, 1 cu 1: true.
  • "10" == "1e1": 1e1 este notație științifică pentru 10: true.
  • 100 == "1e2": tot numeric: true.
  • "abc" == 0: ca la primul caz, false.

Pe PHP 7, orice string nenumeric comparat cu un întreg devenea 0, așa că "abc" == 0 era true. Asta producea bug-uri reale în validări de tipul if ($input == 0). Ce nu s-a schimbat: două stringuri numerice tot se compară numeric, deci "1" == "01" rămâne true chiar și în PHP 8.4.

Concluzia practică: în cod nou folosești === peste tot unde nu ai un motiv clar pentru comparația lejeră, iar când migrezi un proiect de pe PHP 7 cauți condițiile cu == 0 sau == '', pentru că și-au schimbat comportamentul.

Ce urmărește intervievatorul: Verifică dacă știi regulile exacte ale comparației lejere și schimbarea din PHP 8. Mulți candidați răspund după comportamentul vechi din PHP 7 sau nu știu că două stringuri numerice se compară ca numere.

2 Junior

Ce valori sunt considerate „false” (falsy) în PHP? Ce afișează if ("0"), if ("0.0") și if ([])?

Răspuns scurt: Falsy sunt: false, 0, 0.0, -0.0, "", "0", [] și null. Deci if ("0") și if ([]) nu intră pe ramură, dar if ("0.0") intră, pentru că "0.0" e un string nevid diferit de "0".

Când PHP evaluează o valoare într-un context boolean (if, while, !, &&), o convertește la bool după o listă fixă. Sunt false doar:

  • false și null
  • întregul 0 și float-ul 0.0 (inclusiv -0.0)
  • stringul gol "" și stringul "0"
  • array-ul gol []

Orice altceva e true: "0.0", " " (un spațiu), "false", [0], un obiect (chiar și unul gol, de tip stdClass), -1, NAN.

Capcana clasică apare la datele venite din formulare sau din baza de date, unde totul e string:

PHP
$qty = $_POST['qty'] ?? '';
if (!$qty) {
    echo 'Cantitate lipsă'; // se afișează și pentru "0"
}

Dacă utilizatorul a introdus 0 cu intenție, codul îl tratează ca valoare lipsă. Soluția este să compari explicit ce vrei să verifici: $qty === '' pentru câmp gol, apoi o validare numerică separată. La fel, empty($x) folosește exact aceeași listă de valori falsy, deci empty("0") este true.

Altă sursă de bug-uri: "0.0" și " " sunt true, deci un if ($price) nu te protejează de prețuri „zero” scrise cu zecimale. Regula sănătoasă: verificări booleene implicite doar pe valori care sunt deja bool.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă știi lista exactă și dacă recunoști bug-ul cu "0" din formulare. Greșeala tipică este să crezi că "0.0" sau " " sunt false.

3 Junior

Ce rezultat și ce mesaje produce fiecare linie în PHP 8?

PHP
var_dump("5" + "5");
var_dump("5" . "5");
var_dump("5 mere" + 1);
var_dump("mere" + 1);

Răspuns scurt: Prima linie dă int(10), a doua string(2) "55". A treia dă int(6) cu un Warning „A non-numeric value encountered”, iar a patra aruncă TypeError: Unsupported operand types: string + int.

PHP are operatori separați pentru adunare (+) și concatenare (.), așa că tipul rezultatului depinde de operator, nu de operanzi. "5" + "5" convertește ambele stringuri numerice la întregi și dă 10. "5" . "5" lipește textele și dă "55".

Pentru cazurile 3 și 4 contează clasificarea stringurilor introdusă în PHP 8.0 prin RFC-ul „Saner numeric strings”:

  • numeric: "5", " 5", "5 ", "1.5e3" (spațiile la început și la sfârșit sunt permise din PHP 8)
  • leading-numeric: începe cu un număr și continuă cu altceva, de exemplu "5 mere". Se folosește partea numerică (5), dar primești E_WARNING.
  • non-numeric: "mere". În operații aritmetice aruncă TypeError.

Pe PHP 7, "mere" + 1 dădea doar un warning și rezultatul 1, ceea ce ascundea bug-uri. Acum eroarea oprește execuția dacă nu e prinsă.

În practică, înainte de calcule convertești explicit și validezi: filter_var($v, FILTER_VALIDATE_INT) sau is_numeric($v), apoi (int) ori (float). Așa nu depinzi de conversiile automate și nu ai warning-uri în log.

Ce urmărește intervievatorul: Verifică diferența dintre + și . și cunoașterea noii clasificări a stringurilor numerice din PHP 8. Candidații spun des că a patra linie dă 1, ca pe PHP 7.

Eroarea, în practică:Unsupported operand types: string + intA non-numeric value encountered

4 Junior

De ce 0.1 + 0.2 == 0.3 este false în PHP? Ce se întâmplă cu PHP_INT_MAX + 1? Cum lucrezi corect cu bani?

Răspuns scurt: Float-urile sunt stocate binar (IEEE 754) și 0.1 nu are reprezentare exactă, deci suma e 0.30000000000000004. PHP_INT_MAX + 1 nu dă eroare, ci devine float. Pentru bani folosești întregi (bani, cenți) sau BCMath.

PHP folosește pentru float formatul IEEE 754 cu dublă precizie. Multe fracții zecimale (0.1, 0.2) sunt periodice în baza 2, așa că se stochează o aproximare. Rezultatul adunării diferă de 0.3 în ultimele cifre, iar == compară exact.

Variante corecte:

PHP
$eq = abs((0.1 + 0.2) - 0.3) < PHP_FLOAT_EPSILON; // comparație cu toleranță
$total = 1999 + 2999;                             // bani ca întregi (bani/cenți)
echo bcadd('0.1', '0.2', 2);                      // "0.30", BCMath

Pentru int, pe sisteme pe 64 de biți PHP_INT_MAX este 9223372036854775807. Dacă îl depășești, PHP nu face overflow ca în C, ci transformă rezultatul în float, cu pierdere de precizie: var_dump(PHP_INT_MAX + 1) afișează float(9.223372036854776E+18). Un ID mare dintr-un API extern poate fi corupt astfel, motiv pentru care json_decode are opțiunea JSON_BIGINT_AS_STRING.

Alte detalii utile: intdiv(7, 2) dă 3 (împărțire întreagă), 7 / 2 dă 3.5, iar % lucrează pe întregi și păstrează semnul deîmpărțitului (-7 % 3 este -1). Pentru rest pe float folosești fmod(). Pentru afișare, rotunjești cu round($x, 2) sau number_format, dar rotunjirea nu repară calculele intermediare.

Ce urmărește intervievatorul: Se verifică înțelegerea reprezentării numerelor și dacă știi de ce nu ții prețuri în float. Mulți nu știu că depășirea lui int produce tăcut un float.

5 Junior

Ce afișează fiecare conversie explicită?

PHP
var_dump((int) "12abc", (int) "1e3", (int) 12.9, (int) "0x1A");
var_dump((bool) "0.0", (string) false, (array) null);

Răspuns scurt: 12, 1000, 12, 0, apoi true, "" și []. Conversia la int citește partea numerică de la început, trunchiază zecimalele și nu înțelege prefixul hexazecimal în stringuri.

Cast-urile (int), (float), (string), (bool), (array) nu aruncă niciodată erori, ci aplică reguli fixe:

  • (int) "12abc": citește cifrele de la început și se oprește la primul caracter invalid, deci 12.
  • (int) "1e3": din PHP 7.1 notația științifică e recunoscută, deci 1000.
  • (int) 12.9: trunchiază spre zero, nu rotunjește, deci 12. Pentru rotunjire folosești (int) round(12.9).
  • (int) "0x1A": prefixul 0x nu e interpretat în stringuri, deci 0. Pentru baze diferite folosești intval("1A", 16) sau hexdec("1A").
  • (bool) "0.0": doar "" și "0" sunt stringuri false, deci true.
  • (string) false: stringul gol "". (string) true este "1", motiv pentru care echo false; nu afișează nimic.
  • (array) null: array gol. (array) "x" dă ["x"], iar (array) $obiect dă proprietățile ca array (cele private și protected primesc chei cu caractere speciale).

Fiindcă cast-ul „reușește” mereu, nu e o validare: (int) "abc" dă 0 fără niciun semnal. Pentru date de la utilizator validezi întâi cu filter_var($v, FILTER_VALIDATE_INT), care întoarce false la input invalid, apoi folosești valoarea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că un cast nu validează și cunoști cazurile limită. Greșeala tipică: a crede că (int) 12.9 rotunjește la 13 sau că (int) "0x1A" dă 26.

6 Junior

Ce face operatorul <=> (spaceship)? Ce returnează pentru numere, stringuri și array-uri?

Răspuns scurt: $a <=> $b întoarce -1, 0 sau 1 după cum $a e mai mic, egal sau mai mare decât $b. Folosește aceleași reguli ca <, == și >, inclusiv la stringuri numerice și array-uri.

Operatorul a apărut în PHP 7.0 și este făcut în primul rând pentru funcțiile de sortare, care așteaptă un întreg negativ, zero sau pozitiv:

PHP
usort($produse, fn($a, $b) => $a['pret'] <=> $b['pret']);

Reguli de comparare:

  • numere: comparație numerică obișnuită, 2 <=> 10 dă -1
  • două stringuri numerice: tot numeric, deci "10" <=> "9" dă 1 (nu -1 ca la o comparație alfabetică)
  • stringuri nenumerice: comparație byte cu byte, deci "abc" <=> "abd" dă -1, iar literele mari vin înaintea celor mici ("Z" <=> "a" dă -1)
  • array-uri: întâi după numărul de elemente ([1, 2] <=> [1, 2, 3] dă -1), apoi element cu element pe aceleași chei ([1, 2, 3] <=> [1, 2, 4] dă -1)

Pentru sortare descrescătoare inversezi operanzii ($b <=> $a). Pentru mai multe criterii poți compara array-uri: [$a['nota'], $a['nume']] <=> [$b['nota'], $b['nume']].

Capcana: pe stringuri cu diacritice, comparația e pe bytes, deci „Ștefan” ajunge după „Zoe”. Pentru ordine alfabetică corectă în română folosești Collator din extensia intl.

Ce urmărește intervievatorul: Verifică dacă știi folosirea operatorului în sortări și cum se comportă pe tipuri diferite. Candidații uită de comparația numerică a stringurilor ca "10" și "9".

Eroarea, în practică:usort(): Returning bool from comparison function

7 Junior

Care este diferența dintre define() și const în PHP?

Răspuns scurt: const e evaluat la compilare și poate fi folosit în clase și la nivelul namespace-ului, dar nu în interiorul unui if sau al unei funcții. define() e o funcție apelată la runtime, deci merge în condiții și cu nume calculate.

Ambele creează constante, valori care nu se mai pot schimba după definire, dar diferă ca mecanism:

PHP
const VERSION = '2.1';                  // la compilare
define('ENV', getenv('APP_ENV') ?: 'prod'); // la runtime

if (!defined('DEBUG')) {
    define('DEBUG', false);             // const nu e permis aici
}

class Order {
    const STATUS_NEW = 'new';           // în clasă merge doar const
}

Diferențe concrete:

  • Locul: const se poate folosi la nivelul fișierului, al namespace-ului sau în clase, interfețe și enum-uri. define() nu definește constante de clasă.
  • Momentul: const e procesat la compilare, deci nu poate sta într-un bloc if, function sau try. define() e cod obișnuit.
  • Nume dinamice: define('LIMIT_' . $tip, 10) e posibil, cu const nu.
  • Namespace: const X într-un namespace App; creează App\X. define('X', ...) creează constanta globală X, dacă nu scrii explicit define('App\X', ...).
  • Valori: ambele acceptă din PHP 7 array-uri și expresii constante. const nu acceptă apeluri de funcții (const A = time(); e eroare), define() da.

În cod modern, constantele legate de un concept stau în clase sau în enum-uri, nu globale.

Ce urmărește intervievatorul: Se verifică dacă știi diferența compilare/runtime și unde poate apărea fiecare. Mulți nu știu că const nu merge într-un if și că define nu ține cont de namespace.

Eroarea, în practică:Undefined constant "PRET"Constant expression contains invalid operations

8 Junior

Ce afișează codul și de ce?

PHP
$x = true and false;
var_dump($x);
$y = true && false;
var_dump($y);

Răspuns scurt: Afișează bool(true) și apoi bool(false). Operatorul and are prioritate mai mică decât =, deci prima linie se execută ca ($x = true) and false.

PHP are două seturi de operatori logici: && / || și and / or (plus xor). Fac același lucru logic, dar au precedență diferită. && și || sunt mai prioritari decât atribuirea, iar and și or sunt mai puțin prioritari decât ea.

Prima linie se evaluează așa:

PHP
($x = true) and false; // $x primește true, rezultatul expresiei se aruncă

A doua linie este $y = (true && false), deci $y este false.

Singurul loc unde or este folosit intenționat e idiomul vechi:

PHP
$f = fopen('date.txt', 'r') or die('Nu pot deschide fișierul');

Aici precedența mică e exact ce vrei: întâi atribuirea, apoi, dacă rezultatul e falsy, die(). Totuși, în cod modern preferi o verificare explicită și o excepție.

Pentru a evita surprizele: folosești doar && și ||, iar când amesteci operatori pui paranteze. Unelte precum PHP-CS-Fixer au reguli care înlocuiesc automat and/or cu &&/||. Aceeași atenție trebuie la ! combinat cu instanceof sau la ternare înlănțuite, care din PHP 8 cer paranteze explicite.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă înțelegi precedența operatorilor, nu doar tabelele de adevăr. Majoritatea candidaților răspund false la prima linie.

9 Junior

Care este diferența dintre operatorul nullsafe ?-> și ??? Ce afișează $user?->getAddress()?->city ?? 'necunoscut' dacă $user este null?

Răspuns scurt: ?-> (PHP 8.0) oprește lanțul de apeluri și întoarce null dacă obiectul din stânga e null. ?? întoarce valoarea din dreapta când stânga e null sau nedefinită. Expresia afișează necunoscut.

Înainte de PHP 8 scriai verificări în cascadă:

PHP
$city = null;
if ($user !== null) {
    $address = $user->getAddress();
    if ($address !== null) {
        $city = $address->city;
    }
}

Cu operatorul nullsafe devine $city = $user?->getAddress()?->city;. Dacă $user e null, restul lanțului nu se mai evaluează (short-circuit), deci getAddress() nu e apelată, iar rezultatul e null. Combinat cu ?? primești o valoare implicită.

Diferențe importante:

  • ?-> reacționează doar la null. Dacă $user e false sau un array, primești eroare ca la -> normal.
  • ?? verifică și dacă variabila sau cheia există, fără warning: $_GET['page'] ?? 1. ?-> nu suprimă warning-ul pentru o variabilă nedefinită.
  • ?-> nu se poate folosi la scriere: $user?->name = 'Ana'; e eroare de compilare.
  • ??= atribuie doar dacă valoarea e null: $config['timeout'] ??= 30;.

Nu abuza de ?->: dacă un utilizator logat trebuie să aibă mereu adresă, un null acolo e un bug. Ascunderea lui cu ?-> mută eroarea mai departe, unde e mai greu de găsit.

Ce urmărește intervievatorul: Verifică dacă știi sintaxa modernă și limitele ei. Greșeala frecventă e să crezi că ?-> tratează orice valoare falsy sau că merge la atribuire.

Eroarea, în practică:Undefined array key "email"Call to a member function on null

10 Junior

Toate valorile din $_POST sunt stringuri. Cum verifici corect că un câmp conține un număr întreg pozitiv? Ce probleme au is_numeric() și ctype_digit()?

Răspuns scurt: Cel mai sigur folosești filter_var($v, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1]]), care întoarce întregul sau false. is_numeric() acceptă și "1e3", " 5" sau "-2.5", iar ctype_digit() respinge numerele negative și dă erori la alte tipuri.

Datele din formulare, query string și cookie-uri ajung în PHP mereu ca stringuri (sau array-uri de stringuri). Trebuie să decizi explicit ce format accepți.

PHP
$qty = filter_var($_POST['qty'] ?? '', FILTER_VALIDATE_INT, [
    'options' => ['min_range' => 1, 'max_range' => 1000],
]);
if ($qty === false) {
    $errors['qty'] = 'Introdu o cantitate între 1 și 1000.';
}

Ce face fiecare variantă:

  • is_numeric() răspunde la întrebarea „ar merge în calcul?”. Acceptă "1e3", "0.5", "-7", " 42" și, din PHP 8, "42 ". E bun pentru „număr oarecare”, nu pentru „întreg pozitiv”.
  • ctype_digit("123") e true doar dacă toate caracterele sunt cifre. Respinge "-5" și "+5", iar ctype_digit("") e false. Pe argumente non-string (de exemplu un int) comportamentul e ciudat și e deprecated din PHP 8.1.
  • filter_var cu FILTER_VALIDATE_INT acceptă spații la margini, respinge zerourile la început ("042" dă false) și verifică intervalul. Întoarce direct int.
  • (int) $v nu validează, transformă "abc" în 0.

Atenție la verificarea rezultatului: folosești === false, pentru că 0 poate fi o valoare validă când min_range e 0.

Ce urmărește intervievatorul: Intervievatorul vede dacă știi că inputul e mereu text și dacă alegi funcția potrivită pentru regula de business. Mulți folosesc is_numeric și acceptă fără să vrea "1e3" sau zecimale.

Eroarea, în practică:Argument #1 must be of type int, string givenCannot assign string to property of type float

11 Mid

Unde e bug-ul?

PHP
$roles = ['admin', 'editor'];
$pos = array_search($_GET['role'], $roles);
if ($pos) {
    echo "Rol valid";
}
var_dump(in_array(null, [0, 1]), in_array("1e1", ["10"]));

Răspuns scurt: array_search întoarce 0 pentru 'admin', iar 0 e falsy, deci adminul e respins. Trebuie $pos !== false. Ultima linie afișează true de două ori, pentru că in_array compară lejer dacă nu-i dai true ca al treilea argument.

Sunt două capcane diferite.

1. Poziția 0 e falsy. array_search întoarce cheia găsită sau false. Pentru primul element cheia e 0, iar if (0) nu intră pe ramură. Varianta corectă:

PHP
$pos = array_search($_GET['role'], $roles, true);
if ($pos !== false) {
    echo "Rol valid";
}

Aceeași problemă există la strpos, care întoarce 0 când textul căutat e la început.

2. Comparația lejeră. in_array și array_search folosesc implicit ==. De aici:

  • in_array(null, [0, 1]) e true, fiindcă null == 0
  • in_array("1e1", ["10"]) e true, fiindcă ambele sunt stringuri numerice egale ca valoare
  • in_array("abc", [0]) era true pe PHP 7 și e false pe PHP 8

Cu al treilea parametru strict = true se folosește ===, iar rezultatele devin previzibile. Pentru liste de valori permise (roluri, statusuri, coloane de sortare) folosești întotdeauna modul strict sau, mai bine, un enum cu tryFrom().

Bonus de performanță: in_array e o căutare liniară. Dacă verifici des aceeași listă mare, construiești un array cu valorile ca chei și folosești isset($permise[$rol]), care e o căutare în tabelă hash.

Ce urmărește intervievatorul: Verifică două lucruri: confuzia între 0 și false și comparația lejeră din funcțiile de căutare. Este un bug foarte frecvent în cod real, inclusiv în verificări de permisiuni.

12 Mid

Ce face exact declare(strict_types=1)? Dacă fișierul A are strict types și apelează o funcție definită în fișierul B fără strict types, ce mod se aplică?

Răspuns scurt: Activează verificarea strictă a tipurilor scalare pentru apelurile făcute din fișierul respectiv: "5" nu mai e convertit la int, ci aruncă TypeError. Contează fișierul care face apelul, deci în exemplu se aplică modul strict, al lui A.

PHP are două moduri pentru tipurile scalare (int, float, string, bool) declarate pe parametri și pe return:

  • coercive (implicit): function f(int $x) apelată cu "5" primește 5. Cu "5 mere" aruncă TypeError. Cu 5.7, din PHP 8.1 primești un Deprecated („Implicit conversion from float to int loses precision”), iar valoarea devine 5.
  • strict: valoarea trebuie să aibă exact tipul cerut. Singura excepție permisă este int acolo unde se cere float.

Directiva e per fișier și trebuie să fie prima instrucțiune. Pentru parametri, contează fișierul din care se face apelul, nu cel în care e definită funcția:

PHP
// B.php, fără strict_types
function dublu(int $x): int { return $x * 2; }

// A.php
declare(strict_types=1);
require 'B.php';
dublu("5"); // TypeError, apelul e din A

Pentru valorile de return, contează fișierul în care e definită funcția. Asta e logic: autorul unei biblioteci decide ce returnează, iar cel care o folosește decide cât de strict o apelează.

Directiva afectează și funcțiile interne: strlen(123) aruncă TypeError în mod strict. Nu afectează operatorii ("5" + 1 merge în continuare) și nici proprietățile tipizate atribuite din alt fișier, unde contează tot fișierul care face atribuirea.

Ce urmărește intervievatorul: Mulți candidați spun ce face directiva, dar puțini știu că e per fișier și că decide apelantul. Intervievatorul verifică înțelegerea reală, utilă când integrezi biblioteci.

Eroarea, în practică:Argument #1 must be of type int, string givenstrict_types declaration must be first statement

13 Mid

Explică tipurile din PHP 8.x: union, intersection, nullable, mixed, void, never și DNF types. Dă câte un exemplu unde le-ai folosi.

Răspuns scurt: Union (int|string, 8.0) acceptă oricare tip, intersection (A&B, 8.1) cere toate interfețele, ?T e prescurtarea pentru T|null. mixed acceptă orice, void nu returnează nimic, never nu se mai întoarce deloc, iar DNF (8.2) combină: (A&B)|null.

Sistemul de tipuri a crescut mult în versiunile 8:

PHP
function findUser(int|string $id): ?User { /* ... */ }        // union + nullable
function save(Countable&Traversable $items): void { /* ... */ } // intersection
function fail(string $msg): never { throw new DomainException($msg); }
function cache(string $key, mixed $value): void { /* ... */ }
function handle((Countable&ArrayAccess)|null $x): void { /* ... */ } // DNF, 8.2
  • Union types (8.0): parametrul poate fi oricare dintre tipuri. Util când o funcție primește ID numeric sau slug.
  • Nullable ?User: echivalent cu User|null. Nu se poate combina sintaxa ? cu union, scrii int|string|null.
  • Intersection types (8.1): obiectul trebuie să implementeze toate interfețele, de exemplu o colecție numărabilă și iterabilă. Funcționează doar cu clase și interfețe.
  • DNF types (8.2, Disjunctive Normal Form): uniuni de intersecții, cu paranteze.
  • mixed (8.0): orice valoare, inclusiv null. E explicit „nu știu tipul”, mai onest decât lipsa declarației.
  • void: funcția nu întoarce valoare. return; e permis, return null; nu.
  • never (8.1): funcția fie aruncă excepție, fie oprește scriptul (exit). Analizatoarele statice știu că după apel codul nu mai continuă.
  • Din 8.2, null, false și true pot fi tipuri de sine stătătoare.

Folosite bine, aceste tipuri fac multe validări manuale inutile și ajută PHPStan sau IDE-ul să găsească bug-uri înainte de rulare.

Ce urmărește intervievatorul: Se verifică dacă ești la zi cu limbajul și dacă știi în ce versiune a apărut fiecare tip. Greșeala comună e confuzia între void și never sau între union și intersection.

Eroarea, în practică:Return value must be of type float, none returnedA void function must not return a value

14 Mid

Ce afișează codul? Explică de ce array-ul și obiectul se comportă diferit.

PHP
function modify(array $a, stdClass $o) {
    $a[] = 4;
    $o->n = 99;
    $o = new stdClass;
    $o->n = 1;
}
$arr = [1, 2, 3];
$obj = new stdClass;
$obj->n = 0;
modify($arr, $obj);
echo count($arr), " ", $obj->n;

Răspuns scurt: Afișează 3 99. Array-ul e transmis prin valoare, deci modificarea rămâne în funcție. Obiectul e transmis ca handle (identificator): $o->n = 99 modifică obiectul original, iar $o = new stdClass schimbă doar variabila locală.

În PHP toate argumentele se transmit implicit prin valoare. Diferența vine din ce anume este „valoarea”:

  • Pentru un array, valoarea e array-ul întreg. Funcția lucrează pe o copie, deci $a[] = 4 nu afectează $arr. Copia nu se face imediat: PHP folosește copy-on-write, adică ambele variabile partajează aceeași zonă de memorie până când una dintre ele e modificată. Abia atunci se duplică. Transmiterea unui array mare fără să-l modifici e deci ieftină.
  • Pentru un obiect, valoarea e un handle către obiect. Variabilele $obj și $o indică același obiect, așa că $o->n = 99 se vede în afară. Când scrii $o = new stdClass, nu modifici obiectul, ci faci variabila locală să indice alt obiect. $obj rămâne legat de primul.

De aceea se spune incorect că „obiectele sunt transmise prin referință”. O referință adevărată (&$o) ar fi făcut ca și reatribuirea să se vadă în afară, iar rezultatul ar fi fost 3 1.

Consecințe practice: dacă vrei ca o funcție să nu poată modifica obiectul primit, folosești obiecte imutabile (proprietăți readonly) sau faci clone. Iar pentru array-uri mari nu ai nevoie de & doar pentru performanță, copy-on-write rezolvă deja asta.

Ce urmărește intervievatorul: Intervievatorul verifică modelul mental despre valori, handle-uri și referințe. Răspunsul greșit tipic este „obiectele se transmit prin referință”, de unde ar rezulta 3 1.

15 Senior

Cum stochează PHP intern valorile? Explică zval, reference counting, copy-on-write și când intervine garbage collector-ul.

Răspuns scurt: Fiecare valoare e un zval, cu tipul și valoarea. Stringurile, array-urile și obiectele au un contor de referințe; memoria se eliberează când contorul ajunge la 0. Garbage collector-ul de cicluri intervine doar pentru structuri care se referă circular.

În Zend Engine (PHP 7 și 8), o variabilă conține un zval: o structură mică, cu tipul și valoarea. Tipurile simple (int, float, bool, null) sunt stocate direct în zval și se copiază la fiecare atribuire, ceea ce e ieftin. Tipurile complexe (string, array, obiect) sunt alocate separat și au un refcount, numărul de variabile care le folosesc.

PHP
$a = str_repeat('x', 1_000_000); // refcount 1
$b = $a;                          // refcount 2, nicio copiere
$b .= 'y';                        // abia acum se copiază (copy-on-write)
unset($a);                        // refcount scade, memoria se eliberează la 0

Pentru array-uri, copy-on-write înseamnă că transmiterea către funcții și atribuirea sunt gratuite până la prima scriere. Folosirea inutilă a referințelor (&) poate chiar strica optimizarea, pentru că forțează separarea valorii.

Refcount-ul nu rezolvă ciclurile: dacă $a->child = $b și $b->parent = $a, iar apoi faci unset pe ambele, contoarele rămân la 1. Pentru asta există un garbage collector de cicluri, care pornește când bufferul de „rădăcini posibile” se umple (10.000 de intrări implicit). Îl poți forța cu gc_collect_cycles() și controla cu gc_enable().

Contează practic în scripturi lungi: workeri de coadă, importuri mari, aplicații pe RoadRunner sau Swoole. Acolo urmărești memory_get_usage(), eviți ciclurile inutile și, la nevoie, folosești WeakReference sau WeakMap pentru cache-uri care nu trebuie să țină obiectele în viață.

Ce urmărește intervievatorul: Întrebare pentru senior: arată dacă înțelegi costul real al operațiilor și poți depana scurgeri de memorie. Greșeala tipică e credința că $b = $a copiază imediat un array mare.

Stringuri, regex, JSON și date

16 Junior

Ce afișează strlen("Ștefan") și mb_strlen("Ștefan")? Ce se întâmplă cu strtoupper("ștefan") în PHP 8.2+?

Răspuns scurt: strlen dă 7, pentru că „Ș” ocupă 2 bytes în UTF-8, iar mb_strlen dă 6 caractere. strtoupper("ștefan") dă șTEFAN: din PHP 8.2 funcția lucrează doar pe litere ASCII. Pentru diacritice folosești mb_strtoupper.

Un string în PHP este o secvență de bytes, fără informație despre encoding. În UTF-8, literele ASCII ocupă un byte, iar ă, â, î, ș, ț ocupă câte doi. Funcțiile clasice (strlen, substr, strrev, str_pad, ucfirst) lucrează pe bytes, deci pe text românesc pot da rezultate greșite sau pot tăia o literă la jumătate.

PHP
echo strlen("Ștefan");          // 7
echo mb_strlen("Ștefan");       // 6
echo substr("ștrudel", 0, 1);   // un byte invalid, se afișează „�”
echo mb_substr("ștrudel", 0, 1); // ș
echo mb_strtoupper("ștefan");   // ȘTEFAN

Din PHP 8.2, strtolower, strtoupper, ucfirst și altele nu mai depind de locale și modifică doar A–Z. Asta face rezultatul previzibil, dar înseamnă că pentru diacritice ai nevoie obligatoriu de varianta mb_.

Lucruri utile:

  • mb_str_pad (PHP 8.3) aliniază corect text cu diacritice, mb_ucfirst și mb_trim au apărut în PHP 8.4.
  • strrev pe UTF-8 strică textul. Inversezi cu implode('', array_reverse(mb_str_split($s))).
  • Pentru expresii regulate pe UTF-8 adaugi modificatorul u.

Când ai nevoie de lungime pentru o coloană din baza de date (de exemplu VARCHAR(50) în MySQL cu utf8mb4, unde limita e în caractere), validezi cu mb_strlen.

Ce urmărește intervievatorul: Verifică dacă știi că stringurile PHP sunt bytes și dacă ai lucrat cu text în română. Candidații folosesc des strlen pentru validarea lungimii unui nume și nu știu de schimbarea din 8.2.

Eroarea, în practică:Argument #2 ($encoding) must be a valid encoding

17 Junior

Unde e bug-ul? Cum îl repari în PHP 8?

PHP
$email = "admin@site.ro";
if (strpos($email, "admin")) {
    echo "Cont de administrator";
}

Răspuns scurt: strpos întoarce 0, poziția de început, iar 0 e falsy, deci mesajul nu apare. Corect: strpos(...) !== false sau, din PHP 8.0, str_contains($email, "admin"), str_starts_with($email, "admin").

strpos($haystack, $needle) întoarce poziția primei apariții (de la 0) sau false dacă textul nu există. Când textul căutat e chiar la început, rezultatul e 0, iar if (0) e fals. Bug-ul e clasic tocmai pentru că funcționează în teste unde textul apare la mijloc.

Variante corecte:

PHP
if (strpos($email, "admin") !== false) { /* ... */ } // compatibil cu PHP 7
if (str_contains($email, "admin")) { /* ... */ }     // PHP 8.0+
if (str_starts_with($email, "admin@")) { /* ... */ } // PHP 8.0+, mai precis

În exemplu, intenția era probabil „emailul începe cu admin”. str_contains ar accepta și superadmin@site.ro sau ion@admin.ro, ceea ce într-o verificare de rol ar fi o problemă de securitate. Alegerea funcției contează la fel de mult ca operatorul.

Detalii:

  • str_contains($s, "") întoarce true pentru orice string, pentru că stringul gol apare oriunde.
  • Toate sunt sensibile la majuscule. Pentru variante fără, există stripos. Nu există str_icontains, deci folosești stripos(...) !== false sau compari după mb_strtolower.
  • Funcțiile noi lucrează pe bytes, dar căutarea unui subșir UTF-8 valid tot funcționează corect.

Rolurile nu se deduc oricum din email, dar întrebarea testează pattern-ul !== false, care apare la multe funcții PHP.

Ce urmărește intervievatorul: Întrebare de bază care arată dacă ai fost deja „mușcat” de capcana cu poziția 0. Bonus dacă observi că și logica (contains față de starts_with) e greșită.

18 Junior

Ce afișează fiecare linie? Când folosești sintaxa cu acolade la interpolare?

PHP
$user = ['name' => 'Ana', 'tags' => ['php']];
$obj = new stdClass; $obj->city = 'Cluj';
echo "Salut $user[name]\n";
echo "Salut {$user['name']}, tag: {$user['tags'][0]}\n";
echo "Oraș: $obj->city, {$obj->city}s\n";
echo 'Salut $user[name]\n';

Răspuns scurt: Primele trei linii afișează „Salut Ana”, „Salut Ana, tag: php” și „Oraș: Cluj, Clujs”. Ultima, între ghilimele simple, afișează textul literal, inclusiv \n. Acoladele sunt necesare pentru chei între ghilimele, array-uri pe mai multe niveluri și când textul continuă lipit de variabilă.

În stringurile cu ghilimele duble și în heredoc, PHP înlocuiește variabilele cu valorile lor. Există două sintaxe:

Sintaxa simplă recunoaște $var, $arr[cheie] (cheia fără ghilimele) și $obj->prop, doar pe un nivel. "$user[tags][0]" nu face ce te-ai aștepta: interpolează $user['tags'] (un array, cu warning „Array to string conversion”), apoi adaugă textul [0].

Sintaxa cu acolade {$...} acceptă orice expresie care începe cu $: chei cu ghilimele, mai multe niveluri, proprietăți înlănțuite, apeluri de metode:

PHP
echo "Total: {$order->getTotal()} lei";
echo "{$obj->city}s"; // fără acolade, PHP ar căuta proprietatea $obj->citys

Nu poți apela funcții simple ({strtoupper($x)}) și nici constante. Pentru asta folosești concatenarea sau sprintf.

Între ghilimele simple nu există interpolare și nici secvențe ca \n sau \t, doar \' și \\. De aceea ultima linie afișează exact Salut $user[name]\n.

Sintaxa "${var}" este deprecated din PHP 8.2, deci în cod nou folosești {$var}. Când textul devine complicat, sprintf sau un template sunt mai ușor de citit decât interpolarea.

Ce urmărește intervievatorul: Verifică regulile de interpolare, sursă frecventă de warning-uri și texte greșite. Candidații nu știu că sintaxa simplă merge doar pe un nivel.

Eroarea, în practică:Using ${var} in strings is deprecatedunexpected string content "", expecting identifier

19 Junior

Scrie o funcție care formatează un preț în stil românesc: 1234.5 devine 1.234,50 lei. Ce face printf("%05.1f|%-6s|", 3.14159, "ab")?

Răspuns scurt: number_format($pret, 2, ',', '.') . ' lei' dă 1.234,50 lei. printf afișează 003.1|ab |: lățime 5 completată cu zerouri și o zecimală, apoi text aliniat la stânga pe 6 caractere.

Pentru numere, number_format($n, $zecimale, $separatorZecimal, $separatorMii) rotunjește și formatează:

PHP
function formatPret(float|int $pret): string
{
    return number_format($pret, 2, ',', '.') . ' lei';
}
echo formatPret(1234.5); // 1.234,50 lei

Rezultatul e string și se folosește doar la afișare. Calculele le faci înainte, pe valoarea numerică.

Familia printf / sprintf folosește specificatori de forma %[flag][lățime][.precizie]tip:

  • %d întreg, %f float, %s string, %x hexazecimal, %% semnul procent
  • %05.1f: lățime totală 5, completare cu 0, o zecimală: 003.1
  • %-6s: aliniere la stânga pe 6 caractere: ab urmat de 4 spații
  • %'*8s: completare cu caracterul *: *******x
  • %2$s %1$s: argumente după poziție, util la traduceri unde ordinea cuvintelor diferă

printf afișează și întoarce lungimea, sprintf întoarce stringul, vsprintf primește argumentele ca array.

Pentru aplicații multilingve, extensia intl are NumberFormatter, care știe convențiile fiecărei limbi și monedei:

PHP
$fmt = new NumberFormatter('ro_RO', NumberFormatter::CURRENCY);
echo $fmt->formatCurrency(1234.5, 'RON');

Atenție: %f ține cont de locale, %F nu. Dacă ai setat setlocale, %F evită surprizele cu virgula.

Ce urmărește intervievatorul: Se verifică dacă știi uneltele standard de formatare, folosite zilnic în facturi și rapoarte. Greșeala frecventă e formatarea manuală cu str_replace sau formatarea înainte de calcule.

Eroarea, în practică:number_format(): $num must be of type int|floatUnknown format specifier "p"

20 Junior

Cum transformi un array în JSON și înapoi? Ce fac JSON_UNESCAPED_UNICODE, JSON_THROW_ON_ERROR și al doilea parametru al json_decode?

Răspuns scurt: json_encode($data) și json_decode($json, true); cu true primești array-uri asociative în loc de obiecte stdClass. JSON_UNESCAPED_UNICODE păstrează diacriticele lizibile, iar JSON_THROW_ON_ERROR aruncă JsonException în loc să întoarcă tăcut null sau false.

Funcțiile de bază:

PHP
$data = ['nume' => 'Ștefan', 'note' => [9, 10]];
$json = json_encode($data, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR);

try {
    $back = json_decode($input, true, 512, JSON_THROW_ON_ERROR);
} catch (JsonException $e) {
    http_response_code(400);
    echo 'JSON invalid: ' . $e->getMessage();
}

Detalii care contează:

  • Fără JSON_UNESCAPED_UNICODE, „Ș” devine Ș. JSON-ul rămâne valid, dar e greu de citit în loguri.
  • json_decode fără true întoarce obiecte stdClass ($obj->nume). Cu true primești array-uri.
  • Fără JSON_THROW_ON_ERROR, la eroare json_decode întoarce null, la fel ca pentru JSON-ul valid "null". Trebuie să verifici json_last_error(), iar mulți uită.
  • json_encode eșuează pe UTF-8 invalid. Cu JSON_INVALID_UTF8_SUBSTITUTE înlocuiești caracterele stricate.
  • Un array cu chei 0..n-1 devine listă JSON [...]. Orice alte chei îl transformă în obiect {...}. Un array gol devine [], deci dacă API-ul cere obiect folosești JSON_FORCE_OBJECT sau new stdClass.
  • Float-urile ca 10.0 devin 10, decât dacă adaugi JSON_PRESERVE_ZERO_FRACTION.
  • Din PHP 8.3, json_validate($s) verifică validitatea fără să construiască structura în memorie.

Ce urmărește intervievatorul: JSON e prezent în orice aplicație PHP modernă. Intervievatorul verifică dacă tratezi erorile și știi de ce un array poate deveni obiect în JSON.

Eroarea, în practică:Cannot use object of type stdClass as arrayJsonException: Syntax error

21 Junior

Scrie o funcție care normalizează un nume introdus de utilizator: " ion-ȘTEFAN popescu " trebuie să devină "Ion-Ștefan Popescu". Ce funcții pentru text folosești și ce capcane au?

Răspuns scurt: Elimini spațiile de la margini cu trim, comprimi spațiile multiple cu preg_replace('/\s+/u', ' ', ...), apoi aplici mb_convert_case($s, MB_CASE_TITLE, 'UTF-8'), care pune majusculă după spații și cratime și știe diacritice. ucwords nu tratează corect „ș” și „ț”.

PHP
function formatNume(string $s): string
{
    $s = preg_replace('/\s+/u', ' ', trim($s));
    return mb_convert_case(mb_strtolower($s), MB_CASE_TITLE, 'UTF-8');
}

echo formatNume("  ion-ȘTEFAN   popescu "); // Ion-Ștefan Popescu

Pașii, explicați:

  • trim($s) elimină spațiile, tab-urile și liniile noi de la capete. Al doilea parametru permite alte caractere: trim("--abc--", "-") dă abc. Atenție, e o listă de caractere, nu un șir: rtrim("1.500", "0") dă 1.5, iar rtrim("factura.pdf", ".pdf") ar tăia și literele „f” și „d” de la final dacă ar exista.
  • preg_replace('/\s+/u', ' ', ...) înlocuiește orice secvență de spații cu un singur spațiu. Modificatorul u evită problemele cu bytes UTF-8.
  • mb_convert_case(..., MB_CASE_TITLE) pune majusculă la începutul fiecărui cuvânt și litere mici în rest, inclusiv pentru ș, ț, ă. Tratează și cratima ca separator de cuvinte.

De ce nu ucwords(strtolower($s)): din PHP 8.2 ambele lucrează doar pe ASCII, deci „ștefan” rămâne „ștefan”, iar „ȘTEFAN” devine „Ștefan” doar parțial corect. ucwords are un al doilea parametru pentru delimitatori (ucwords($s, " -")), dar tot nu știe diacritice.

Alte funcții utile din aceeași familie:

  • substr($s, -4) ia ultimele 4 caractere (".pdf"), iar din PHP 8.0 substr pe o poziție în afara textului întoarce "", nu false
  • str_pad("7", 3, "0", STR_PAD_LEFT) dă "007"
  • wordwrap rupe textul pe linii, dar pe bytes

Discută și limitele regulii: nume ca „O'Brien” sau „McDonald” nu se normalizează corect automat. Pentru date reale, normalizarea agresivă poate fi mai rea decât păstrarea textului introdus, cu doar trim și comprimarea spațiilor.

Ce urmărește intervievatorul: Exercițiu practic de lucru cu text, frecvent în formulare. Intervievatorul verifică dacă știi funcțiile mb_ și dacă îți dai seama de limitele normalizării automate.

22 Mid

Scrie o funcție care primește un text în română și returnează cele mai frecvente 3 cuvinte, ignorând majusculele și punctuația.

Răspuns scurt: Transformi textul în litere mici cu mb_strtolower, îl spargi în cuvinte cu preg_split('/[^\p{L}\p{N}]+/u', ...), numeri cu array_count_values, sortezi descrescător cu arsort și iei primele 3 cu array_slice(..., 0, 3, true).

O soluție compactă, corectă pentru diacritice:

PHP
function topCuvinte(string $text, int $n = 3): array
{
    $cuvinte = preg_split('/[^\p{L}\p{N}]+/u', mb_strtolower($text), -1, PREG_SPLIT_NO_EMPTY);
    $frecv = array_count_values($cuvinte);
    arsort($frecv);
    return array_slice($frecv, 0, $n, true);
}

print_r(topCuvinte("Ana are mere. Ana are pere; mere, mere!"));
// [mere => 3, ana => 2, are => 2]

Ce ar trebui să explici la interviu:

  • mb_strtolower în loc de strtolower, ca „Școală” și „școală” să fie același cuvânt.
  • \p{L} înseamnă orice literă Unicode, iar modificatorul u face ca PCRE să lucreze pe caractere UTF-8, nu pe bytes. str_word_count nu e potrivit aici, pentru că nu recunoaște diacriticele românești ca litere.
  • PREG_SPLIT_NO_EMPTY elimină bucățile goale de la început sau sfârșit.
  • array_slice cu al patrulea parametru true păstrează cheile, altfel cuvintele s-ar pierde.
  • La egalitate, ordinea nu e garantată de arsort în mod explicit. Dacă cerința o specifică (de exemplu alfabetic), folosești uksort sau uasort cu două criterii.

Complexitatea e O(n) pentru numărare plus O(k log k) pentru sortarea celor k cuvinte distincte. Pentru texte foarte mari citești pe bucăți și actualizezi contoarele, fără să ții tot textul în memorie.

Ce urmărește intervievatorul: Este o problemă clasică de live coding care arată cât de bine cunoști funcțiile pentru stringuri și array-uri. Candidații uită de diacritice sau pierd cheile la array_slice.

23 Mid

Scrie o validare pentru o dată în formatul YYYY-MM-DD folosind o expresie regulată cu grupuri numite. De ce regex-ul singur nu e suficient?

Răspuns scurt: preg_match('/^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/', $s, $m) extrage părțile, apoi checkdate((int)$m['m'], (int)$m['d'], (int)$m['y']) verifică dacă data există. Regex-ul verifică doar forma, deci acceptă și 2025-02-30.

Grupurile numite (?<nume>...) fac codul mai clar decât indicii numerici:

PHP
function esteDataValida(string $s): bool
{
    if (!preg_match('/^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/', $s, $m)) {
        return false;
    }
    return checkdate((int) $m['m'], (int) $m['d'], (int) $m['y']);
}

var_dump(esteDataValida('2024-02-29')); // true, an bisect
var_dump(esteDataValida('2025-02-30')); // false

Puncte de discutat:

  • ^ și $ ancorează potrivirea pe tot stringul. Fără ele, x2025-01-01y ar trece. Atenție: $ acceptă și un \n final. Pentru strictețe totală folosești \z sau modificatorul D.
  • preg_match întoarce 1, 0 sau false la eroare de pattern. Array-ul $m conține atât cheile numite, cât și pe cele numerice.
  • Regex-ul verifică forma, iar regulile calendarului (luni de 30 de zile, ani bisecți) le verifică checkdate.

O alternativă fără regex:

PHP
$d = DateTimeImmutable::createFromFormat('!Y-m-d', $s);
$ok = $d !== false && $d->format('Y-m-d') === $s;

Comparația finală e necesară pentru că createFromFormat acceptă 2025-02-30 și îl transformă în 2 martie. Prefixul ! resetează ora la 00:00:00, altfel obiectul primește ora curentă.

Ce urmărește intervievatorul: Arată dacă știi regex practic și limitele lui. Greșeala tipică e să consideri că un pattern ca \d{4}-\d{2}-\d{2} validează complet o dată.

24 Mid

Ce face preg_replace_callback? Care e diferența dintre cuantificatorii greedy și lazy? Ce afișează preg_replace('/<b>.*<\/b>/', '', 'a<b>1</b>c<b>2</b>d')?

Răspuns scurt: preg_replace_callback calculează înlocuirea cu o funcție pentru fiecare potrivire. .* e greedy și ia cât mai mult, deci exemplul șterge tot de la primul <b> la ultimul </b> și afișează ad. Cu .*? (lazy) ar afișa acd.

Cuantificatorii *, +, ?, {n,m} sunt greedy: potrivesc cât mai multe caractere, apoi dau înapoi doar cât e nevoie. În exemplu, .* începe după primul <b> și se întinde până la ultimul </b> din text. Adăugând ? după cuantificator îl faci lazy, adică se oprește la prima variantă posibilă:

PHP
echo preg_replace('/<b>.*<\/b>/', '', 'a<b>1</b>c<b>2</b>d');  // ad
echo preg_replace('/<b>.*?<\/b>/', '', 'a<b>1</b>c<b>2</b>d'); // acd

O alternativă frecvent mai rapidă este o clasă negată: <b>[^<]*<\/b>.

preg_replace_callback e util când înlocuirea depinde de ce ai găsit:

PHP
$text = 'Total: 100 EUR, transport 20 EUR';
echo preg_replace_callback(
    '/(\d+) EUR/',
    fn(array $m) => ($m[1] * 5) . ' lei',
    $text
);

Alte detalii:

  • /u pentru UTF-8, /i pentru case-insensitive, /s ca . să includă și \n, /x pentru pattern-uri cu spații și comentarii.
  • preg_quote($s, '/') escapează un text introdus de utilizator înainte să-l pui în pattern.
  • Pentru HTML real nu folosești regex, ci DOMDocument sau, din PHP 8.4, Dom\HTMLDocument, care parsează conform standardului HTML5.
  • Pattern-urile cu cuantificatori imbricați, ca (a+)+, pot duce la catastrophic backtracking. PHP le oprește la pcre.backtrack_limit, iar preg_last_error() îți spune ce s-a întâmplat.

Ce urmărește intervievatorul: Verifică regex dincolo de nivelul de bază: callback-uri, greedy/lazy și riscuri de performanță. Mulți nu știu de ce primul exemplu șterge și textul din mijloc.

25 Mid

Ai o listă de fișiere img12.png, img2.png, IMG1.png. Cum le sortezi „natural” și fără să conteze majusculele? Și cum sortezi corect nume românești cu diacritice?

Răspuns scurt: natcasesort($files) sau usort($files, 'strnatcasecmp') dau ordinea IMG1, img2, img12. Pentru nume românești folosești Collator din extensia intl, cu locale ro_RO, pentru că strcmp compară bytes și pune „Ștefan” după „Zoe”.

Comparația implicită a stringurilor (strcmp, sort) e lexicografică pe bytes. Pentru img12 și img2 compară caracter cu caracter, iar 1 < 2, deci img12 vine primul. Pentru oameni, ordinea naturală e cea în care numerele din text sunt comparate ca numere.

PHP
$files = ['img12.png', 'img2.png', 'IMG1.png'];
sort($files);           // IMG1.png, img12.png, img2.png (majusculele întâi)
natcasesort($files);    // IMG1.png, img2.png, img12.png, păstrează cheile
usort($files, 'strnatcasecmp'); // aceeași ordine, cu reindexare

Funcțiile de comparare:

  • strcmp / strcasecmp: ordine pe bytes, cu sau fără majuscule (ASCII)
  • strnatcmp / strnatcasecmp: ordine naturală
  • sort($a, SORT_NATURAL | SORT_FLAG_CASE): același efect direct la sortare

Pentru texte în română, bytes-ii UTF-8 pentru ă, î, ș, ț au valori mai mari decât orice literă ASCII, așa că „Ștefan” ajunge după „Zoe”. Soluția corectă:

PHP
$c = new Collator('ro_RO');
$c->sort($nume); // Ana, Ștefan, Zoe

Collator aplică regulile limbii: â după a, ș după s, și poate fi configurat pentru majuscule sau accente. Dacă sortezi în baza de date, aceeași problemă se rezolvă cu un collation potrivit (de exemplu utf8mb4_ro_0900_ai_ci în MySQL 8), nu în PHP.

Ce urmărește intervievatorul: Verifică dacă știi că există comparații diferite pentru cazuri diferite. Intervievatorul caută menționarea ordinii naturale și a problemei diacriticelor.

26 Mid

Unde e bug-ul? Ce afișează codul?

PHP
$start = new DateTime('2025-01-31');
$next = $start->modify('+1 month');
echo $start->format('Y-m-d'), ' ', $next->format('Y-m-d');

Răspuns scurt: Afișează 2025-03-03 2025-03-03. DateTime::modify modifică obiectul însuși și îl returnează, deci $start s-a schimbat și el. În plus, 31 ianuarie plus o lună dă 31 februarie, care trece în 3 martie. Soluția: DateTimeImmutable și 'last day of next month' dacă asta e intenția.

Sunt două probleme separate.

Mutabilitatea. DateTime e mutabil: modify(), add(), setDate() schimbă obiectul și întorc același obiect. $start și $next sunt deci una și aceeași instanță. DateTimeImmutable are aceleași metode, dar fiecare întoarce un obiect nou:

PHP
$start = new DateTimeImmutable('2025-01-31');
$next = $start->modify('+1 month'); // $start rămâne 2025-01-31

Acest bug apare des când un obiect dată e transmis unei funcții care îl „ajustează” și strică valoarea apelantului. În cod nou, DateTimeImmutable e alegerea implicită.

Aritmetica lunilor. +1 month adaugă 1 la lună și păstrează ziua: 31 februarie nu există, iar PHP face overflow și ajunge la 3 martie (2025 nu e bisect). Dacă vrei ultima zi din luna următoare:

PHP
$start->modify('last day of next month'); // 2025-02-28

Alte reguli utile:

  • Setezi explicit fusul orar, de exemplu new DateTimeImmutable('now', new DateTimeZone('Europe/Bucharest')), și stochezi în baza de date în UTC.
  • Diferența dintre date se calculează cu $a->diff($b), care întoarce un DateInterval (->days pentru numărul total de zile), nu împărțind timestamp-uri la 86400, pentru că trecerea la ora de vară face ca unele zile să aibă 23 sau 25 de ore.
  • Pentru teste, injectezi un ceas (de exemplu interfața ClockInterface din PSR-20) în loc să apelezi new DateTime() direct.

Ce urmărește intervievatorul: Arată dacă ai lucrat cu date reale: abonamente, facturi, termene. Mulți nu știu că DateTime e mutabil sau că „+1 month” poate sări peste o lună.

27 Senior

Un client raportează că pe site numele apar ca „Ștefan” sau cu semne de întrebare în loc de diacritice. Cum ai depana problema, pas cu pas?

Răspuns scurt: Urmăresc lanțul de encoding de la sursă la browser: conexiunea PDO (charset=utf8mb4), coloanele MySQL, antetul Content-Type și funcțiile care lucrează pe bytes. „Ș” înseamnă UTF-8 citit ca Latin-1, iar „?” indică de obicei date stricate la salvare.

Răspunsul bun e structurat, ca un plan de depanare:

  • Identific simptomul. „Ș” în loc de „Ș” (mojibake) înseamnă că bytes-ii UTF-8 sunt corecți, dar sunt interpretați ca Latin-1 sau Windows-1252 undeva pe drum. Semnul „?” sau „�” înseamnă de cele mai multe ori că la scriere s-a făcut o conversie într-un charset care nu avea caracterul, iar datele sunt pierdute.
  • Verific datele brute. Fac bin2hex() pe valoare în PHP și HEX(coloana) în MySQL. „Ș” corect în UTF-8 este c898. Dacă găsesc c388cb9c, textul a fost codat de două ori (double encoding).
  • Conexiunea la baza de date. DSN-ul PDO trebuie să conțină charset=utf8mb4. Fără el, conexiunea poate folosi latin1, iar MySQL convertește la scriere și la citire.
  • Schema. Tabela și coloana trebuie să fie utf8mb4. Vechiul utf8 din MySQL acceptă maximum 3 bytes și nu poate stoca emoji.
  • Răspunsul HTTP. header('Content-Type: text/html; charset=UTF-8') și <meta charset="utf-8">. Pentru JSON, application/json, care e implicit UTF-8.
  • Codul PHP. Caut substr, strtoupper, str_pad, wordwrap pe texte cu diacritice, sau htmlentities cu alt charset. Verific dacă fișierele sursă sunt UTF-8 fără BOM.
  • Repar și previn. Corectez configurația, scriu un script de conversie pentru datele afectate (testat întâi pe o copie), apoi adaug un test automat cu un nume care conține diacritice.

Ce urmărește intervievatorul: Întrebare de situație: intervievatorul urmărește dacă ai o metodă de depanare, nu încercări la întâmplare. Un candidat bun știe să deosebească mojibake de date pierdute.

Array-uri

Exersează capitolul cu exerciții reale: Curs PHP online →
28 Junior

Câte elemente are array-ul și care sunt cheile lui?

PHP
$a = [1 => 'a', "1" => 'b', 1.5 => 'c', true => 'd', "01" => 'e'];
var_dump($a);

Răspuns scurt: Are două elemente: cheia 1 cu valoarea 'd' și cheia "01" cu valoarea 'e'. "1", 1.5 și true sunt convertite toate la întregul 1 și suprascriu valoarea, iar "01" rămâne string.

Cheile unui array PHP pot fi doar int sau string. Orice altă valoare este convertită după reguli fixe:

  • un string care e un întreg zecimal „canonic” ("1", "-5", dar nu "01", "1.0" sau " 1") devine int
  • un float e trunchiat la int (1.5 devine 1), iar din PHP 8.1 primești un Deprecated pentru pierderea zecimalelor
  • true devine 1, false devine 0
  • null devine "" (deprecated în PHP 8.5)
  • array-urile și obiectele nu pot fi chei, primești TypeError („Illegal offset type”)

În exemplu, patru dintre chei ajung la 1, iar fiecare atribuire o suprascrie pe cea anterioară, deci rămâne 'd'. Ordinea elementelor e dată de prima inserare a cheii.

De ce contează în practică:

  • Când construiești un index după un câmp din baza de date, ID-urile vin ca stringuri "15", dar ajung chei int. $map["15"] și $map[15] sunt același element, deci e ok.
  • Coduri ca "007" sau numere de telefon cu zero în față rămân stringuri, iar "7" e altă cheie.
  • La array_merge, cheile întregi sunt renumerotate. Un array indexat după ID-uri numerice își pierde astfel ID-urile, în timp ce unul cu chei string nu. Bug-ul apare tocmai din conversia automată a cheilor.

Când cheile pot arăta ca numere, dar trebuie păstrate ca atare, adaugi un prefix ("id_15") sau folosești + în loc de array_merge.

Ce urmărește intervievatorul: Verifică dacă știi că array-urile PHP au reguli speciale pentru chei. Candidații cred de obicei că rezultă cinci elemente.

29 Junior

Ce chei primesc elementele adăugate cu []?

PHP
$a = [5 => 'x'];
$a[] = 'y';
$a["10"] = 'z';
$a[] = 'w';
$b = [-5 => 'a'];
$b[] = 'b';
print_r(array_keys($a));
print_r(array_keys($b));

Răspuns scurt: $a are cheile 5, 6, 10 și 11: [] folosește cea mai mare cheie întreagă plus 1. $b are cheile -5 și -4 începând cu PHP 8.3; pe versiunile anterioare a doua cheie era 0.

Un array PHP ține minte „următoarea cheie liberă”, egală cu cea mai mare cheie întreagă folosită vreodată, plus 1. $a[] = valoare și array_push folosesc această valoare.

Pas cu pas pentru $a:

  • [5 => 'x']: următoarea cheie devine 6
  • $a[] = 'y' primește 6, următoarea devine 7
  • $a["10"] = 'z': "10" e convertit la întregul 10, următoarea devine 11
  • $a[] = 'w' primește 11

Pentru chei negative, PHP 8.3 a schimbat regula: dacă prima cheie întreagă e -5, următoarea e -4. În PHP 8.2 și mai vechi, după o cheie negativă următoarea era 0. Dacă ai cod care depinde de asta (rar, dar posibil la migrări), comportamentul se schimbă.

Alte detalii care derutează:

  • După unset, contorul nu scade: $x = [1, 2, 3]; unset($x[2]); $x[] = 4; pune 4 la cheia 3, nu 2.
  • Cheile string nu influențează contorul.
  • Un array cu chei „găurite” nu mai e listă: array_is_list($a) (PHP 8.1) întoarce false, iar json_encode îl transformă în obiect JSON.

Când ai nevoie de indici consecutivi, refaci numerotarea cu array_values().

Ce urmărește intervievatorul: Întrebarea testează dacă știi cum se alocă cheile automate și schimbarea din 8.3. Greșeala tipică e să crezi că [] pune elementul la poziția count($a).

30 Junior

Ce afișează codul? Cum obții un array cu indici consecutivi după ștergere?

PHP
$a = [1, 2, 3];
unset($a[1]);
$a[] = 9;
echo json_encode($a);
for ($i = 0; $i < count($a); $i++) {
    echo $a[$i];
}

Răspuns scurt: json_encode afișează {"0":1,"2":3,"3":9}, un obiect, pentru că cheile nu mai sunt 0..n-1. Bucla for dă warning „Undefined array key 1”. Reindexezi cu array_values($a) sau ștergi cu array_splice.

unset($a[1]) scoate elementul cu cheia 1, dar nu renumerotează celelalte chei. Array-ul devine [0 => 1, 2 => 3], apoi [] adaugă 9 la cheia 3 (cea mai mare cheie plus 1).

Două consecințe:

  • JSON. json_encode produce listă [...] doar pentru chei consecutive de la 0. Altfel produce obiect. Frontend-ul care aștepta un array primește {"0":1,"2":3,"3":9} și apelul .map() din JavaScript eșuează.
  • Bucla for. count($a) e 3, deci $i ia valorile 0, 1, 2. $a[1] nu există (warning în PHP 8, null ca valoare), iar $a[3] nu e afișat niciodată.

Soluții:

PHP
$a = array_values($a);         // [1, 3, 9]
array_splice($a, 1, 1);        // șterge și reindexează pe loc
$a = array_values(array_filter($a, fn($v) => $v !== 2));

Pentru parcurgere, foreach e alegerea sigură: merge pe chei, oricare ar fi ele. for cu index presupune o listă, iar din PHP 8.1 poți verifica asta cu array_is_list($a).

Regula practică: înainte să trimiți un array filtrat sau din care ai șters elemente într-un răspuns JSON, îl treci prin array_values.

Ce urmărește intervievatorul: Verifică dacă înțelegi că array-urile PHP sunt de fapt dicționare ordonate. Bug-ul cu JSON-ul care devine obiect apare des în API-uri.

31 Junior

Care e diferența dintre sort, asort, ksort, rsort, arsort și usort? Unde e bug-ul în $sorted = sort($produse);?

Răspuns scurt: sort sortează valorile și renumerotează cheile, asort sortează valorile păstrând cheile, ksort sortează după chei, prefixul r inversează ordinea, iar u primește o funcție de comparare. Toate modifică array-ul pe loc și întorc true, deci $sorted devine true.

Funcțiile de sortare din PHP au nume construite din litere:

  • sort / rsort: după valoare, crescător / descrescător, cheile se pierd (devin 0..n-1)
  • asort / arsort: după valoare, păstrează asocierea cheie-valoare
  • ksort / krsort: după cheie
  • usort, uasort, uksort: cu funcție de comparare proprie, pe valori fără chei, pe valori cu chei, pe chei

Toate primesc array-ul prin referință și îl modifică direct. Valoarea întoarsă e bool (în PHP 8.2+ întotdeauna true). Deci:

PHP
$sorted = sort($produse); // $sorted === true, $produse e sortat

Dacă vrei să păstrezi originalul, copiezi întâi: $sorted = $produse; sort($sorted);. Copierea e ieftină datorită copy-on-write.

Alegerea funcției depinde de date:

PHP
$preturi = ['mere' => 5, 'pere' => 3, 'prune' => 8];
asort($preturi);   // ['pere' => 3, 'mere' => 5, 'prune' => 8]
sort($preturi);    // [3, 5, 8], numele fructelor s-au pierdut

Al doilea parametru (flags) schimbă comparația: SORT_STRING, SORT_NUMERIC, SORT_NATURAL, SORT_FLAG_CASE. Implicit, PHP compară „inteligent”, ceea ce pe un amestec de numere și stringuri dă rezultate greu de prezis.

Din PHP 8.0 sortarea e stabilă: elementele egale își păstrează ordinea inițială. Pe asta te poți baza când sortezi succesiv după mai multe criterii.

Ce urmărește intervievatorul: Întrebarea verifică dacă știi familia de funcții și faptul că sortarea e pe loc. Greșeala tipică e folosirea lui sort pe un array asociativ și pierderea cheilor.

Eroarea, în practică:Argument could not be passed by reference

32 Junior

Ce diferență este între $a + $b, array_merge($a, $b) și [...$a, ...$b]? Ce afișează [1, 2] + [5, 6, 7]?

Răspuns scurt: + păstrează elementele din stânga și adaugă din dreapta doar cheile care lipsesc, deci [1, 2] + [5, 6, 7] dă [1, 2, 7]. array_merge și spread renumerotează cheile întregi și suprascriu cheile string cu valoarea din dreapta.

Cele trei operații arată la fel, dar tratează cheile diferit.

Operatorul + (uniune) compară cheile. Dacă o cheie există deja în stânga, valoarea din dreapta e ignorată:

PHP
[1, 2] + [5, 6, 7];                  // [0 => 1, 1 => 2, 2 => 7]
$defaults = ['limit' => 10, 'sort' => 'id'];
$opts = $_GET + $defaults;           // valorile din GET au prioritate

E ideal pentru valori implicite și pentru array-uri indexate după ID-uri, unde vrei să păstrezi cheile întregi.

array_merge pune elementele unul după altul. Cheile întregi sunt renumerotate de la 0, iar la cheile string câștigă ultima valoare:

PHP
array_merge(['a' => 1, 5 => 'x'], ['a' => 2, 5 => 'y']);
// ['a' => 2, 0 => 'x', 1 => 'y']

Capcana: un array [15 => $userA, 22 => $userB] trecut prin array_merge își pierde ID-urile.

Spread [...$a, ...$b] (PHP 7.4, cu chei string din PHP 8.1) se comportă ca array_merge. E util inline și merge și cu Traversable, de exemplu cu generatoare.

Performanță: array_merge într-o buclă ($all = array_merge($all, $batch)) copiază tot array-ul la fiecare pas, deci complexitatea devine pătratică. Mai bine colectezi bucățile și faci un singur array_merge(...$batches) la final.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semantica diferită a cheilor. Mulți cred că + adună sau concatenează array-urile.

33 Junior

Cum funcționează destructurarea array-urilor în PHP? Arată cum interschimbi două variabile, cum extragi chei numite și cum o folosești în foreach.

Răspuns scurt: Cu [$a, $b] = $array (sau list()) atribui elementele în variabile, după poziție sau după cheie: ['id' => $id] = $row. Interschimbarea e [$a, $b] = [$b, $a], iar în foreach poți scrie foreach ($rows as ['id' => $id, 'nume' => $nume]).

Destructurarea a apărut cu list() și are sintaxa scurtă [] din PHP 7.1:

PHP
[$x, [$y, $z]] = [1, [2, 3]];              // imbricat
[, $second] = ['a', 'b', 'c'];             // sari peste elemente
['id' => $id, 'nume' => $nume] = $row;     // după chei
[$a, $b] = [$b, $a];                        // interschimbare fără variabilă temporară

foreach ($comenzi as ['id' => $id, 'total' => $total]) {
    echo "$id: $total\n";
}

[$user, $error] = validate($input);         // „return” cu mai multe valori

Reguli de știut:

  • Nu poți amesteca destructurarea pozițională cu cea pe chei în aceeași paranteză.
  • Dacă o cheie lipsește, variabila primește null și apare warning-ul „Undefined array key”. Destructurarea nu e deci o validare.
  • Poți destructura prin referință (PHP 7.3): [&$first] = $arr; modifică array-ul.
  • Funcționează și pe rezultatul unei funcții: [$an, $luna] = explode('-', '2025-03');. Cu explode și un input fără -, a doua variabilă rămâne null, deci pentru date externe verifici numărul de elemente.

Pentru funcții care întorc mai multe valori, destructurarea e practică pe termen scurt. Dacă aceeași structură circulă prin mai multe locuri, un obiect cu proprietăți tipizate (de exemplu o clasă readonly) e mai clar și verificabil de IDE.

Ce urmărește intervievatorul: Verifică familiaritatea cu sintaxa modernă, des folosită în cod curat. Candidații nu știu varianta cu chei sau faptul că o cheie lipsă produce doar un warning.

Eroarea, în practică:Cannot mix keyed and unkeyed array entries

34 Junior

Ai un array de rânduri din baza de date: [['id' => 3, 'nume' => 'Ana'], ['id' => 5, 'nume' => 'Ion']]. Cum obții [3 => 'Ana', 5 => 'Ion'] și cum obții rândurile indexate după id?

Răspuns scurt: array_column($rows, 'nume', 'id') dă [3 => 'Ana', 5 => 'Ion'], iar array_column($rows, null, 'id') dă rândurile complete, indexate după id. Ambele se fac într-un singur apel, fără buclă.

array_column($array, $coloanaValoare, $coloanaCheie) extrage o coloană dintr-o listă de array-uri sau obiecte:

PHP
$rows = [
    ['id' => 3, 'nume' => 'Ana'],
    ['id' => 5, 'nume' => 'Ion'],
];

$nume   = array_column($rows, 'nume');        // ['Ana', 'Ion']
$map    = array_column($rows, 'nume', 'id');  // [3 => 'Ana', 5 => 'Ion']
$byId   = array_column($rows, null, 'id');    // [3 => [...], 5 => [...]]

Indexarea după ID e foarte utilă: transformă căutarea unui element dintr-o buclă (O(n)) într-un acces direct $byId[5] (O(1) în medie). E tehnica standard când combini date din două surse, de exemplu comenzi și clienți:

PHP
$clienti = array_column($clientiRows, null, 'id');
foreach ($comenzi as $c) {
    echo $clienti[$c['client_id']]['nume'] ?? 'necunoscut';
}

Detalii:

  • Dacă două rânduri au același id, ultimul câștigă, fără avertisment.
  • Funcționează și pe obiecte cu proprietăți publice (din PHP 7.0).
  • Cu PDO poți obține direct perechi cheie-valoare cu fetchAll(PDO::FETCH_KEY_PAIR).

Varianta cu foreach e la fel de corectă, dar array_column exprimă intenția mai clar și e implementată în C, deci de obicei e și mai rapidă.

Ce urmărește intervievatorul: Este o operație de zi cu zi pe date din baza de date. Intervievatorul vede dacă știi funcția și al treilea parametru, pe care mulți îl ignoră.

35 Junior

Cum implementezi o stivă și o coadă cu array-uri în PHP? De ce array_shift poate fi lent pe array-uri mari și ce alternativă ai?

Răspuns scurt: Stiva folosește array_push / $a[] = și array_pop, iar coada $a[] = și array_shift. array_shift reindexează toate cheile numerice, deci costă O(n) la fiecare apel. Pentru cozi mari folosești SplQueue sau un index de citire.

Un array PHP poate juca ambele roluri:

PHP
// stivă (LIFO)
$stack = [];
$stack[] = 'a';
$stack[] = 'b';
echo array_pop($stack);   // b

// coadă (FIFO)
$queue = ['a', 'b', 'c'];
echo array_shift($queue); // a
array_unshift($queue, 'z'); // adaugă la început

array_pop și $a[] = lucrează la capătul array-ului și sunt O(1). array_shift și array_unshift modifică începutul, iar PHP trebuie să renumeroteze toate cheile întregi rămase. Cu o coadă de sute de mii de elemente procesată element cu element, timpul total devine pătratic.

Alternative:

PHP
$q = new SplQueue();
$q->enqueue('a');
$q->enqueue('b');
echo $q->dequeue();       // a, O(1)

// sau cu index, fără să modifici array-ul
for ($i = 0; $i < count($items); $i++) { /* procesezi $items[$i] */ }

SPL mai are SplStack, SplPriorityQueue (coadă cu priorități, utilă la algoritmi ca Dijkstra) și SplObjectStorage. Extensia ds (Data Structures) oferă Ds\Queue și Ds\Deque, dar nu e instalată implicit, așa că verifici întâi dacă e disponibilă pe server.

La interviu e bine să spui ambele variante: pentru câteva zeci de elemente, array-ul simplu e perfect și mai lizibil, iar optimizarea are sens doar la volume mari.

Ce urmărește intervievatorul: Verifică structurile de date de bază și înțelegerea costului operațiilor. Puțini candidați știu că array_shift renumerotează cheile.

Eroarea, în practică:Can't shift from an empty datastructure

36 Mid

Scrie o sortare pentru un clasament: întâi după punctaj descrescător, apoi după nume crescător. Datele: [['n' => 'Ion', 's' => 9], ['n' => 'Ana', 's' => 9], ['n' => 'Bob', 's' => 10]].

Răspuns scurt: usort($rows, fn($a, $b) => [$b['s'], $a['n']] <=> [$a['s'], $b['n']]); dă ordinea Bob, Ana, Ion. Compari array-uri cu <=>, iar pentru criteriul descrescător inversezi $a și $b doar pe acea poziție.

Funcția de comparare a lui usort primește două elemente și trebuie să întoarcă un număr negativ, zero sau pozitiv. Varianta explicită:

PHP
usort($rows, function (array $a, array $b): int {
    if ($a['s'] !== $b['s']) {
        return $b['s'] <=> $a['s'];    // punctaj descrescător
    }
    return strcmp($a['n'], $b['n']);   // nume crescător
});

Varianta compactă folosește faptul că <=> compară array-uri element cu element:

PHP
usort($rows, fn($a, $b) => [$b['s'], $a['n']] <=> [$a['s'], $b['n']]);
// Bob (10), Ana (9), Ion (9)

Greșeli frecvente:

  • funcție care întoarce bool ($a['s'] > $b['s']): din PHP 8 primești un Deprecated, iar ordinea poate fi greșită, pentru că lipsește cazul „egal”
  • scăderea $a['s'] - $b['s'] pe float-uri: 0.5 e convertit la 0 și elementele par egale
  • folosirea usort pe un array asociativ ale cărui chei trebuie păstrate: atunci e nevoie de uasort

Alternativa „pe coloane” e array_multisort(array_column($rows, 's'), SORT_DESC, array_column($rows, 'n'), SORT_ASC, $rows);.

Când datele vin din baza de date, sortarea se face direct în SQL cu ORDER BY s DESC, n ASC, mai ales dacă există și paginare. Sortarea în PHP are sens pentru date deja în memorie sau combinate din mai multe surse.

Ce urmărește intervievatorul: Live coding clasic. Intervievatorul urmărește dacă știi contractul funcției de comparare și cum tratezi criteriile cu direcții diferite.

Eroarea, în practică:usort(): Returning bool from comparison function

37 Mid

Unde e bug-ul? Frontend-ul primește uneori un obiect în loc de listă.

PHP
$produse = array_filter($produse, fn($p) => $p['stoc'] > 0);
header('Content-Type: application/json');
echo json_encode($produse);

Răspuns scurt: array_filter păstrează cheile originale, deci dacă elimină un element din mijloc, cheile devin „găurite” și json_encode produce un obiect JSON. Soluția: array_values(array_filter(...)).

Funcțiile array_filter, array_unique, array_diff și array_intersect păstrează cheile elementelor rămase. Asta e util pentru array-uri asociative, dar strică listele:

PHP
$a = array_filter([10, 0, 30], fn($v) => $v > 0);
// [0 => 10, 2 => 30]
echo json_encode($a);                 // {"0":10,"2":30}
echo json_encode(array_values($a));   // [10,30]

Bug-ul e greu de prins pentru că apare doar când se elimină un element care nu e la final. Dacă toate produsele au stoc, sau dacă lipsesc doar ultimele, răspunsul arată corect. În JavaScript, data.forEach sau data.map aruncă apoi eroare pe un obiect.

Soluții și prevenție:

  • reindexezi explicit cu array_values înainte de serializare
  • pentru API-uri, construiești răspunsul printr-o funcție sau clasă care garantează listă (de exemplu verifici cu array_is_list, PHP 8.1)
  • un test de integrare cu date care conțin elemente filtrate la mijloc

Alte detalii despre array_filter: fără callback elimină toate valorile falsy, inclusiv 0 și "0", ceea ce poate șterge date valide. Cu ARRAY_FILTER_USE_KEY sau ARRAY_FILTER_USE_BOTH primești în callback cheia sau ambele.

array_map cu un singur array păstrează cheile, deci nu repară problema dacă e aplicat după filtrare.

Ce urmărește intervievatorul: Este un bug real și frecvent în API-uri PHP. Intervievatorul verifică dacă știi ce funcții păstrează cheile și legătura cu json_encode.

38 Mid

Ce fac funcțiile array_find, array_find_key, array_any și array_all (PHP 8.4)? Cum ai scris același cod înainte?

Răspuns scurt: array_find întoarce primul element care respectă condiția (sau null), array_find_key cheia lui, array_any spune dacă măcar un element o respectă, iar array_all dacă toate. Înainte foloseai foreach cu return/break sau array_filter, care parcurge tot array-ul.

Funcțiile au fost adăugate în PHP 8.4 și primesc un array și un callback fn($valoare, $cheie):

PHP
$users = [
    ['id' => 1, 'activ' => false],
    ['id' => 2, 'activ' => true],
];

$primulActiv = array_find($users, fn($u) => $u['activ']);     // ['id' => 2, ...]
$cheie       = array_find_key($users, fn($u) => $u['activ']); // 1
$existaActiv = array_any($users, fn($u) => $u['activ']);      // true
$totiActivi  = array_all($users, fn($u) => $u['activ']);      // false

Toate se opresc la primul rezultat decisiv (short-circuit). Varianta veche des întâlnită, array_values(array_filter(...))[0] ?? null, parcurge tot array-ul și construiește un array intermediar.

Detalii care contează:

  • array_find întoarce null și când nu găsește nimic, și când elementul găsit chiar e null. Dacă valorile pot fi null, folosești array_find_key și verifici !== null.
  • array_all([]) întoarce true, iar array_any([]) întoarce false, ca în logică.
  • PHP 8.5 a adăugat array_first() și array_last(), care întorc prima și ultima valoare fără să mute pointerul intern, cum făceau reset() și end().

Pentru proiecte care trebuie să ruleze și pe versiuni mai vechi, poți folosi un polyfill prin Composer, de exemplu symfony/polyfill-php84, care definește funcțiile doar dacă lipsesc. Verifici versiunea minimă din composer.json ("php": ">=8.4") înainte să le folosești direct.

Ce urmărește intervievatorul: Arată dacă urmărești evoluția limbajului. Intervievatorul apreciază când știi și limitele, de exemplu ambiguitatea lui null la array_find.

39 Senior

Ai două liste de câte 200.000 de emailuri și vrei emailurile care apar în ambele. Cum ai scrie codul și care e complexitatea fiecărei variante?

Răspuns scurt: Un foreach cu in_array e O(n·m) și poate dura minute. Corect: construiești un set cu array_flip($b) și verifici cu isset, în O(n + m). array_intersect dă același rezultat, dar compară valorile ca stringuri și e de obicei mai lent decât varianta cu chei.

Varianta naivă:

PHP
$comune = [];
foreach ($a as $email) {
    if (in_array($email, $b, true)) {   // parcurge $b la fiecare pas
        $comune[] = $email;
    }
}

Cu 200.000 de elemente în fiecare listă, asta înseamnă de ordinul a 40 de miliarde de comparații în cel mai rău caz.

Varianta eficientă folosește faptul că un array PHP e o tabelă hash, iar căutarea după cheie e O(1) în medie:

PHP
$setB = array_flip($b);          // emailurile devin chei
$comune = [];
foreach ($a as $email) {
    if (isset($setB[$email])) {
        $comune[] = $email;
    }
}
// sau: array_keys(array_intersect_key(array_flip($a), $setB));

Ce mai trebuie spus la interviu:

  • Normalizarea: Ana@Site.ro și ana@site.ro sunt același email. Aplici strtolower(trim($e)) pe ambele liste înainte de comparație.
  • Duplicatele: array_flip le elimină automat. Dacă trebuie păstrate, explici cerința.
  • Cheile numerice: dacă valorile sunt stringuri ca "123", array_flip le face chei int. Pentru isset rezultatul rămâne corect.
  • Memoria: un array cu 200.000 de chei string ocupă zeci de MB. Dacă datele sunt în baza de date, un JOIN sau WHERE email IN (SELECT ...) cu index evită încărcarea în PHP.

Ca regulă, înainte de optimizare măsori: hrtime(true) pentru timp și memory_get_peak_usage() pentru memorie.

Ce urmărește intervievatorul: Verifică gândirea despre complexitate și cunoașterea faptului că array-urile PHP sunt hash map-uri. Mulți scriu in_array în buclă fără să se gândească la volum.

40 Senior

Cum sunt implementate array-urile în PHP 7 și 8? Ce înseamnă packed array și hash array și când ai alege o altă structură?

Răspuns scurt: Un array e un HashTable ordonat. Dacă cheile sunt întregi crescători, PHP folosește varianta packed, fără tabelă de hash, mai compactă și mai rapidă. Pentru cantități mari de date tipizate sau acces specializat poți folosi obiecte, SplFixedArray, generatoare ori structurile din extensia ds.

Intern, un array PHP este o structură HashTable care păstrează ordinea de inserare. Elementele stau într-un vector de „bucket-uri” (cheie, hash, valoare), iar separat există o tabelă de hash care duce de la cheie la poziție.

Packed array: când cheile sunt întregi și crescătoare (de exemplu 0, 1, 2...), PHP poate renunța la tabela de hash și accesează elementul direct după poziție. Ocupă mai puțină memorie și e mai rapid. Un array creat cu [] și completat cu $a[] = ... sau cu range() rămâne packed.

Hash array: când apar chei string, chei întregi în ordine aleatorie sau „găuri” mari, array-ul e convertit. Conversia e transparentă, dar crește memoria.

Consecințe practice:

  • Un array PHP e un instrument universal, dar nu ieftin: fiecare element are un zval de 16 bytes plus structura bucket-ului. Măsori cu memory_get_usage() înainte și după încărcare.
  • Pentru milioane de rânduri, nu le încarci pe toate în memorie: le procesezi în flux cu generatoare sau cu cursoare din baza de date.
  • Pentru structuri cu câmpuri fixe (o comandă, un utilizator), obiectele cu proprietăți declarate sunt de obicei mai compacte decât array-urile asociative, pentru că numele proprietăților nu sunt stocate per obiect, și oferă tipuri.
  • SplFixedArray are dimensiune fixă și doar chei întregi. Față de un packed array obișnuit diferența de memorie e mică în PHP 8, deci îl alegi mai ales pentru semantică.
  • Pentru cozi, seturi și deque-uri eficiente există extensia ds, dacă o poți instala pe server.

Ce urmărește intervievatorul: Întrebare de senior: intervievatorul vrea să vadă dacă poți raționa despre memorie și performanță. Răspunsurile slabe se opresc la „un array e o listă”.

Funcții și closures

41 Junior

Ce probleme au aceste declarații în PHP 8.x?

PHP
function f(int $a = 1, int $b) {}
function g(int $x = null) {}

Răspuns scurt: Prima pune un parametru opțional înaintea unuia obligatoriu: din PHP 8.0 primești Deprecated, iar valoarea implicită a lui $a e ignorată. A doua face tipul implicit nullable prin = null, ceea ce e deprecated din PHP 8.4; scrii explicit ?int $x = null.

Parametri opționali înaintea celor obligatorii. La un apel pozițional, nu poți omite $a fără să omiți și $b, deci valoarea implicită nu are niciun efect. PHP 8.0 tratează $a ca obligatoriu și afișează: „Optional parameter $a declared before required parameter $b is implicitly treated as a required parameter”. Regula sănătoasă: parametrii obligatorii primii, cei opționali la final.

PHP
function f(int $b, int $a = 1) {}
f(5);              // $a = 1
f(5, a: 3);        // cu argumente numite (PHP 8.0)

Nullable implicit. Înainte de PHP 7.1 nu exista ?int, așa că PHP accepta int $x = null ca prescurtare pentru „int sau null”. PHP 8.4 marchează forma ca deprecated, pentru că ascunde faptul că funcția acceptă null:

PHP
function g(?int $x = null) {}

Alte reguli despre valori implicite:

  • trebuie să fie expresii constante: literali, constante, array-uri; din PHP 8.1 și new, de exemplu Logger $log = new NullLogger()
  • parametrii impliciți se evaluează la fiecare apel, nu o singură dată cum se întâmplă în Python, deci nu există capcana cu liste partajate
  • dacă ai mulți parametri opționali, un obiect de opțiuni sau argumentele numite sunt mai clare decât f(1, null, null, true)

Rector (o unealtă de refactorizare automată) are reguli care corectează ambele cazuri în tot proiectul.

Ce urmărește intervievatorul: Verifică dacă scrii semnături curate și dacă știi deprecierile recente. Multe proiecte vechi au aceste forme, care umplu logurile la upgrade.

Eroarea, în practică:Optional parameter declared before required

42 Junior

Cum scrii o funcție care primește oricâte argumente? Cum transmiți un array existent ca argumente separate?

Răspuns scurt: Cu un parametru variadic, function sum(int ...$numere), care adună argumentele într-un array. Transmiți un array cu operatorul spread: sum(...$lista). Din PHP 8.1, cheile string din array sunt tratate ca argumente numite.

Parametrul variadic se marchează cu ... și trebuie să fie ultimul:

PHP
function sum(int ...$numere): int
{
    return array_sum($numere);
}

echo sum();          // 0
echo sum(1, 2, 3);   // 6
$lista = [4, 5];
echo sum(...$lista); // 9, spread la apel

Tipul declarat se aplică fiecărui element, deci sum(1, "x") aruncă TypeError. Poți combina parametri normali cu cel variadic: function log(string $nivel, string ...$mesaje).

Despre spread la apel:

  • funcționează cu orice iterable, inclusiv cu generatoare
  • din PHP 8.1, un array cu chei string e despachetat ca argumente numite: f(...['b' => 2, 'a' => 1]) pune valorile pe parametrii cu același nume
  • după un argument numit nu mai poți pune argumente poziționale

Varianta veche, func_get_args(), funcționează încă, dar nu are tipuri, nu apare în semnătură și nu poate fi verificată de IDE sau de PHPStan. În cod nou nu are motiv să fie folosită.

Un caz practic: o funcție care construiește o clauză IN cu oricâte ID-uri, function findByIds(int ...$ids): array. Tipizarea garantează că primești doar întregi, iar numărul de elemente se află cu count($ids), ca să generezi placeholder-ele potrivite.

Variadicele se pot primi și prin referință (&...$refs), dar e un caz rar.

Ce urmărește intervievatorul: Întrebare de bază despre semnături. Intervievatorul verifică dacă știi sintaxa modernă în locul lui func_get_args() și faptul că tipul se aplică fiecărui element.

Eroarea, în practică:Only arrays and Traversables can be unpackedOnly the last parameter can be variadic

43 Junior

Scrie o funcție care aplatizează un array imbricat de orice adâncime: [1, [2, [3, 4]], 5] devine [1, 2, 3, 4, 5].

Răspuns scurt: Recursiv: parcurgi elementele, pentru fiecare array apelezi funcția din nou și adaugi rezultatul, iar valorile simple le adaugi direct. Alternativ, array_walk_recursive cu o closure care adaugă prin referință în rezultat.

Soluția recursivă clasică:

PHP
function flatten(array $items): array
{
    $result = [];
    foreach ($items as $item) {
        if (is_array($item)) {
            array_push($result, ...flatten($item));
        } else {
            $result[] = $item;
        }
    }
    return $result;
}

print_r(flatten([1, [2, [3, 4]], 5])); // [1, 2, 3, 4, 5]

Variante pe care merită să le menționezi:

PHP
function flatten2(array $items): array
{
    $out = [];
    array_walk_recursive($items, function ($v) use (&$out) {
        $out[] = $v;
    });
    return $out;
}

function flattenGen(iterable $items): Generator
{
    foreach ($items as $item) {
        is_iterable($item) ? yield from flattenGen($item) : yield $item;
    }
}
// iterator_to_array(flattenGen($a), false)

Ce urmărește intervievatorul:

  • Cazul de bază: valoarea simplă, unde recursivitatea se oprește.
  • Cheile: soluțiile de mai sus produc o listă nouă. Cu iterator_to_array trebuie false ca al doilea argument, altfel cheile duplicate se suprascriu.
  • Adâncimea: PHP nu are o limită fixă a stivei de apeluri și nici optimizare pentru recursivitatea finală (tail call). O recursivitate foarte adâncă consumă memorie până la memory_limit sau poate opri procesul. Xdebug oprește execuția la xdebug.max_nesting_level. Pentru date de adâncime necunoscută, o variantă iterativă cu stivă proprie e mai sigură.
  • Complexitate: O(n) după numărul total de elemente, plus copierile la array_push(...).

Ce urmărește intervievatorul: Problemă clasică de recursivitate. Se verifică dacă știi să definești cazul de bază și dacă cunoști alternative din biblioteca standard.

44 Junior

Scrie o funcție care calculează al n-lea număr Fibonacci. De ce varianta recursivă simplă e lentă și cum o optimizezi?

Răspuns scurt: Varianta recursivă fib(n-1) + fib(n-2) recalculează aceleași valori și are complexitate exponențială. Varianta iterativă cu două variabile e O(n) în timp și O(1) în memorie. Alternativ, recursivitate cu memoizare.

Varianta directă după definiție:

PHP
function fibRec(int $n): int
{
    return $n < 2 ? $n : fibRec($n - 1) + fibRec($n - 2);
}

Pentru fibRec(40) se fac sute de milioane de apeluri, pentru că fibRec(38) e calculat de două ori, fibRec(37) de trei ori și așa mai departe. Complexitatea crește aproximativ ca 1,6 la puterea n.

Varianta iterativă:

PHP
function fib(int $n): int
{
    if ($n < 0) {
        throw new InvalidArgumentException('n trebuie să fie >= 0');
    }
    [$a, $b] = [0, 1];
    for ($i = 0; $i < $n; $i++) {
        [$a, $b] = [$b, $a + $b];
    }
    return $a;
}

Varianta cu memoizare păstrează rezultatele deja calculate:

PHP
function fibMemo(int $n, array &$memo = []): int
{
    if ($n < 2) return $n;
    return $memo[$n] ??= fibMemo($n - 1, $memo) + fibMemo($n - 2, $memo);
}

Puncte bonus:

  • Overflow: pe 64 de biți, fib(92) e ultima valoare care încape în int. fib(93) ar deveni float și s-ar pierde precizia, iar cu tipul de return int primești TypeError. Pentru valori mai mari folosești extensia GMP sau BCMath.
  • Validarea: n negativ.
  • Testarea: cazurile 0, 1, 2 și o valoare cunoscută, de exemplu fib(10) === 55.

Ce urmărește intervievatorul: Arată dacă înțelegi costul recursivității și știi să optimizezi. Intervievatorii apreciază când candidatul menționează singur limita de overflow.

45 Junior

Ce afișează codul și de ce?

PHP
$x = 1;
$byVal = function () use ($x) { return $x; };
$byRef = function () use (&$x) { return $x; };
$arrow = fn() => $x;
$x = 2;
echo $byVal(), $byRef(), $arrow();

Răspuns scurt: Afișează 121. use ($x) și funcția săgeată copiază valoarea în momentul creării closure-ului, deci văd 1. Doar use (&$x) leagă closure-ul de variabila originală și vede valoarea 2.

O funcție anonimă în PHP nu vede automat variabilele din jur. Trebuie să le capturezi explicit:

  • use ($x): copiază valoarea lui $x la momentul în care e creat closure-ul. Modificările ulterioare din afară nu se văd, iar modificările din interior nu ies în afară.
  • use (&$x): capturează prin referință. Closure-ul și codul din afară lucrează pe aceeași variabilă.
  • fn() => $x (PHP 7.4): capturează automat, prin valoare, orice variabilă folosită. E echivalent cu use ($x), nu cu use (&$x).

De ce ordinea contează în exemplu: toate trei closure-urile sunt create când $x e 1, iar apelurile au loc după $x = 2.

Captura prin valoare e de obicei ce vrei, de exemplu când creezi funcții într-o buclă:

PHP
$fns = [];
for ($i = 0; $i < 3; $i++) {
    $fns[] = fn() => $i;
}
// fiecare întoarce 0, 1, 2. Cu use (&$i), toate ar întoarce 3

Captura prin referință e utilă pentru acumulatori, de exemplu cu array_walk:

PHP
$total = 0;
array_walk($items, function ($i) use (&$total) { $total += $i['pret']; });

O funcție săgeată nu poate modifica variabile din exterior, pentru că are doar copii. Dacă ai nevoie de asta, folosești funcție anonimă clasică cu &. Obiectele capturate prin valoare rămân același obiect, pentru că se copiază doar handle-ul.

Ce urmărește intervievatorul: Este întrebarea standard despre closures în PHP, dintr-un unghi practic. Greșeala frecventă e să crezi că funcțiile săgeată capturează prin referință.

46 Mid

Ce forme poate lua un callable în PHP? Ce face sintaxa strlen(...) din PHP 8.1 și de ce e mai bună decât 'strlen'?

Răspuns scurt: Un callable poate fi numele unei funcții ca string, un array [$obj, 'metoda'] sau [Clasa::class, 'statica'], un Closure sau un obiect cu __invoke. strlen(...) (first-class callable syntax) creează direct un Closure, verificat la creare și ușor de analizat de IDE.

Formele unui callable:

PHP
$a = 'strtoupper';                     // funcție globală
$b = [$mailer, 'send'];                // metodă de instanță
$c = [Report::class, 'create'];        // metodă statică
$d = 'Report::create';                 // tot statică, ca string
$e = fn($x) => $x * 2;                 // closure
$f = new class { public function __invoke($x) { return $x; } };

echo $a('salut');                       // apel direct
array_map($b, $emails);                 // transmis mai departe

Formele cu string și array au probleme: o greșeală de tipar apare abia la rulare, refactorizarea automată nu le găsește, iar metodele private nu pot fi apelate de altcineva prin ele.

First-class callable syntax (PHP 8.1) creează un Closure din orice funcție sau metodă:

PHP
$len   = strlen(...);
$send  = $mailer->send(...);
$make  = Report::create(...);
$names = array_map(trim(...), $rows);

Avantaje:

  • dacă funcția nu există, eroarea apare imediat, la crearea closure-ului
  • păstrează vizibilitatea contextului: în interiorul clasei poți transmite $this->helper(...) chiar dacă helper e privată
  • IDE-ul și PHPStan știu exact ce funcție e referită

Pentru tipare, folosești callable ca tip de parametru sau, mai precis, Closure. callable nu poate fi folosit ca tip de proprietate, motiv pentru care clasele care stochează callback-uri declară proprietatea Closure și convertesc cu Closure::fromCallable($c) sau cu sintaxa (...).

Ce urmărește intervievatorul: Verifică dacă știi cum se transmit funcții ca valori, lucru frecvent în callback-uri, evenimente și middleware. Puțini candidați cunosc sintaxa (...).

Eroarea, în practică:Value of type null is not callablearray_map(): Argument #1 must be a valid callback

47 Mid

Scrie o funcție memoize(callable $fn): Closure care întoarce o versiune a lui $fn ce ține minte rezultatele pentru argumentele deja văzute.

Răspuns scurt: Funcția întoarce un closure care capturează un array $cache prin referință, construiește o cheie din argumente (de exemplu cu serialize) și apelează $fn doar dacă cheia nu există. Funcționează corect doar pentru funcții pure, fără efecte secundare.

O implementare simplă:

PHP
function memoize(callable $fn): Closure
{
    $cache = [];
    return function (mixed ...$args) use ($fn, &$cache): mixed {
        $key = serialize($args);
        if (!array_key_exists($key, $cache)) {
            $cache[$key] = $fn(...$args);
        }
        return $cache[$key];
    };
}

$slowSquare = function (int $n): int { usleep(100_000); return $n * $n; };
$fast = memoize($slowSquare);
$fast(4); // calculează
$fast(4); // din cache

Decizii pe care trebuie să le explici:

  • &$cache: fără referință, fiecare apel ar lucra pe o copie goală a array-ului.
  • Cheia: serialize tratează și array-uri imbricate. implode(',', $args) ar confunda ['1,2'] cu [1, 2]. Pentru obiecte, serialize poate fi scump sau imposibil (closures), iar acolo se folosește spl_object_id sau un WeakMap.
  • array_key_exists față de isset: dacă funcția întoarce null, isset ar considera că lipsește și ar recalcula de fiecare dată.
  • Doar funcții pure: o funcție care citește din baza de date sau depinde de oră ar întoarce valori vechi.
  • Memoria: cache-ul crește fără limită. Într-un request web obișnuit nu contează, pentru că memoria se eliberează la final, dar într-un worker de lungă durată ai nevoie de o limită (LRU) sau de un cache extern, ca Redis sau APCu.

Pentru o singură funcție, un static $cache = []; în interiorul ei face același lucru mai simplu.

Ce urmărește intervievatorul: Live coding care combină closures, referințe și funcții de ordin superior. Intervievatorul urmărește cheia de cache, cazul null și limitările.

48 Mid

Ce fac Closure::bind, bindTo și call? Ce este un closure static și când îl folosești?

Răspuns scurt: Ele schimbă obiectul $this și scope-ul de clasă al unui closure, deci acesta poate accesa membrii privați ai acelei clase. Un closure static function () {} nu are $this legat, ceea ce evită ținerea în memorie a obiectului părinte și accesul accidental la el.

Un closure creat într-o metodă primește automat $this și scope-ul clasei. Îl poți „muta” în alt context:

PHP
class Cont {
    private int $sold = 100;
}

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

echo Closure::bind($citesteSold, new Cont, Cont::class)(); // 100
echo $citesteSold->call(new Cont);                         // 100, leagă și apelează
$legat = $citesteSold->bindTo(new Cont, Cont::class);
  • bind($closure, $obiect, $scope) este forma statică, iar bindTo($obiect, $scope) forma de instanță. Ambele întorc un closure nou.
  • call($obiect, ...$args) (PHP 7.0) leagă temporar și apelează imediat, cu scope-ul clasei obiectului.
  • Al treilea argument decide ce membri privați sunt vizibili.

Unde se folosește real: biblioteci de testare sau hidratare care populează proprietăți private fără reflection, containere DI și framework-uri care rulează callback-uri cu un anumit $this, cum fac rutele în Laravel. În cod de aplicație e rar necesar și ocolește încapsularea, deci trebuie justificat.

Closure-uri static:

PHP
class Repo {
    public function filters(): array {
        return [static fn($r) => $r['activ']];
    }
}

Un closure non-static creat într-o metodă păstrează referința la $this. Dacă e stocat undeva pe termen lung (un cache, o listă de event listeners), ține obiectul în viață. Marcat static, nu mai poate folosi $this, iar intenția e explicită. Funcțiile săgeată pot fi și ele static fn.

Ce urmărește intervievatorul: Întrebare de mid pentru cine lucrează cu framework-uri sau biblioteci. Se verifică dacă înțelegi legarea lui $this și costurile ei.

OOP în PHP modern

49 Junior

Ce eroare apare și de ce?

PHP
class User {
    public int $id;
    public ?string $email;
}
$u = new User();
echo $u->email ?? 'fără email';
echo $u->id;

Răspuns scurt: Prima linie afișează „fără email”, pentru că ?? tratează proprietatea neinițializată ca lipsă. A doua aruncă Error: Typed property User::$id must not be accessed before initialization. O proprietate tipizată fără valoare implicită nu e null, ci neinițializată, chiar dacă tipul e nullable.

Din PHP 7.4, proprietățile pot avea tip. O proprietate tipizată fără valoare implicită pornește în starea specială uninitialized, diferită de null. Citirea ei aruncă Error. Proprietățile fără tip pornesc în continuare cu null.

Detaliul care surprinde: și ?string $email e neinițializată. Tipul nullable spune că poate primi null, nu că primește automat null. Ca să pornească de la null scrii public ?string $email = null;.

isset() și ?? nu aruncă eroare pe o proprietate neinițializată, ci o tratează ca nesetată. De aceea prima linie funcționează.

Cum eviți problema:

PHP
class User {
    public function __construct(
        public int $id,
        public ?string $email = null,
    ) {}
}

Cu promovarea în constructor, obiectul nu poate exista fără id. Asta e ideea de bază: un obiect ar trebui să fie valid imediat după construire.

Unde e utilă starea neinițializată: la hidratare (ORM-uri, deserializare), când obiectul e creat fără constructor și proprietățile sunt completate ulterior. Pentru proprietăți readonly, starea neinițializată e obligatorie, pentru că valoarea se poate atribui o singură dată, din interiorul clasei.

Ca depanare, ReflectionProperty::isInitialized($obj) îți spune starea fără să arunce eroare.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre null și neinițializat la proprietățile tipizate. Majoritatea candidaților cred că ?string pornește automat cu null.

Eroarea, în practică:Typed property accessed before initialization

50 Junior

Scrie o clasă care numără câte obiecte au fost create. Ce diferență este între o proprietate statică și una de instanță și de ce nu poți folosi $this într-o metodă statică?

Răspuns scurt: Folosești o proprietate private static int $count, incrementată în constructor, și o metodă statică count(). Proprietatea statică aparține clasei și e partajată de toate obiectele. O metodă statică nu rulează pe un obiect, deci nu are $this.

PHP
class Comanda
{
    private static int $count = 0;
    public readonly int $numar;

    public function __construct()
    {
        self::$count++;
        $this->numar = self::$count;
    }

    public static function count(): int
    {
        return self::$count;
    }
}

new Comanda(); new Comanda();
echo Comanda::count(); // 2

Diferențe:

  • Proprietatea de instanță ($this->numar) există separat în fiecare obiect.
  • Proprietatea statică (self::$count) există o singură dată, la nivelul clasei. Se accesează cu self::, static:: sau NumeClasa::, cu $ în față.
  • Metoda statică se apelează pe clasă (Comanda::count()) și nu are un obiect curent, de aceea $this aruncă Error. Poate folosi doar alți membri statici sau obiecte primite ca parametri.

Când sunt potrivite membrii statici: constructori numiți (Money::fromCents(100)), funcții utilitare pure, constante și cache-uri la nivel de clasă.

Când devin problemă: starea statică e o formă de variabilă globală. Într-un request PHP-FPM obișnuit dispare la final, dar în teste se păstrează între cazuri, iar în workeri de lungă durată (RoadRunner, Swoole) crește între request-uri. Codul care folosește metode statice pentru dependențe (Db::query()) e greu de testat, pentru că dependența nu poate fi înlocuită cu un obiect fals. În aplicații mari preferi dependențe injectate prin constructor.

Atenție la moștenire: o proprietate statică declarată doar în părinte e partajată și de clasele copil.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței clasă/obiect prin membrii statici. Un răspuns bun menționează și dezavantajele stării statice.

Eroarea, în practică:Using $this when not in object contextAccess to undeclared static property

51 Junior

Scrie un mic builder de query cu interfață fluentă: (new Query('users'))->where('activ = 1')->orderBy('nume')->limit(10)->toSql(). Ce tip de return pui pe metode?

Răspuns scurt: Fiecare metodă modifică starea și întoarce $this, cu tipul de return static, ca subclasele să păstreze înlănțuirea. Metoda finală toSql() întoarce stringul. Pentru siguranță, builder-ul poate fi și imutabil, întorcând un clone modificat.

PHP
class Query
{
    private array $wheres = [];
    private ?string $order = null;
    private ?int $limit = null;

    public function __construct(private string $table) {}

    public function where(string $cond): static
    {
        $this->wheres[] = $cond;
        return $this;
    }

    public function orderBy(string $col): static
    {
        $this->order = $col;
        return $this;
    }

    public function limit(int $n): static
    {
        $this->limit = $n;
        return $this;
    }

    public function toSql(): string
    {
        $sql = "SELECT * FROM {$this->table}";
        if ($this->wheres) $sql .= ' WHERE ' . implode(' AND ', $this->wheres);
        if ($this->order)  $sql .= " ORDER BY {$this->order}";
        if ($this->limit !== null) $sql .= " LIMIT {$this->limit}";
        return $sql;
    }
}

De ce static și nu self: dacă class UserQuery extends Query are metode proprii, $q->where(...)->doarActivi() trebuie să știe că obiectul e UserQuery. Tipul static (PHP 8.0) spune exact asta.

Variantă imutabilă, preferată când același builder e refolosit:

PHP
public function where(string $cond): static
{
    $copy = clone $this;
    $copy->wheres[] = $cond;
    return $copy;
}

Așa, $baza->where('a') și $baza->where('b') nu se influențează reciproc.

La interviu e bine să spui și limita exemplului: condițiile sunt stringuri brute. Un builder real folosește placeholder-e și valori legate prin PDO, iar numele de tabele și coloane le verifică într-o listă albă.

Ce urmărește intervievatorul: Exercițiu de OOP de bază cu un pattern foarte folosit. Se verifică returnul $this, tipul static și conștientizarea problemei de SQL injection.

52 Junior

Ce diferență este între instanceof, get_class($obj), $obj::class și Clasa::class? Ce afișează $admin instanceof User dacă Admin extends User?

Răspuns scurt: Afișează true: instanceof verifică întreaga ierarhie, inclusiv interfețele implementate. get_class($obj) și $obj::class (PHP 8.0) întorc numele exact al clasei obiectului, iar Clasa::class întoarce numele complet calificat, la compilare, fără să încarce clasa.

PHP
interface CanLogin {}
class User implements CanLogin {}
class Admin extends User {}

$admin = new Admin();

var_dump($admin instanceof Admin);     // true
var_dump($admin instanceof User);      // true, clasă părinte
var_dump($admin instanceof CanLogin);  // true, interfață moștenită
echo get_class($admin);                // Admin
echo $admin::class;                    // Admin (PHP 8.0+)
echo User::class;                      // User, sau App\Models\User cu namespace

Când folosești fiecare:

  • instanceof pentru decizii de comportament: „obiectul știe să facă X?”. Verifici preferabil o interfață, nu o clasă concretă, ca să respecți polimorfismul. instanceof pe ceva care nu e obiect întoarce false, fără eroare.
  • get_class / $obj::class pentru loguri, mesaje de eroare și chei de cache. Compararea get_class($x) === User::class e fragilă, pentru că exclude subclasele.
  • Clasa::class în loc de stringuri scrise de mână: $container->get(Mailer::class), #[Route(controller: HomeController::class)]. IDE-ul îl recunoaște la redenumiri, iar o greșeală de tipar apare imediat.

Ca observație de design: multe if ($x instanceof A) ... elseif ($x instanceof B) într-un loc sunt un semn că logica ar trebui mutată într-o metodă comună a acelor clase, numită polimorfic. În PHP 8 poți scrie și match (true) { $x instanceof A => ..., default => ... }, dar problema de design rămâne aceeași.

is_a($obj, User::class) și is_subclass_of sunt echivalente funcționale, utile când numele clasei e într-o variabilă.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre tipul exact și ierarhia de tipuri. Intervievatorul apreciază când candidatul preferă verificarea pe interfețe.

Eroarea, în practică:Calling get_class() without arguments is deprecated

53 Junior

Ai un enum Status: string cu cazurile Paid = 'paid' și New = 'new'. Cum obții cazul dintr-o valoare venită din baza de date, ce face from față de tryFrom și cum adaugi o etichetă afișabilă?

Răspuns scurt: Status::from('paid') întoarce Status::Paid și aruncă ValueError pentru o valoare necunoscută, iar tryFrom întoarce null. Eticheta o pui într-o metodă a enum-ului, cu match ($this). Lista cazurilor se obține cu Status::cases().

Un backed enum (PHP 8.1) asociază fiecărui caz o valoare string sau int, potrivită pentru stocare în baza de date sau pentru API-uri:

PHP
enum Status: string
{
    case New = 'new';
    case Paid = 'paid';

    const DEFAULT = self::New;

    public function label(): string
    {
        return match ($this) {
            self::New => 'Nouă',
            self::Paid => 'Plătită',
        };
    }

    public function isFinal(): bool
    {
        return $this === self::Paid;
    }
}

$s = Status::from($row['status']);         // ValueError dacă valoarea nu există
$s = Status::tryFrom($_GET['status'] ?? '') ?? Status::DEFAULT;
echo $s->value;                            // 'paid'
echo $s->name;                             // 'Paid'
echo $s->label();

Când folosești fiecare: from pentru date în care ai încredere (baza ta de date), unde o valoare necunoscută e un bug și trebuie să oprească execuția. tryFrom pentru input de la utilizator, unde tratezi lipsa cu o valoare implicită sau un mesaj de eroare.

Alte facilități:

  • Status::cases() întoarce toate cazurile, util pentru <select> în formulare.
  • Enum-urile pot implementa interfețe și pot folosi traits fără proprietăți.
  • Un match pe un enum fără default aruncă UnhandledMatchError dacă adaugi un caz nou și uiți să-l tratezi. PHPStan îți semnalează asta încă de la analiză.
  • Cazurile sunt singletoni, deci se compară cu ===.
  • Enum-urile nu pot avea proprietăți proprii (stare) și nu pot fi instanțiate cu new.

Ce urmărește intervievatorul: Întrebarea merge dincolo de „ce e un enum” și verifică folosirea practică. Greșeala tipică e folosirea lui from direct pe inputul utilizatorului.

Eroarea, în practică:is not a valid backing value for enumCase of backed enum must have a value

54 Junior

Când se apelează __destruct? Ce afișează codul?

PHP
class Fisier {
    public function __construct(public string $nume) { echo "deschid {$this->nume}\n"; }
    public function __destruct() { echo "închid {$this->nume}\n"; }
}
function lucreaza() {
    $f = new Fisier('a.txt');
    echo "lucrez\n";
}
lucreaza();
echo "gata\n";

Răspuns scurt: Afișează „deschid a.txt”, „lucrez”, „închid a.txt”, „gata”. Destructorul se apelează când nu mai există nicio referință la obiect, aici la ieșirea din funcție, sau la finalul scriptului pentru obiectele rămase.

PHP folosește numărarea referințelor (reference counting). Când ultima variabilă care indică un obiect dispare (iese din scope, primește altă valoare sau i se face unset), obiectul e distrus imediat, iar __destruct rulează în acel moment. În exemplu, $f e locală, deci obiectul moare la }-ul funcției, înainte de „gata”.

Cazuri în care momentul se schimbă:

  • dacă funcția ar fi returnat $f și rezultatul ar fi fost salvat, obiectul ar fi trăit mai departe
  • obiectele implicate în referințe circulare nu sunt distruse imediat, ci când rulează garbage collector-ul de cicluri sau la final
  • la finalul scriptului, obiectele rămase sunt distruse într-o ordine pe care nu ar trebui să te bazezi
  • dacă scriptul se oprește cu o eroare fatală sau cu exit dintr-un destructor, alți destructori pot să nu mai ruleze

Ce pui într-un destructor: eliberarea resurselor pe care le deține obiectul (un fișier temporar, un lock, o conexiune proprie). Ce nu pui: logică de business importantă, ca salvarea în baza de date sau trimiterea unui email, pentru că nu ai garanții clare despre momentul rulării și o excepție aruncată acolo e greu de tratat.

PHP închide automat resursele interne (fișiere deschise cu fopen, conexiuni PDO) când obiectul sau variabila dispare. Destructorii sunt deci rar necesari în codul de aplicație. Pentru curățenie sigură în cazul excepțiilor, try / finally e de obicei o alegere mai explicită.

Ce urmărește intervievatorul: Arată dacă înțelegi ciclul de viață al obiectelor. Candidații cred des că destructorul rulează doar la finalul scriptului.

55 Junior

Ce sunt constructorii numiți (named constructors)? Scrie o clasă Money care se poate crea din bani (fromBani(150)) și din lei (fromLei('1.50')), fără să permiți new Money(...) din exterior.

Răspuns scurt: Sunt metode statice care creează obiectul și au nume care explică sursa datelor. Faci constructorul private și expui fromBani() și fromLei(), fiecare validând și convertind inputul. Așa obiectul e mereu valid, iar codul care îl folosește e mai clar.

PHP permite un singur constructor pe clasă, fără supraîncărcare. Când un obiect se poate crea din surse diferite, metodele statice cu nume clare rezolvă problema:

PHP
final class Money
{
    private function __construct(public readonly int $bani)
    {
        if ($bani < 0) {
            throw new InvalidArgumentException('Suma nu poate fi negativă');
        }
    }

    public static function fromBani(int $bani): self
    {
        return new self($bani);
    }

    public static function fromLei(string $lei): self
    {
        if (!preg_match('/^\d+(\.\d{1,2})?$/', $lei)) {
            throw new InvalidArgumentException("Sumă invalidă: $lei");
        }
        return new self((int) round((float) $lei * 100));
    }

    public function add(Money $o): self
    {
        return new self($this->bani + $o->bani);
    }
}

$total = Money::fromLei('1.50')->add(Money::fromBani(25)); // 175 de bani

Avantaje:

  • Intenția e vizibilă: Money::fromLei('1.50') nu poate fi confundat cu 150 de lei, cum s-ar întâmpla cu new Money(150).
  • Validarea e centralizată: constructorul privat garantează că orice obiect Money trece prin aceleași reguli.
  • Imutabilitate: add întoarce un obiect nou, deci valoarea nu se schimbă accidental.

Exemple din biblioteca standard: DateTimeImmutable::createFromFormat(), iar enum-urile au from() și tryFrom().

Conversia din float folosește round, pentru că 1.15 * 100 dă 114.99999999999999, iar (int) simplu ar trunchia la 114. Dacă vrei să eviți complet float-ul, parsezi separat partea întreagă și zecimalele ca stringuri.

Ce urmărește intervievatorul: Verifică dacă știi să proiectezi obiecte valide și expresive, fără supraîncărcarea constructorilor. Detaliul cu rotunjirea arată atenție la bani.

Eroarea, în practică:Call to private __construct() from global scope

56 Mid

Ce sunt property hooks și asymmetric visibility din PHP 8.4? Rescrie un getter și un setter clasic folosindu-le.

Răspuns scurt: Property hooks permit cod get și set direct pe proprietate, deci validarea rămâne la accesul $obj->name, fără metode getName()/setName(). Asymmetric visibility (public private(set)) permite citirea publică și scrierea doar din interiorul clasei.

Înainte de PHP 8.4, pentru validare foloseai proprietăți private și metode:

PHP
class Persoana {
    private string $nume;
    public function getNume(): string { return $this->nume; }
    public function setNume(string $v): void {
        if (trim($v) === '') throw new InvalidArgumentException('Nume gol');
        $this->nume = $v;
    }
}

Cu property hooks:

PHP
class Persoana
{
    public string $nume {
        set(string $v) {
            if (trim($v) === '') {
                throw new InvalidArgumentException('Nume gol');
            }
            $this->nume = trim($v);
        }
    }

    public string $salut {
        get => "Bună, {$this->nume}!";   // proprietate virtuală, fără stocare
    }

    public private(set) int $vizite = 0;  // citire publică, scriere internă

    public function viziteaza(): void { $this->vizite++; }
}

$p = new Persoana();
$p->nume = '  Ana ';
echo $p->salut;      // Bună, Ana!
$p->vizite = 10;     // Error: Cannot modify private(set) property

Ce aduc:

  • API-ul clasei rămâne simplu ($p->nume), iar dacă ulterior ai nevoie de validare, o adaugi fără să schimbi codul care folosește clasa.
  • O proprietate cu doar get care nu folosește valoarea stocată e virtuală și nu ocupă memorie.
  • Hooks pot fi declarate și în interfețe: interface HasName { public string $name { get; } }.

Asymmetric visibility înlocuiește pattern-ul „proprietate privată + getter”. Funcționează și în promovarea din constructor: public function __construct(public private(set) string $id). Proprietățile readonly primesc implicit protected(set).

Limitări: hooks nu merg pe proprietăți statice, iar readonly nu poate fi combinat cu hooks. Sunt disponibile doar din PHP 8.4, deci contează versiunea minimă a proiectului.

Ce urmărește intervievatorul: Întrebarea verifică dacă urmărești noutățile limbajului. Intervievatorii apreciază când știi și limitările, nu doar sintaxa.

Eroarea, în practică:Property is read-only (property hook)No default value for virtual hooked property

57 Mid

Ai o clasă readonly Money cu amount și currency. Cum scrii o metodă withAmount() care întoarce o copie modificată? Ce eroare apare la $this->items[] = $x pe o proprietate readonly array?

Răspuns scurt: În PHP 8.5, withAmount întoarce clone($this, ['amount' => $a]); înainte, creai un obiect nou cu new static($a, $this->currency). Adăugarea într-un array readonly aruncă „Cannot indirectly modify readonly property”, pentru că și modificarea conținutului e o scriere.

O proprietate readonly (PHP 8.1) poate fi atribuită o singură dată, din interiorul clasei, de obicei în constructor. O clasă readonly (PHP 8.2) face toate proprietățile ei readonly. Pentru obiecte-valoare imutabile, metodele „wither” întorc un obiect nou în loc să-l modifice pe cel curent:

PHP
final readonly class Money
{
    public function __construct(
        public int $amount,
        public string $currency,
    ) {}

    public function withAmount(int $amount): static
    {
        return new static($amount, $this->currency);      // orice PHP 8.2+
        // return clone($this, ['amount' => $amount]);    // PHP 8.5
    }
}

$a = new Money(100, 'RON');
$b = $a->withAmount(250);   // $a rămâne 100

De ce nu merge clone simplu urmat de atribuire: obiectul clonat are deja proprietatea inițializată, deci o nouă atribuire e interzisă. PHP 8.3 a permis reinițializarea proprietăților readonly în __clone(), iar PHP 8.5 a adăugat clone($obj, [...]), care face exact ce cere un wither. Apelul trebuie făcut din interiorul clasei, pentru că o proprietate readonly are implicit protected(set).

Despre array-uri: readonly array $items interzice și $this->items[] = $x, și $this->items['k'] = 1, pentru că amândouă modifică valoarea proprietății. Primești Error: Cannot indirectly modify readonly property. Creezi un array nou și un obiect nou.

Limita importantă: readonly e „superficial”. Dacă proprietatea conține un obiect mutabil (de exemplu un DateTime), obiectul acela poate fi modificat în continuare. Pentru imutabilitate reală folosești în interior tot obiecte imutabile, cum e DateTimeImmutable.

Ce urmărește intervievatorul: Verifică experiența practică cu obiecte imutabile, nu doar definiția lui readonly. Candidații încearcă des clone plus atribuire și se lovesc de eroare.

Eroarea, în practică:Cannot modify readonly property

58 Mid

O clasă folosește două traits care definesc amândouă metoda hi(). Cum rezolvi conflictul? Pot traits să aibă metode abstracte și membri statici?

Răspuns scurt: Cu insteadof alegi ce implementare câștigă, iar cu as păstrezi cealaltă sub alt nume, eventual cu altă vizibilitate. Da: un trait poate declara metode abstracte pe care clasa trebuie să le implementeze, proprietăți și metode statice, iar din PHP 8.2 și constante.

Dacă două traits aduc o metodă cu același nume, PHP dă eroare fatală până când spui explicit ce vrei:

PHP
trait Logger  { public function hi(): string { return 'log'; } }
trait Greeter { public function hi(): string { return 'salut'; } }

class Service
{
    use Logger, Greeter {
        Greeter::hi insteadof Logger;      // hi() vine din Greeter
        Logger::hi as protected logHi;     // păstrezi și varianta Logger
    }
}

as poate și doar să schimbe vizibilitatea: use Greeter { hi as private; }.

Alte reguli utile:

  • Prioritate: o metodă definită în clasă suprascrie metoda din trait, care la rândul ei suprascrie metoda moștenită din părinte.
  • Metode abstracte: un trait poate cere clasei o metodă, de exemplu abstract protected function tableName(): string;. Din PHP 8.0, semnătura implementării e verificată.
  • Statice: fiecare clasă care folosește trait-ul primește propria copie a proprietăților statice, deci nu sunt partajate între clase, spre deosebire de moștenire.
  • Constante în traits sunt permise din PHP 8.2.
  • Proprietăți: dacă clasa definește o proprietate cu același nume ca trait-ul, trebuie să fie compatibilă (aceeași vizibilitate și valoare inițială), altfel e eroare.
  • self din trait se referă la clasa care îl folosește, iar __CLASS__ dă tot numele acelei clase.

Ca design, conflictele frecvente de nume sunt un semnal că traits sunt folosite pentru prea mult. Ele sunt bune pentru comportament mic și reutilizabil (timestamps, un helper de logging). Pentru logică de business, compoziția prin obiecte injectate e mai ușor de testat.

Ce urmărește intervievatorul: Întrebare dintr-un unghi practic despre traits: rezolvarea conflictelor. Intervievatorul verifică dacă ai folosit traits în cod real, nu doar definiția lor.

Eroarea, în practică:Trait method has not been applied, collision

59 Mid

Scrie o clasă Collection care poate fi parcursă cu foreach, numărată cu count() și accesată ca array ($c[0]). Ce interfețe implementezi?

Răspuns scurt: Implementezi IteratorAggregate (metoda getIterator(), cel mai simplu cu un generator sau ArrayIterator), Countable (metoda count()) și ArrayAccess (offsetExists, offsetGet, offsetSet, offsetUnset). Opțional JsonSerializable pentru json_encode.

PHP
/** @template T */
final class Collection implements IteratorAggregate, Countable, ArrayAccess, JsonSerializable
{
    /** @param array<int, T> $items */
    public function __construct(private array $items = []) {}

    public function getIterator(): Iterator
    {
        yield from $this->items;
    }

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

    public function offsetExists(mixed $offset): bool { return isset($this->items[$offset]); }
    public function offsetGet(mixed $offset): mixed { return $this->items[$offset] ?? null; }
    public function offsetSet(mixed $offset, mixed $value): void
    {
        $offset === null ? $this->items[] = $value : $this->items[$offset] = $value;
    }
    public function offsetUnset(mixed $offset): void { unset($this->items[$offset]); }

    public function map(callable $fn): self
    {
        return new self(array_map($fn, $this->items));
    }

    public function jsonSerialize(): array
    {
        return array_values($this->items);
    }
}

$c = new Collection([1, 2]);
$c[] = 3;
foreach ($c as $x) echo $x;
echo count($c), json_encode($c->map(fn($x) => $x * 10));

Explicații:

  • IteratorAggregate e mai simplu decât Iterator, care cere cinci metode (current, key, next, rewind, valid). Un generator în getIterator() rezolvă totul.
  • offsetSet cu null tratează sintaxa $c[] = 3.
  • Tipurile de return trebuie declarate. Fără ele, PHP 8.1+ afișează Deprecated pentru incompatibilitate cu interfața internă.
  • Funcțiile pentru array-uri (array_map, in_array, sort) nu funcționează pe obiecte ArrayAccess, motiv pentru care colecțiile își definesc metode proprii, ca map sau filter.

Stringable este implementată automat de orice clasă cu __toString().

Ce urmărește intervievatorul: Verifică familiaritatea cu interfețele predefinite din PHP, pe care se bazează colecțiile din framework-uri. Se urmărește și dacă știi diferența Iterator / IteratorAggregate.

Eroarea, în practică:Return type of ... should be compatiblemust implement interface Traversable as part of...

60 Mid

De ce apare „Deprecated: Creation of dynamic property” în PHP 8.2? Cum repari un proiect vechi plin de astfel de mesaje?

Răspuns scurt: Din PHP 8.2, atribuirea unei proprietăți nedeclarate pe un obiect ($obj->x = 1) e deprecated, iar în PHP 9 va deveni eroare. Repari declarând proprietățile în clasă. Ca soluție temporară sau pentru cazuri intenționate există atributul #[AllowDynamicProperties], iar stdClass și clasele cu __set rămân permise.

Proprietățile dinamice au permis mereu cod ca:

PHP
class User {}
$u = new User();
$u->emial = 'ana@site.ro'; // greșeală de tipar, creează o proprietate nouă

Aici nu apărea nicio eroare, iar bug-ul se vedea abia când $u->email era gol. RFC-ul pentru PHP 8.2 a marcat practica ca deprecated, ca limbajul să prindă astfel de greșeli.

Ce rămâne permis fără avertisment:

  • obiectele stdClass (inclusiv cele din json_decode fără true)
  • clasele care definesc __get și __set, pentru că gestionează explicit proprietățile
  • clasele marcate cu #[\AllowDynamicProperties], atribut moștenit de subclase

Plan de reparare într-un proiect vechi:

  • găsești toate cazurile cu PHPStan (nivelul de bază le raportează) sau din logurile cu Deprecated
  • declari proprietățile lipsă, cu tip: public ?string $email = null;
  • dacă o clasă chiar stochează date arbitrare, le muți într-o proprietate array $data cu metode de acces
  • pentru cod terț pe care nu-l poți modifica, adaugi temporar #[AllowDynamicProperties] pe clasele afectate și notezi asta ca datorie tehnică
  • Rector are o regulă care adaugă automat proprietățile declarate pe baza atribuirilor găsite

Merită făcut acum, nu la upgrade-ul spre PHP 9: proprietățile declarate sunt mai rapide și mai compacte în memorie, iar IDE-ul le poate completa automat.

Ce urmărește intervievatorul: Arată dacă ai trecut prin migrări reale de versiune. Intervievatorul apreciază un plan concret, nu doar „pun atributul peste tot”.

Eroarea, în practică:Creation of dynamic property is deprecated

61 Senior

Ce înseamnă covarianța tipurilor de return și contravarianța parametrilor în PHP? Care dintre metodele de mai jos sunt valide?

PHP
interface Repo {
    public function find(int $id): ?Entity;
    public function save(User $u): void;
}
class UserRepo implements Repo {
    public function find(int|string $id): User { /* ... */ }
    public function save(Entity $u): void { /* ... */ }
}

(presupune că User extends Entity)

Răspuns scurt: Ambele sunt valide din PHP 7.4. O clasă copil poate restrânge tipul de return (covarianță: User în loc de ?Entity) și poate lărgi tipul parametrilor (contravarianță: int|string în loc de int, Entity în loc de User). Invers nu e permis.

Regulile vin din principiul de substituție Liskov (LSP): oriunde codul folosește un Repo, trebuie să poată primi un UserRepo fără surprize.

Covarianța return-ului: clasa copil poate promite ceva mai specific. Cine apelează find() pe un Repo așteaptă ?Entity. Un User (care e un Entity, niciodată null) respectă promisiunea, deci e permis.

Contravarianța parametrilor: clasa copil poate accepta mai mult. Cine apelează save() trimite un User. Dacă UserRepo::save acceptă orice Entity, acceptă sigur și un User. La fel, int|string include int.

Ce nu e permis:

PHP
public function find(int $id): mixed;     // return mai larg: eroare fatală
public function save(Admin $u): void;     // parametru mai îngust: eroare fatală

Dacă subclasa ar cere un Admin, codul care îi dă un User obișnuit ar crăpa.

Alte reguli conexe:

  • vizibilitatea poate fi doar lărgită (protected devine public), nu restrânsă
  • un parametru nou în subclasă trebuie să fie opțional
  • static ca tip de return e covariant prin definiție
  • proprietățile tipizate sunt invariante: tipul trebuie să rămână identic, pentru că sunt și citite, și scrise. Excepție fac proprietățile cu hooks doar de citire, din PHP 8.4.

Suportul complet pentru varianță a venit în PHP 7.4. Înainte, semnăturile trebuiau să fie identice, ceea ce forța documentarea tipurilor reale doar în PHPDoc.

Ce urmărește intervievatorul: Întrebare de senior despre corectitudinea ierarhiilor. Se verifică dacă știi regulile și motivul lor (LSP), nu doar dacă le-ai memorat.

62 Senior

Ce este WeakMap (PHP 8.0) și ce problemă rezolvă față de un array indexat cu spl_object_id($obj)?

Răspuns scurt: WeakMap asociază date unor obiecte folosite ca chei, fără să țină acele obiecte în viață. Când obiectul e distrus, intrarea dispare automat. Un array cu spl_object_id ține datele după moartea obiectului, iar ID-ul poate fi refolosit de un obiect nou, ceea ce produce date greșite.

Scenariu tipic: vrei un cache cu informații calculate pentru obiecte pe care nu le controlezi (entități ORM, request-uri), fără să adaugi proprietăți în clasele lor.

Varianta cu array:

PHP
private array $cache = [];
public function meta(object $o): array {
    return $this->cache[spl_object_id($o)] ??= $this->compute($o);
}

Probleme:

  • Array-ul nu știe când obiectul moare, deci memoria crește continuu într-un proces lung.
  • spl_object_id e unic doar cât timp obiectul trăiește. După distrugere, același ID poate fi dat unui obiect nou, care primește din cache datele altui obiect. E un bug greu de reprodus.
  • Dacă ții obiectul în array ca să eviți refolosirea ID-ului, îl împiedici să fie eliberat, deci ai o scurgere de memorie.

Cu WeakMap:

PHP
private WeakMap $cache;
public function __construct() { $this->cache = new WeakMap(); }

public function meta(object $o): array {
    return $this->cache[$o] ??= $this->compute($o);
}

Cheia e obiectul însuși, ținut printr-o referință slabă: nu crește contorul de referințe. Când nu mai există alte referințe, obiectul e distrus, iar intrarea din WeakMap dispare automat. count($cache) scade în consecință.

Unde e util concret: ORM-uri event dispatchers, memoizare per obiect, aplicații pe workeri de lungă durată.

Pentru o singură referință fără map există WeakReference::create($obj) (PHP 7.4), cu ->get(), care întoarce null după ce obiectul a fost distrus.

Ce urmărește intervievatorul: Întrebare de senior despre memorie și ciclul de viață al obiectelor. Puțini candidați știu că ID-urile de obiect se refolosesc.

Excepții și erori

Exersează capitolul cu exerciții reale: Curs PHP online →
63 Junior

Ce afișează fiecare apel?

PHP
function a() {
    try { return "try"; }
    finally { echo "finally "; }
}
function b() {
    try { return "try"; }
    finally { return "finally"; }
}
echo a(), "\n";
echo b(), "\n";

Răspuns scurt: Primul afișează finally try, al doilea finally. Blocul finally rulează mereu înainte ca funcția să iasă, chiar și după return. Dacă finally are propriul return, acesta înlocuiește valoarea din try.

Ordinea pentru a(): return "try" calculează valoarea de return și o păstrează, apoi rulează finally, care afișează „finally ”, iar abia apoi funcția se întoarce și echo afișează „try”. De aceea „finally” apare primul pe linie.

În b(), finally execută propriul return, care înlocuiește valoarea păstrată. Mai grav, un return în finally înghite și excepțiile:

PHP
function c() {
    try { throw new RuntimeException('Eroare importantă'); }
    finally { return 'ok'; } // excepția dispare fără urmă
}
echo c(); // ok

De aceea regula practică este: în finally nu pui return, break sau continue, ci doar cod de curățenie.

La ce e bun finally:

PHP
$lock = fopen('/tmp/import.lock', 'c');
flock($lock, LOCK_EX);
try {
    importa();
} finally {
    flock($lock, LOCK_UN);  // rulează și dacă importa() aruncă excepție
    fclose($lock);
}

Garanția e că eliberarea resursei se face indiferent cum se termină blocul try: normal, cu return sau cu o excepție care merge mai departe. finally nu rulează doar dacă procesul e oprit brusc (exit în anumite cazuri, eroare fatală de memorie, kill de la sistem).

Poți avea try / finally fără catch: excepția se propagă, dar curățenia se face.

Ce urmărește intervievatorul: Verifică dacă înțelegi ordinea exactă de execuție. Intervievatorul punctează în plus dacă știi că return în finally ascunde excepții.

64 Junior

Cum prinzi mai multe tipuri de excepții în același bloc? Contează ordinea blocurilor catch? Ce prinde catch (Throwable $e)?

Răspuns scurt: Cu catch (InvalidArgumentException | DomainException $e) (PHP 7.1). Ordinea contează: se folosește primul catch compatibil, deci tipurile specifice vin înaintea celor generale. Throwable prinde atât Exception, cât și Error (de exemplu TypeError).

Ierarhia de bază în PHP 7 și 8:

Throwable
├── Exception (RuntimeException, LogicException, JsonException, PDOException...)
└── Error (TypeError, ValueError, ArithmeticError, DivisionByZeroError...)

Exemplu cu mai multe blocuri:

PHP
try {
    $order = $service->place($data);
} catch (ValidationException | DomainException $e) {
    return response($e->getMessage(), 422);
} catch (PDOException $e) {
    $logger->error('DB', ['e' => $e]);
    return response('Încearcă mai târziu', 503);
} catch (Throwable) {          // PHP 8.0: fără variabilă
    return response('Eroare internă', 500);
}

Reguli:

  • PHP verifică blocurile catch de sus în jos și îl folosește pe primul compatibil cu tipul excepției, inclusiv prin moștenire. Un catch (Exception $e) pus primul ar face blocurile specifice de sub el inutile.
  • Din PHP 8.0 poți omite variabila când nu o folosești: catch (Throwable).
  • catch (Exception $e) nu prinde TypeError sau DivisionByZeroError, pentru că acestea moștenesc Error. E o greșeală frecventă în codul migrat de pe PHP 5.
  • Nu poți scrie propria clasă care implementează direct Throwable. Extinzi Exception sau una dintre subclasele ei.

Despre unde prinzi: catch (Throwable) are sens la marginea aplicației (front controller, handler-ul unui job), unde transformi orice eroare într-un răspuns 500 și un log. În logica de business prinzi doar ce poți trata concret. Un catch general în mijlocul codului ascunde bug-uri.

Ce urmărește intervievatorul: Verifică cunoașterea ierarhiei de excepții și a sintaxei multi-catch. Greșeala tipică este credința că Exception prinde tot.

Eroarea, în practică:Fatal error: Uncaught Exception

65 Junior

Când îți creezi propriile clase de excepții? Scrie o excepție PaymentFailedException care păstrează eroarea originală de la procesatorul de plăți.

Răspuns scurt: Când apelantul trebuie să trateze diferit acea situație sau când vrei să adaugi context. Extinzi o excepție SPL potrivită, adaugi date utile și transmiți excepția originală ca $previous, ca să nu pierzi cauza și stack trace-ul.

O excepție proprie e utilă când codul care o prinde ia o decizie pe baza tipului: o plată refuzată se afișează clientului, o eroare de rețea se reîncearcă.

PHP
final class PaymentFailedException extends RuntimeException
{
    public function __construct(
        public readonly string $orderId,
        string $message,
        ?Throwable $previous = null,
    ) {
        parent::__construct($message, 0, $previous);
    }

    public static function fromGateway(string $orderId, Throwable $e): self
    {
        return new self($orderId, "Plata pentru comanda $orderId a eșuat", $e);
    }
}

try {
    $gateway->charge($order);
} catch (GatewayException $e) {
    throw PaymentFailedException::fromGateway($order->id, $e);
}

Puncte importante:

  • $previous păstrează lanțul. În loguri, $e->getPrevious() arată cauza reală, cu mesajul și stack trace-ul ei. Fără el, depanarea devine ghicit.
  • Clasa de bază: RuntimeException pentru erori care țin de mediu (rețea, servicii externe), LogicException pentru greșeli de programare (argument invalid, stare imposibilă), DomainException pentru reguli de business încălcate.
  • Context ca proprietăți (aici orderId), nu doar în mesaj. Codul care prinde excepția le poate folosi fără să parseze text.
  • Constructori numiți (fromGateway) păstrează mesajele consecvente.
  • Mesajul e pentru dezvoltatori și loguri. Ce vede clientul se decide la nivelul de prezentare, ca să nu expui detalii interne.

Nu crea o excepție pentru fiecare funcție. O ierarhie mică pe modul (de exemplu o interfață PaymentException implementată de câteva clase) e suficientă.

Ce urmărește intervievatorul: Arată dacă știi să proiectezi tratarea erorilor, nu doar să folosești try/catch. Greșeala frecventă e pierderea excepției originale.

Eroarea, în practică:Fatal error: Uncaught Exceptioncannot implement interface Throwable

66 Mid

Care e diferența dintre erorile clasice PHP (warning, notice, deprecated) și excepții? Cum configurezi display_errors și log_errors în producție și cum transformi warning-urile în excepții?

Răspuns scurt: Warning-urile și notice-urile nu opresc scriptul, doar raportează, iar excepțiile întrerup execuția dacă nu sunt prinse. În producție: display_errors=Off, log_errors=On, error_reporting=E_ALL. Cu set_error_handler arunci ErrorException pentru warning-uri, ca să nu treacă neobservate.

PHP are două mecanisme istorice:

  • Erori clasice (E_WARNING, E_NOTICE, E_DEPRECATED și altele), raportate de motor sau de funcții. Execuția continuă, iar rezultatul e adesea null sau false. Exemple: „Undefined array key”, „file_get_contents(): Failed to open stream”.
  • Excepții (Throwable), care urcă pe stivă până la un catch sau opresc scriptul.

PHP 8 a transformat multe erori în excepții (TypeError, ValueError), dar warning-urile au rămas.

Configurare recomandată:

; producție
error_reporting = E_ALL
display_errors = Off
log_errors = On
error_log = /var/log/php/app.log

; dezvoltare
display_errors = On

Afișarea erorilor în producție scurge informații (căi, fragmente de cod, uneori parole din DSN), iar dezactivarea completă a raportării ascunde problemele. Corect: raportezi tot, dar doar în log.

Transformarea warning-urilor în excepții:

PHP
set_error_handler(function (int $no, string $msg, string $file, int $line): bool {
    if (!(error_reporting() & $no)) {
        return false; // eroare suprimată cu @ sau dezactivată
    }
    throw new ErrorException($msg, 0, $no, $file, $line);
});

Astfel, un fișier inexistent sau o cheie lipsă devine o excepție vizibilă, cu stack trace, iar bug-ul nu mai produce date greșite în tăcere. Framework-urile moderne fac asta implicit în dezvoltare. Operatorul @ suprimă raportarea, iar din PHP 8 nu mai poate ascunde erorile fatale.

Ce urmărește intervievatorul: Verifică dacă știi să configurezi un mediu de producție sigur și să nu ignori warning-urile. Mulți candidați lasă display_errors=On sau dezactivează raportarea.

Eroarea, în practică:E_USER_ERROR to trigger_error() is deprecated

67 Mid

Ce aruncă fiecare linie în PHP 8?

PHP
echo 1 % 0;
echo 1 / 0;
echo intdiv(1, 0);
echo str_repeat('x', -1);
echo strlen([]);
echo fdiv(1, 0);

Răspuns scurt: Primele trei aruncă DivisionByZeroError („Modulo by zero”, „Division by zero”), str_repeat aruncă ValueError, strlen([]) aruncă TypeError, iar fdiv(1, 0) întoarce INF fără eroare. În PHP 7, 1 / 0 dădea doar un warning și INF.

PHP 8.0 a făcut comportamentul funcțiilor interne mult mai consecvent:

  • DivisionByZeroError (subclasă de ArithmeticError, deci de Error) pentru /, % și intdiv cu împărțitor zero. În PHP 7, / dădea warning și INF, iar % arunca deja eroare.
  • fdiv() (PHP 8.0) urmează standardul IEEE 754 pentru float-uri: întoarce INF, -INF sau NAN. E utilă în calcule științifice unde infinitul e o valoare acceptată.
  • ValueError (nou în PHP 8.0) pentru argumente de tip corect, dar cu valoare invalidă: str_repeat('x', -1), array_combine cu array-uri de lungimi diferite, array_chunk($a, 0). Înainte, aceste funcții întorceau false sau null cu un warning.
  • TypeError pentru tip greșit la funcțiile interne, indiferent de strict_types, dacă tipul nu poate fi convertit: un array nu devine niciodată string.

Mesajele sunt și ele mai clare: „str_repeat(): Argument #2 ($times) must be greater than or equal to 0”.

Consecința practică la migrare: codul vechi care verifica if ($rez === false) după astfel de apeluri nu mai ajunge la verificare, pentru că excepția se aruncă înainte. Validezi inputul înainte de apel (de exemplu if ($total === 0) înainte de împărțire) și prinzi Error doar la nivelul aplicației.

ArithmeticError mai apare la intdiv(PHP_INT_MIN, -1) și la deplasări de biți cu valori negative.

Ce urmărește intervievatorul: Întrebarea verifică dacă știi schimbările din PHP 8 la tratarea erorilor interne. Mulți candidați cred că împărțirea la zero dă încă un warning.

Eroarea, în practică:strlen(): Argument #1 must be of type stringDivisionByZeroError: Division by zero

68 Mid

Cum prinzi și loghezi erorile fatale care nu pot fi prinse cu try/catch, de exemplu „Allowed memory size exhausted” sau „Maximum execution time exceeded”?

Răspuns scurt: Cu register_shutdown_function, care rulează la finalul scriptului chiar și după o eroare fatală. În ea citești error_get_last() și, dacă tipul este E_ERROR sau similar, loghezi și trimiți un răspuns curat. Excepțiile neprinse se tratează separat cu set_exception_handler.

Unele erori opresc motorul PHP imediat și nu sunt excepții: depășirea memory_limit, depășirea max_execution_time, unele erori de compilare. Nu ajung în niciun catch.

PHP
set_exception_handler(function (Throwable $e): void {
    error_log((string) $e);
    http_response_code(500);
    echo 'A apărut o eroare. Încearcă din nou.';
});

register_shutdown_function(function (): void {
    $err = error_get_last();
    $fatal = E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR;
    if ($err !== null && ($err['type'] & $fatal)) {
        error_log(sprintf('FATAL %s in %s:%d', $err['message'], $err['file'], $err['line']));
        if (!headers_sent()) {
            http_response_code(500);
        }
    }
});

Detalii care fac diferența:

  • Memoria: la „memory exhausted”, funcția de shutdown are foarte puțină memorie. Unele aplicații rezervă un buffer la pornire ($reserve = str_repeat(' ', 1024 * 64);) și îl eliberează primul lucru în handler.
  • Timpul: max_execution_time măsoară doar timpul de execuție PHP pe Linux, nu așteptarea după baza de date sau rețea. Un script care pare blocat poate să nu fie oprit de această limită. Pe CLI limita implicită e 0, adică nelimitat.
  • set_exception_handler se ocupă de excepțiile neprinse. După rularea lui scriptul se oprește.
  • Ordinea: întâi handler-ul de excepții (dacă e cazul), apoi funcțiile de shutdown, apoi destructorii.

În aplicații reale, aceste handler-e trimit evenimentul și către un serviciu de monitorizare a erorilor (Sentry, de exemplu), unde vezi frecvența și contextul.

Ce urmărește intervievatorul: Arată dacă ai depanat aplicații în producție, unde erorile fatale fără log sunt cele mai greu de investigat. Puțini candidați știu de error_get_last și limitele de memorie din handler.

Eroarea, în practică:Allowed memory size of 134217728 bytes exhausted

69 Senior

Când arunci o excepție și când întorci null, false sau un obiect rezultat? Cum ai proiecta tratarea erorilor pentru un modul de import de comenzi dintr-un CSV?

Răspuns scurt: Arunci excepție când operația nu își poate respecta contractul (date corupte, serviciu căzut) și apelantul trebuie oprit. Întorci null când lipsa e un rezultat normal (findByEmail). Pentru operații cu multe erori așteptate, ca validarea rândurilor dintr-un import, întorci un obiect rezultat care colectează erorile.

Câteva criterii:

  • null pentru absență normală: findUserByEmail() care nu găsește nimic. Tipul ?User o spune explicit, iar PHPStan obligă apelantul să trateze cazul. Dacă absența e de fapt o eroare, există o a doua metodă care aruncă: getUserById() aruncă UserNotFound.
  • false e un stil vechi al funcțiilor interne (strpos, fopen), ambiguu și ușor de confundat cu 0. În cod nou nu îl folosești ca semnal de eroare.
  • Excepții pentru situații în care codul nu poate continua corect: conexiune pierdută, configurație lipsă, invariant încălcat. Avantajul: nu pot fi ignorate din greșeală.
  • Obiect rezultat când erorile sunt așteptate și multiple.

Pentru importul de comenzi:

PHP
final class ImportResult
{
    /** @var list<array{line:int, error:string}> */
    public array $errors = [];
    public int $imported = 0;
}

foreach ($reader->rows() as $line => $row) {
    try {
        $service->import(OrderRow::fromArray($row)); // aruncă ValidationException
        $result->imported++;
    } catch (ValidationException $e) {
        $result->errors[] = ['line' => $line, 'error' => $e->getMessage()];
    }
}

Decizii de explicat:

  • un rând invalid nu trebuie să oprească restul importului, dar trebuie raportat cu numărul liniei
  • o eroare de infrastructură (PDOException) nu se prinde aici, ci oprește importul, pentru că fiecare rând ar eșua la fel
  • tranzacție pe rând sau pe lot, în funcție de cerință: „totul sau nimic” față de „importă ce se poate”
  • utilizatorul primește un raport clar, iar logul tehnic conține detaliile

Ce urmărește intervievatorul: Întrebare de senior despre design. Intervievatorul caută criterii clare și distincția dintre erori așteptate și erori de infrastructură.

70 Senior

Un script PHP rulat din cron în fiecare noapte se oprește uneori la jumătate, fără niciun mesaj în logul aplicației. Cum ai investiga?

Răspuns scurt: Verific întâi unde merge ieșirea scriptului (cron o pierde dacă nu e redirecționată), apoi logurile sistemului pentru OOM killer, setările CLI (memory_limit, error_log, alt php.ini), suprapunerea rulărilor și timeout-urile serviciilor externe. Apoi adaug loguri de progres, handler de shutdown și un lock.

Un răspuns structurat:

  • Unde se duce ieșirea? Linia din crontab arată adesea ca php import.php fără redirecționare. Erorile ajung pe STDERR și se pierd sau pleacă într-un email de sistem necitit. Schimb în php import.php >> /var/log/import.log 2>&1 și verific codul de ieșire.
  • Configurația CLI. PHP CLI folosește de obicei alt php.ini decât PHP-FPM (php --ini arată care). Poate avea log_errors dezactivat sau alt memory_limit. Rulez php -i | grep -E 'memory_limit|error_log|display_errors' cu același utilizator ca cron-ul.
  • Procesul a fost omorât? Dacă PHP nu a apucat să scrie nimic, poate fi OOM killer-ul Linux: caut în dmesg sau journalctl -k mesaje „Out of memory: Killed process”. Și un timeout din alt sistem (de exemplu un container cu limită de timp) poate opri procesul din afară.
  • Rulări suprapuse. Dacă scriptul durează mai mult decât intervalul cron, două instanțe pot lucra pe aceleași date. Adaug un lock cu flock sau rulez prin flock -n /tmp/import.lock php import.php.
  • Dependențe externe. Un API sau o conexiune la baza de date fără timeout poate bloca procesul. Setez timeout-uri explicite (cURL, PDO) și refac conexiunea la scripturile lungi, pentru că MySQL închide conexiunile inactive după wait_timeout.
  • Observabilitate. Adaug loguri de progres („lot 40 din 120”), register_shutdown_function cu error_get_last() și memoria (memory_get_peak_usage(true)) la fiecare lot.
  • Repararea propriu-zisă. Dacă e memorie, procesez în loturi și folosesc generatoare. Dacă e durată, împart munca în joburi idempotente, care pot fi rerulate sigur.

Ce urmărește intervievatorul: Întrebare de situație care arată experiența de producție. Intervievatorul urmărește dacă te gândești la mediu (cron, CLI, sistem de operare), nu doar la codul PHP.

Formulare, sesiuni, cookie-uri și PDO

71 Junior

Scrie procesarea unui formular de înregistrare cu nume, email, varsta și checkbox-ul termeni. Arată validarea, mesajele de eroare și repopularea câmpurilor.

Răspuns scurt: Verifici că cererea e POST, citești câmpurile cu ?? '' și trim, validezi fiecare (inclusiv că checkbox-ul nebifat lipsește complet din $_POST), colectezi erorile într-un array și, dacă există erori, reafișezi formularul cu valorile escapate cu htmlspecialchars.

PHP
$errors = [];
$old = ['nume' => '', 'email' => '', 'varsta' => ''];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $old['nume']   = trim($_POST['nume'] ?? '');
    $old['email']  = trim($_POST['email'] ?? '');
    $old['varsta'] = trim($_POST['varsta'] ?? '');

    if (mb_strlen($old['nume']) < 2) {
        $errors['nume'] = 'Numele trebuie să aibă cel puțin 2 caractere.';
    }
    if (filter_var($old['email'], FILTER_VALIDATE_EMAIL) === false) {
        $errors['email'] = 'Adresa de email nu e validă.';
    }
    $varsta = filter_var($old['varsta'], FILTER_VALIDATE_INT, ['options' => ['min_range' => 16, 'max_range' => 120]]);
    if ($varsta === false) {
        $errors['varsta'] = 'Vârsta trebuie să fie între 16 și 120.';
    }
    if (!isset($_POST['termeni'])) {
        $errors['termeni'] = 'Trebuie să accepți termenii.';
    }

    if (!$errors) {
        // salvare, apoi redirect (Post/Redirect/Get)
        header('Location: /multumim', true, 303);
        exit;
    }
}
$e = fn(string $v): string => htmlspecialchars($v, ENT_QUOTES, 'UTF-8');
HTML
<input name="email" value="<?= $e($old['email']) ?>">
<?php if (isset($errors['email'])): ?><p class="err"><?= $e($errors['email']) ?></p><?php endif ?>

Detalii de discutat:

  • un checkbox nebifat nu trimite nimic, deci $_POST['termeni'] nu există
  • câmpurile multiple (name="tags[]") ajung ca array, iar un atacator poate trimite array în loc de string, deci verifici tipul înainte de trim
  • validarea din HTML (required, type="email") e doar pentru confortul utilizatorului, pentru că poate fi ocolită
  • valorile reafișate sunt escapate, altfel formularul devine vector de XSS
  • în aplicații reale adaugi și token CSRF

Ce urmărește intervievatorul: Este exercițiul de bază pentru orice job PHP. Intervievatorul urmărește validarea pe server, checkbox-ul lipsă, escaparea și redirect-ul.

72 Junior

Ce este pattern-ul Post/Redirect/Get și ce problemă rezolvă?

Răspuns scurt: După procesarea cu succes a unui formular POST, serverul răspunde cu un redirect (303 sau 302) către o pagină GET. Astfel, un refresh nu retrimite formularul, deci nu apar comenzi sau mesaje duplicate, iar URL-ul final poate fi salvat ca bookmark.

Fără PRG, fluxul arată așa: utilizatorul trimite formularul, scriptul salvează comanda și afișează direct „Comanda a fost plasată”. Dacă utilizatorul apasă F5, browserul întreabă „Retrimiți datele formularului?”, iar la confirmare comanda se plasează a doua oară.

Cu PRG:

PHP
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $id = $orders->create($data);
    $_SESSION['flash'] = 'Comanda a fost plasată.';
    header('Location: /comenzi/' . $id, true, 303);
    exit;
}

Browserul primește 303 See Other și face o cerere GET nouă către /comenzi/123. Un refresh repetă doar acest GET, care e sigur.

Detalii:

  • 303 spune explicit „continuă cu GET”. 302 e interpretat la fel de browsere în practică, dar 303 e semantic corect. 307 și 308 păstrează metoda POST, deci nu sunt potrivite aici.
  • Mesajul de succes trebuie transmis între cereri: printr-un flash message în sesiune sau prin parametri în URL (?ok=1), fără date personale în URL.
  • Dacă validarea eșuează, de obicei nu faci redirect, ci reafișezi formularul cu erori în același răspuns, ca să păstrezi valorile introduse. Alternativ, le pui în sesiune și redirecționezi, cum fac framework-urile.
  • PRG nu protejează de dublu-click rapid pe „Trimite”. Pentru asta adaugi un token de idempotență în formular, verificat la salvare, sau dezactivezi butonul din JavaScript ca măsură suplimentară.

Ce urmărește intervievatorul: Verifică înțelegerea ciclului cerere/răspuns și a problemelor reale de UX. Un răspuns bun menționează coduri de status și cazul dublu-click.

73 Junior

Unde e problema de securitate?

PHP
session_start();
if (empty($_SESSION['user_id'])) {
    header('Location: /login');
}
$pdo->exec('DELETE FROM posts WHERE id = ' . (int) $_GET['id']);
echo 'Șters';

Răspuns scurt: Lipsește exit după header('Location: ...'). Header-ul doar adaugă un antet în răspuns, iar scriptul continuă, deci ștergerea se execută și pentru vizitatorii nelogați. Un client care nu urmează redirect-ul (de exemplu curl) vede chiar și mesajul „Șters”.

header() nu oprește execuția. Setează un antet HTTP care va fi trimis browserului, apoi PHP rulează mai departe toate liniile. Browserul urmează redirect-ul și utilizatorul nu observă nimic, dar pe server ștergerea a avut deja loc. Cu curl -i "https://site.ro/delete.php?id=5", un atacator vede tot răspunsul.

Corect:

PHP
session_start();
if (empty($_SESSION['user_id'])) {
    header('Location: /login', true, 302);
    exit;
}

Alte probleme din fragment, de menționat la interviu:

  • O acțiune distructivă pe GET. Un link sau o imagine (<img src="/delete.php?id=5">) pe alt site poate declanșa ștergerea pentru un utilizator logat. Ștergerea se face prin POST, cu token CSRF.
  • Lipsa autorizării. Utilizatorul e logat, dar codul nu verifică dacă postarea îi aparține. Corect: DELETE FROM posts WHERE id = ? AND user_id = ?.
  • Cast-ul (int) previne aici SQL injection, dar prepared statements sunt varianta consecventă.

Ca pattern, verificările de acces se pun într-o funcție care se oprește singură:

PHP
function requireLogin(): int {
    if (empty($_SESSION['user_id'])) {
        header('Location: /login');
        exit;
    }
    return (int) $_SESSION['user_id'];
}

Cu tipul de return never pentru o funcție redirect(), PHPStan știe că după apel codul nu mai continuă.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente vulnerabilități în cod PHP scris de mână. Intervievatorul verifică dacă știi că header() nu oprește scriptul.

74 Junior

Ce afișează codul la prima vizită? Cum ștergi un cookie și ce opțiuni setezi pentru un cookie de „ține-mă minte”?

PHP
setcookie('tema', 'dark', time() + 3600);
echo $_COOKIE['tema'] ?? 'nesetat';

Răspuns scurt: Afișează nesetat. setcookie doar trimite antetul Set-Cookie, iar $_COOKIE conține ce a trimis browserul în cererea curentă, deci valoarea apare abia la următoarea cerere. Ștergi cookie-ul setând o dată de expirare în trecut, cu același path și domeniu.

Fluxul: serverul trimite Set-Cookie: tema=dark în răspuns, browserul îl salvează, iar la cererile următoare trimite Cookie: tema=dark. PHP populează $_COOKIE la începutul cererii, din antetul primit. De aceea un cookie setat acum nu e vizibil în aceeași cerere. Dacă ai nevoie imediat de valoare, o folosești din variabila ta.

Forma modernă, cu array de opțiuni (PHP 7.3+):

PHP
setcookie('remember', $token, [
    'expires'  => time() + 60 * 60 * 24 * 30,
    'path'     => '/',
    'secure'   => true,      // doar prin HTTPS
    'httponly' => true,      // inaccesibil din JavaScript
    'samesite' => 'Lax',     // nu e trimis la majoritatea cererilor cross-site
]);

Ștergere:

PHP
setcookie('remember', '', ['expires' => time() - 3600, 'path' => '/']);
unset($_COOKIE['remember']);

Path-ul și domeniul trebuie să coincidă cu cele de la creare, altfel browserul consideră că e alt cookie.

Reguli:

  • setcookie trebuie apelat înainte de orice output, ca orice antet.
  • Un cookie e controlat de client, deci poate fi modificat. Nu stochezi acolo user_id=5 sau admin=1. Pentru „ține-mă minte” stochezi un token aleator lung, iar pe server păstrezi doar hash-ul lui, cu utilizatorul și data expirării.
  • Limita practică e de aproximativ 4 KB per cookie, iar toate cookie-urile se trimit la fiecare cerere, deci încarcă traficul.
  • Din cauza regulilor GDPR și ePrivacy, cookie-urile care nu sunt strict necesare cer consimțământ.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului HTTP din spatele cookie-urilor și a opțiunilor de securitate. Greșeala tipică e așteptarea ca $_COOKIE să se actualizeze imediat.

75 Junior

Implementează „flash messages” cu sesiuni: un mesaj setat înainte de redirect, afișat o singură dată pe pagina următoare.

Răspuns scurt: Salvezi mesajul în $_SESSION['flash'] înainte de redirect, iar pe pagina următoare îl citești și îl ștergi imediat din sesiune, apoi îl afișezi escapat. Ștergerea la citire face ca un refresh să nu-l mai arate.

PHP
final class Flash
{
    public static function add(string $type, string $message): void
    {
        $_SESSION['_flash'][] = ['type' => $type, 'message' => $message];
    }

    /** @return list<array{type: string, message: string}> */
    public static function pull(): array
    {
        $messages = $_SESSION['_flash'] ?? [];
        unset($_SESSION['_flash']);
        return $messages;
    }
}

// după salvare
session_start();
Flash::add('success', 'Profilul a fost actualizat.');
header('Location: /profil', true, 303);
exit;
PHP
// în layout
<?php foreach (Flash::pull() as $f): ?>
  <div class="alert alert-<?= htmlspecialchars($f['type']) ?>">
    <?= htmlspecialchars($f['message']) ?>
  </div>
<?php endforeach ?>

Explicații:

  • session_start() trebuie apelat pe ambele pagini, înainte de orice output, pentru că trimite cookie-ul de sesiune.
  • pull citește și șterge într-un singur pas. Mesajul apare o dată, iar un refresh nu-l repetă.
  • Lista de mesaje permite mai multe notificări (de exemplu o eroare și o informare).
  • Escaparea e necesară dacă mesajul conține date introduse de utilizator, cum ar fi un nume de produs.
  • Clasa cu metode statice e acceptabilă pentru un exemplu mic. Într-o aplicație testabilă, sesiunea ar fi injectată ca obiect.

Capcană: dacă după add nu urmează un redirect, ci pagina e afișată direct, mesajul va apărea pe pagina curentă (dacă layout-ul apelează pull) sau pe următoarea. Fii consecvent în ce flux îl folosești.

Framework-urile au același mecanism: session()->flash() în Laravel, addFlash() în Symfony.

Ce urmărește intervievatorul: Exercițiu practic despre sesiuni, mai concret decât „cum funcționează sesiunile”. Intervievatorul urmărește ștergerea la citire și escaparea.

76 Junior

Scrie conexiunea PDO la MySQL pentru o aplicație nouă. Ce opțiuni setezi și de ce?

Răspuns scurt: DSN cu charset=utf8mb4, PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC și PDO::ATTR_EMULATE_PREPARES => false. Credențialele vin din variabile de mediu, nu din cod.

PHP
$dsn = sprintf('mysql:host=%s;port=%d;dbname=%s;charset=utf8mb4',
    getenv('DB_HOST'), (int) (getenv('DB_PORT') ?: 3306), getenv('DB_NAME'));

$pdo = new PDO($dsn, getenv('DB_USER'), getenv('DB_PASS'), [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES   => false,
]);

De ce fiecare opțiune:

  • charset=utf8mb4 în DSN setează encoding-ul conexiunii. Fără el, diacriticele și emoji pot fi stricate. Rularea separată a unui SET NAMES e o variantă mai veche și mai fragilă.
  • ERRMODE_EXCEPTION face ca orice eroare SQL să arunce PDOException. Din PHP 8.0 e modul implicit, dar setarea explicită documentează intenția. În modurile vechi (silent), un query greșit întorcea false, iar codul continua cu date lipsă.
  • FETCH_ASSOC întoarce rânduri doar cu chei după numele coloanelor. Implicit, FETCH_BOTH dublează datele, cu chei numerice și cu nume.
  • EMULATE_PREPARES => false folosește prepared statements native ale MySQL: query-ul și valorile ajung separat la server, iar tipurile numerice vin ca int sau float, nu ca stringuri. Cu emularea activă, PDO construiește textul query-ului în PHP. Escaparea e corectă când charset-ul e setat în DSN, dar varianta nativă e mai simplă de explicat și mai robustă.

Alte bune practici:

  • un singur obiect PDO per cerere, creat la nevoie și injectat unde trebuie
  • new PDO aruncă PDOException la eșec, iar mesajul poate conține detalii despre server. Îl loghezi, nu îl afișezi
  • conexiunile persistente (PDO::ATTR_PERSISTENT) au sens doar în situații măsurate, pentru că pot păstra stare (tranzacții, variabile) între cereri

Ce urmărește intervievatorul: Verifică dacă știi configurarea sigură de bază a accesului la date. Candidații uită de charset sau lasă mesajele de eroare vizibile.

77 Junior

Ce diferență este între fetch(), fetchAll(), fetchColumn() și fetchAll(PDO::FETCH_KEY_PAIR)? Cum afli ID-ul ultimului rând inserat și ce capcană are rowCount()?

Răspuns scurt: fetch() întoarce următorul rând sau false, fetchAll() toate rândurile ca array, fetchColumn() o singură valoare, iar FETCH_KEY_PAIR un array [col1 => col2]. ID-ul inserat îl dă $pdo->lastInsertId(). rowCount() e sigur doar pentru INSERT/UPDATE/DELETE, nu pentru SELECT.

PHP
$stmt = $pdo->prepare('SELECT id, nume FROM users WHERE activ = ?');
$stmt->execute([1]);

$row  = $stmt->fetch();         // ['id' => 1, 'nume' => 'Ana'] sau false
$all  = $stmt->fetchAll();      // list de rânduri (din ce a rămas)

$count = $pdo->query('SELECT COUNT(*) FROM users')->fetchColumn(); // "42" sau 42
$map   = $pdo->query('SELECT id, nume FROM users')->fetchAll(PDO::FETCH_KEY_PAIR); // [1 => 'Ana']
$byId  = $pdo->query('SELECT id, nume, email FROM users')->fetchAll(PDO::FETCH_UNIQUE); // indexat după id
$users = $stmt->fetchAll(PDO::FETCH_CLASS, User::class);

Când folosești fiecare:

  • fetch() într-un while pentru rezultate mari, ca să nu ții tot în memorie (cu precizarea că, implicit, driverul MySQL tot aduce rezultatul complet în memorie)
  • fetchAll() pentru liste mici și medii
  • fetchColumn() pentru COUNT, EXISTS, o singură valoare. Întoarce false dacă nu există rând
  • FETCH_KEY_PAIR, FETCH_UNIQUE, FETCH_GROUP construiesc direct structuri utile, fără bucle suplimentare

lastInsertId() întoarce ID-ul generat de AUTO_INCREMENT pentru ultimul INSERT pe aceeași conexiune. Valoarea vine ca string. E sigur la concurență, pentru că fiecare conexiune are propriul ID, dar trebuie apelat imediat după insert. În PostgreSQL folosești INSERT ... RETURNING id.

rowCount() după UPDATE întoarce în MySQL rândurile efectiv modificate, nu cele găsite. Un UPDATE care setează aceeași valoare dă 0, deci nu e un indicator corect pentru „rândul nu există”. Pentru SELECT, documentația PDO nu garantează valoarea, deci număra rândurile primite sau folosește COUNT(*).

Ce urmărește intervievatorul: Arată dacă ai lucrat efectiv cu PDO, dincolo de fetchAll. Capcana cu rowCount() la UPDATE apare des în cod real.

78 Mid

Scrie o funcție care selectează utilizatorii după o listă de ID-uri, findByIds([3, 7, 12]), folosind prepared statements. De ce nu poți lega direct un array la un singur placeholder?

Răspuns scurt: Un placeholder reprezintă o singură valoare scalară, deci generezi câte un ? pentru fiecare ID: implode(',', array_fill(0, count($ids), '?')), apoi transmiți array-ul la execute. Tratezi separat lista goală, pentru că IN () e SQL invalid.

PHP
/** @param list<int> $ids */
function findByIds(PDO $pdo, array $ids): array
{
    $ids = array_values(array_unique(array_map('intval', $ids)));
    if ($ids === []) {
        return [];
    }
    $placeholders = implode(',', array_fill(0, count($ids), '?'));
    $stmt = $pdo->prepare("SELECT id, nume FROM users WHERE id IN ($placeholders)");
    $stmt->execute($ids);
    return $stmt->fetchAll(PDO::FETCH_UNIQUE);
}

De ce așa:

  • PDO leagă fiecare placeholder la o singură valoare. WHERE id IN (?) cu execute([implode(',', $ids)]) ar compara id cu stringul "3,7,12". MySQL îl convertește la 3, deci primești un singur rând, fără nicio eroare. E un bug greu de observat.
  • Placeholder-ele generate conțin doar ? și virgule, iar valorile ajung separat. Concatenarea în SQL e sigură pentru că nu include date de la utilizator.
  • array_values contează: execute cu placeholder-e poziționale are nevoie de chei 0..n-1. După array_unique sau array_filter pot apărea găuri, iar PDO aruncă eroare.
  • Lista goală se tratează explicit.
  • FETCH_UNIQUE întoarce rezultatul indexat după prima coloană, gata de folosit.

Alte observații:

  • La liste foarte mari (zeci de mii de ID-uri) ajungi la limitele de placeholder-e ale bazei de date sau la query-uri lente. Le împarți în bucăți cu array_chunk, sau încarci ID-urile într-o tabelă temporară și faci JOIN.
  • Ordinea rezultatelor nu urmează ordinea din listă. Dacă ai nevoie de ea, reordonezi în PHP sau folosești ORDER BY FIELD(id, ...) în MySQL.

Ce urmărește intervievatorul: Este o problemă practică frecventă cu PDO. Se verifică dacă știi ce reprezintă un placeholder și dacă tratezi cazurile limită.

79 Mid

Utilizatorul poate alege coloana după care se sortează un tabel: ?sort=pret&dir=desc. De ce nu poți folosi un placeholder pentru ORDER BY și cum scrii codul sigur?

Răspuns scurt: Placeholder-ele leagă doar valori, nu identificatori (nume de coloane, tabele) sau cuvinte cheie ca ASC/DESC. Soluția e o listă albă: mapezi inputul pe un set fix de coloane permise și pe două direcții, apoi construiești SQL-ul doar din valorile tale.

Ce nu funcționează:

PHP
$stmt = $pdo->prepare('SELECT * FROM produse ORDER BY ? ' . $_GET['dir']);
$stmt->execute([$_GET['sort']]);

ORDER BY ? devine ORDER BY 'pret', adică sortare după un string constant, deci nicio sortare. Iar $_GET['dir'] concatenat direct permite SQL injection, de exemplu cu o subinterogare care extrage date prin comportamentul sortării.

Varianta sigură:

PHP
$coloane = [
    'pret'  => 'p.pret',
    'nume'  => 'p.nume',
    'nou'   => 'p.created_at',
];
$sort = $coloane[$_GET['sort'] ?? ''] ?? 'p.created_at';
$dir  = strtolower($_GET['dir'] ?? '') === 'asc' ? 'ASC' : 'DESC';

$stmt = $pdo->prepare("SELECT p.id, p.nume, p.pret FROM produse p
                       WHERE p.categorie_id = :cat
                       ORDER BY $sort $dir, p.id DESC
                       LIMIT :limit");
$stmt->bindValue(':cat', (int) $_GET['cat'], PDO::PARAM_INT);
$stmt->bindValue(':limit', 20, PDO::PARAM_INT);
$stmt->execute();

Principii:

  • În SQL ajung doar stringuri scrise de tine în cod. Inputul servește doar drept cheie de căutare în lista albă.
  • Cheile expuse în URL (nou) pot fi diferite de numele coloanelor, deci nu îți dezvălui schema.
  • Al doilea criteriu (p.id) face ordinea deterministă, important la paginare.
  • LIMIT cu placeholder cere PDO::PARAM_INT când emularea e activă, altfel valoarea ajunge între ghilimele și MySQL dă eroare.
  • Aceeași regulă se aplică pentru numele de tabele dinamice sau pentru coloanele din SELECT.

Escaparea manuală a identificatorilor cu backtick-uri e posibilă, dar lista albă e mai simplă și mai sigură.

Ce urmărește intervievatorul: Arată dacă înțelegi limitele prepared statements, o zonă unde apar SQL injection chiar și în cod care folosește PDO. Mulți candidați cred că PDO rezolvă automat tot.

80 Mid

Scrie un endpoint care descarcă un raport CSV cu toate comenzile, compatibil cu Excel și cu diacritice corecte.

Răspuns scurt: Setezi antetele Content-Type: text/csv; charset=UTF-8 și Content-Disposition: attachment; filename="...", scrii BOM-ul UTF-8 ca Excel să recunoască diacriticele, apoi scrii rândurile cu fputcsv direct în php://output, rând cu rând, fără să construiești tot fișierul în memorie.

PHP
header('Content-Type: text/csv; charset=UTF-8');
header('Content-Disposition: attachment; filename="comenzi-' . date('Y-m-d') . '.csv"');
header('Cache-Control: no-store');

$out = fopen('php://output', 'w');
fwrite($out, "\xEF\xBB\xBF"); // BOM UTF-8 pentru Excel

fputcsv($out, ['ID', 'Client', 'Total', 'Data'], ';', '"', '');

$stmt = $pdo->query('SELECT id, client, total, created_at FROM comenzi ORDER BY id');
while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
    $row[1] = sanitizeCsvCell($row[1]);
    fputcsv($out, $row, ';', '"', '');
}
fclose($out);
exit;

function sanitizeCsvCell(string $v): string
{
    return preg_match('/^[=+\-@\t\r]/', $v) ? "'" . $v : $v;
}

Explicații:

  • php://output scrie direct în răspuns. Rândurile pleacă pe măsură ce sunt generate, deci memoria rămâne mică chiar pentru sute de mii de comenzi. Pentru volume mari folosești și o interogare nebufferată sau procesare pe loturi.
  • BOM-ul (EF BB BF) e necesar pentru Excel pe Windows, care altfel deschide fișierul ca ANSI și strică diacriticele.
  • Separatorul ;: Excel configurat pentru România folosește virgula ca separator zecimal, deci așteaptă ; între coloane.
  • Parametrul escape gol ('') evită comportamentul nestandard al caracterului \. Din PHP 8.4, lăsarea lui implicită e deprecated, deci îl specifici explicit.
  • CSV injection: o celulă care începe cu =, +, - sau @ poate fi interpretată de Excel ca formulă. Prefixarea cu apostrof o neutralizează.
  • Pentru exporturi foarte mari sau lente, generezi fișierul într-un job în fundal și trimiți utilizatorului un link, ca să nu lovești limitele de timp ale serverului web.

Ce urmărește intervievatorul: Exercițiu practic, foarte frecvent în aplicații de business. Intervievatorul urmărește antetele, memoria și detaliile de compatibilitate (BOM, separator, formule).

81 Senior

Trebuie să procesezi 5 milioane de rânduri dintr-o tabelă MySQL într-un script PHP. De ce fetchAll() produce „Allowed memory size exhausted” chiar și cu fetch() în buclă, și cum rezolvi?

Răspuns scurt: PDO cu MySQL folosește implicit interogări bufferate: tot rezultatul ajunge în memoria PHP la execute(), oricum ai citi rândurile. Soluții: dezactivezi buffering-ul (MYSQL_ATTR_USE_BUFFERED_QUERY => false) sau procesezi pe loturi după cheie (WHERE id > ?), cu un generator.

Cu MYSQL_ATTR_USE_BUFFERED_QUERY activ (implicit), execute() aduce întregul rezultat în memoria procesului. fetch() doar citește din acest buffer, așa că memoria e deja ocupată.

Varianta 1: interogare nebufferată

PHP
$pdo->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
$stmt = $pdo->query('SELECT id, email FROM users');
while ($row = $stmt->fetch()) {
    process($row);
}

Rândurile vin din rețea pe măsură ce le citești. Limitări: pe aceeași conexiune nu poți rula altă interogare până nu termini sau închizi cursorul, iar rezultatul ține resurse pe server cât durează procesarea. De obicei se folosește o conexiune separată pentru citire.

Varianta 2: loturi după cheie (keyset pagination), cu generator

PHP
function usersInBatches(PDO $pdo, int $size = 1000): Generator
{
    $lastId = 0;
    $stmt = $pdo->prepare('SELECT id, email FROM users WHERE id > ? ORDER BY id LIMIT ' . $size);
    do {
        $stmt->execute([$lastId]);
        $rows = $stmt->fetchAll();
        foreach ($rows as $row) {
            yield $row;
        }
        $lastId = $rows ? end($rows)['id'] : $lastId;
    } while (count($rows) === $size);
}

foreach (usersInBatches($pdo) as $user) { process($user); }

Fiecare lot folosește indexul primar și are cost constant. LIMIT ... OFFSET ar deveni tot mai lent, pentru că baza de date trebuie să parcurgă și să arunce rândurile sărite. Loturile permit și reluarea după o oprire, dacă salvezi ultimul ID.

Alte detalii: scrierile le grupezi în tranzacții pe lot, eliberezi referințele la obiectele mari după fiecare lot și urmărești memory_get_usage() în log. Dacă folosești un ORM, golești periodic identity map-ul, altfel ține toate entitățile în memorie.

Ce urmărește intervievatorul: Întrebare de senior despre volume reale de date. Puțini candidați știu că fetch() în buclă nu ajută cu interogările bufferate.

Eroarea, în practică:Allowed memory size of 134217728 bytes exhausted

82 Senior

Pe o pagină, mai multe cereri AJAX trimise simultan se execută una după alta, nu în paralel, deși serverul are resurse libere. Care e cauza probabilă în PHP și cum o rezolvi?

Răspuns scurt: Blocarea sesiunii: handler-ul implicit pe fișiere ține un lock de la session_start() până la finalul scriptului, deci cererile aceluiași utilizator se așteaptă. Rezolvi cu session_write_close() imediat ce nu mai scrii în sesiune sau cu read_and_close.

Sesiunile PHP stochează implicit datele într-un fișier per utilizator. Ca să evite scrieri concurente care s-ar suprascrie, session_start() pune un lock exclusiv (flock) pe fișier. Lock-ul se eliberează la session_write_close() sau la finalul scriptului. Dacă o cerere AJAX durează două secunde (de exemplu un raport), toate celelalte cereri ale aceluiași utilizator stau după ea.

Simptomul tipic: în tab-ul Network din browser, cererile pornesc simultan, dar se termină în cascadă, iar timpul de „waiting” al fiecăreia include durata celei de dinainte.

Soluții:

PHP
session_start();
$userId = $_SESSION['user_id'] ?? null;
session_write_close();     // eliberează lock-ul, datele rămân citibile în $_SESSION

$raport = genereazaRaportLent($userId);
PHP
session_start(['read_and_close' => true]); // PHP 7.0+, citește și închide imediat

După session_write_close(), modificările din $_SESSION nu se mai salvează. Dacă trebuie să scrii mai târziu, redeschizi cu session_start(), cu condiția să nu fi trimis deja output.

Alte variante:

  • Handler-e de sesiune în Redis sau Memcached. Extensia phpredis are locking opțional, deci comportamentul depinde de configurare (redis.session.locking_enabled). Fără lock, două cereri care scriu simultan se pot suprascrie, deci trebuie decis conștient.
  • Endpoint-uri de API cu autentificare prin token, care nu folosesc deloc sesiunea.

La depanare, confirmi ipoteza măsurând cu microtime(true) momentul în care session_start() se întoarce. Dacă durează cât cererea anterioară, ai găsit cauza.

Ce urmărește intervievatorul: Este o problemă de performanță reală și greu de diagnosticat fără să cunoști mecanismul. Intervievatorul verifică înțelegerea concurenței în PHP.

Securitate în cod PHP

83 Junior

Unde sunt problemele de XSS în acest șablon?

PHP
<a href="<?= htmlspecialchars($user['website']) ?>">Site</a>
<input value=<?= htmlspecialchars($user['nume']) ?>>
<script>var nume = "<?= htmlspecialchars($user['nume']) ?>";</script>

Răspuns scurt: htmlspecialchars protejează doar textul HTML și atributele între ghilimele. Linkul acceptă javascript:alert(1), atributul fără ghilimele poate fi spart cu un spațiu (x onfocus=alert(1) autofocus), iar în <script> contextul e JavaScript, unde ai nevoie de json_encode.

Escaparea depinde de contextul în care pui valoarea.

1. URL în href. htmlspecialchars transformă <, >, & și ghilimelele, dar javascript:alert(document.cookie) nu conține niciunul. Validezi schema:

PHP
$url = $user['website'];
$safe = preg_match('#^https?://#i', $url) ? $url : '#';
echo '<a href="' . htmlspecialchars($safe, ENT_QUOTES) . '" rel="noopener">Site</a>';

2. Atribut fără ghilimele. Fără ghilimele, un spațiu încheie valoarea, iar restul devine atribut nou. Punând mereu atributele între ghilimele duble, htmlspecialchars e suficient. Din PHP 8.1, flag-urile implicite sunt ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, deci se escapează și apostroful. Pe versiuni mai vechi, ghilimelele simple nu erau escapate implicit.

3. JavaScript inline. În <script>, entitățile HTML nu sunt decodate, iar un nume ca </script><script>alert(1)</script> închide blocul. Corect:

PHP
<script>
const nume = <?= json_encode($user['nume'], JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT) ?>;
</script>

Sau, mai curat, pui datele într-un atribut data-* escapat și le citești din JavaScript.

Alte reguli:

  • escapezi la afișare, nu la salvare, pentru că același text poate ajunge în HTML, JSON sau PDF
  • pentru HTML introdus de utilizator (editor de text bogat) folosești o bibliotecă de sanitizare, de exemplu HTML Purifier, nu strip_tags
  • un template engine cu auto-escape (Twig, Blade) reduce greșelile, dar nu rezolvă contextele URL și JavaScript fără atenție
  • un antet Content-Security-Policy limitează pagubele dacă totuși scapă ceva

Ce urmărește intervievatorul: Verifică dacă înțelegi escaparea în funcție de context, nu doar „pun htmlspecialchars”. Aproape toți candidații ratează cazul javascript:.

Eroarea, în practică:Constant FILTER_SANITIZE_STRING is deprecated

84 Junior

Unde sunt greșelile în acest cod de autentificare?

PHP
$user = $repo->findByEmail($_POST['email']);
if ($user && md5($_POST['parola']) == $user['parola']) {
    login($user);
}
// la înregistrare: $hash = md5($parola);  coloana: parola VARCHAR(32)

Răspuns scurt: MD5 e un hash rapid, fără salt, nepotrivit pentru parole, iar == permite comparații lejere. Corect: password_hash($parola, PASSWORD_DEFAULT) la înregistrare, password_verify() la login, coloană VARCHAR(255) și password_needs_rehash() pentru actualizarea treptată a hash-urilor.

Problemele:

  • MD5 e rapid. Un hash pentru parole trebuie să fie intenționat lent, ca atacurile prin forță brută pe o bază de date furată să fie costisitoare. MD5 și SHA-256 simplu sunt făcute să fie rapide.
  • Fără salt. Doi utilizatori cu aceeași parolă au același hash, iar tabelele precalculate (rainbow tables) găsesc instant parolele comune.
  • == între hash-uri. Dacă ambele hash-uri arată ca 0e urmat doar de cifre, PHP le compară ca numere în notație științifică (0 egal cu 0) și le consideră egale. Există parole cunoscute cu MD5 de această formă.
  • Coloana de 32 de caractere nu poate stoca algoritmi moderni.

Varianta corectă:

PHP
// înregistrare
$hash = password_hash($parola, PASSWORD_DEFAULT); // bcrypt azi, salt inclus

// login
$user = $repo->findByEmail($email);
if ($user === null || !password_verify($parola, $user['parola'])) {
    throw new InvalidCredentials();   // același mesaj pentru ambele cazuri
}
if (password_needs_rehash($user['parola'], PASSWORD_DEFAULT)) {
    $repo->updatePassword($user['id'], password_hash($parola, PASSWORD_DEFAULT));
}
session_regenerate_id(true);

Detalii:

  • password_hash generează automat un salt aleator și îl include în rezultat, împreună cu algoritmul și costul ($2y$12$...). Nu stochezi saltul separat.
  • PASSWORD_DEFAULT poate deveni alt algoritm în versiuni viitoare. De aceea coloana are 255 de caractere. PHP 8.4 a crescut costul implicit bcrypt de la 10 la 12.
  • PASSWORD_ARGON2ID e disponibil dacă PHP e compilat cu libargon2 sau libsodium.
  • bcrypt folosește doar primii 72 de bytes ai parolei.
  • Migrarea de pe MD5: la următorul login reușit verifici vechiul hash cu hash_equals, apoi îl înlocuiești cu password_hash. Alternativ, aplici password_hash direct peste hash-urile MD5 existente și verifici în două etape.

Ce urmărește intervievatorul: Întrebare de securitate din unghi practic: recunoașterea greșelilor în cod existent și migrarea. Intervievatorul apreciază menționarea lui password_needs_rehash.

Eroarea, în practică:password_hash(): $algo must be a valid algorithm

85 Mid

Trebuie să generezi un token de resetare a parolei. De ce nu folosești rand(), mt_rand(), uniqid() sau md5(time())? Ce folosești?

Răspuns scurt: Acestea nu sunt criptografic sigure: valorile pot fi ghicite sau reproduse dacă atacatorul cunoaște momentul generării ori câteva valori anterioare. Folosești bin2hex(random_bytes(32)) pentru tokenuri și random_int() pentru numere, ambele bazate pe sursa sigură a sistemului de operare.

Funcțiile vechi au probleme diferite:

  • rand() și mt_rand() folosesc un generator pseudo-aleator (Mersenne Twister) care nu e destinat securității. Din câteva valori observate se poate reconstrui starea internă și prezice valorile următoare.
  • uniqid() se bazează pe timpul curent în microsecunde. E unic în practică, dar previzibil.
  • md5(time()) are doar câteva mii de valori posibile într-o oră. MD5 nu adaugă entropie, doar schimbă forma.

Variante sigure, disponibile din PHP 7.0:

PHP
$token = bin2hex(random_bytes(32));     // 64 de caractere hex, 256 de biți de entropie
$cod   = random_int(100000, 999999);    // cod numeric de 6 cifre
$url   = rtrim(strtr(base64_encode(random_bytes(32)), '+/', '-_'), '='); // varianta URL-safe

Ambele folosesc sursa criptografică a sistemului de operare și aruncă excepție dacă aceasta nu e disponibilă, în loc să întoarcă o valoare slabă.

Din PHP 8.2 există și extensia Random, cu clasa Random\Randomizer (getBytes(), shuffleArray(), getInt()). Implicit folosește tot generatorul securizat.

Pentru tokenul de resetare, generarea e doar o parte:

  • în baza de date stochezi hash('sha256', $token), nu tokenul, ca o bază de date furată să nu permită resetări
  • tokenul expiră (de exemplu după o oră) și e de unică folosință
  • la verificare compari hash-urile cu hash_equals
  • mesajul „Dacă adresa există, ai primit un email” e același și pentru adrese inexistente, ca să nu permiți enumerarea conturilor
  • după resetare invalidezi celelalte sesiuni și tokenuri ale utilizatorului

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre aleator „statistic” și aleator criptografic. Greșeala tipică e folosirea uniqid() sau md5(time()) pentru tokenuri.

86 Mid

Ce probleme are această verificare a unui API key și cum o corectezi?

PHP
if ($_GET['key'] == getenv('API_KEY')) {
    // acces permis
}

Răspuns scurt: Comparația == permite type juggling, iar dacă API_KEY lipsește din mediu, getenv întoarce false. În plus, compararea obișnuită se oprește la primul caracter diferit, ceea ce permite atacuri de timp. Corect: verifici că cheia e configurată și string, apoi folosești hash_equals($expected, $provided).

Sunt trei probleme suprapuse.

1. Configurație lipsă. Dacă variabila de mediu nu e setată, getenv întoarce false. Comparația lejeră cu un input gol poate trece. $_GET['key'] lipsă e și el o problemă: în PHP 8 dă warning și valoarea null, iar null == false este true. Deci un deploy cu configurația uitată deschide API-ul tuturor.

2. Type juggling. Cu ==, două stringuri care arată ca numere se compară numeric. Pentru valori de tip hash, cele care încep cu 0e urmat doar de cifre sunt egale între ele, pentru că ambele valorează 0. Un atacator nu are nevoie de cheie, ci doar de o valoare de forma potrivită.

3. Timing attack. O comparație obișnuită se oprește la primul caracter diferit, deci durează puțin mai mult când prefixul e corect. Cu suficient de multe măsurători, un atacator poate ghici cheia caracter cu caracter. Diferența e mică, dar exploatabilă în condiții de laborator și pe rețele apropiate.

Varianta corectă:

PHP
$expected = getenv('API_KEY');
if (!is_string($expected) || strlen($expected) < 32) {
    throw new RuntimeException('API_KEY nu e configurată');
}
$provided = $_SERVER['HTTP_X_API_KEY'] ?? '';
if (!is_string($provided) || !hash_equals($expected, $provided)) {
    http_response_code(401);
    exit;
}

hash_equals (PHP 5.6+) compară în timp constant raportat la lungimea stringului așteptat. Cheia se trimite într-un antet, nu în URL, pentru că URL-urile apar în loguri, în istoricul browserului și în antetul Referer. Ideal, pe server stochezi doar un hash al cheii.

Ce urmărește intervievatorul: Combină trei capcane de securitate specifice PHP. Intervievatorul verifică dacă vezi și cazul de configurare lipsă, nu doar pe ===.

87 Mid

După login, aplicația redirecționează la $_GET['next']. Ce vulnerabilitate apare și cum o repari?

PHP
header('Location: ' . $_GET['next']);
exit;

Răspuns scurt: Este un open redirect: un atacator trimite un link legitim, de tipul site.ro/login?next=https://site-fals.ro, iar după login victima ajunge pe site-ul lui, unde i se pot cere din nou datele. Permiți doar căi relative interne, validate strict, sau o listă albă de destinații.

Atacul arată așa: victima primește un email cu un link real către https://site.ro/login?next=https://site-ro.com/login. Vede domeniul corect, se loghează, apoi e trimisă pe o copie a site-ului care afișează „Sesiunea a expirat, loghează-te din nou” și îi colectează parola. Încrederea vine de la domeniul tău.

Verificări care nu ajung:

  • str_starts_with($next, '/') acceptă //site-fals.ro, pe care browserul îl tratează ca URL absolut (protocol-relative)
  • str_contains($next, 'site.ro') acceptă https://site.ro.atacator.com
  • /\site-fals.ro poate fi interpretat de unele browsere ca //

Variantă sigură, care acceptă doar căi interne:

PHP
function safeRedirectPath(?string $next, string $default = '/'): string
{
    if (!is_string($next) || $next === '') {
        return $default;
    }
    if (!preg_match('#^/(?![/\\\\])[^\s]*$#', $next)) {
        return $default;          // trebuie să înceapă cu un singur /
    }
    $parts = parse_url($next);
    if ($parts === false || isset($parts['scheme']) || isset($parts['host'])) {
        return $default;
    }
    return $next;
}

header('Location: ' . safeRedirectPath($_GET['next'] ?? null), true, 302);
exit;

Alternativ, nu primești URL-ul deloc: salvezi în sesiune pagina de unde a venit utilizatorul înainte să fie trimis la login, sau accepți doar chei dintr-o listă (?next=comenzi).

Antetele HTTP nu pot conține caractere de linie nouă. PHP blochează din 5.1.2 încercările de header injection, cu warning, dar validarea ta trebuie să respingă oricum orice caracter de control.

Ce urmărește intervievatorul: Verifică o vulnerabilitate des ignorată, care nu ține de baza de date. Intervievatorul urmărește dacă știi de ce verificările naive pot fi ocolite.

88 Mid

Unde ții credențialele bazei de date, cheile de API și alte secrete într-o aplicație PHP? Ce greșeli duc la scurgerea lor?

Răspuns scurt: În variabile de mediu sau într-un manager de secrete, cu .env doar local, exclus din Git și din folderul public. Scurgerile vin din secrete comise, copii .bak accesibile din web, phpinfo() uitat și erori afișate în producție.

Principiul: codul e același în toate mediile, iar configurația secretă vine din afara lui.

PHP
// config.php, comis în Git, fără valori
return [
    'db' => [
        'dsn'  => getenv('DB_DSN') ?: throw new RuntimeException('DB_DSN lipsește'),
        'user' => getenv('DB_USER'),
        'pass' => getenv('DB_PASS'),
    ],
];

throw ca expresie e posibil din PHP 8.0. Variabilele se setează în configurația PHP-FPM (env[DB_PASS] = ...), în serverul web, în platforma de hosting sau în containerul Docker. Local, biblioteci ca vlucas/phpdotenv sau symfony/dotenv citesc un fișier .env.

Surse frecvente de scurgeri:

  • Git: o parolă comisă o singură dată rămâne în istoric chiar dacă o ștergi ulterior. Soluția corectă e rotirea secretului, nu doar rescrierea istoricului. Unelte ca gitleaks sau scanarea de secrete din GitHub prind cazurile la push.
  • Fișiere în document root: .env, config.php.bak, config.php~ (copii create de editoare), dump-uri .sql. Un .php.bak nu e executat, deci serverul îl livrează ca text. Document root-ul trebuie să conțină doar folderul public (de exemplu public/), cu restul codului deasupra lui.
  • phpinfo() afișează și variabilele de mediu.
  • Erori afișate: un PDOException neprins poate arăta DSN-ul. În producție display_errors=Off.
  • Loguri: nu loghezi request-uri întregi cu antete Authorization sau parole din formulare.

Alte bune practici: un utilizator de bază de date cu drepturi minime (fără DROP, fără acces la alte baze), chei diferite pentru fiecare mediu și posibilitatea de a roti orice secret fără modificări de cod.

Ce urmărește intervievatorul: Verifică maturitatea operațională: cum lucrezi cu secrete în echipă și în producție. Mulți candidați nu știu că un secret comis trebuie rotit, nu doar șters.

89 Mid

Faci code review unui coleg junior și găsești cod cu SQL construit prin concatenare din $_GET și date afișate fără escapare. Cum dai feedback?

Răspuns scurt: Marchez problema ca blocantă, arăt un input concret care o exploatează și varianta corectă (prepared statements, escapare la afișare), apoi propun o discuție scurtă sau pair programming. Vorbesc despre cod, nu despre persoană, și caut cauza în proces.

Un răspuns bun are structură și empatie.

1. Separ ce e blocant de ce e opțional. SQL injection și XSS sunt vulnerabilități, deci codul nu intră în producție așa. Le marchez clar ca necesare, separat de sugestiile de stil.

2. Arăt concret, nu doar „e nesigur”.

Linia 42: id-ul vine din $_GET și ajunge direct în SQL.
Cu ?id=1 OR 1=1 interogarea returnează toate comenzile, inclusiv ale altor clienți.
Propunere:
$stmt = $pdo->prepare('SELECT * FROM comenzi WHERE id = ? AND user_id = ?');
$stmt->execute([$id, $userId]);

La fel pentru XSS: un nume de produs ca <script>...</script> care ar rula la fiecare vizitator.

3. Explic de ce, nu doar ce. Un junior care înțelege principiul (datele nu se amestecă niciodată cu codul, fie SQL, fie HTML) aplică singur regula data viitoare.

4. Aleg canalul potrivit. Dacă problemele apar în mai multe locuri, propun o discuție de 15 minute sau pair programming în loc de 20 de comentarii scrise, care pot fi descurajante.

5. Tonul. Formulez despre cod („aici query-ul e vulnerabil”), nu despre persoană („ai scris greșit”), și recunosc ce e bine făcut în același PR.

6. Rezolv cauza. Verific dacă problema există și în restul proiectului, propun o regulă în ghidul echipei, un helper comun pentru acces la date, analiză statică în CI (PHPStan cu reguli de securitate, Psalm cu analiza taint) și un punct în checklist-ul de review.

7. Verific rezultatul. Revin pe PR după modificări și confirm explicit că totul e în regulă.

Ce urmărește intervievatorul: Întrebare comportamentală despre colaborare și standarde de securitate. Intervievatorul urmărește echilibrul între fermitate pe probleme critice și respect față de coleg.

90 Senior

De ce e periculos unserialize() pe date venite de la utilizator, de exemplu dintr-un cookie? Ce folosești în loc?

Răspuns scurt: unserialize poate crea obiecte din orice clasă încărcabilă și le apelează metodele magice, iar lanțuri de astfel de metode (gadget chains) pot duce la ștergere de fișiere sau execuție de cod. Folosești JSON sau, minim, allowed_classes => false și semnătură HMAC.

Formatul serialize descrie și clasa obiectelor. La unserialize, PHP creează instanțe ale acelor clase fără să apeleze constructorul, apoi apelează __unserialize sau __wakeup, iar mai târziu __destruct. Atacatorul controlează valorile tuturor proprietăților.

Un exemplu simplificat de clasă „gadget”:

PHP
class TempFile {
    public string $path;
    public function __destruct() { @unlink($this->path); }
}
// atacatorul trimite: O:8:"TempFile":1:{s:4:"path";s:9:"index.php";}

La finalul cererii, destructorul șterge index.php. În aplicații reale, lanțurile combină clase din framework-uri și biblioteci populare. Există unelte publice (de exemplu PHPGGC) care generează astfel de payload-uri pentru versiuni cunoscute, motiv pentru care vulnerabilitatea e luată foarte în serios.

Măsuri:

  • Nu deserializezi date controlate de client. Pentru cookie-uri, câmpuri ascunse sau API-uri folosești JSON, care produce doar array-uri și scalari.
  • Dacă trebuie totuși unserialize (de exemplu pentru un format moștenit), limitezi clasele:
PHP
$data = unserialize($raw, ['allowed_classes' => false]); // obiectele devin __PHP_Incomplete_Class
  • Datele pe care le trimiți clientului și le primești înapoi le semnezi cu hash_hmac('sha256', $payload, $secret) și verifici semnătura cu hash_equals înainte de orice procesare.
  • Atenție la phar: până în PHP 8.0, funcțiile de fișiere (file_exists, fopen) apelate cu phar:// deserializau automat metadatele arhivei. PHP 8.0 a eliminat deserializarea automată, dar pe versiuni vechi rămâne o cale de atac prin upload de fișiere.
  • Datele serializate stocate în cache sau în baza de date sunt sigure doar dacă nimeni din afară nu le poate scrie.

Ce urmărește intervievatorul: Întrebare de senior despre o clasă de vulnerabilități specifică PHP. Intervievatorul verifică dacă înțelegi mecanismul, nu doar regula „nu folosi unserialize”.

Eroarea, în practică:unserialize(): Error at offset of bytesmethod on an incomplete object

Composer, unelte și PHP 8.x

Exersează capitolul cu exerciții reale: Curs PHP online →
91 Junior

Ce înseamnă constrângerile de versiune ^2.3, ~2.3, 2.3.* și >=2.3 în composer.json? Ce diferență este între require și require-dev?

Răspuns scurt: ^2.3 permite orice versiune >=2.3.0 și <3.0.0, ~2.3 la fel (>=2.3, <3.0), dar ~2.3.1 doar <2.4.0. 2.3.* înseamnă orice patch din 2.3, iar >=2.3 e nelimitat în sus și riscant. require-dev conține uneltele de dezvoltare (PHPUnit, PHPStan), excluse în producție cu composer install --no-dev.

Composer presupune că pachetele respectă semantic versioning: MAJOR.MINOR.PATCH, unde MAJOR schimbă API-ul incompatibil, MINOR adaugă funcționalități compatibile, PATCH repară bug-uri.

  • ^2.3 (caret): orice versiune compatibilă conform semver, >=2.3.0 <3.0.0. Este constrângerea recomandată. Pentru versiuni 0.x e mai strictă: ^0.3 înseamnă >=0.3.0 <0.4.0, pentru că înainte de 1.0 orice versiune minoră poate rupe compatibilitatea.
  • ~2.3 (tilde): ultima cifră specificată poate crește. ~2.3 dă >=2.3 <3.0, iar ~2.3.1 dă >=2.3.1 <2.4.0.
  • **2.3.***: doar versiunile 2.3.x.
  • >=2.3: acceptă și 3.0, 4.0, cu schimbări incompatibile. Se evită.
  • *** sau dev-main**: instabile, nepotrivite pentru producție.
JSON
{
    "require": {
        "php": ">=8.2",
        "ext-pdo": "*",
        "monolog/monolog": "^3.5"
    },
    "require-dev": {
        "phpunit/phpunit": "^11.0",
        "phpstan/phpstan": "^2.0"
    }
}

"php" și "ext-*" sunt cerințe de platformă: Composer refuză instalarea dacă serverul nu le îndeplinește.

require-dev conține ce trebuie doar dezvoltatorilor și CI-ului. În producție rulezi:

BASH
composer install --no-dev --optimize-autoloader --classmap-authoritative

Așa reduci dimensiunea, suprafața de atac și timpul de autoload. Unelte de test lăsate pe server pot fi chiar vulnerabile, cum a fost cazul unui script din PHPUnit expus public în versiuni vechi.

Comenzi utile: composer outdated pentru versiuni noi disponibile, composer audit pentru vulnerabilități cunoscute în dependențe, composer why vendor/pachet pentru a afla cine a adus o dependență.

Ce urmărește intervievatorul: Verifică lucrul de zi cu zi cu dependențe, dintr-un unghi diferit de diferența json/lock. Mulți candidați confundă ^ cu ~.

92 Junior

Care sunt diferențele dintre PHP rulat din linia de comandă (CLI) și PHP rulat de serverul web (PHP-FPM)? Cum afli ce php.ini și ce setări se folosesc?

Răspuns scurt: Sunt SAPI-uri diferite, adesea cu php.ini diferit. În CLI max_execution_time e 0, nu există date de cerere HTTP, dar ai $argv, STDIN și coduri de ieșire. Configurația o afli cu php --ini și php -i, iar pentru FPM cu phpinfo() prin web.

SAPI (Server API) este modul prin care PHP e pornit. Cele mai frecvente sunt cli (scripturi, cron, Composer, worker-e) și fpm-fcgi (cereri web prin Nginx sau Apache). Constanta PHP_SAPI îți spune în care rulezi.

Diferențe practice:

  • Configurație: pe multe distribuții Linux există fișiere separate, de exemplu /etc/php/8.3/cli/php.ini și /etc/php/8.3/fpm/php.ini, plus directoare conf.d. O extensie activată doar pentru FPM lipsește în CLI și invers.
  • Limite: în CLI, max_execution_time e 0 (fără limită). memory_limit poate fi diferit.
  • Context: în CLI nu există $_GET, $_POST, $_COOKIE sau sesiuni de browser. $_SERVER conține variabilele de mediu și argv. Argumentele vin prin $argv și $argc sau getopt().
  • I/O: ai STDIN, STDOUT, STDERR. echo ajunge în terminal, iar codul de ieșire îl setezi cu exit(1), util pentru cron și CI.
  • Utilizatorul: scriptul CLI rulează cu utilizatorul care l-a pornit, iar FPM cu utilizatorul pool-ului (de exemplu www-data). Permisiunile pe fișiere pot da rezultate diferite.
  • OPcache e dezactivat implicit în CLI (opcache.enable_cli=0).

Comenzi utile:

BASH
php --ini                    # ce fișiere php.ini sunt încărcate
php -i | grep memory_limit   # setarea efectivă în CLI
php -m                       # extensiile încărcate
php -d memory_limit=1G import.php  # suprascriere doar pentru o rulare

Pentru FPM, creezi temporar o pagină cu phpinfo() sau afișezi ini_get('memory_limit'), pe care o ștergi imediat după verificare.

Ce urmărește intervievatorul: Verifică înțelegerea mediului de rulare. Multe probleme de tipul „pe server merge, din cron nu” vin din aceste diferențe.

93 Mid

Scrie un autoloader PSR-4 minimal cu spl_autoload_register pentru namespace-ul App\ mapat pe folderul src/. Ce face Composer în plus?

Răspuns scurt: Înregistrezi o funcție care primește numele complet al clasei, verifică prefixul App\, transformă restul în cale (\ devine /, plus .php) și include fișierul dacă există. Composer face același lucru, plus classmap optimizat, mai multe prefixe, fișiere de funcții (files) și dependențele din vendor/.

PHP
spl_autoload_register(function (string $class): void {
    $prefix = 'App\\';
    $baseDir = __DIR__ . '/src/';

    if (!str_starts_with($class, $prefix)) {
        return; // lasă alte autoloadere să încerce
    }
    $relative = substr($class, strlen($prefix));
    $file = $baseDir . str_replace('\\', '/', $relative) . '.php';

    if (is_file($file)) {
        require $file;
    }
});

// App\Http\Controller\HomeController  =>  src/Http/Controller/HomeController.php

Cum funcționează: la prima folosire a unei clase necunoscute (new, un apel static, class_exists(); instanceof nu declanșează autoload), PHP apelează pe rând autoloader-ele înregistrate, cu numele complet calificat. Dacă după toate clasa tot nu există, apare eroarea „Class not found”.

Detalii de corectitudine:

  • Pe Linux, sistemul de fișiere e sensibil la majuscule, deci app\models\User nu va găsi src/Models/User.php. Pe macOS sau Windows poate merge local și pică pe server.
  • Autoloader-ul nu aruncă excepții când nu găsește clasa, ca să permită altora să încerce.
  • Funcțiile și constantele nu se pot încărca automat. Composer le include la fiecare cerere prin cheia "files".

Echivalentul în Composer:

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

După modificare rulezi composer dump-autoload. Composer adaugă:

  • classmap generat (-o), adică un array clasă-fișier care evită verificările pe disc
  • --classmap-authoritative, care nu mai caută deloc pe disc clasele care lipsesc din hartă
  • integrare cu APCu (--apcu)
  • autoload-dev pentru clasele de test

Ce urmărește intervievatorul: Întrebarea verifică dacă înțelegi mecanismul din spatele lui vendor/autoload.php. Greșeala frecventă e problema cu majusculele care apare doar pe serverul Linux.

Eroarea, în practică:Class "Produs" not found

94 Mid

Scrie un generator care citește un CSV de câțiva GB rând cu rând și întoarce fiecare rând ca array asociativ, cu antetul ca chei. Ce fac yield from și getReturn()?

Răspuns scurt: O funcție cu yield deschide fișierul, citește antetul cu fgetcsv, apoi face yield array_combine($header, $row) pentru fiecare rând, deci în memorie e doar rândul curent. yield from deleagă către alt generator sau iterabil, iar getReturn() dă valoarea din return după terminarea generatorului.

PHP
function readCsv(string $path, string $sep = ','): Generator
{
    $fh = fopen($path, 'rb');
    if ($fh === false) {
        throw new RuntimeException("Nu pot deschide $path");
    }
    try {
        $header = fgetcsv($fh, null, $sep, '"', '');
        $line = 1;
        while (($row = fgetcsv($fh, null, $sep, '"', '')) !== false) {
            $line++;
            if ($row === [null]) {
                continue; // linie goală
            }
            if (count($row) !== count($header)) {
                throw new UnexpectedValueException("Linia $line are " . count($row) . ' coloane');
            }
            yield $line => array_combine($header, $row);
        }
        return $line - 1; // numărul de rânduri de date
    } finally {
        fclose($fh);
    }
}

$gen = readCsv('comenzi.csv');
foreach ($gen as $line => $row) {
    importa($row);
}
echo 'Rânduri procesate: ' . $gen->getReturn();

Ce trebuie explicat:

  • Execuție leneșă: apelul readCsv() nu rulează nimic, ci întoarce un obiect Generator. Codul avansează până la următorul yield abia când foreach cere un element. Memoria rămâne constantă, indiferent de mărimea fișierului.
  • Chei: yield $cheie => $valoare setează cheia, aici numărul liniei, util în mesajele de eroare.
  • finally închide fișierul și dacă bucla se oprește devreme sau apare o excepție. Când generatorul e distrus înainte de final, blocul finally rulează.
  • yield from deleagă: yield from readCsv('ian.csv'); yield from readCsv('feb.csv'); combină fișiere. Cheile provin din generatoarele interne, deci se pot repeta.
  • getReturn() funcționează doar după ce generatorul s-a terminat, altfel aruncă excepție.
  • Un generator poate fi parcurs o singură dată. send($v) trimite valori înapoi în generator, dar e rar folosit în cod de aplicație.

Ce urmărește intervievatorul: Generatoarele sunt verificate aici dintr-un unghi practic, cu un caz real de memorie. Intervievatorul urmărește închiderea fișierului și validarea rândurilor.

Eroarea, în practică:Cannot traverse an already closed generatorCannot get return value of a generator

95 Mid

Ce noutăți din PHP 8.3, 8.4 și 8.5 folosești sau ai urmări într-un proiect nou?

Răspuns scurt: 8.3: constante de clasă tipizate, atributul #[\Override], json_validate(). 8.4: property hooks, asymmetric visibility, new fără paranteze în lanț, array_find și înrudite, depreciera nullable implicit. 8.5: pipe operator |>, clone cu proprietăți modificate, array_first/array_last, atributul #[\NoDiscard].

PHP 8.3

  • Typed class constants: const string VERSION = '1.0';, verificate și în subclase.
  • #[\Override]: marchezi o metodă care trebuie să suprascrie una din părinte sau dintr-o interfață. Dacă metoda părinte e redenumită, primești eroare în loc de un bug tăcut.
  • json_validate(), accesul dinamic la constante (Foo::{$name}), mb_str_pad, reinițializarea proprietăților readonly în __clone.

PHP 8.4

  • Property hooks și asymmetric visibility (public private(set)), care elimină mult cod cu getteri și setteri.
  • new Foo()->metoda() fără paranteze suplimentare în jurul lui new.
  • array_find, array_find_key, array_any, array_all.
  • Atributul #[\Deprecated] pentru funcțiile tale, mb_trim, mb_ucfirst, parser HTML5 nou (Dom\HTMLDocument).
  • Deprecierea tipurilor nullable implicite (int $x = null) și costul bcrypt implicit crescut la 12.

PHP 8.5

  • Pipe operator: rezultatul din stânga devine argumentul funcției din dreapta.
PHP
$slug = $titlu
    |> trim(...)
    |> strtolower(...)
    |> (fn($s) => preg_replace('/[^a-z0-9]+/', '-', $s));
  • clone($obj, ['prop' => $valoare]), util pentru obiecte readonly.
  • array_first(), array_last(), atributul #[\NoDiscard] (avertisment dacă rezultatul unei funcții e ignorat), extensia URI pentru parsare standardizată de URL-uri.

Cum alegi ce folosești: versiunea minimă din composer.json și de pe servere decide. O bibliotecă publică folosește noutățile cu întârziere. O aplicație internă, cu control asupra serverului, poate trece mai repede. Fiecare versiune minoră are suport activ doi ani și încă doi ani doar de securitate, deci planifici upgrade-uri regulate. Rector automatizează o parte din migrare.

Ce urmărește intervievatorul: Verifică dacă urmărești limbajul după PHP 8.0. Un răspuns bun alege câteva noutăți și explică ce problemă rezolvă, nu le enumeră pe toate.

96 Mid

Ce face un analizor static ca PHPStan sau Psalm și cum îl introduci într-un proiect existent cu mii de erori? Cum descrii tipul „array de obiecte User” pe care PHP nu-l poate exprima?

Răspuns scurt: Analizează codul fără să-l ruleze și găsește erori de tip, metode inexistente și null netratat. Într-un proiect vechi pornești cu un nivel mic și un baseline, ca CI-ul să blocheze doar erorile noi. Tipurile lipsă din limbaj le scrii în PHPDoc: list<User>.

PHP verifică tipurile la rulare, doar pe drumul de cod executat. Un analizor static citește tot codul și deduce tipurile, așa că găsește probleme înainte de producție:

  • apeluri către metode sau proprietăți inexistente
  • null posibil folosit fără verificare ($user->getName() după un find() care poate întoarce null)
  • argumente de tip greșit, cod mort, condiții mereu adevărate
  • match incomplet pe un enum

PHPStan are niveluri de la 0 la 10 (în versiunea 2), fiecare cu reguli mai stricte.

Introducerea într-un proiect vechi:

BASH
composer require --dev phpstan/phpstan
vendor/bin/phpstan analyse src --level 5 --generate-baseline

Baseline-ul (phpstan-baseline.neon) înregistrează erorile existente, iar analiza raportează doar erorile noi. Rulezi analiza în CI la fiecare pull request, apoi reduci baseline-ul treptat, de exemplu reparând fișierele pe care le atingi oricum, și crești nivelul când erorile scad.

Tipuri în PHPDoc, înțelese de PHPStan, Psalm și IDE:

PHP
/**
 * @param list<User> $users          listă cu chei 0..n-1
 * @param array<string, int> $stoc   chei string, valori int
 * @return array{total: int, items: list<Item>}  formă fixă de array
 */
function raport(array $users, array $stoc): array { /* ... */ }

/**
 * @template T
 * @param class-string<T> $class
 * @return T
 */
function make(string $class): object { return new $class(); }

Generice ca list<User> nu există în limbaj, dar cu PHPDoc analizorul verifică totuși că pui doar User în listă. Pentru framework-uri există extensii (Larastan pentru Laravel, phpstan-symfony) care înțeleg „magia” acestora.

Ce urmărește intervievatorul: Verifică dacă ai lucrat cu unelte de calitate a codului și dacă ai o strategie realistă pentru cod existent. Termenul „baseline” e semnalul că ai făcut asta efectiv.

97 Senior

Ce sunt Fibers în PHP 8.1? Fac ele codul PHP paralel? Cum le folosesc biblioteci ca Revolt sau AMPHP?

Răspuns scurt: Un Fiber e o funcție care se poate opri cu Fiber::suspend() și relua cu resume(), păstrându-și stiva. Nu aduce paralelism: totul rulează pe un singur fir, cooperativ. Bibliotecile async îl folosesc ca să aștepte I/O fără callback-uri.

Exemplu minimal:

PHP
$fiber = new Fiber(function (string $x): string {
    $y = Fiber::suspend($x . '1');   // se oprește și trimite '1' afară
    return $y . '3';
});

$v = $fiber->start('a');   // 'a1'
$fiber->resume('2');       // reia, $y devine '2'
echo $v . $fiber->getReturn(); // a1 + 23 => a123

Diferența față de generatoare: un generator se poate suspenda doar în propria funcție, la yield, iar codul care îl apelează trebuie să știe că lucrează cu un generator. Un fiber se poate suspenda oriunde în stiva de apeluri, inclusiv într-o funcție apelată la cinci niveluri adâncime, fără ca funcțiile intermediare să se schimbe.

De ce contează: într-o bibliotecă asincronă, $client->get($url) poate trimite cererea, înregistra socket-ul într-un event loop și apela Fiber::suspend(). Event loop-ul rulează alte fibers până când răspunsul sosește, apoi reia fiber-ul inițial. Pentru programator codul arată sincron, dar în timpul așteptărilor de rețea se fac alte lucruri.

Revolt e un event loop construit pe Fibers, pe care se bazează AMPHP v3.

Ce nu fac Fibers:

  • nu rulează cod PHP pe mai multe nuclee. Un calcul intens blochează tot
  • funcțiile clasice (PDO, file_get_contents, sleep) blochează procesul, deci nu câștigi nimic fără drivere asincrone dedicate
  • nu sunt pentru cod de aplicație obișnuit, ci pentru autorii de biblioteci

Pentru paralelism real în PHP există procese multiple (cozi cu workeri, pcntl_fork), extensia parallel (cu ZTS) sau, cel mai frecvent, mai multe procese PHP-FPM.

Ce urmărește intervievatorul: Întrebare de senior care distinge concurența de paralelism. Mulți candidați cred că Fibers sunt fire de execuție.

98 Senior

Un endpoint PHP răspunde în 3 secunde în loc de 300 ms. Cum găsești cauza, pas cu pas, înainte să schimbi codul?

Răspuns scurt: Măsor întâi, nu ghicesc: confirm când apare problema, separ timpul PHP de timpul bazei de date și al serviciilor externe, apoi profilez cererea lentă (Xdebug, Blackfire, SPX sau un APM). Optimizez ce arată profilul și măsor din nou.

Un plan structurat:

1. Reproduc și delimitez. Toate cererile sunt lente sau doar pentru anumiți utilizatori sau date? De când? Ce s-a schimbat (deploy, volum de date, trafic)? Logul de acces al serverului web cu timpul de răspuns arată tiparul.

2. Măsor pe straturi. Adaug temporar măsurători cu hrtime(true) în jurul blocurilor mari (încărcare, interogări, apeluri HTTP, randare) sau mă uit în APM (New Relic, Datadog, Tideways) dacă există. De cele mai multe ori timpul e în I/O, nu în PHP.

3. Baza de date. Activez logul de interogări lente sau număr interogările pe cerere. Caut:

  • N+1 (aceeași interogare repetată în buclă)
  • interogări fără index, verificate cu EXPLAIN
  • interogări care aduc mult mai multe date decât se afișează

4. Servicii externe. Un apel HTTP fără timeout sau o rezolvare DNS lentă pot adăuga secunde. Verific cURL cu CURLOPT_CONNECTTIMEOUT și CURLOPT_TIMEOUT.

5. Profiler pentru codul PHP. Dacă timpul e chiar în PHP, rulez cererea cu Xdebug în modul profiler (rezultat citit în KCachegrind sau qcachegrind), cu Blackfire sau SPX. Caut funcțiile cu timp propriu mare și numărul de apeluri: o funcție ieftină apelată de un milion de ori, o sortare în buclă, in_array pe liste mari.

6. Mediul. OPcache activ? Pool-ul FPM e saturat (cererile așteaptă un worker liber)? Sesiunea blochează cererile paralele?

7. Corectez și verific. Schimb un singur lucru odată, măsor din nou în aceleași condiții, adaug cache doar unde datele permit și las o metrică sau o alertă care să prindă regresia data viitoare.

Ce urmărește intervievatorul: Întrebare de situație care arată maturitatea în depanarea performanței. Intervievatorul caută „măsor întâi” și cunoașterea uneltelor, nu optimizări la întâmplare.

99 Senior

Echipa ta întreține o aplicație PHP mare, fără tipuri și fără strict_types. Cum ai introduce treptat tipuri stricte și analiză statică, fără să blochezi livrările și fără să strici producția?

Răspuns scurt: Încep cu ce nu schimbă comportamentul: PHPStan cu baseline în CI și teste pe fluxurile critice. Apoi adaug tipuri și strict_types fișier cu fișier, începând cu codul nou, folosesc Rector pentru schimbări mecanice și urmăresc TypeError în producție.

Un plan pe care l-aș propune echipei:

1. Explic de ce, cu exemple din proiect. Iau două-trei bug-uri reale recente care ar fi fost prinse de tipuri (un null neașteptat, un "0" tratat ca fals). E mai convingător decât argumentele generale.

2. Plasa de siguranță întâi. Teste automate pe fluxurile critice (login, comandă, plată), chiar și câteva teste end-to-end. Fără ele, orice refactorizare e riscantă.

3. Analiza statică, fără schimbări de cod. PHPStan la un nivel mic, cu baseline pentru erorile existente, rulat în CI pe fiecare pull request. Regula echipei: nu adăugăm erori noi. Nivelul crește când baseline-ul scade.

4. Tipuri treptat, din exterior spre interior.

  • tot codul nou: declare(strict_types=1), parametri, return și proprietăți tipizate
  • codul existent: întâi tipuri de return și PHPDoc (nu schimbă comportamentul la rulare), apoi tipuri pe parametri în modulele cu teste bune
  • strict_types doar pe fișiere complet tipizate, pentru că directiva afectează apelurile făcute din acel fișier

5. Automatizare. Rector adaugă tipuri deduse sigur din cod și rezolvă schimbări mecanice. Fiecare lot de modificări automate intră într-un PR separat, ușor de revizuit.

6. Monitorizarea producției. După fiecare lot, urmăresc în loguri TypeError și deprecated-urile noi. Un monitor de erori (Sentry, de exemplu) arată rapid regresiile.

7. Ritm sustenabil. Regula „lași fișierul mai bun decât l-ai găsit”, plus un procent mic din fiecare sprint, negociat cu product owner-ul. Nu propun o rescriere mare care oprește funcționalitățile noi.

La final, trec convențiile în ghidul echipei și în checklist-ul de code review, ca noii colegi să le aplice de la început.

Ce urmărește intervievatorul: Întrebare comportamentală pentru senior: schimbare tehnică într-o echipă, cu riscuri reale. Intervievatorul urmărește pragmatismul și grija pentru producție, nu entuziasmul pentru unelte.

100 Senior

Aplicația ta va rula pe un server de aplicații persistent (FrankenPHP în worker mode, RoadRunner sau Swoole) în loc de PHP-FPM. Ce tipuri de bug-uri apar și cum scrii codul ca să le eviți?

Răspuns scurt: Aplicația nu mai pornește de la zero la fiecare cerere, deci starea rămâne între cereri: statice, singleton-uri, cache-uri, conexiuni închise de server. Apar scurgeri de date între utilizatori și memorie în creștere. Soluții: servicii fără stare, reset după cerere, reciclarea workerilor.

În modelul clasic PHP-FPM, fiecare cerere pornește cu memoria goală, construiește aplicația și o distruge la final („shared nothing”). Multe greșeli sunt astfel ascunse: o variabilă statică sau un cache în memorie dispare automat. Într-un worker persistent, aplicația e încărcată o dată și servește mii de cereri, ceea ce aduce performanță, dar schimbă regulile.

Bug-uri tipice:

  • Scurgeri de date între utilizatori: un serviciu care ține utilizatorul curent într-o proprietate ($this->currentUser) sau într-o variabilă statică îl poate păstra pentru cererea următoare, a altui utilizator. Este cel mai grav caz.
  • Memorie în creștere: array-uri statice folosite ca cache, loguri ținute în memorie, listeneri adăugați la fiecare cerere.
  • Conexiuni moarte: o conexiune PDO deschisă la pornire poate fi închisă de MySQL după wait_timeout, iar cererile încep să pice cu „MySQL server has gone away”.
  • Superglobale și funcții globale: $_SESSION, header(), exit() și session_start() se comportă altfel sau sunt gestionate de runtime. exit poate opri tot workerul.
  • Configurație citită o singură dată: modificările de mediu nu se văd până la repornire.

Practici:

  • servicii fără stare (stateless): datele cererii circulă ca parametri sau într-un obiect request, nu în proprietăți ale serviciilor partajate
  • reset explicit după fiecare cerere (Symfony are ResetInterface și kernel.reset, Laravel Octane are mecanisme similare)
  • reconectare sau verificare a conexiunilor înaintea folosirii
  • max_requests sau echivalentul pentru reciclarea periodică a workerilor, ca plasă de siguranță
  • teste care trimit cereri succesive cu utilizatori diferiți pe același worker
  • monitorizarea memoriei per worker în timp

Ce urmărește intervievatorul: Întrebare de senior despre o tendință actuală în ecosistemul PHP. Intervievatorul verifică dacă înțelegi modelul „shared nothing” și ce se strică atunci când dispare.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de PHP, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață PHP scriind cod, nu doar citind

Curs PHP: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.