PHP array_merge(): unire due o più array

array_merge($a, $b) restituisce un nuovo array con gli elementi di $a seguiti da quelli di $b. Le chiavi numeriche vengono rinumerate da 0; quando entrambi gli array hanno la stessa chiave stringa, vince il valore dell'array successivo. Puoi passare quanti array vuoi.

<?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() non modifica i suoi argomenti. Restituisce l'array combinato, quindi assegna il risultato: $all = array_merge($all, $more);.

Le chiavi numeriche vengono rinumerate

array_merge() tratta le chiavi intere come posizioni, non come nomi. Ogni elemento con chiave intera viene accodato e riceve una nuova chiave a partire da 0, anche se gli array usavano gli stessi numeri o avevano buchi. È ciò che vuoi per le liste, e una sorpresa quando i numeri sono ID.

<?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

Le chiavi stringa che sembrano interi ('101') vengono memorizzate come interi, quindi anche loro vengono rinumerate. Chiavi come 'id101' restano come sono.

array_merge vs l'operatore +

Anche l'operatore + (unione di array) combina array, ma con la regola opposta: per ogni chiave che esiste già nell'array di sinistra vince il valore di sinistra e quello di destra viene scartato. Non rinumera mai. Questo rende + il modo naturale per riempire i valori di default, e array_merge() il modo naturale per sovrascriverli.

<?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']);

L'ultimo esempio del blocco è la classica trappola di +: ['a', 'b'] + ['x', 'y', 'z'] dà a, b, z, perché le chiavi 0 e 1 esistono già a sinistra.

Sintassi spread: [...$a, ...$b]

L'operatore spread espande gli array dentro un array letterale. Si comporta come array_merge(): le chiavi intere vengono rinumerate e, da PHP 8.1, le chiavi stringa sono consentite e vince l'ultima. Si legge bene quando mescoli array e valori singoli.

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

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

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

Per accodare un array a uno esistente sul posto, vedi array_push() con l'operatore spread.

Unire un array di array

Quando gli array da combinare sono a loro volta in una lista, espandi quella lista dentro array_merge(). È anche il modo veloce di unire dentro un ciclo: raccogli i pezzi, poi uniscili una volta.

<?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 []

Scrivere $all = array_merge($all, $batch); dentro il ciclo funziona, ma copia l'intero array che cresce a ogni passaggio, e con migliaia di elementi diventa lento.

array_merge_recursive e array_replace

array_merge_recursive() unisce anche gli array annidati, ma per una chiave stringa duplicata con valori semplici non sovrascrive: raccoglie entrambi i valori in un nuovo array. Per la configurazione raramente è ciò che vuoi. Lì lo strumento giusto è di solito array_replace_recursive(): sovrascrive i valori a ogni livello e mantiene le chiavi.

<?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

Leggi le tre righe JSON dall'alto verso il basso: array_merge() ha sostituito l'intero array db e perso host, array_merge_recursive() ha trasformato port e debug in liste di due elementi, e array_replace_recursive() ha prodotto la configurazione che intendevi.

Errore comune: unire non rimuove nulla

array_merge() mantiene i valori duplicati che stanno sotto chiavi diverse. Unendo due liste di tag ottieni due volte ogni tag in comune. Passa il risultato a array_unique() e poi a array_values() per rinumerarlo.

<?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";

La pagina su array_unique tratta la rimozione dei duplicati da righe e array annidati.