Obținerea unui singur element
Această lecție arată cum se obține un element dintr-un tablou: după poziția lui, după o condiție sau la întâmplare. Arată și cum se verifică dacă un element există în general.
Când o căutare poate eșua, PHP răspunde cu null. Citirea unui index care nu există, cum ar fi $words[5] într-un tablou de 5 elemente, nu oprește programul: ridică un avertisment (Undefined array key 5) și dă null.
Operatorul de coalescență nulă ?? face aceeași citire sigură și silențioasă: $words[5] ?? "missing" caută indexul fără niciun avertisment și revine la "missing" atunci când nu există niciun element. Această pereche — null pentru „nu există” și ?? pentru valoarea de rezervă — este idiomul care străbate toată pagina.
PHP 8.4 a adăugat și funcții de căutare gata făcute: array_find(), array_any() și array_all(). Ele sunt folosite mai jos alături de clasicele in_array() și count().
Obținerea după poziție
Fiecare element al unei liste simple are o poziție numită index. Primul index este 0, deci ultimul este count($words) - 1.
Pentru a citi un element după poziție, scrie indexul între paranteze pătrate: $words[3]. PHP nu numără de la sfârșit — $words[-1] ar căuta o cheie -1 care nu există. Ultimul element se citește cu array_key_last().
Pentru un index care poate fi în afara intervalului, ?? înlocuiește o întreagă familie de funcții ajutătoare: $words[$i] ?? null este „elementul de la poziție, sau null”, iar $words[$i] ?? fallback($i) este „elementul de la poziție, sau altfel”.
Elementul de la o poziție
$words[3] citește elementul de la indexul 3. Deoarece numărarea începe de la 0, acesta este al patrulea cuvânt.
Ieșire: script PHP
<?php
$words = ["one", "two", "three", "four", "five"];
// Pozițiile încep de la 0, deci indexul 3 este al patrulea element.
echo $words[3], "\n";
Primul și ultimul element
Primul element este $words[0]. Pentru ultimul, array_key_last($words) returnează ultima cheie — aici 4, pentru că tabloul are 5 elemente, dar primul index este 0. $words[-1] nu ar funcționa: PHP nu are indecși negativi pentru tablouri.
Ieșire: script PHP
<?php
$words = ["one", "two", "three", "four", "five"];
// Primul element se află la indexul 0.
echo $words[0], "\n";
// array_key_last() dă ultima cheie, aici 4.
echo $words[array_key_last($words)], "\n";
Elementul de la o poziție, sau null
elementAt() răspunde cu elementul sau cu null. Indexul 1 există, deci primul apel afișează two. Indexul 5 nu există: funcția ajutătoare dă null, nu se ridică niciun avertisment, iar ?? "missing" de la locul apelului transformă null în textul missing.
Ieșire: script PHP
<?php
// elementAt returnează elementul de la indexul $i, sau null când nu există niciunul.
function elementAt(array $items, int $i): mixed {
return $items[$i] ?? null;
}
$words = ["one", "two", "three", "four", "five"];
// Indexul 1 există, deci valoarea de rezervă de după ?? nu este folosită.
echo elementAt($words, 1) ?? "missing", "\n";
// Indexul 5 nu există: niciun avertisment, doar null -> "missing".
echo elementAt($words, 5) ?? "missing", "\n";
Elementul de la o poziție, sau o valoare de rezervă
Valoarea de rezervă de după ?? poate fi calculată. fallback(5) primește indexul și construiește mesajul „The value for index 5 is undefined”. ?? este leneș: funcția rulează doar atunci când elementul lipsește într-adevăr.
Ieșire: script PHP
<?php
// Valoarea de rezervă construiește un mesaj din indexul pe care îl primește.
function fallback(int $i): string {
return "The value for index $i is undefined";
}
$words = ["one", "two", "three", "four", "five"];
// ?? citește un index inexistent fără avertisment și apelează
// fallback() doar atunci când elementul lipsește într-adevăr.
echo $words[5] ?? fallback(5), "\n";
Obținerea după condiție
Deseori nu cunoști poziția. În schimb cunoști o condiție: primul cuvânt mai lung de 3 litere, ultimul cuvânt care începe cu „f”. Condiția este o funcție care primește un element și returnează true sau false.
Începând cu PHP 8.4 asta se scrie pe un singur rând: array_find() returnează primul element care trece testul — sau null atunci când niciunul nu trece. Așa că „nu s-a potrivit nimic” nu are nevoie de niciun indicator special: este pur și simplu null, iar ?? sau o verificare !== null se ocupă de el.
Nu există o funcție pentru ultima potrivire. Inversează mai întâi tabloul cu array_reverse(): prima potrivire din tabloul inversat este ultima potrivire din cel original.
Prima potrivire
array_find() dă primul cuvânt cu strlen($w) > 3. Acel cuvânt este three.
Ieșire: script PHP
<?php
$words = ["one", "two", "three", "four", "five"];
// array_find() returnează primul element care trece testul.
echo array_find($words, fn($w) => strlen($w) > 3), "\n";
Ultima potrivire
array_reverse($words) pune five pe primul loc. array_find() parcurge apoi tabloul inversat și se oprește la primul cuvânt care începe cu f — care este ultimul astfel de cuvânt din tabloul original.
Ieșire: script PHP
<?php
$words = ["one", "two", "three", "four", "five"];
// Inversează mai întâi tabloul: prima potrivire din tabloul
// inversat este ultima potrivire din cel original.
$last = array_find(array_reverse($words), fn($w) => str_starts_with($w, "f"));
echo $last, "\n";
Prima potrivire, sau null
Niciun cuvânt nu este mai lung de 6 litere, deci array_find() returnează null și ?? "not found" afișează valoarea de rezervă. În tabloul de numere primul număr par este 2, deci verificarea !== null trece și se afișează 2.
Ieșire: script PHP
<?php
$words = ["one", "two", "three", "four", "five"];
$numbers = [1, 2, 3, 4];
// Niciun cuvânt nu este mai lung de 6 litere: array_find() returnează null.
$w = array_find($words, fn($s) => strlen($s) > 6);
echo $w ?? "not found", "\n";
// Primul număr par există, deci verificarea trece.
$n = array_find($numbers, fn($n) => $n % 2 === 0);
if ($n !== null) {
echo $n, "\n";
}
Ultima potrivire, sau null
Numerele inversate încep cu 4, iar 4 este par — căutarea nimerește imediat. Dacă nu ar fi existat niciun număr par, array_find() ar fi returnat null și if nu ar fi afișat nimic.
Ieșire: script PHP
<?php
$numbers = [1, 2, 3, 4];
// Caută în tabloul inversat: primul rezultat găsit este ultima potrivire.
$lastEven = array_find(array_reverse($numbers), fn($n) => $n % 2 === 0);
if ($lastEven !== null) {
echo $lastEven, "\n";
}
Obținerea unei valori prezente
Un tablou PHP poate conține null pentru a marca o valoare care lipsește. Când vrei doar prima valoare reală, condiția este pur și simplu $v !== null.
array_find() cu acest test returnează primul element care conține într-adevăr o valoare — sau chiar null atunci când tot tabloul este format doar din goluri, ceea ce se citește iarăși firesc cu ??.
Prima valoare care nu este null
Tabloul începe cu un gol: null. Testul $v !== null îl sare, iar array_find() returnează two, prima valoare care este într-adevăr acolo.
Ieșire: script PHP
<?php
$values = [null, "two", "three"];
// Prima valoare care este într-adevăr acolo.
echo array_find($values, fn($v) => $v !== null), "\n";
Element aleatoriu
Pentru a alege un element aleatoriu, alege un index aleatoriu. mt_rand($min, $max) returnează un număr întreg între cele două limite, ambele incluse, deci mt_rand(0, count($numbers) - 1) este exact un index valid.
mt_srand(42) pornește generatorul de la o sămânță fixă. Cu aceeași sămânță programul alege de fiecare dată același element, ceea ce face ieșirea previzibilă — acest exemplu folosește o sămânță doar pentru ca rezultatul lui să fie reproductibil. Renunță la mt_srand() atunci când vrei un rezultat diferit la fiecare rulare.
Alegerea unui element aleatoriu
Cu sămânța 42 generatorul alege indexul 2, deci programul afișează 3. Schimbă sămânța și poate ieși un alt număr.
Ieșire: script PHP
<?php
$numbers = [1, 2, 3, 4];
// O sămânță fixă face ca alegerea „aleatorie” să fie aceeași la fiecare rulare.
mt_srand(42);
$i = mt_rand(0, count($numbers) - 1);
echo $numbers[$i], "\n";
Verificarea existenței unui element
Pentru a verifica dacă o valoare se află într-un tablou, folosește in_array(). Transmite mereu true ca al treilea argument: acesta cere ca tipul și valoarea să corespundă, așa că șirul de caractere "1" nu este confundat cu numărul 1.
PHP nu are containsAll(). O mică funcție ajutătoare cu array_all() (nouă în PHP 8.4) face treaba: fiecare valoare căutată trebuie să treacă propria verificare in_array().
Un tablou este gol atunci când count($x) === 0 și nu este gol atunci când count($x) > 0. Există și empty($x), mai scurt, dar ai grijă: este true pentru orice valoare falsy — 0, "", null — nu doar pentru tablouri goale, așa că comparația explicită cu count() spune exact ce vrei să spui.
Conține o valoare
four se află în tablou, deci prima verificare afișează true. zero nu se află, deci a doua afișează false. Al treilea argument true face ca in_array() să compare cu ===.
Ieșire: script PHP
<?php
$words = ["one", "two", "three", "four", "five"];
// Al treilea argument true cere tip și valoare identice.
echo json_encode(in_array("four", $words, true)), "\n";
echo json_encode(in_array("zero", $words, true)), "\n";
Conține toate valorile
Atât four, cât și one se află în tablou, deci containsAll() returnează true. zero lipsește, deci al doilea apel returnează false — array_all() se oprește la prima valoare căutată care nu trece.
Ieșire: script PHP
<?php
// containsAll este true doar atunci când fiecare valoare căutată se află în $items.
function containsAll(array $items, array $wanted): bool {
return array_all($wanted, fn($v) => in_array($v, $items, true));
}
$words = ["one", "two", "three", "four", "five"];
echo json_encode(containsAll($words, ["four", "one"])), "\n";
echo json_encode(containsAll($words, ["one", "zero"])), "\n";
Gol sau nu gol
$empty are numărul de elemente 0, deci count($empty) === 0 este true. $words are 5 elemente, deci count($words) > 0 este de asemenea true. json_encode() transformă fiecare valoare booleană în textul true.
Ieșire: script PHP
<?php
$words = ["one", "two", "three", "four", "five"];
$empty = [];
// Un tablou este gol atunci când numărul lui de elemente este 0.
echo json_encode(count($empty) === 0), "\n";
echo json_encode(count($words) > 0), "\n";