array_merge() w PHP: łączenie dwóch lub więcej tablic

array_merge($a, $b) zwraca nową tablicę z elementami $a, po których następują elementy $b. Klucze liczbowe są numerowane od nowa od 0; gdy obie tablice mają ten sam klucz tekstowy, wygrywa wartość z późniejszej tablicy. Możesz podać dowolnie wiele tablic.

<?php
$fruits = ['apple', 'pear'];
$veg    = ['carrot', 'leek'];
print_r(array_merge($fruits, $veg));

$defaults = ['color' => 'blue', 'size' => 'M'];
$chosen   = ['size' => 'L'];
print_r(array_merge($defaults, $chosen));   // later value wins

array_merge() nie zmienia swoich argumentów. Zwraca połączoną tablicę, więc przypisz wynik: $all = array_merge($all, $more);.

Klucze liczbowe są numerowane od nowa

array_merge() traktuje klucze całkowite jak pozycje, a nie nazwy. Każdy element z kluczem całkowitym jest dopisywany i dostaje nowy klucz od 0, nawet jeśli tablice używały tych samych liczb lub miały luki. Tego chcesz przy listach, ale to niespodzianka, gdy liczby są identyfikatorami.

<?php
$a = [5 => 'Ada', 9 => 'Linus'];
$b = [5 => 'Grace'];

print_r(array_merge($a, $b));   // keys 0, 1, 2: the IDs are gone

$usersById = [101 => 'Ada', 102 => 'Linus'];
$more      = [103 => 'Grace'];
print_r($usersById + $more);    // + keeps the integer keys

Klucze tekstowe wyglądające jak liczby całkowite ('101') są zapisywane jako liczby całkowite, więc również są numerowane od nowa. Klucze takie jak 'id101' pozostają bez zmian.

array_merge vs operator +

Operator + (suma tablic) także łączy tablice, ale z odwrotną zasadą: dla każdego klucza, który już istnieje w lewej tablicy, wygrywa lewa wartość, a prawa jest odrzucana. Nigdy nie numeruje od nowa. Dlatego + naturalnie nadaje się do uzupełniania wartości domyślnych, a array_merge() do ich nadpisywania.

<?php
$defaults = ['theme' => 'light', 'lang' => 'en', 'per_page' => 20];
$user     = ['theme' => 'dark'];

print_r(array_merge($defaults, $user));   // user overrides defaults
print_r($user + $defaults);               // same result: user is on the left

// With lists, + compares positions and drops duplicates by key
print_r(['a', 'b'] + ['x', 'y', 'z']);

Ostatni przykład w bloku to klasyczna pułapka +: ['a', 'b'] + ['x', 'y', 'z'] daje a, b, z, bo klucze 0 i 1 już istnieją po lewej.

Składnia rozpakowania: [...$a, ...$b]

Operator rozpakowania rozwija tablice wewnątrz literału tablicy. Działa jak array_merge(): klucze całkowite są numerowane od nowa, a od PHP 8.1 dozwolone są klucze tekstowe i wygrywa późniejszy. Czyta się go dobrze, gdy mieszasz tablice z pojedynczymi wartościami.

<?php
$first  = [1, 2];
$second = [3, 4];

print_r([...$first, ...$second, 5]);

$base  = ['host' => 'localhost', 'port' => 3306];
$local = ['port' => 3307];
print_r([...$base, ...$local]);

Aby dopisać tablicę do istniejącej w miejscu, zobacz array_push() z operatorem rozpakowania.

Łączenie tablicy tablic

Gdy tablice do połączenia same są na liście, rozpakuj tę listę w array_merge(). To także szybki sposób łączenia w pętli: zbierz kawałki, a potem połącz raz.

<?php
$pages = [
    ['ada', 'linus'],
    ['grace'],
    ['margaret', 'alan'],
];

$all = array_merge(...$pages);
print_r($all);

$batches = [];
for ($page = 1; $page <= 3; $page++) {
    $batches[] = range($page * 10, $page * 10 + 2);   // pretend API page
}
echo implode(', ', array_merge(...$batches)), "\n";

var_dump(array_merge(...[]));   // an empty list gives []

Zapis $all = array_merge($all, $batch); w pętli działa, ale przy każdym przebiegu kopiuje całą rosnącą tablicę, co przy tysiącach elementów staje się wolne.

array_merge_recursive i array_replace

array_merge_recursive() łączy też zagnieżdżone tablice, ale dla powtórzonego klucza tekstowego ze zwykłą wartością nie nadpisuje: zbiera obie wartości w nową tablicę. Przy konfiguracji rzadko tego chcesz. Tam zwykle właściwym narzędziem jest array_replace_recursive(): nadpisuje wartości na każdym poziomie i zachowuje klucze.

<?php
$defaults = ['db' => ['host' => 'localhost', 'port' => 3306], 'debug' => false];
$override = ['db' => ['port' => 3307], 'debug' => true];

echo json_encode(array_merge($defaults, $override)), "\n";
echo json_encode(array_merge_recursive($defaults, $override)), "\n";
echo json_encode(array_replace_recursive($defaults, $override)), "\n";

print_r(array_replace([5 => 'a', 9 => 'b'], [9 => 'B']));   // keeps integer keys

Przeczytaj trzy linie JSON od góry: array_merge() zastąpiło całą tablicę db i zgubiło host, array_merge_recursive() zamieniło port i debug w dwuelementowe listy, a array_replace_recursive() dało konfigurację, o którą chodziło.

Częsty błąd: łączenie niczego nie usuwa

array_merge() zachowuje powtórzone wartości, które leżą pod różnymi kluczami. Połączenie dwóch list tagów daje każdy wspólny tag dwa razy. Przepuść wynik przez array_unique(), a potem array_values(), aby ponumerować go od nowa.

<?php
$postTags  = ['php', 'arrays', 'beginner'];
$extraTags = ['arrays', 'tutorial', 'php'];

$merged = array_merge($postTags, $extraTags);
echo implode(', ', $merged), "\n";

$unique = array_values(array_unique($merged));
echo implode(', ', $unique), "\n";

Strona o array_unique opisuje usuwanie duplikatów z wierszy i zagnieżdżonych tablic.