supprimer - vider tableau php




PHP: Supprimer un élément d'un tableau (20)

unset ne change 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 )

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'inclut plus cet élément?

Je pensais que le mettre à null ferait, mais apparemment cela ne fonctionne pas.


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

Utiliser unset() pour les 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)

Aussi, pour un élément nommé:

unset($array["elementName"]);

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 )

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 une autre array_splice() .

De plus, si vous avez la valeur et ne connaissez pas la clé pour supprimer l'élément, vous pouvez utiliser array_search() pour obtenir la clé.

méthode unset()

Notez que lorsque vous utilisez unset() les clés de tableau ne changeront pas / ne seront pas réindexées. Si vous souhaitez réindexer les clés, vous pouvez utiliser array_values() après unset() pour convertir toutes les clés en clés numériques énumérées à 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()

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() besoin du décalage, pas de la clé! comme second 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() même que unset() prend le tableau par référence, cela 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 pas appeler plusieurs fois unset() ou array_splice() , vous pouvez utiliser les fonctions array_diff() ou array_diff_key() selon que vous connaissez les valeurs ou les clés des éléments vous voulez supprimer.

Méthode array_diff()

Si vous connaissez les valeurs des éléments de tableau que vous souhaitez supprimer, vous pouvez utiliser array_diff() . Comme auparavant avec unset() cela ne changera / réindexera pas 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
)

Méthode array_diff_key()

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

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.


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, 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 pour que 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 le contenu du tableau de $ fields pour refléter le nouveaux attributs.

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


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


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

Simplement, unset($array[$key]) fonctionnerait.

Pour les tableaux contenant 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);

  1. array_splice($array, 2, 1);

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 ) 

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

Supposons que vous ayez un tel tableau:

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

Pour supprimer le storage , faites:

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

Et vous obtenez:

Array
(
    [user_id] => 193
)

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

N'oubliez pas que le tableau doit être non foreach après la fonction foreach .


Détruire 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éposez 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

Solutions:

  1. Pour supprimer un élément, utilisez unset() :
unset($array[3]);
unset($array['foo']);
  1. Pour supprimer plusieurs éléments non contigus, utilisez également unset() :
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. 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 que This doesn't exist anymore, alors que le second dit que 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 mettrait à jour son inventaire avec:

unset($products['XL1000']);

Toutefois, si le nombre de pignons XL1000 est temporairement épuisé, mais si vous envisagez de 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 lorsque 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 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 en un tableau numérique densément rempli, utilisez array_values() :

$animals = array_values($animals);

array_splice() réindexer 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 respectivement array_shift () et array_pop () .


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


  // 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 supprimera toutes les chaînes de clé 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]);
}

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

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

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}




arrays