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 nullferait, mais apparemment, cela ne fonctionne pas.

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.

Supprimer un élément du tableau

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

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

Supprimer plusieurs éléments du 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éthode

Si 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éthode

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

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

  // 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"]);

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

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

    echo $fruit;
?>

Production:

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

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']]

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 unsetde 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 ifcondition est nécessaire car si elle indexn'est pas trouvée, unset()supprimera automatiquement le premier élément du tableau qui n'est pas ce que nous voulons

Solutions:

1. Pour supprimer un élément, utilisez unset () :

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

2. Pour supprimer plusieurs éléments non contigus, utilisez également unset () :

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

3. 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 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
)

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

unset () plusieurs éléments fragmentés d'un tableau

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 () dynamiquement

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 ]

Supprimer les clés du tableau en copiant le tableau

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' ]

Supprimez un élément de tableau basé sur une clé:

Utilisez la unsetfonction comme ci-dessous:

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

unset($a[1]);

print_r($a);

/*

    Output:

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

*/

Supprimez un élément de tableau basé sur la valeur:

Utilisez la array_searchfonction 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.

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 le code suivant:

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

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:

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

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

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