C'è un modo semplice per eliminare un elemento da un array usando PHP, in modo tale che foreach ($array)non includa più quell'elemento?

Ho pensato che impostarlo su nullavrebbe funzionato, ma a quanto pare non funziona.

Esistono diversi modi per eliminare un elemento array, in cui alcuni sono più utili per alcune attività specifiche rispetto ad altri.

Elimina un elemento dell'array

Se si desidera eliminare solo un elemento dell'array, è possibile utilizzare unset() o in alternativa \array_splice().

Inoltre, se si dispone del valore e non si conosce la chiave per eliminare l'elemento, è possibile utilizzare \array_search()per ottenere la chiave.

unset()

Si noti che quando si utilizzano unset()le chiavi dell'array non cambieranno / reindicizzeranno. Se vuoi reindicizzare le chiavi che puoi usare\array_values() dopo di unset()che convertirai tutte le chiavi in ​​chiavi enumerate a partire da 0.

Codice

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    unset($array[1]);
                //↑ Key which you want to delete

?>

Produzione

[
    [0] => a
    [2] => c
]

\array_splice() metodo

Se usi \array_splice() le chiavi verranno automaticamente reindicizzate, ma le chiavi associative non cambieranno al contrario delle \array_values()quali convertiranno tutte le chiavi in ​​chiavi numeriche.

Anche \array_splice() bisogno dell'offset, non della chiave! come secondo parametro.

Codice

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    \array_splice($array, 1, 1);
                        //↑ Offset which you want to delete

?>

Produzione

[
    [0] => a
    [1] => c
]

array_splice() uguale a unset() prendere l'array per riferimento e ciò significa che non si desidera assegnare i valori di ritorno di tali funzioni all'array.

Elimina più elementi dell'array

Se si desidera eliminare più elementi dell'array e non si desidera chiamare unset()o \array_splice()più volte, è possibile utilizzare le funzioni \array_diff()o \array_diff_key()dipendere da se si conoscono i valori o le chiavi degli elementi che si desidera eliminare.

\array_diff() metodo

Se si conoscono i valori degli elementi dell'array che si desidera eliminare, è possibile utilizzare \array_diff(). Come prima unset(), non cambierà / reindicizzerà le chiavi dell'array.

Codice

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff($array, ["a", "c"]);
                               //└────────┘→ Array values which you want to delete

?>

Produzione

[
    [1] => b
]

\array_diff_key() metodo

Se conosci le chiavi degli elementi che vuoi eliminare, allora vuoi usare \array_diff_key(). Qui devi assicurarti di passare le chiavi come chiavi nel secondo parametro e non come valori. Altrimenti, devi capovolgere l'array con\array_flip() . E anche qui le chiavi non cambieranno / reindicizzeranno.

Codice

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
                                    //↑           ↑ Array keys which you want to delete
?>

Produzione

[
    [1] => b
]

Inoltre, se si desidera utilizzare unset()o \array_splice()eliminare più elementi con lo stesso valore, è possibile utilizzare \array_keys()per ottenere tutte le chiavi per un valore specifico e quindi eliminare tutti gli elementi.

Va notato che unset()manterrà intatti gli indici, che è quello che ti aspetteresti quando usi gli indici di stringa (array come hashtable), ma può essere abbastanza sorprendente quando si tratta di array indicizzati interi:

$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [3]=>
  int(3)
} */

$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

Quindi array_splice()può essere usato se desideri normalizzare le tue chiavi intere. Un'altra opzione sta usando array_values()dopo unset():

$array = array(0, 1, 2, 3);

unset($array[2]);
$array = array_values($array);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

  // Our initial array
  $arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");
  print_r($arr);

  // Remove the elements who's values are yellow or red
  $arr = array_diff($arr, array("yellow", "red"));
  print_r($arr);

Questo è l'output del codice sopra:

Array
(
    [0] => blue
    [1] => green
    [2] => red
    [3] => yellow
    [4] => green
    [5] => orange
    [6] => yellow
    [7] => indigo
    [8] => red
)

Array
(
    [0] => blue
    [1] => green
    [4] => green
    [5] => orange
    [7] => indigo
)

Ora array_values ​​() reindicizzerà bene un array numerico, ma rimuoverà tutte le stringhe chiave dall'array e le sostituirà con i numeri. Se è necessario conservare i nomi delle chiavi (stringhe) o reindicizzare l'array se tutte le chiavi sono numeriche, utilizzare array_merge ():

$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);

Uscite

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)

$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}

unset($array[$index]);

Se si dispone di un array indicizzato numericamente in cui tutti i valori sono univoci (o non sono univoci ma si desidera rimuovere tutte le istanze di un determinato valore), è possibile semplicemente utilizzare array_diff () per rimuovere un elemento corrispondente, come questo:

$my_array = array_diff($my_array, array('Value_to_remove'));

Per esempio:

$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);

Questo visualizza quanto segue:

4
3

In questo esempio, l'elemento con il valore 'Charles' viene rimosso come può essere verificato dalle chiamate sizeof () che riportano una dimensione 4 per l'array iniziale e 3 dopo la rimozione.

Inoltre, per un elemento denominato:

unset($array["elementName"]);

Distruggi un singolo elemento di un array

unset()

$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);

L'output sarà:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [3]=>
  string(1) "D"
  [4]=>
  string(1) "E"
}

Se è necessario indicizzare nuovamente l'array:

$array1 = array_values($array1);
var_dump($array1);

Quindi l'output sarà:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [2]=>
  string(1) "D"
  [3]=>
  string(1) "E"
}

Rimuovi l'elemento dalla fine dell'array : restituisce il valore dell'elemento rimosso

mixed array_pop(array &$array)

$stack = array("orange", "banana", "apple", "raspberry");
$last_fruit = array_pop($stack);
print_r($stack);
print_r('Last Fruit:'.$last_fruit); // Last element of the array

L'output sarà

Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
Last Fruit: raspberry

Rimuovere il primo elemento (rosso) da un array , - restituisce il valore dell'elemento rimosso

mixed array_shift ( array &$array )

$color = array("a" => "red", "b" => "green" , "c" => "blue");
$first_color = array_shift($color);
print_r ($color);
print_r ('First Color: '.$first_color);

L'output sarà:

Array
(
    [b] => green
    [c] => blue
)
First Color: red

<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Produzione:

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

Per evitare di fare una ricerca si può giocare con array_diff:

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

In questo caso non è necessario cercare / utilizzare la chiave.

Se devi eliminare più valori in un array e le voci in quell'array sono oggetti o dati strutturati, [array_filter][1]è la soluzione migliore. Le voci che restituiscono un true dalla funzione di callback verranno mantenute.

$array = [
    ['x'=>1,'y'=>2,'z'=>3], 
    ['x'=>2,'y'=>4,'z'=>6], 
    ['x'=>3,'y'=>6,'z'=>9]
];

$results = array_filter($array, function($value) {
    return $value['x'] > 2; 
}); //=> [['x'=>3,'y'=>6,z=>'9']]

Matrici associative

Per gli array associativi, utilizzare unset:

$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);

// RESULT: array('a' => 1, 'c' => 3)

Matrici numeriche

Per le matrici numeriche, utilizzare array_splice:

$arr = array(1, 2, 3);
array_splice($arr, 1, 1);

// RESULT: array(0 => 1, 1 => 3)

Nota

L'uso unsetdi array numerici non produrrà un errore, ma rovinerà gli indici:

$arr = array(1, 2, 3);
unset($arr[1]);

// RESULT: array(0 => 1, 2 => 3)

Se è necessario rimuovere più elementi da un array associativo, è possibile utilizzare array_diff_key () (qui utilizzato con array_flip () ):

$my_array = array(
  "key1" => "value 1",
  "key2" => "value 2",
  "key3" => "value 3",
  "key4" => "value 4",
  "key5" => "value 5",
);

$to_remove = array("key2", "key4");

$result = array_diff_key($my_array, array_flip($to_remove));

print_r($result);

Produzione:

Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 ) 

unset() distrugge le variabili specificate.

Il comportamento unset()all'interno di una funzione può variare a seconda del tipo di variabile che si sta tentando di distruggere.

Se una variabile globalizzata si trova unset()all'interno di una funzione, viene distrutta solo la variabile locale. La variabile nell'ambiente chiamante manterrà lo stesso valore di prima unset()chiamata.

<?php
    function destroy_foo()
    {
        global $foo;
        unset($foo);
    }

    $foo = 'bar';
    destroy_foo();
    echo $foo;
?>

La risposta del codice sopra sarà barra .

A unset()una variabile globale all'interno di una funzione:

<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

    $bar = "something";
    foo();
?>

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

Se l'indice è specificato:

$arr = ['a', 'b', 'c'];
$index = 0;    
unset($arr[$index]);  // $arr = ['b', 'c']

Se l'indice NON è specificato:

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

La ifcondizione è necessaria perché se indexnon viene trovata, unset()eliminerà automaticamente il primo elemento dell'array che non è quello che vogliamo

soluzioni:

1. Per eliminare un elemento, utilizzare unset () :

unset($array[3]);
unset($array['foo']);

2. Per eliminare più elementi non contigui, utilizzare anche unset () :

unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);

3. Per eliminare più elementi contigui, utilizzare array_splice () :

array_splice($array, $offset, $length);

Ulteriori spiegazioni:

L'uso di queste funzioni rimuove tutti i riferimenti a questi elementi da PHP. Se si desidera mantenere una chiave nell'array, ma con un valore vuoto, assegnare la stringa vuota all'elemento:

$array[3] = $array['foo'] = '';

Oltre alla sintassi, c'è una differenza logica tra l'utilizzo di unset () e l'assegnazione di '' all'elemento. Il primo dice This doesn't exist anymore,mentre il secondo diceThis still exists, but its value is the empty string.

Se hai a che fare con i numeri, assegnare 0 potrebbe essere un'alternativa migliore. Pertanto, se un'azienda interrompesse la produzione del pignone modello XL1000, aggiornerebbe il suo inventario con:

unset($products['XL1000']);

Tuttavia, se si è temporaneamente esaurito i pignoni XL1000, ma stava pianificando di ricevere una nuova spedizione dall'impianto alla fine di questa settimana, è meglio:

$products['XL1000'] = 0;

Se dissetate () un elemento, PHP regola l'array in modo che il loop funzioni ancora correttamente. Non compatta l'array per riempire i fori mancanti. Questo è ciò che intendiamo quando diciamo che tutti gli array sono associativi, anche quando sembrano essere numerici. Ecco un esempio:

// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
print $animals[1];  // Prints 'bee'
print $animals[2];  // Prints 'cat'
count($animals);    // Returns 6

// unset()
unset($animals[1]); // Removes element $animals[1] = 'bee'
print $animals[1];  // Prints '' and throws an E_NOTICE error
print $animals[2];  // Still prints 'cat'
count($animals);    // Returns 5, even though $array[5] is 'fox'

// Add a new element
$animals[ ] = 'gnu'; // Add a new element (not Unix)
print $animals[1];  // Prints '', still empty
print $animals[6];  // Prints 'gnu', this is where 'gnu' ended up
count($animals);    // Returns 6

// Assign ''
$animals[2] = '';   // Zero out value
print $animals[2];  // Prints ''
count($animals);    // Returns 6, count does not decrease

Per compattare l'array in un array numerico densamente riempito, utilizzare array_values ​​() :

$animals = array_values($animals);

In alternativa, array_splice () reindicizza automaticamente le matrici per evitare di lasciare buchi:

// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
array_splice($animals, 2, 2);
print_r($animals);
Array
(
    [0] => ant
    [1] => bee
    [2] => elk
    [3] => fox
)

Ciò è utile se si utilizza l'array come una coda e si desidera rimuovere elementi dalla coda pur consentendo l'accesso casuale. Per rimuovere in sicurezza il primo o l'ultimo elemento da un array, utilizzare rispettivamente array_shift () e array_pop () .

Supponiamo di avere il seguente array:

Array
(
    [user_id] => 193
    [storage] => 5
)

Per eliminare storage, fai:

unset($attributes['storage']);
$attributes = array_filter($attributes);

E ottieni:

Array
(
    [user_id] => 193
)

Vorrei solo dire che avevo un oggetto particolare che aveva attributi variabili (fondamentalmente stava mappando una tabella e stavo cambiando le colonne nella tabella, quindi anche gli attributi nell'oggetto, che riflettono la tabella, sarebbero diversi):

class obj {
    protected $fields = array('field1','field2');
    protected $field1 = array();
    protected $field2 = array();
    protected loadfields(){}
    // This will load the $field1 and $field2 with rows of data for the column they describe
    protected function clearFields($num){
        foreach($fields as $field) {
            unset($this->$field[$num]);
            // This did not work the line below worked
            unset($this->{$field}[$num]); // You have to resolve $field first using {}
        }
    }
}

Lo scopo $fieldsera solo, quindi non devo guardare ovunque nel codice quando vengono cambiati, guardo solo l'inizio della classe e cambio l'elenco degli attributi e il contenuto dell'array $ fields per riflettere il nuovo attributi.

Segui le funzioni predefinite:

io)

$Array = array("test1", "test2", "test3", "test3");

unset($Array[2]);

ii)

$Array = array("test1", "test2", "test3", "test3");

array_pop($Array);

iii)

$Array = array("test1", "test2", "test3", "test3");

array_splice($Array,1,2);

iv)

$Array = array("test1", "test2", "test3", "test3");

array_shift($Array);

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Crea il tuo array nella variabile $arraye poi dove ho messo 'elemento che vuoi eliminare' metti qualcosa del tipo: "a". E se vuoi eliminare più elementi, allora: "a", "b".

Usa array_search per ottenere la chiave e rimuoverla con unset se trovata:

if (($key = array_search('word', $array)) !== false) {
    unset($array[$key]);
}

unset () elementi multipli, frammentati da un array

Sebbene unset()sia stato menzionato qui diverse volte, non è ancora stato menzionato che unset()accetta più variabili, rendendo semplice eliminare più elementi non contigui da un array in una sola operazione:

// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]

unset () in modo dinamico

unset () non accetta una matrice di chiavi da rimuovere, quindi il codice seguente fallirà (avrebbe reso leggermente più facile usare unset () in modo dinamico però).

$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);

Invece, unset () può essere usato in modo dinamico in un ciclo foreach:

$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
    unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]

Rimuovere le chiavi dell'array copiando l'array

C'è anche un'altra pratica che deve ancora essere menzionata. A volte, il modo più semplice per sbarazzarsi di alcune chiavi dell'array è semplicemente copiare $ array1 in $ array2.

$array1 = range(1,10);
foreach ($array1 as $v) {
    // Remove all even integers from the array
    if( $v % 2 ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 1, 3, 5, 7, 9 ];

Ovviamente, la stessa pratica si applica alle stringhe di testo:

$array1 = [ 'foo', '_bar', 'baz' ];
foreach ($array1 as $v) {
    // Remove all strings beginning with underscore
    if( strpos($v,'_')===false ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 'foo', 'baz' ]

Rimuovere un elemento array in base a una chiave:

Utilizzare la unsetfunzione come di seguito:

$a = array(
       'salam',
       '10',
       1
);

unset($a[1]);

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

Rimuovi un elemento array in base al valore:

Utilizzare la array_searchfunzione per ottenere un elemento chiave e utilizzare il modo sopra per rimuovere un elemento dell'array come di seguito:

$a = array(
       'salam',
       '10',
       1
);

$key = array_search(10, $a);

if ($key !== false) {
    unset($a[$key]);
}

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

Due modi per rimuovere il primo elemento di un array mantenendo l'ordine dell'indice e anche se non si conosce il nome chiave del primo elemento.

Soluzione n. 1

// 1 is the index of the first object to get
// NULL to get everything until the end
// true to preserve keys
$array = array_slice($array, 1, null, true);

Soluzione n. 2

// Rewinds the array's internal pointer to the first element
// and returns the value of the first array element.
$value = reset($array);
// Returns the index element of the current array position
$key = key($array);
unset($array[$key]);

Per questi dati di esempio:

$array = array(10 => "a", 20 => "b", 30 => "c");

Devi avere questo risultato:

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}

Usa il seguente codice:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);

<?php
    // If you want to remove a particular array element use this method
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");

    print_r($my_array);
    if (array_key_exists("key1", $my_array)) {
        unset($my_array['key1']);
        print_r($my_array);
    }
    else {
        echo "Key does not exist";
    }
?>

<?php
    //To remove first array element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1);
    print_r($new_array);
?>


<?php
    echo "<br/>    ";
    // To remove first array element to length
    // starts from first and remove two element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1, 2);
    print_r($new_array);
?>

Produzione

 Array ( [key1] => value 1 [key2] => value 2 [key3] =>
 value 3 ) Array (    [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )

Per array associativi, con chiavi non intere:

Semplicemente, unset($array[$key])funzionerebbe.

Per le matrici con chiavi intere e se si desidera mantenere le chiavi:

1. $array = [ 'mango', 'red', 'orange', 'grapes'];

   unset($array[2]);
   $array = array_values($array);

2. array_splice($array, 2, 1);

Questo può aiutare ...

<?php
    $a1 = array("a"=>"red", "b"=>"green", "c"=>"blue", "d"=>"yellow");
    $a2 = array("a"=>"purple", "b"=>"orange");
    array_splice($a1, 0, 2, $a2);
    print_r($a1);
?>

Il risultato sarà:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);