Existe-t-il un moyen simple de supprimer un élément d'un tableau à l'aide de PHP, de telle sorte que foreach ($array)
n'inclue plus cet élément?
Je pensais que le régler le null
ferait, mais apparemment, cela ne fonctionne pas.
Existe-t-il un moyen simple de supprimer un élément d'un tableau à l'aide de PHP, de telle sorte que foreach ($array)
n'inclue plus cet élément?
Je pensais que le régler le null
ferait, mais apparemment, cela ne fonctionne pas.
Réponses:
Il existe différentes manières de supprimer un élément de tableau, certaines étant plus utiles pour certaines tâches spécifiques que d'autres.
Si vous souhaitez supprimer un seul élément du tableau, vous pouvez utiliser unset()
ou alternativement \array_splice()
.
Aussi, si vous avez la valeur et ne connaissez pas la clé pour supprimer l'élément que vous pouvez utiliser \array_search()
pour obtenir la clé.
unset()
Notez que lorsque vous utilisez unset()
les clés du tableau ne changera pas / réindexera. Si vous souhaitez réindexer les clés que vous pouvez utiliser, \array_values()
après unset()
quoi toutes les clés seront converties en clés numériques énumérées à partir de 0.
Code
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
unset($array[1]);
//↑ Key which you want to delete
?>
Production
[
[0] => a
[2] => c
]
\array_splice()
méthodeSi vous utilisez \array_splice()
les clés, elles seront automatiquement réindexées, mais les clés associatives ne changeront pas, contrairement à \array_values()
ce qui convertira toutes les clés en clés numériques.
Aussi \array_splice()
besoin du décalage, pas de la clé! comme deuxième paramètre.
Code
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
//↑ Offset which you want to delete
?>
Production
[
[0] => a
[1] => c
]
array_splice()
identique à unset()
prendre le tableau par référence, ce qui signifie que vous ne voulez pas attribuer les valeurs de retour de ces fonctions au tableau.
Si vous souhaitez supprimer plusieurs éléments du tableau et ne souhaitez pas appeler unset()
ou \array_splice()
plusieurs fois, vous pouvez utiliser les fonctions \array_diff()
ou \array_diff_key()
selon que vous connaissez les valeurs ou les clés des éléments que vous souhaitez supprimer.
\array_diff()
méthodeSi vous connaissez les valeurs des éléments du tableau que vous souhaitez supprimer, vous pouvez les utiliser \array_diff()
. Comme auparavant, unset()
il ne changera / réindexera pas les clés du tableau.
Code
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff($array, ["a", "c"]);
//└────────┘→ Array values which you want to delete
?>
Production
[
[1] => b
]
\array_diff_key()
méthodeSi vous connaissez les clés des éléments que vous souhaitez supprimer, alors vous voulez utiliser \array_diff_key()
. Ici, vous devez vous assurer de passer les clés en tant que clés dans le deuxième paramètre et non en tant que valeurs. Sinon, vous devez retourner le tableau avec\array_flip()
. Et ici aussi, les clés ne changeront pas / ne seront pas réindexées.
Code
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
//↑ ↑ Array keys which you want to delete
?>
Production
[
[1] => b
]
De plus, si vous souhaitez utiliser unset()
ou \array_splice()
supprimer plusieurs éléments avec la même valeur, vous pouvez utiliser \array_keys()
pour obtenir toutes les clés d'une valeur spécifique, puis supprimer tous les éléments.
array_splice
, comme décrit dans les autres réponses.
array (3) { [0]=>int(0) ...
lorsque vous unset($x[2])
de $x = array(1, 2, 3, 4);
résultat doit être var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }
(il était probablement faute de frappe)
unset
peut avoir plusieurs arguments: void unset ( mixed $var [, mixed $... ] )
.
Il convient de noter que unset()
les index resteront intacts, ce à quoi vous vous attendez lorsque vous utilisez des index de chaîne (tableau comme table de hachage), mais cela peut être assez surprenant lorsqu'il s'agit de tableaux indexés entiers:
$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)
} */
Vous array_splice()
pouvez donc l'utiliser si vous souhaitez normaliser vos clés entières. Une autre option consiste à utiliser array_values()
aprèsunset()
:
$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)
} */
array_splice
peut avoir un sens (entre autres).
// 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);
C'est la sortie du code ci-dessus:
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
)
Maintenant, array_values () va bien réindexer un tableau numérique, mais il supprimera toutes les chaînes de clés du tableau et les remplacera par des nombres. Si vous devez conserver les noms de clés (chaînes) ou réindexer le tableau si toutes les clés sont numériques, utilisez array_merge ():
$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);
Les sorties
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]);
Si vous avez un tableau indexé numériquement où toutes les valeurs sont uniques (ou non, mais que vous souhaitez supprimer toutes les instances d'une valeur particulière), vous pouvez simplement utiliser array_diff () pour supprimer un élément correspondant, comme ceci:
$my_array = array_diff($my_array, array('Value_to_remove'));
Par exemple:
$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);
Cela affiche les éléments suivants:
4
3
Dans cet exemple, l'élément avec la valeur «Charles» est supprimé, comme le vérifient les appels sizeof () qui signalent une taille de 4 pour le tableau initial et de 3 après la suppression.
De plus, pour un élément nommé:
unset($array["elementName"]);
$a = array("A"=>1, "B"=>2, "C"=>"a");
print_r($a);
unset($a["B"]);
print_r($a);
donne (formaté): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
Détruisez un seul élément d'un tableau
unset()
$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);
La sortie sera:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[3]=>
string(1) "D"
[4]=>
string(1) "E"
}
Si vous devez réindexer le tableau:
$array1 = array_values($array1);
var_dump($array1);
La sortie sera alors:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
Pop l'élément hors de la fin du tableau - retourne la valeur de l'élément supprimé
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
La sortie sera
Array
(
[0] => orange
[1] => banana
[2] => apple
)
Last Fruit: raspberry
Supprimer le premier élément (rouge) d'un tableau , - retourner la valeur de l'élément supprimé
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);
La sortie sera:
Array
(
[b] => green
[c] => blue
)
First Color: red
array_shift
réindexation des éléments clés si elle est entière, c'est donc mauvais, vous pouvez donc l'utiliser: stackoverflow.com/a/52826684/1407491
<?php
$stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Production:
[
[0] => fruit2
[1] => fruit3
[2] => fruit4
]
fruit1
array_shift
ne peut supprimer que le premier élément du tableau. de même, utilisez array_pop
pour supprimer le dernier élément du tableau.
Pour éviter de faire une recherche, on peut jouer avec array_diff
:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
Dans ce cas, il n'est pas nécessaire de rechercher / utiliser la clé.
Si vous devez supprimer plusieurs valeurs dans un tableau et que les entrées de ce tableau sont des objets ou des données structurées, [array_filter][1]
c'est votre meilleur pari. Les entrées qui renvoient un vrai de la fonction de rappel seront conservées.
$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']]
Pour les tableaux associatifs, utilisez unset
:
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
Pour les tableaux numériques, utilisez array_splice
:
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
L'utilisation unset
de tableaux numériques ne produira pas d'erreur, mais cela gâchera vos index:
$arr = array(1, 2, 3);
unset($arr[1]);
// RESULT: array(0 => 1, 2 => 3)
Si vous devez supprimer plusieurs éléments d'un tableau associatif, vous pouvez utiliser array_diff_key () (ici utilisé avec 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);
Production:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
unset()
détruit les variables spécifiées.
Le comportement de unset()
intérieur d'une fonction peut varier en fonction du type de variable que vous essayez de détruire.
Si une variable globalisée se trouve à l' unset()
intérieur d'une fonction, seule la variable locale est détruite. La variable dans l'environnement appelant conservera la même valeur que précédemment unset()
.
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
La réponse du code ci-dessus sera bar .
Pour unset()
une variable globale à l'intérieur d'une fonction:
<?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);
}
Si l'index est spécifié:
$arr = ['a', 'b', 'c'];
$index = 0;
unset($arr[$index]); // $arr = ['b', 'c']
Si l'index n'est PAS spécifié:
$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 if
condition est nécessaire car si elle index
n'est pas trouvée, unset()
supprimera automatiquement le premier élément du tableau qui n'est pas ce que nous voulons
Solutions:
unset($array[3]); unset($array['foo']);
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
array_splice($array, $offset, $length);
Plus d'explications:
L'utilisation de ces fonctions supprime toutes les références à ces éléments de PHP. Si vous souhaitez conserver une clé dans le tableau, mais avec une valeur vide, affectez la chaîne vide à l'élément:
$array[3] = $array['foo'] = '';
Outre la syntaxe, il existe une différence logique entre l'utilisation de unset () et l'affectation de '' à l'élément. Le premier dit This doesn't exist anymore,
tandis que le second ditThis still exists, but its value is the empty string.
Si vous avez affaire à des nombres, l'attribution de 0 peut être une meilleure alternative. Ainsi, si une entreprise arrêtait la production du pignon modèle XL1000, elle mettrait à jour son inventaire avec:
unset($products['XL1000']);
Cependant, s'il manquait temporairement de pignons XL1000, mais prévoyait de recevoir une nouvelle livraison de l'usine plus tard cette semaine, c'est mieux:
$products['XL1000'] = 0;
Si vous désactivez () un élément, PHP ajuste le tableau afin que la boucle fonctionne toujours correctement. Il ne compacte pas le tableau pour combler les trous manquants. C'est ce que nous voulons dire lorsque nous disons que tous les tableaux sont associatifs, même lorsqu'ils semblent être numériques. Voici un exemple:
// 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
Pour compacter le tableau en un tableau numérique densément rempli, utilisez array_values () :
$animals = array_values($animals);
Alternativement, array_splice () réindexe automatiquement les tableaux pour éviter de laisser des trous:
// 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
)
Cela est utile si vous utilisez le tableau en tant que file d'attente et que vous souhaitez supprimer des éléments de la file d'attente tout en autorisant un accès aléatoire. Pour supprimer en toute sécurité le premier ou le dernier élément d'un tableau, utilisez array_shift () et array_pop () , respectivement.
Supposons que vous ayez le tableau suivant:
Array
(
[user_id] => 193
[storage] => 5
)
Pour supprimer storage
, procédez comme suit:
unset($attributes['storage']);
$attributes = array_filter($attributes);
Et vous obtenez:
Array
(
[user_id] => 193
)
array_filter
sert-il?
Je voudrais juste dire que j'avais un objet particulier qui avait des attributs variables (il s'agissait essentiellement de mapper une table et je modifiais les colonnes de la table, donc les attributs de l'objet, reflétant la table varieraient également):
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 {}
}
}
}
Le but de $fields
était juste, donc je n'ai pas à regarder partout dans le code quand ils sont modifiés, je regarde juste le début de la classe et change la liste des attributs et le contenu du tableau $ fields pour refléter le nouveau les attributs.
Suivez les fonctions par défaut:
je)
$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"]);
?>
Créez votre tableau dans la variable $array
, puis là où j'ai mis «élément que vous souhaitez supprimer», vous mettez quelque chose comme: «a». Et si vous souhaitez supprimer plusieurs éléments, alors: "a", "b".
Utilisez array_search pour obtenir la clé et supprimez-la avec unset si elle est trouvée:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
Tandis que unset()
ait été mentionné ici plusieurs fois, il reste à mentionner qu'il unset()
accepte plusieurs variables, ce qui facilite la suppression de plusieurs éléments non contigus d'un tableau en une seule opération:
// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]
unset () n'accepte pas un tableau de clés à supprimer, donc le code ci-dessous échouera (cela aurait cependant légèrement facilité l'utilisation dynamique de unset ()).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
Au lieu de cela, unset () peut être utilisé dynamiquement dans une boucle foreach:
$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]
Il existe également une autre pratique qui n'a pas encore été mentionnée. Parfois, le moyen le plus simple de se débarrasser de certaines clés de tableau est de simplement copier $ array1 dans $ 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 ];
Évidemment, la même pratique s'applique aux chaînes de texte:
$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' ]
Utilisez la unset
fonction comme ci-dessous:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Utilisez la array_search
fonction pour obtenir une clé d'élément et utilisez la méthode ci-dessus pour supprimer un élément de tableau comme ci-dessous:
$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
)
*/
Deux façons de supprimer le premier élément d'un tableau en conservant l'ordre de l'index et également si vous ne connaissez pas le nom de clé du premier élément.
// 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);
// 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]);
Pour cet exemple de données:
$array = array(10 => "a", 20 => "b", 30 => "c");
Vous devez avoir ce résultat:
array(2) {
[20]=>
string(1) "b"
[30]=>
string(1) "c"
}
<?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);
?>
Production
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 )
Pour les tableaux associatifs, avec des clés non entières:
Cela unset($array[$key])
fonctionnerait simplement .
Pour les tableaux ayant des clés entières et si vous souhaitez conserver vos clés:
$array = [ 'mango', 'red', 'orange', 'grapes'];
unset($array[2]);
$array = array_values($array);
array_splice($array, 2, 1);
Cela peut aider ...
<?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);
?>
Le résultat sera:
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()
les itérations sur le tableau n'inclura plus la valeur supprimée. OTOH, il est vrai que la réponse de Stevan est ample et, en fait, c'était la réponse que je cherchais - mais pas l'OP :)