Transformarea unei colecții
O transformare pornește de la o colecție, de exemplu un tablou, și construiește din ea o colecție nouă. Originalul nu este modificat.
Tablourile din PHP vin cu o familie mare de funcții deja gata pentru asta: array_map aplică o funcție fiecărui element, array_merge unește tablouri, array_combine lipește cheile la valori, array_column alege o singură poziție din fiecare rând, iar implode transformă un tablou în text. Acolo unde nicio funcție gata făcută nu se potrivește, o buclă foreach scurtă rezolvă treaba.
Același tablou PHP funcționează și ca listă, și ca depozit de tip cheie:valoare. O listă simplă are cheile 0, 1, 2 și așa mai departe; un tablou asociativ are cheile alese de tine. Amândouă păstrează intrările în ordinea inserării și amândouă sunt folosite în această pagină.
Map
Operația map aplică aceeași funcție fiecărui element și adună răspunsurile într-un tablou nou, de aceeași lungime. De exemplu, poate transforma 1, 2, 3 în 3, 6, 9.
În PHP asta face exact array_map: primește mai întâi funcția și apoi tabloul și întoarce un tablou nou. Funcția este adesea o funcție-săgeată scurtă, precum fn($x) => $x * 3.
array_map nu modifică niciodată tabloul original. Construiește și întoarce unul nou, așa că le poți păstra pe amândouă.
Map cu array_map
array_map apelează funcția-săgeată pe fiecare element și întoarce un tablou nou. Aici înmulțește fiecare număr cu 3, iar implode afișează noul tablou ca 3, 6, 9.
Ieșire: script PHP
<?php
$numbers = [1, 2, 3];
// array_map apelează funcția pe fiecare element și întoarce un tablou nou
$tripled = array_map(fn($x) => $x * 3, $numbers);
echo implode(", ", $tripled) . "\n";
Map cu indicele
Uneori contează și poziția elementului. foreach îți dă atât cheia, cât și valoarea, iar într-o listă simplă cheile sunt chiar pozițiile 0, 1, 2. Aici fiecare valoare este înmulțită cu propriul indice, așa că programul afișează 0, 2, 6.
Ieșire: script PHP
<?php
$numbers = [1, 2, 3];
$result = [];
// foreach dă atât cheia (indicele), cât și valoarea
foreach ($numbers as $idx => $value) {
$result[] = $value * $idx;
}
echo implode(", ", $result) . "\n";
Sari peste unele rezultate
Uneori unele rezultate trebuie eliminate. Întoarce null pentru ele, apoi scoate valorile null cu array_filter. Atenție: array_filter păstrează cheile originale, așa că tabloul filtrat are în continuare cheile 0 și 2, iar json_encode îl afișează ca {"0":3,"2":9}. array_values îl reindexează într-o listă curată: [3,9].
Ieșire: script PHP
<?php
$numbers = [1, 2, 3];
// întoarce null pentru elementele care trebuie eliminate
$mapped = array_map(fn($x) => $x === 2 ? null : $x * 3, $numbers);
// array_filter scoate valoarea null, dar păstrează cheile originale
$kept = array_filter($mapped, fn($v) => $v !== null);
// array_values reindexează tabloul la 0, 1, 2, ...
$result = array_values($kept);
echo json_encode($kept) . "\n";
echo json_encode($result) . "\n";
Transformarea cheilor unui tablou
Pentru a schimba cheile unui tablou asociativ, transformă cheile și lipește-le din nou la valori. array_keys dă toate cheile, array_map('strtoupper', ...) le scrie cu majuscule, iar array_combine împerechează noile chei cu vechile valori.
Ieșire: script PHP
<?php
$numbersMap = ["key1" => 1, "key2" => 2];
// scrie fiecare cheie cu majuscule, apoi lipește noile chei la vechile valori
$upperKeys = array_combine(
array_map('strtoupper', array_keys($numbersMap)),
$numbersMap
);
echo json_encode($upperKeys) . "\n";
Transformarea valorilor unui tablou
Pentru a schimba valorile, păstrează cheile și calculează valori noi. array_map poate parcurge două tablouri în același timp — aici cheile și valorile — astfel încât fiecare valoare nouă este vechea valoare plus lungimea cheii sale: 1 + strlen("key1") este 5.
Ieșire: script PHP
<?php
$numbersMap = ["key1" => 1, "key2" => 2];
// păstrează cheile, calculează o valoare nouă din fiecare pereche cheie:valoare
$newValues = array_combine(
array_keys($numbersMap),
array_map(fn($key, $value) => $value + strlen($key),
array_keys($numbersMap), $numbersMap)
);
echo json_encode($newValues) . "\n";
Zip
Operația zip ia două tablouri și împerechează elementele lor după poziție: primul cu primul, al doilea cu al doilea și așa mai departe.
PHP are un idiom clasic pentru asta: array_map(null, $a, $b). Când callback-ul este null și există mai multe tablouri, array_map construiește un tablou de perechi. Observă că nu se oprește la tabloul mai scurt — locurile lipsă sunt completate cu null — așa că fă zip pe tablouri de aceeași lungime sau taie mai întâi pe cel mai lung cu array_slice.
Zip pe două tablouri
Cu null pe post de callback, array_map împerechează cele două tablouri într-un tablou de tablouri cu două elemente. json_encode arată tot rezultatul pe un singur rând.
Ieșire: script PHP
<?php
$colors = ["red", "brown", "grey"];
$animals = ["fox", "bear", "wolf"];
// array_map cu null pe post de callback împerechează tablourile element cu element
$pairs = array_map(null, $colors, $animals);
echo json_encode($pairs) . "\n";
Zip cu o transformare
Nu ai nevoie întotdeauna de perechile în sine. Dă-i lui array_map un callback adevărat și ambele tablouri, iar el apelează funcția cu un element din fiecare. ucfirst scrie cu majusculă prima literă a numelui animalului.
Ieșire: script PHP
<?php
$colors = ["red", "brown", "grey"];
$animals = ["fox", "bear", "wolf"];
// callback-ul primește un element din fiecare tablou
$sentences = array_map(
fn($color, $animal) => "Animalul " . ucfirst($animal) . " are culoarea " . $color,
$colors,
$animals
);
echo implode("\n", $sentences) . "\n";
Unzip pe un tablou de perechi
Operația unzip este inversa: un tablou de perechi devine două tablouri. array_column adună elementul de la o poziție din fiecare pereche — poziția 0 dă cuvintele, iar poziția 1 dă numerele.
Ieșire: script PHP
<?php
$numberPairs = [["one", 1], ["two", 2], ["three", 3]];
// array_column alege elementul de la o poziție din fiecare pereche
$words = array_column($numberPairs, 0);
$numbers = array_column($numberPairs, 1);
echo implode(", ", $words) . "\n";
echo implode(", ", $numbers) . "\n";
Associate
Operația associate construiește un tablou asociativ dintr-o listă. Fiecare element îți dă o cheie și o valoare. Un tablou nu poate conține aceeași cheie de două ori, așa că, dacă două elemente produc aceeași cheie, câștigă cel de mai târziu.
Șablonul este o buclă foreach simplă: pornește de la un tablou gol și atribuie $result[$key] = $value pentru fiecare element. PHP păstrează intrările în ordinea în care au fost adăugate.
Elementele pe post de chei
Elementul însuși devine cheie, iar valoarea este calculată din el. Aici cuvintele sunt chei, iar lungimile lor sunt valori, așa că programul afișează {"one":3,"two":3,"three":5}.
Ieșire: script PHP
<?php
$numbers = ["one", "two", "three"];
$lengths = [];
// fiecare cuvânt devine cheie, lungimea lui devine valoare
foreach ($numbers as $word) {
$lengths[$word] = strlen($word);
}
echo json_encode($lengths) . "\n";
Elementele pe post de valori
Elementul devine valoare, iar cheia este calculată din el. Aici cheia este prima literă scrisă cu majusculă, luată cu $word[0] și strtoupper. Atât two, cât și three încep cu T, așa că three îl înlocuiește pe two și tabloul are doar două intrări.
Ieșire: script PHP
<?php
$numbers = ["one", "two", "three"];
$byFirstLetter = [];
// cheia este prima literă; un cuvânt de mai târziu îl înlocuiește pe unul de mai înainte
foreach ($numbers as $word) {
$byFirstLetter[strtoupper($word[0])] = $word;
}
echo json_encode($byFirstLetter) . "\n";
Calculează atât cheia, cât și valoarea
Poți calcula din element atât cheia, cât și valoarea. Aici cheia este prima literă, iar valoarea este lungimea cuvântului. Din nou câștigă intrarea T de mai târziu.
Ieșire: script PHP
<?php
$numbers = ["one", "two", "three"];
$lengthByLetter = [];
// cheia este prima literă, valoarea este lungimea cuvântului
foreach ($numbers as $word) {
$lengthByLetter[strtoupper($word[0])] = strlen($word);
}
echo json_encode($lengthByLetter) . "\n";
Cheia și valoarea dintr-un singur element
Uneori un singur element conține ambele părți. explode împarte un nume complet la spațiu într-un tablou de cuvinte, iar atribuirea de listă [$first, $last] = ... îl despachetează. Numele de familie devine cheie, iar prenumele devine valoare.
Ieșire: script PHP
<?php
$names = ["Alice Adams", "Brian Brown"];
$byLastName = [];
foreach ($names as $fullName) {
[$first, $last] = explode(" ", $fullName); // împarte la spațiu
$byLastName[$last] = $first; // nume de familie -> prenume
}
echo json_encode($byLastName) . "\n";
Flatten
Operația flatten transformă o colecție imbricată, de exemplu un tablou de tablouri, într-un singur tablou simplu, cu toate elementele în ordine.
În PHP, array_merge unește oricâte tablouri, iar cele trei puncte împrăștie tablourile interioare în apel: array_merge(...$nested).
Aplatizarea unui tablou de tablouri
Cele trei puncte transformă array_merge(...$numberSets) în array_merge([1, 2, 3], [4, 5, 6]). Două tablouri interioare de câte trei numere devin un singur tablou de șase.
Ieșire: script PHP
<?php
$numberSets = [[1, 2, 3], [4, 5, 6]];
// cele trei puncte împrăștie tablourile interioare în array_merge
$result = array_merge(...$numberSets);
echo implode(", ", $result) . "\n";
Aplatizarea valorilor din obiecte
Un flat map ia mai întâi un tablou din fiecare element, apoi unește toate acele tablouri. array_map citește proprietatea $values a fiecărui container, iar array_merge cu cele trei puncte lipește cele trei tablouri într-unul singur.
Ieșire: script PHP
<?php
declare(strict_types=1);
class Container {
public function __construct(public array $values) {}
}
$containers = [
new Container(["one", "two", "three"]),
new Container(["four", "five"]),
new Container(["six", "seven", "eight"]),
];
// mai întâi asociază fiecărui container valorile sale, apoi unește toate acele tablouri
$result = array_merge(...array_map(fn($c) => $c->values, $containers));
echo implode(", ", $result) . "\n";
Reprezentarea ca șir de caractere
Adesea vrei să arăți o colecție ca text ușor de citit, de exemplu cu virgule între elemente.
În PHP, implode primește un separator și un tablou și întoarce un singur șir de caractere. Numerele sunt transformate automat în text. Extrele — un prefix, un postfix, o limită sau o transformare — se fac cu concatenare de șiruri de caractere, cu array_slice sau cu array_map înainte de unire.
Unirea cu un separator
implode pune ", " între cuvinte și întoarce un singur șir de caractere.
Ieșire: script PHP
<?php
$numbers = ["one", "two", "three"];
echo implode(", ", $numbers) . "\n";
Adăugarea unui prefix și a unui postfix
Un prefix și un postfix sunt doar text în jurul rezultatului unit. În PHP le adaugi cu operatorul ..
Ieșire: script PHP
<?php
$numbers = ["one", "two", "three"];
// adaugă prefixul și postfixul în jurul textului unit
$text = "început: " . implode(" | ", $numbers) . ": sfârșit";
echo $text . "\n";
Limitarea numărului de elemente
Pentru un tablou lung poate vrei să arăți doar primele câteva elemente. range(1, 100) construiește numerele, array_slice($numbers, 0, 10) ia primele 10, iar "...>" este adăugat la final pentru a arăta că restul elementelor au fost tăiate. implode transformă singur numerele în text.
Ieșire: script PHP
<?php
$numbers = range(1, 100);
// ia doar primele 10 numere
$limit = 10;
$parts = array_slice($numbers, 0, $limit);
if (count($numbers) > $limit) {
$parts[] = "<...>";
}
echo implode(", ", $parts) . "\n";
Transformarea fiecărui element înainte de unire
Pentru a schimba fiecare element înainte de unire, transformă mai întâi tabloul cu array_map, apoi aplică implode pe rezultat. Aici fiecare cuvânt devine "Element: " plus cuvântul scris cu majuscule.
Ieșire: script PHP
<?php
$numbers = ["one", "two", "three"];
// schimbă mai întâi fiecare cuvânt, apoi unește rezultatele
$parts = array_map(fn($word) => "Element: " . strtoupper($word), $numbers);
echo implode(", ", $parts) . "\n";