Eliminazione di un elemento da un array in PHP
https://stackoverflow.com/questions/369602
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
C'è un modo semplice per eliminare un elemento da un array utilizzando PHP, in modo tale che foreach ($array) non include più che di un elemento?
Ho pensato che l'impostazione di null vorresti farlo, ma a quanto pare non funziona.
Soluzione
Ci sono diversi modi per eliminare un elemento di un array, dove alcuni sono più utili per alcuni compiti specifici rispetto ad altri.
Elimina un elemento dell'array
Se si desidera eliminare un solo elemento dell'array è possibile utilizzare \unset() oppure \array_splice() .
Anche se si ha il valore e non si conosce la chiave per eliminare l'elemento è possibile utilizzare \array_search() per ottenere la chiave.
\array_values() metodo
Si noti che quando si utilizza array_splice() le chiavi dell'array non cambieranno / reindex. Se desideri reindicizzare i tasti è possibile utilizzare \array_diff() dopo < => che converte tutte le chiavi ai tasti numerici enumerate partire da 0.
Codice
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
\unset($array[1]);
//↑ Key which you want to delete
?>
Output
[
[0] => a
[2] => c
]
\array_diff_key() metodo
Se si utilizza \array_flip() le chiavi saranno reindicizzate automaticamente, ma le chiavi associative non cambierà al contrario di \array_keys() che convertirà tutti i tasti ai tasti numerici.
Anche <=> ha bisogno l'offset, non è la chiave! come secondo parametro.
Codice
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
//↑ Offset which you want to delete
?>
Output
[
[0] => a
[1] => c
]
<=> uguale <=> prendere la matrice per il riferimento, e questo significa che non si desidera assegnare i valori di ritorno di queste funzioni di back alla matrice.
Elimina più elementi di matrice
Se si desidera eliminare più elementi di un array e non si desidera chiamare o <=> <=> più volte è possibile utilizzare le funzioni <=> o <=> a seconda se si conoscono i valori o le chiavi di gli elementi che si desidera eliminare.
<=> metodo
Se si conoscono i valori degli elementi di un array che si desidera eliminare, quindi è possibile utilizzare <=>. Come prima con <=> non cambierà / reindex i tasti della matrice.
Codice
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff($array, ["a", "c"]);
//└────────┘→ Array values which you want to delete
?>
Output
[
[1] => b
]
<=> metodo
Se conoscete le chiavi degli elementi che si desidera eliminare, quindi si desidera utilizzare <=>. Qui bisogna fare in modo di passare le chiavi come chiavi nel secondo parametro e non come valori. In caso contrario, è necessario capovolgere l'array con <=> . E anche qui le chiavi non cambieranno / reindex.
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
?>
Output
<*>Inoltre, se si desidera utilizzare o <=> <=> per eliminare più elementi con lo stesso valore è possibile utilizzare <=> per ottenere tutte le chiavi per un valore specifico e quindi eliminare tutti gli elementi.
Altri suggerimenti
Si deve notare che unset() manterrà intatto indici, che è quello che ci si aspetta quando si utilizza indici di stringa (array come tabella hash), ma può essere abbastanza sorprendente quando si tratta di matrici interi indicizzato:
$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)
} */
array_splice() può essere utilizzato se vuoi per normalizzare le vostre chiavi intere. Un'altra opzione sta usando array_values() dopo <=> :
$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 di cui 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() si indicizza un array numerico bene, ma sarà rimuovere tutti i principali stringhe dell'array e li sostituisce con i numeri.Se avete bisogno di conservare la chiave di nomi (stringhe), o reindicizzare l'array se tutti i tasti numerici, 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 dove tutti i valori sono unici (o sono non univoco, ma si desidera rimuovere tutte le istanze di un determinato valore), si può semplicemente utilizzare array_diff () per rimuovere un elemento corrispondente, come questo :
$my_array = array_diff($my_array, array('Value_to_remove'));
Ad 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 il seguente:
4
3
In questo esempio, l'elemento con il valore 'Charles' viene rimosso come si può verificare dal sizeof () chiamate che riportano una dimensione di 4 per la matrice iniziale e 3 dopo la rimozione.
Inoltre, per un elemento denominato:
unset($array["elementName"]);
distruggere 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 ri indice di matrice:
$array1 = array_values($array1);
var_dump($array1);
L'uscita sarà:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
Estrae l'elemento alla 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 , - restituire 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 = array("fruit1", "fruit2", "fruit3", "fruit4");
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Output:
Array
(
[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 c'è bisogno di cercare / usare il tasto.
Se si deve eliminare più valori di un array ed le voci in tale array sono oggetti o dati strutturati, [array_filter][1] è la soluzione migliore. Le voci che restituiscono un vero dalla funzione di callback vengono mantenuti.
$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']]
unset() distrugge le variabili specificate.
Il comportamento di <=> all'interno di una funzione può variare a seconda del tipo di variabile che si sta tentando di distruggere.
Se è <=> all'interno di una funzione, solo la variabile locale viene distrutta una variabile globale. La variabile nell'ambiente chiamando manterrà lo stesso valore di prima <=> è stato chiamato.
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
La risposta del codice di cui sopra sarà bar .
Per <=> una variabile globale all'interno di una funzione:
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
Gli array associativi
Per gli array associativi, utilizzare unset:
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
Le 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
Utilizzando unset per le matrici numeriche non produrrà un errore, ma rovinare il vostro 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 usato 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);
Output:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
Si supponga di avere il seguente array:
Array
(
[user_id] => 193
[storage] => 5
)
Per eliminare storage, fare:
unset($attributes['storage']);
$attributes = array_filter($attributes);
E si ottiene:
Array
(
[user_id] => 193
)
Vorrei solo dire che ho avuto un particolare oggetto che aveva attributi variabili (era fondamentalmente tracciando un tavolo e stava cambiando le colonne della tabella, quindi gli attributi nell'oggetto, che riflette la tabella varierebbe pure ):
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 di $fields era solo, quindi non deve guardare ovunque nel codice quando sono cambiato, mi basta guardare all'inizio della classe e modificare l'elenco degli attributi ed il $ campi il contenuto di matrice per riflettere i nuovi attributi.
Segui le funzioni predefinite:
i)
$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);
Soluzioni:
- Per eliminare un elemento, utilizzare unset():
unset($array[3]); unset($array['foo']);
- Per eliminare più elementi non contigui, anche uso unset():
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
- Per eliminare più elementi contigui, uso array_splice():
array_splice($array, $offset, $length);
Ulteriori spiegazioni:
L'uso di queste funzioni consente di rimuovere 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 per l'elemento:
$array[3] = $array['foo'] = '';
Oltre alla sintassi, c'è una logica della differenza tra l'utilizzo di unset() e l'assegnazione " per l'elemento.La prima dice che This doesn't exist anymore, mentre la seconda dice This still exists, but its value is the empty string.
Se hai a che fare con i numeri, l'assegnazione di 0 potrebbe essere un'alternativa migliore.Quindi, se una società ha cessato la produzione del modello XL1000 pignone, sarebbe aggiornare il suo inventario con:
unset($products['XL1000']);
Tuttavia, anche se temporaneamente esaurito XL1000 pignoni, ma stava pensando di ricevere una nuova spedizione dalla pianta alla fine di questa settimana, questa è la migliore:
$products['XL1000'] = 0;
Se si unset() un elemento, PHP regola la matrice in modo che il loop funziona ancora correttamente.Non compact array di riempire i buchi mancanti.Questo è ciò che intendiamo quando diciamo che tutti gli array associativi, anche quando sembrano essere numerico.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 una zona densamente riempito array numerico, utilizzo array_values():
$animals = array_values($animals);
In alternativa, array_splice() automaticamente reindexes matrici per evitare di lasciare i fori:
// 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
)
Questo è utile se si utilizza la matrice come una coda e si desidera rimuovere elementi dalla coda, pur consentendo l'accesso casuale.Per rimuovere in modo sicuro il primo o l'ultimo elemento di un array, utilizzare array_shift() e array_pop(), rispettivamente.
unset () multipli, elementi frammentati da un array
Mentre unset() è stato menzionato qui diverse volte, deve ancora essere menzionato che <=> accetta più variabili rendendo facile eliminare più elementi contigui da una matrice 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 un array di chiavi per rimuovere, in modo che il codice qui sotto sicuro (sarebbe reso leggermente più facile da usare unset () dinamicamente però).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
Invece, unset () può essere utilizzato 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 ]
Rimuovi le chiavi degli array copiando la matrice
C'è anche un'altra pratica che deve ancora essere menzionato. A volte, il modo più semplice per sbarazzarsi di alcuni tasti di array è quello di copiare semplicemente $ 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 vale per le 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' ]
<?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);
?>
Output
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 )
Rimuovi un elemento di matrice basata su una chiave:
Utilizzare la funzione unset come di seguito:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Rimuovi un elemento di matrice in base al valore:
Utilizzare la funzione array_search per ottenere una chiave elemento e utilizzare le modalità di cui sopra per rimuovere un elemento di matrice come segue:
$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
)
*/
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Crea l'array nella variabile $array e 'elemento che si desidera eliminare' allora dove ho messo di mettere qualcosa di simile a: "a". E se si desidera eliminare più elementi, allora:. "A", "b"
Con il seguente codice:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
Due modi per rimuovere il primo elemento di un array con mantenere ordine dell'indice e anche se non si conosce il nome della chiave del primo elemento.
Soluzione # 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 # 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 questo i dati di esempio:
$array = array(10 => "a", 20 => "b", 30 => "c");
È necessario disporre di questo risultato:
array(2) {
[20]=>
string(1) "b"
[30]=>
string(1) "c"
}
Utilizza array_search per ottenere la chiave e rimuoverlo con unset se trovato:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
Per array associativi con chiavi non interi:
Semplicemente, unset($array[$key]) funzionerebbe.
Per gli array con chiavi intere e se si desidera mantenere le chiavi:
-
$array = [ 'mango', 'red', 'orange', 'grapes'];unset($array[2]); $array = array_values($array); -
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);
unset non cambia l'indice, ma array_splice fa:
$arrayName = array('1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
500 => 'somevalue500',
);
echo $arrayName['500'];
//somevalue500
array_splice($arrayName, 1, 2);
print_r($arrayName);
//Array ( [0] => somevalue [1] => somevalue500 )
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
500 => 'somevalue500',
);
echo $arrayName['500'];
//somevalue500
unset($arrayName[1]);
print_r($arrayName);
//Array ( [0] => somevalue [1] => somevalue500 )
