PHP: supprimer un élément d'un tableau

y a-t-il un moyen facile de supprimer un élément d'un tableau en utilisant PHP , de sorte que foreach ($array) n'inclut plus cet élément?

je pensais que le mettre sur null le ferait, mais apparemment il ne fonctionne pas.

2029
demandé sur Akintunde-Rotimi 2008-12-15 23:28:55
la source

30 ответов

il y a différentes façons de supprimer un élément de tableau, où certaines sont plus utiles pour certaines tâches spécifiques que d'autres.

supprimer un élément de tableau

si vous voulez supprimer un seul élément de tableau, vous pouvez utiliser unset() ou une alternative array_splice() .

aussi si vous avez la valeur et ne savez pas la clé pour supprimer l'élément que vous pouvez utiliser array_search() pour obtenir la clé.

unset() méthode

notez que lorsque vous utilisez unset() les touches du tableau ne changeront pas/reindex. Si vous voulez reindex les clés, vous pouvez utiliser array_values() après unset() qui convertira toutes les clés numériques énumérées clés à partir de 0.

Code

<?php

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

?>

sortie

Array (
    [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 par rapport à array_values() qui convertira toutes les clés en Clés numériques.

aussi array_splice() a besoin de l'offset, pas de la clé! comme deuxième paramètre.

Code

<?php

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

?>

sortie

Array (
    [0] => a
    [1] => c
)

array_splice() comme unset() prenez le tableau par référence, cela signifie que vous ne voulez pas attribuer les valeurs de retour de ces fonctions de nouveau au tableau.

supprimer les éléments de tableaux multiples

Si vous voulez supprimer plusieurs éléments de tableau et ne veux pas l'appeler unset() ou array_splice() plusieurs fois, vous pouvez utiliser les fonctions array_diff() ou array_diff_key() selon si vous connaissez le les valeurs ou les touches des éléments que vous souhaitez supprimer.

array_diff() méthode

Si vous connaissez les valeurs des éléments du tableau dont vous souhaitez supprimer, puis vous pouvez utiliser array_diff() . Comme avant avec unset() il ne changera pas/reindex les clés du tableau.

Code

<?php

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

?>

sortie

Array (
    [1] => b
)

array_diff_key() méthode

Si vous connaissez les clés des éléments que vous souhaitez supprimer, puis que vous souhaitez utiliser array_diff_key() . Ici, vous devez assurez-vous de passer les touches comme clés dans le deuxième paramètre, et non comme des valeurs. Sinon, vous devez retourner le tableau avec array_flip() . Et aussi ici les clés ne changeront pas/reindex.

Code

<?php

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

sortie

Array (
    [1] => b
)

aussi si vous voulez utiliser unset() ou array_splice() pour supprimer plusieurs éléments avec la même valeur, vous pouvez utiliser array_keys() pour obtenir toutes les clés pour une valeur spécifique et puis supprimer tous les éléments.

2300
répondu Rizier123 2018-06-28 12:57:27
la source

Il convient de noter que unset() va garder les index intacte, qui est ce que vous attendez lors de l'utilisation chaîne index (tableau comme table de hachage (hashtable), mais peut être assez surprenant lorsque l'on traite avec entier tableaux indexés:

$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)
} */

Donc array_splice() peut être utilisé si vous souhaitez normaliser votre entier clés. Une autre option est d'utiliser array_values() après 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)
} */
1306
répondu Stefan Gehrig 2012-01-13 21:32:09
la source
  // 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 () réindexera joliment un tableau numérique, mais supprimera toutes les chaînes clés du tableau et les remplacera par des nombres. Si vous avez besoin de préserver les noms de clés (chaînes), ou de reindex 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);

sorties

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)
323
répondu Marcel Cozma 2015-09-19 22:12:54
la source
$key = array_search($needle,$array);
if($key!==false){
    unset($array[$key]);
}
177
répondu liamvictor 2012-06-03 14:50:11
la source
unset($array[$index]);
62
répondu Eran Galperin 2008-12-15 23:31:31
la source

Si vous avez un tableau indexé numériquement où toutes les valeurs sont uniques (ou ils ne sont pas uniques, mais vous souhaitez supprimer toutes les occurrences de la valeur), 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);

ce qui affiche ce qui suit:

4
3

Dans cet exemple, l'élément avec la valeur "Charles" est supprimé peut être vérifiée par l' sizeof () appelle qui signalent une taille de 4 pour le tableau initial, et 3 après la suppression.

57
répondu Robin Nixon 2012-11-26 12:25:05
la source

aussi, pour un élément nommé:

unset($array["elementName"]);

50
répondu DefenestrationDay 2010-07-31 05:06:55
la source

détruire un seul élément d'un réseau

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 indexer le tableau:

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

alors la sortie sera:

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

Pop l'élément à 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
27
répondu KTAnj 2016-05-25 21:16:34
la source
<?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
23
répondu Saurabh Chandra Patel 2014-02-02 14:28:52
la source

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é.

21
répondu Mugoma J. Okomba 2016-09-23 01:10:50
la source

unset() détruit les variables spécifiées.

Le comportement de unset() à l'intérieur d'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 unset() a été appelé.

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

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

le Answer of le code ci-dessus sera bar

À unset() une variable globale à l'intérieur d'une fonction

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

$bar = "something";
foo();
?>
14
répondu Ankit Aggarwal 2015-08-04 17:31:40
la source

si vous devez supprimer plusieurs valeurs dans un tableau et que les entrées dans ce tableau sont des objets ou des données structurées, [array_filter][1] est votre meilleur pari. Ces entrées qui renvoient un vrai à partir de la fonction de rappel sera retenu.

$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']]
14
répondu spyle 2016-02-18 04:40:49
la source

tableaux associatifs

pour les matrices associatives, utiliser 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, utiliser array_splice :

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

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

Note

utilisant unset pour les tableaux numériques ne produira pas d'erreur, mais il va gâcher vos index :

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

// RESULT : array(0 => 1, 2 => 3)
14
répondu John Slegers 2016-03-11 21:48:25
la source

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);

sortie:

Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 ) 
13
répondu Simon 2016-04-21 00:05:31
la source
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
11
répondu GigolNet Guigolachvili 2018-07-30 15:54:36
la source

je voudrais juste dire que j'avais un objet particulier, qui avait des attributs variables (il était essentiellement mapping une table et je changeais les colonnes dans la table, de sorte que les attributs dans l'objet, reflétant la table serait varier aussi bien

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 {}
        }
    }
}

tout le but de $fields était juste pour que je n'aie pas à chercher partout dans le code quand ils sont changés, je regarde juste au début de la classe et change la liste des attributs et le contenu du tableau $fields pour refléter les nouveaux attributs.

m'a pris un peu de temps pour comprendre ça. J'espère que cela peut aider quelqu'un.

6
répondu Oxydel 2014-09-26 11:12:39
la source

Suivez fonctions par défaut

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);
6
répondu msvairam 2016-01-25 16:07:09
la source

supposons que vous ayez un tel tableau:

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

pour supprimer storage , faire:

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

et vous obtenez:

Array
(
    [user_id] => 193
)
6
répondu Tebe 2016-05-25 21:17:17
la source
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result= array_pop($arr);
print_r($result);
4
répondu Jens Erat 2013-05-17 13:21:37
la source
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>

Créer votre tableau dans la variable $tableau et puis où j'ai mis 'élément que vous souhaitez supprimer" vous mettre quelque chose comme: "un". Et si vous voulez supprimer plusieurs alors: "a", "b".

4
répondu Joshua Charles Pickwell 2017-11-23 11:24:52
la source

unset() multiples, fragmentées des éléments d'un tableau

même si unset() a été mentionné ici à plusieurs reprises, il n'a pas encore été mentionné que unset () accepte plusieurs variables ce qui rend facile de supprimer plusieurs éléments non contiguës 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' ]

débranché() dynamiquement

unset() n'accepte pas un tableau de clés à supprimer, donc le code ci-dessous va échouer (il l'aurait fait légèrement plus facile à utiliser unset() dynamiquement cependant).

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

à la place, 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 y a aussi une autre pratique qui n'a pas encore été mentionnée. Parfois, la façon la 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' ]
4
répondu Kristoffer Bohmann 2017-12-07 09:28:59
la source

Solutions:

  1. pour supprimer un élément, utiliser hors fonction () :
unset($array[3]);
unset($array['foo']);
  1. pour supprimer plusieurs éléments non contiguës, utiliser également unset () :
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. pour supprimer plusieurs éléments contigus, utiliser array_splice () :
array_splice($array, $offset, $length);

autre explication:

utilisant ces fonctions supprime toutes les références à ces éléments de PHP. Si vous voulez garder une clé dans le tableau, mais avec une valeur vide, assignez la chaîne vide à l'élément:

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

en plus de la syntaxe, il y a une différence logique entre utiliser unset( ) et l'attribution " de 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 modèle xl1000 sprocket, elle mettrait à jour son inventaire avec:

unset($products['XL1000']);

cependant, si elle était temporairement à court de pignons XL1000, mais prévoyait de recevoir une nouvelle cargaison de l'usine plus tard cette semaine, c'est mieux:

$products['XL1000'] = 0;

si vous unset () un élément, PHP ajuste le tableau de sorte que la boucle fonctionne encore correctement. Il ne compacte pas le réseau pour combler les trous manquants. C'est ce que nous voulons dire quand nous disons que tous les tableaux sont associatifs, même quand ils semblent être numérique. 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 new element
$animals[ ] = 'gnu'; // add 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 dans 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
    )

c'est utile si vous utilisez le tableau comme file d'attente et que vous voulez supprimer des éléments de la file d'attente tout en permettant l'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.

3
répondu Star 2018-01-29 14:08:20
la source
<?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 ) 
2
répondu UMAR FAROOQUE KHAN 2016-08-16 18:36:02
la source

supprimer un élément de tableau basé sur la touche

Utiliser unset fonction 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 basé sur la valeur:

utiliser array_search fonction pour obtenir la touche d'élément et utiliser la manière ci-dessus pour supprimer l'é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
)

*/
2
répondu MahdiY 2017-09-22 13:28:59
la source

pour les tableaux associatifs, avec des clés non entières:

tout simplement, unset($array[$key]) fonctionnerait.

pour les tableaux ayant des clés entières et si vous voulez maintenir vos clés:

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

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

  1. array_splice($array, 2, 1);
1
répondu Akshay Prakash 2018-04-27 11:23:13
la source

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);
    ?>

résultat sera:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )
0
répondu Klajdi Dosti 2016-09-15 18:18:02
la source

Lors de la suppression d'un élément d'un tableau en PHP, une bonne fonction à utiliser est la fonction unset. Voici un exemple de son utilisation:

$anArray = array("X", "Y", "Z");

unset($anArray[0]);

//'dumps' the content of $anArray to the page:
var_dump($anArray);  

La sortie de la fonction var_dump sera:

array(2) { [1]=> string(1) "Y" [2]=> string(1) "Z" }
0
répondu Arun Vitto 2017-09-14 11:53:35
la source

, Vous pouvez simplement utiliser unset() pour supprimer un tableau.

rappelez-vous que le tableau doit être désactivé après la fonction foreach .

0
répondu Drake Boein 2017-11-06 14:00:27
la source

unset ne pas modifier l'index mais array_splice ne

$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 )
0
répondu inrsaurabh 2018-03-10 18:05:55
la source

$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // here is key to be delete
echo '<br>';
array_values($x);
var_dump($x);
0
répondu Wakar Ahmad Khan 2018-03-21 09:48:02
la source

Autres questions sur php arrays