Funzione PHP: array_replace_recursive()

La funzione array_replace_recursive() in PHP unisce array mantenendo intatta la struttura e le chiavi degli array originali. Sostituisce gli elementi del primo array con gli elementi degli array successivi, scendendo ricorsivamente negli array annidati. È lo strumento giusto quando hai bisogno di sovrapporre un array multidimensionale su un altro — ad esempio, per applicare le impostazioni dell'utente sopra una configurazione predefinita senza appiattire i dati annidati.

Questo capitolo tratta la sintassi della funzione, il comportamento effettivo della ricorsione, diversi esempi pratici (inclusi più array di sostituzione) e le differenze rispetto a funzioni correlate come array_replace() e array_merge_recursive().

Sintassi

La sintassi della funzione array_replace_recursive() è semplice: il primo argomento è l'array che verrà modificato, mentre gli argomenti successivi sono gli array dai quali gli elementi vengono uniti nel primo array.

Sintassi della funzione PHP array_replace_recursive

array_replace_recursive(array $array, array ...$replacements): array

Il primo argomento è l'array di base. Ogni array successivo viene applicato su di esso da sinistra a destra, quindi un valore in un array più in là ha la precedenza sulla stessa chiave in uno precedente. La funzione restituisce un nuovo array e non modifica gli argomenti in loco.

Come funziona

La funzione array_replace_recursive() opera iterando su tutti gli elementi degli array passati come argomenti. Per ogni elemento, la funzione verifica se la chiave esiste nel primo array. Se la chiave non esiste, l'elemento viene semplicemente aggiunto al primo array. Se la chiave esiste, la funzione controlla se il valore è un array. In tal caso, richiama sé stessa ricorsivamente con il valore corrente del primo array e il valore corrispondente nel secondo array come argomenti. Se il valore non è un array, viene semplicemente sostituito con quello del secondo array.

Questo processo si ripete per tutti gli array successivi passati come argomenti, con elementi aggiunti o sostituiti nel primo array secondo necessità. Il risultato finale è un singolo array ottenuto unendo tutti gli elementi degli array di input. Nota: a differenza di array_merge_recursive(), questa funzione sostituisce le chiavi numeriche invece di unirle per indice.

Esempi

Ecco alcuni esempi di utilizzo pratico della funzione array_replace_recursive():

Esempio PHP di utilizzo della funzione array_replace_recursive

L'output di questo codice sarà:

Array
(
    [a] => Array
        (
            [b] => d
        )
)

La ricorsione entra in gioco perché sia $array1['a'] che $array2['a'] sono array, quindi la funzione scende al loro interno e sostituisce b invece di sovrascrivere l'intero ramo a.

Un altro esempio:

PHP - Altro esempio di utilizzo della funzione array_replace_recursive

L'output di questo codice sarà:

Array
(
    [a] => d
)

Qui la ricorsione non avviene: $array2['a'] è lo scalare string 'd', non un array. Quando il valore di sostituzione non è un array, l'intero valore esistente (incluso qualsiasi array annidato) viene sovrascritto completamente. La funzione ricorre solo quando il valore esiste come array su entrambi i lati.

Unione di più array e aggiunta di nuove chiavi

È possibile passare un numero qualsiasi di array di sostituzione. Vengono applicati in ordine e le chiavi non ancora presenti vengono aggiunte anziché sostituite.

PHP array_replace_recursive con più array

<?php

$defaults = ['db' => ['host' => 'localhost', 'port' => 3306]];
$env      = ['db' => ['host' => 'db.internal']];
$cli      = ['db' => ['port' => 5432], 'debug' => true];

$result = array_replace_recursive($defaults, $env, $cli);

print_r($result);

?>

L'output di questo codice sarà:

Array
(
    [db] => Array
        (
            [host] => db.internal
            [port] => 5432
        )

    [debug] => 1
)

Le chiavi annidate host e port vengono ciascuna sovrascritta dagli array successivi, mentre la nuova chiave debug viene aggiunta. Questa sovrapposizione da sinistra a destra è proprio il motivo per cui la funzione è così utile per gestire configurazioni a strati.

array_replace_recursive() vs. funzioni correlate

• array_replace() esegue la stessa sovrapposizione ma solo al primo livello — non scende mai negli array annidati, quindi un valore annidato viene sempre sostituito integralmente.
• array_merge_recursive() combina i valori che condividono una chiave (trasformando due scalari in un array di entrambi) invece di sostituirli, e rinumera le chiavi intere. array_replace_recursive() mantiene un singolo valore sostitutivo e preserva le chiavi originali.
• array_merge() è l'unione non ricorsiva che rinumera anch'essa le chiavi intere.

Se il tuo obiettivo è "prendi questi valori predefiniti e sovrascrivili con questi valori", usa array_replace_recursive(). Se il tuo obiettivo è "raccogli tutto sotto ogni chiave", usa array_merge_recursive().

Conclusione

In conclusione, la funzione array_replace_recursive() in PHP offre un modo pratico per unire array preservando la loro struttura originale e le chiavi. È particolarmente utile per aggiornare dati di configurazione annidati o per unire dataset strutturati senza iterazioni manuali.

Esercitazione