Il modo migliore per cancellare i valori di un array PHP

Qual è più efficiente per cancellare tutti i valori in un array? Il primo mi richiederebbe di usare quella funzione ogni volta nel ciclo del secondo esempio.

foreach ($array as $i => $value) {
    unset($array[$i]);
}

O questo

foreach($blah_blah as $blah) {
    $foo = array();
    //do something
    $foo = null;
}

Come ha detto Zack nei commenti qui sotto, puoi semplicemente ri-istanziarlo usando

$foo = array(); // $foo is still here

Se vuoi qualcosa di più potente usa unset dato che cancellerà anche $ foo dalla tabella dei simboli, se in seguito hai bisogno dell'array per istanziarlo di nuovo.

unset($foo); // $foo is gone
$foo = array(); // $foo is here again

Se vuoi solo ripristinare una variabile su un array vuoto, puoi semplicemente reinizializzarla:

$foo = array();

Si noti che ciò manterrà qualsiasi riferimento ad esso:

$foo = array(1,2,3);
$bar = &$foo;
// ...
$foo = array(); // clear array
var_dump($bar); // array(0) { } -- bar was cleared too!

Se vuoi rompere qualsiasi riferimento ad esso, disattivalo prima:

$foo = array(1,2,3);
$bar = &$foo;
// ...
unset($foo); // break references
$foo = array(); // re-initialize to empty array
var_dump($bar); // array(3) { 1, 2, 3 } -- $bar is unchanged

Purtroppo non posso rispondere alle altre domande, non ho abbastanza reputazione, ma devo sottolineare qualcosa che è MOLTO importante per me e penso che aiuterà anche le altre persone.

Disattivare la variabile è un buon modo, a meno che non sia necessario il riferimento dell'array originale!

Per chiarire cosa intendo: se si dispone di una funzione che utilizza il riferimento dell'array, ad esempio una funzione di ordinamento come

function special_sort_my_array(&$array)
{
    $temporary_list = create_assoziative_special_list_out_of_array($array);

    sort_my_list($temporary_list);

    unset($array);
    foreach($temporary_list as $k => $v)
    {
        $array[$k] = $v;
    }
}

non funziona! Fai attenzione qui, unsetelimina il riferimento, quindi la variabile $arrayviene nuovamente creata e riempita correttamente, ma i valori non sono accessibili dall'esterno della funzione.

Quindi, se hai riferimenti, devi usare $array = array()invece di unset, anche se è meno pulito e comprensibile.

Direi il primo, se l'array è associativo. In caso contrario, utilizzare un forloop:

for ($i = 0; $i < count($array); $i++) { unset($array[$i]); }

Anche se possibile, usando

$array = array();

È preferibile ripristinare l'array su un array vuoto.

Non è unset()abbastanza buono?

unset($array);

Che ne dici $array_name = array();?

Utilizzare array_spliceper svuotare un array e conservare il riferimento:

array_splice($myArray, 0);

ho usato unset () per cancellare l'array ma ho capito che unset () renderà l'array null quindi la necessità di ri-dichiarare l'array come ad esempio

<?php 
    $arr = array();
    array_push($arr , "foo");
    unset($arr); // this will set the array to null hence you need the line below or redeclaring it.
    $arr  = array();

    // do what ever you want here
?>

Vedo che questa domanda è molto vecchia, ma per quel problema ho scritto una funzione ricorsiva per disinserire tutti i valori in un array. Ricorsivo perché è possibile che i valori della matrice data siano anche una matrice. Quindi funziona per me:

function empty_array(& $complete_array) {
    foreach($complete_array as $ckey => $cvalue)
    {
        if (!is_array($cvalue)) {
            $complete_array[$ckey] = "";
        } else {
            empty_array( $complete_array[$ckey]);
        }

    }
    return $complete_array;

}

Quindi, con ciò ottengo l'array con tutte le chiavi e gli array secondari, ma i valori vuoti.

Forse un modo semplice ed economico (meno segni da usare) ...

$array = [];

Possiamo leggere nel manuale di php:

A partire da PHP 5.4 puoi anche usare la sintassi della matrice corta, che sostituisce la matrice () con [].

La funzione unset è utile quando il garbage collector sta facendo il suo giro senza fare una pausa pranzo;

tuttavia la funzione unset semplicemente distrugge il riferimento variabile ai dati, i dati esistono ancora in memoria e PHP vede la memoria come in uso nonostante non abbia più un puntatore ad esso.

Soluzione: assegnare nullalle variabili per cancellare i dati, almeno fino a quando il Garbage Collector non riesce a bloccarli.

$var = null;

e poi disinserirlo in modo simile!

unset($var);

Questo è potente e testato unset ($ gradearray); // ripristina l'array