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

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

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

aussi, pour un élément nommé:

unset($array["elementName"]);

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

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

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

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)

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 ) 

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

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.

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

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
)

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

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

Solutions:

1. pour supprimer un élément, utiliser hors fonction () :

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

2. pour supprimer plusieurs éléments non contiguës, utiliser également unset () :

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

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

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

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
)

*/

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

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

résultat sera:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

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

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

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

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 )

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