Supprimer un élément d'un tableau en PHP

Question

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

Je pensais que le régler sur null je le ferais, mais apparemment ça ne marche pas.

Answer 1

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

Supprimer un élément de matrice

Si vous voulez supprimer un seul élément de tableau, vous pouvez utiliser \unset() ou encore \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é.

méthode \array_values()

Notez que lorsque vous utilisez les touches de array_splice() tableau ne changeront pas / réindexation. Si vous voulez réindexer les clés que vous pouvez utiliser après \array_diff() < => qui vous permet de convertir toutes les clés aux touches numériques à partir de énumérées 0.

code

<?php

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

?>

Sortie

[
    [0] => a
    [2] => c
]

méthode \array_diff_key()

Si vous utilisez les touches seront \array_flip() automatiquement réindexés, mais les touches associatives ne changera pas par opposition à qui convertira \array_keys() toutes les touches aux touches numériques.

En outre le décalage a besoin <=>, pas la clé! en tant que 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
]

<=> même que prendre le tableau <=> par référence, et cela signifie que vous ne voulez pas affecter les valeurs de retour de ces fonctions retour au tableau.

Supprimer plusieurs éléments de réseau

Si vous voulez supprimer plusieurs éléments du tableau et ne veulent pas appeler ou <=> plusieurs fois vous <=> pouvez utiliser les fonctions ou <=> selon que <=> vous connaissez les valeurs ou les touches de les éléments que vous souhaitez supprimer.

méthode <=>

Si vous connaissez les valeurs des éléments du tableau que vous souhaitez supprimer, vous pouvez utiliser <=>. Comme précédemment avec elle ne <=> changer / réindexation 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
]

méthode <=>

Si vous connaissez les clés des éléments que vous souhaitez supprimer, vous voulez utiliser <=>. Ici, vous devez vous assurer que vous passez les touches que les touches du second paramètre et non en tant que valeurs. Dans le cas contraire, vous devez retourner le tableau avec <=>. Et ici les clés ne changeront pas / réindexation.

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

<*>

Aussi, si vous souhaitez utiliser ou <=> supprimer plusieurs <=> éléments avec la même valeur que vous pouvez utiliser

Answer 2

Il convient de noter que unset() gardera index intact, ce qui est ce que vous attendez lorsque vous utilisez les index de chaîne (de tableau comme Hashtable), mais peut être tout à fait 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)
} */

array_splice() peut être utilisé si vous souhaitez normaliser vos clés entiers. Une autre option utilise après array_values() <=> :

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

Désormais, array_values() réindexera correctement 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é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 numérique où toutes les valeurs sont uniques (ou ils ne sont que non uniques 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 celui-ci :

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

affiche les éléments suivants:

4
3

Dans cet exemple, l'élément avec la valeur « Charles » est retiré comme on peut le vérifier par les appels sizeof () qui indiquent une taille de 4 pour la matrice initiale et 3 après l'enlèvement.

En outre, un élément nommé:

unset($array["elementName"]);

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 nouveau tableau:

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

Ensuite, 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 à l'extrémité de réseau - renvoyer 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) à partir d'un tableau , - renvoyer 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, on n'a pas à rechercher / utiliser la touche.

Si vous devez supprimer plusieurs valeurs dans un tableau et les entrées dans ce tableau sont des objets ou des données structurées, est votre meilleur [array_filter][1] pari. Ces entrées qui renvoient un vrai de la fonction de rappel seront conservés.

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

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

Le comportement de l'intérieur d'une <=> fonction peut varier en fonction du type de variable que vous voulez détruire.

Si une variable globale est à l'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 a été appelé <=>.

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

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

La réponse du code ci-dessus sera bar .

Pour une variable globale <=> à l'intérieur d'une fonction:

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

    $bar = "something";
    foo();
?>

tableaux de Associatif

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)

Note

Utilisation <=> numérique les tableaux ne produisent pas une erreur, mais il 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);

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

Supposons que vous avez le tableau suivant:

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

Pour supprimer storage, faites:

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

Et vous obtenez:

Array
(
    [user_id] => 193
)

Je voudrais simplement dire que j'avais un objet particulier qui avait des attributs variables (il a été essentiellement une cartographie de la table et je change les colonnes de la table, de sorte que les attributs de l'objet, ce qui reflète la table varierait ainsi ):

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

était juste, Le but de donc je ne $fields pas regarder partout dans le code quand ils ont changé, je regarde juste au début de la classe et modifier la liste des attributs et champs $ contenu du tableau pour refléter les nouveaux attributs.

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

Solutions:

1. Pour supprimer un élément, utilisez non défini():

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

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

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

3. Pour supprimer plusieurs éléments contigus, utilisez tableau_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 utiliser non défini() et attribuer '' à 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 mettrait à jour son inventaire avec :

unset($products['XL1000']);

Cependant, s'il manque temporairement de pignons XL1000, mais qu'il prévoit de recevoir une nouvelle livraison de l'usine plus tard cette semaine, c'est mieux :

$products['XL1000'] = 0;

Si tu non défini() un élément, PHP ajuste le tableau pour que le bouclage 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 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 tableau_valeurs():

$animals = array_values($animals);

Alternativement, tableau_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
)

Ceci est utile si vous utilisez le tableau comme 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 tableau_shift() et tableau_pop(), respectivement.

unset () multiple, des éléments fragmentés d'un tableau

Alors que a été mentionné unset() ici à plusieurs reprises, il n'a pas encore mentionné que plusieurs variables accepte <=> le rendant facile à supprimer plusieurs éléments non adjacents 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 pour supprimer, de sorte que le code ci-dessous échouera (il aurait rendu un peu plus facile à utiliser unset () dynamiquement si).

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

Au lieu de cela, unset () peut être utilisé de manière dynamique 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 doit encore être mentionné. Parfois, la façon la plus simple de se débarrasser de certaines clés du tableau est de 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 ];

De toute évidence, la même pratique s'applique à des 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' ]

<?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 une clé:

Utilisez la fonction comme ci-dessous unset:

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

Utilisez la fonction pour obtenir une array_search clé de l'élément et utiliser la manière 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
        )

*/

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Créez votre tableau dans la variable et où $array j'ai mis « élément que vous voulez supprimer » vous mettez quelque chose comme: « a ». Et si vous voulez supprimer plusieurs éléments puis:. « A », « b »

Utilisez le code suivant:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);

Deux façons pour enlever le premier élément d'un tableau avec maintien de l'ordre de l'indice et aussi si vous ne connaissez pas le nom de la clé du premier élément.

Solution # 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 # 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 échantillon 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 retirez-le avec unset se trouve:

if (($key = array_search('word', $array)) !== false) {
    unset($array[$key]);
}

Pour les tableaux associatifs, avec des touches non entières:

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

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

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

unset ne change pas l'index, mais array_splice 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 )

Answer 3

Il convient de noter que unset() gardera index intact, ce qui est ce que vous attendez lorsque vous utilisez les index de chaîne (de tableau comme Hashtable), mais peut être tout à fait 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)
} */

array_splice() peut être utilisé si vous souhaitez normaliser vos clés entiers. Une autre option utilise après array_values() <=> :

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

Answer 4

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

Désormais, array_values() réindexera correctement 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é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
)

Answer 5

$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}

Answer 6

unset($array[$index]);

Answer 7

Si vous avez un tableau numérique où toutes les valeurs sont uniques (ou ils ne sont que non uniques 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 celui-ci :

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

affiche les éléments suivants:

4
3

Dans cet exemple, l'élément avec la valeur « Charles » est retiré comme on peut le vérifier par les appels sizeof () qui indiquent une taille de 4 pour la matrice initiale et 3 après l'enlèvement.

Answer 8

En outre, un élément nommé:

unset($array["elementName"]);

Answer 9

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 nouveau tableau:

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

Ensuite, 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 à l'extrémité de réseau - renvoyer 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) à partir d'un tableau , - renvoyer 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

Answer 10

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

Answer 11

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, on n'a pas à rechercher / utiliser la touche.

Answer 12

Si vous devez supprimer plusieurs valeurs dans un tableau et les entrées dans ce tableau sont des objets ou des données structurées, est votre meilleur [array_filter][1] pari. Ces entrées qui renvoient un vrai de la fonction de rappel seront conservés.

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

Answer 13

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

Le comportement de l'intérieur d'une <=> fonction peut varier en fonction du type de variable que vous voulez détruire.

Si une variable globale est à l'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 a été appelé <=>.

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

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

La réponse du code ci-dessus sera bar .

Pour une variable globale <=> à l'intérieur d'une fonction:

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

    $bar = "something";
    foo();
?>

Answer 14

tableaux de Associatif

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)

Note

Utilisation <=> numérique les tableaux ne produisent pas une erreur, mais il gâchera vos index:

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

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

Answer 15

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 ) 

Answer 16

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

Answer 17

Supposons que vous avez le tableau suivant:

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

Pour supprimer storage, faites:

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

Et vous obtenez:

Array
(
    [user_id] => 193
)

Answer 18

Je voudrais simplement dire que j'avais un objet particulier qui avait des attributs variables (il a été essentiellement une cartographie de la table et je change les colonnes de la table, de sorte que les attributs de l'objet, ce qui reflète la table varierait ainsi ):

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

était juste, Le but de donc je ne $fields pas regarder partout dans le code quand ils ont changé, je regarde juste au début de la classe et modifier la liste des attributs et champs $ contenu du tableau pour refléter les nouveaux attributs.

Answer 19

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

Answer 20

Solutions:

1. Pour supprimer un élément, utilisez non défini():

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

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

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

3. Pour supprimer plusieurs éléments contigus, utilisez tableau_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 utiliser non défini() et attribuer '' à 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 mettrait à jour son inventaire avec :

unset($products['XL1000']);

Cependant, s'il manque temporairement de pignons XL1000, mais qu'il prévoit de recevoir une nouvelle livraison de l'usine plus tard cette semaine, c'est mieux :

$products['XL1000'] = 0;

Si tu non défini() un élément, PHP ajuste le tableau pour que le bouclage 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 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 tableau_valeurs():

$animals = array_values($animals);

Alternativement, tableau_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
)

Ceci est utile si vous utilisez le tableau comme 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 tableau_shift() et tableau_pop(), respectivement.

Answer 21

unset () multiple, des éléments fragmentés d'un tableau

Alors que a été mentionné unset() ici à plusieurs reprises, il n'a pas encore mentionné que plusieurs variables accepte <=> le rendant facile à supprimer plusieurs éléments non adjacents 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 pour supprimer, de sorte que le code ci-dessous échouera (il aurait rendu un peu plus facile à utiliser unset () dynamiquement si).

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

Au lieu de cela, unset () peut être utilisé de manière dynamique 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 doit encore être mentionné. Parfois, la façon la plus simple de se débarrasser de certaines clés du tableau est de 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 ];

De toute évidence, la même pratique s'applique à des 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' ]

Answer 22

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

Answer 23

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

Utilisez la fonction comme ci-dessous unset:

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

Utilisez la fonction pour obtenir une array_search clé de l'élément et utiliser la manière 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
        )

*/

Answer 24

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Créez votre tableau dans la variable et où $array j'ai mis « élément que vous voulez supprimer » vous mettez quelque chose comme: « a ». Et si vous voulez supprimer plusieurs éléments puis:. « A », « b »

Answer 25

Utilisez le code suivant:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);

Answer 26

Deux façons pour enlever le premier élément d'un tableau avec maintien de l'ordre de l'indice et aussi si vous ne connaissez pas le nom de la clé du premier élément.

Solution # 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 # 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 échantillon 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"
}

Answer 27

Utilisez array_search pour obtenir la clé et retirez-le avec unset se trouve:

if (($key = array_search('word', $array)) !== false) {
    unset($array[$key]);
}

Answer 28

Pour les tableaux associatifs, avec des touches non entières:

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

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

Answer 29

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 )

Answer 30

$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);

Answer 31

unset ne change pas l'index, mais array_splice 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 )