PHP: Supprimer un élément d'un tableau
Existe-t-il un moyen simple de supprimer un élément d'un tableau à l'aide de PHP, de sorte que foreach ($array) n'inclut plus cet élément?
Je pensais que le mettre à null le ferait, mais apparemment cela ne fonctionne pas.
Il existe différentes manières de supprimer un élément de tableau. Certaines sont plus utiles que d'autres pour certaines tâches.
Supprimer un élément de tableau
Si vous souhaitez supprimer un seul élément de tableau, vous pouvez utiliser \unset() ou alternativement \array_splice() .
De plus, si vous avez la valeur et que vous ne connaissez pas la clé pour supprimer l'élément, vous pouvez utiliser \array_search() pour obtenir la clé.
\unset() méthode
Notez que lorsque vous utilisez \unset(), les clés de tableau ne changeront/ne seront pas réindexées. Si vous voulez réindexer les clés, vous pouvez utiliser \array_values() after \unset() pour convertir toutes les clés 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
?>
Sortie
[
[0] => a
[2] => c
]
\array_splice() méthode
Si vous utilisez \array_splice(), les clés seront automatiquement réindexées, mais les clés associatives ne changeront pas, contrairement à \array_values() qui convertira toutes les clés en clés numériques.
De plus, \array_splice() a besoin du décalage, pas de la clé! comme second paramètre.
Code
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
//↑ Offset which you want to delete
?>
Sortie
[
[0] => a
[1] => c
]
array_splice() identique à \unset() prend le tableau par référence, ce qui signifie que vous ne souhaitez pas affecter les valeurs de retour de ces fonctions au tableau.
Supprimer plusieurs éléments de tableau
Si vous souhaitez supprimer plusieurs éléments de 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 à supprimer.
\array_diff() méthode
Si vous connaissez les valeurs des éléments de tableau que vous souhaitez supprimer, vous pouvez utiliser \array_diff(). Comme auparavant avec \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
?>
Sortie
[
[1] => b
]
\array_diff_key() méthode
Si vous connaissez les clés des éléments que vous souhaitez supprimer, vous souhaitez utiliser \array_diff_key(). Ici, vous devez vous assurer que vous passez 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 aussi ici les clés ne changeront pas/ne réindexeront pas.
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
?>
Sortie
[
[1] => b
]
De même, si vous souhaitez utiliser \unset() ou \array_splice() pour supprimer plusieurs éléments ayant 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.
Il convient de noter que unset() conservera les index intacts, ce que vous attendez lorsque vous utilisez des index de chaîne (array as hashtable), mais peut être assez surprenant lorsque vous utilisez des tableaux indexés d'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)
} */
So array_splice() peut être utilisé si vous souhaitez normaliser vos clés entières. Une autre option consiste à utiliser array_values() after 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);
Voici le résultat 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 () réindexera joliment un tableau numérique, mais il supprimera toutes les chaînes clés du tableau et les remplacera par des nombres. Si vous devez conserver les noms de clé (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 elles sont non uniques mais vous souhaitez supprimer toutes les occurrences 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é, ce qui peut être vérifié par les appels sizeof () signalant une taille de 4 pour le tableau initial et de 3 après la suppression.
Aussi, pour un élément nommé:
unset($array["elementName"]);
Détruit 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 avez besoin d’indexer le tableau:
$array1 = array_values($array1);
var_dump($array1);
Ensuite, le résultat sera:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
Dépose l'élément à la fin du tableau - renvoie 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
Supprime le premier élément (rouge) d'un tableau , - renvoie 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
<?php
$stack = array("fruit1", "fruit2", "fruit3", "fruit4");
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Sortie:
Array
(
[0] => fruit2
[1] => fruit3
[2] => fruit4
)
fruit1
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é.
unset() détruit les variables spécifiées.
Le comportement de unset() dans une fonction peut varier en fonction du type de variable que vous tentez de détruire.
Si une variable globalisée est unset() à l'intérieur d'une fonction, seule la variable locale est détruite. La variable dans l'environnement appelant conservera la même valeur qu'avant l'appel de 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();
?>
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] est votre meilleur choix. Les entrées renvoyant la valeur true à partir 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']]
Tableaux associatifs
Pour les tableaux associatifs, utilisez unset :
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
Tableaux numériques
Pour les tableaux numériques, utilisez array_splice :
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
Remarque
L'utilisation de unset pour les tableaux numériques ne produira pas d'erreur, mais gâchera vos index:
$arr = array(1, 2, 3);
unset($arr[1]);
// RESULT: array(0 => 1, 2 => 3)
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
Si vous devez supprimer plusieurs éléments d'un tableau associatif, vous pouvez utiliser array_diff_key () (utilisé ici 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);
Sortie:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
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);
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
)
Je voudrais juste dire que j'avais un objet particulier qui avait des attributs variables (il s'agissait en fait de mapper une table et de changer les colonnes de la table, de sorte que les attributs de l'objet, reflétant la table, varient é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 à chercher 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 les champs $ array contenu pour refléter les nouveaux attributs.
Solutions:
- Pour supprimer un élément, utilisez unset () :
unset($array[3]); unset($array['foo']);
- Pour supprimer plusieurs éléments non contigus, utilisez également unset () :
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
- Pour supprimer plusieurs éléments contigus, utilisez array_splice () :
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 y a une différence logique entre utiliser unset () et assigner '' à l'élément. Le premier dit This doesn't exist anymore, tandis que le second dit This still exists, but its value is the empty string.
Si vous avez affaire à des nombres, attribuer 0 peut être une meilleure alternative. Ainsi, si une entreprise arrêtait la production du pignon modèle XL1000, elle actualiserait son inventaire avec:
unset($products['XL1000']);
Toutefois, si les pignons XL1000 étaient temporairement épuisés, mais prévoyaient recevoir un nouvel envoi de l’usine plus tard cette semaine, c’est mieux:
$products['XL1000'] = 0;
Si vous unset () un élément, PHP ajuste le tableau pour que le bouclage fonctionne toujours correctement. Cela ne compresse pas le tableau pour combler les trous manquants. C’est ce que nous voulons dire quand nous disons que tous les tableaux sont associatifs, même s’ils semblent 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);
Sinon, 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 souhaitez supprimer des éléments de la file tout en permettant 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.
unset () plusieurs éléments fragmentés d'un tableau
Bien que unset() ait été mentionné ici à plusieurs reprises, il reste à mentionner que 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 () dynamiquement
unset () n'accepte pas un tableau de clés à supprimer, le code ci-dessous va donc échouer (l'utilisation de unset () de manière dynamique serait légèrement plus facile).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
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 ]
Supprimer les clés du tableau en copiant le tableau
Il existe également une autre pratique qui doit encore être mentionnée… .. Parfois, le moyen le plus simple de supprimer certaines clés de tableau consiste 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' ]
Supprimer un élément de tableau basé sur une clé:
Utilisez la fonction unset comme ci-dessous:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Supprimer un élément de tableau en fonction de la valeur:
Utilisez la fonction array_search 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
)
*/
Utilisez le code suivant:
$arr = array('orange', 'banana', 'Apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
<?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 placé l'élément que vous souhaitez supprimer, vous avez mis quelque chose comme: "a". Et si vous souhaitez supprimer plusieurs éléments, alors: "a", "b".
<?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);
?>
Sortie
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 )
Deux manières 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.
Solution 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);
Solution 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]);
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"
}
Utilisez array_search pour obtenir la clé et supprimez-la si non définie:
if (($key = array_search('Word', $array)) !== false) {
unset($array[$key]);
}
$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // Here is the key to be deleted
echo '<br>';
array_values($x);
var_dump($x);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 )
unset ne modifie pas l'index, mais array_splice le fait:
$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 )
Si vous connaissez l'index:
$arr = ['a', 'b', 'c'];
$index = 0;
unset($arr[$index]); // result: $arr = ['b', 'c']
Si vous ne connaissez pas l'index, vous devez d'abord rechercher la valeur:
$arr = ['a', 'b', 'c'];
$index = array_search('a',$arr);
unset($arr[$index]); // result: $arr = ['b', 'c']
si vous souhaitez supprimer un objet spécifique d'un tableau en référence à cet objet, vous pouvez procéder comme suit:
unset($array[array_search($object,$array)]);
Exemple:
<?php
class Foo
{
public $id;
public $name;
}
$foo1 = new Foo();
$foo1->id = 1;
$foo1->name = 'Name1';
$foo2 = new Foo();
$foo2->id = 2;
$foo2->name = 'Name2';
$foo3 = new Foo();
$foo3->id = 3;
$foo3->name = 'Name3';
$array = array($foo1,$foo2,$foo3);
unset($array[array_search($foo2,$array)]);
echo '<pre>';
var_dump($array);
echo '</pre>';
?>
Résultat:
array(2) {
[0]=>
object(Foo)#1 (2) {
["id"]=>
int(1)
["name"]=>
string(5) "Name1"
}
[2]=>
object(Foo)#3 (2) {
["id"]=>
int(3)
["name"]=>
string(5) "Name3"
}
}
Notez que si l'objet se produit plusieurs fois, il ne sera supprimé qu'à la première occurrence!
Nous pouvons modifier le contenu variable avec une référence, en utilisant foreach:
<?php
// Remove all elements in the array
foreach ($array as &$arr) {
$arr = null;
}
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
);
print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);
print_r($arrayName);
Il existe deux méthodes pour effectuer cette tâche: unset () et array_splice ()
Supposons deux tableaux:
$array_1 = array('a'=>'One', 'b'=>'Two', 'c'=>'Three');
$array_2 = array('Red', 'Yellow', 'White', 'Black', 'Green');
Avec unset ()
syntax - unset(array_element)
unset($array_1['a']); // Any valid key
unset($array_2[0]); // Any valid index
- après la suppression d'un élément de tableau, l'index de tableau ne change pas
Avec array_splice ()
syntax - array_splice(array, index, length)
array_splice($array_1, 1, 1); // Remove one element from $array_1 from index 1
array_splice($array_2, 3, 1); // Remove one element from $array_2 from index 3
- Tous les éléments du tableau sont réindexés après la suppression d'un élément du tableau
Vous pouvez simplement utiliser unset() pour supprimer un tableau.
Rappelez-vous qu'un tableau doit être non défini après la fonction foreach.