Funzione PHP: array_merge_recursive

La funzione array_merge_recursive() in PHP combina due o più array in uno solo. La sua caratteristica distintiva è il modo in cui gestisce le chiavi string sovrapposte: invece di permettere a un valore successivo di sovrascrivere quello precedente, unisce entrambi i valori in un sotto-array, ricorrendo ricorsivamente negli array annidati man mano che procede. Questo la rende lo strumento giusto quando vuoi conservare ogni valore piuttosto che lasciare vincere l'ultimo array.

Questa pagina tratta la sintassi e i parametri, come funziona effettivamente la fusione ricorsiva, come differisce da array_merge(), un caso d'uso reale e le insidie da tenere d'occhio.

Sintassi

array_merge_recursive(array $array1, array ...$arrays): array

Parametri

• array1: Il primo array di input.
• ...$arrays: Uno o più array aggiuntivi da unire.

Valore restituito

Restituisce l'array unito risultante.

Come funziona array_merge_recursive?

La funzione applica due regole diverse a seconda del tipo di chiave:

• Le chiavi string che compaiono in più di un array vengono combinate. Se entrambi i valori sono scalari, vengono raccolti in un nuovo sotto-array; se entrambi sono array, la funzione ricorre e li unisce al livello successivo.
• Le chiavi intere (numeriche) non vengono mai sovrascritte. Ogni elemento con chiave numerica viene aggiunto in coda e rinumerato, quindi nulla va perso e il risultato viene reindicizzato da 0.

Questo è il motivo per cui la funzione è "ricorsiva": ogni volta che incontra due array sotto la stessa chiave string, entra in profondità e ripete la stessa logica di fusione sui loro contenuti.

Nota: A differenza di array_merge(), che sovrascrive i valori per le chiavi string sovrapposte e reindicizza le chiavi numeriche, array_merge_recursive() unisce le chiavi string sovrapposte in array annidati preservando ogni valore.

Ecco un esempio di come funziona array_merge_recursive:

Esempio PHP della funzione array_merge_recursive

L'output di questo codice sarà:

Array
(
    [color] => Array
        (
            [favorite] => Array
                (
                    [0] => red
                    [1] => green
                )
            [0] => blue
        )
    [0] => 5
    [1] => 10
)

Come si può vedere, la funzione array_merge_recursive ha unito le chiavi sovrapposte negli array di input in sotto-array.

array_merge() vs. array_merge_recursive()

Vedere le due funzioni affiancate rende concreta la differenza:

<?php

$defaults  = ["roles" => ["user"],   "name" => "Guest"];
$overrides = ["roles" => ["editor"], "name" => "Ann"];

print_r(array_merge($defaults, $overrides));
print_r(array_merge_recursive($defaults, $overrides));

?>

Array                       // array_merge(): later value wins
(
    [roles] => Array
        (
            [0] => editor
        )
    [name] => Ann
)
Array                       // array_merge_recursive(): both values kept
(
    [roles] => Array
        (
            [0] => user
            [1] => editor
        )
    [name] => Array
        (
            [0] => Guest
            [1] => Ann
        )
)

Nota che anche name, una semplice string, è diventata un array ["Guest", "Ann"]. Questa è la principale insidia trattata di seguito: la fusione ricorsiva trasforma ogni chiave string ripetuta in una lista, che tu lo voglia o meno.

Quando usare array_merge_recursive

Ricorri a questa funzione quando l'obiettivo è raccogliere valori piuttosto che sceglierne uno. Un caso comune è il raggruppamento di dati — ad esempio, costruire una mappa da una categoria a tutti i suoi elementi:

<?php

$result = [];
$products = [
    ["category" => "fruit",     "name" => "apple"],
    ["category" => "fruit",     "name" => "pear"],
    ["category" => "vegetable", "name" => "carrot"],
];

foreach ($products as $product) {
    $result = array_merge_recursive(
        $result,
        [$product["category"] => [$product["name"]]]
    );
}

print_r($result);

?>

Array
(
    [fruit] => Array
        (
            [0] => apple
            [1] => pear
        )
    [vegetable] => Array
        (
            [0] => carrot
        )
)

Insidie

• Le chiavi string vengono unite, le chiavi intere vengono aggiunte in coda. Una chiave string ripetuta produce un sotto-array anche quando entrambi i valori sono scalari. Se invece vuoi che i valori successivi sovrascrivano quelli precedenti, usa array_merge() o array_replace_recursive().
• Le chiavi numeriche non vengono preservate. Le chiavi intere vengono sempre rinumerate da 0, quindi non puoi usare array_merge_recursive() per unire due array in base alle loro chiavi numeriche. Usa l'operatore + (unione) se hai bisogno che le chiavi restino invariate.
• Discende solo negli array. Se un lato è uno scalare e l'altro è un array sotto la stessa chiave, entrambi vengono semplicemente raccolti in una lista; lo scalare non viene unito *nell'*array.

Funzioni correlate

• array_merge() — fusione semplice in cui le chiavi string successive sovrascrivono quelle precedenti.
• array_replace_recursive() — ricorre come questa funzione ma sostituisce i valori invece di raccoglierli.
• array_combine() — costruisce un array da un array separato di chiavi e un array di valori.

Conclusione

La funzione array_merge_recursive() è la scelta giusta quando vuoi combinare i valori sotto chiavi string condivise invece di sovrascriverli — raggruppando, aggregando o accumulando dati tra array. Tieni a mente le sue due regole (le chiavi string si uniscono in liste, le chiavi intere vengono reindicizzate) e scegli array_merge() o array_replace_recursive() quando hai invece bisogno del comportamento "vince l'ultimo valore".

Esercizio