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


2516

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.


14
Je ne voudrais pas que la réponse de Konrad soit la plus simple au problème posé. Avec unset()les itérations sur le tableau n'inclura plus la valeur supprimée. OTOH, il est vrai que la réponse de Stevan est ample et, en fait, c'était la réponse que je cherchais - mais pas l'OP :)
brandizzi

32
@danip Être facile à trouver dans le manuel n'empêche pas une question sur StackOverflow. Si la question était une question StackOverflow en double , elle pourrait ne pas appartenir ici. StackOverflow est un bon endroit pour trouver des réponses comme option de choix avant même de regarder dans le manuel.
Dan Nissenbaum

5
@unset ($ array [$ key]); $ array = array_values ​​($ array);
trojan

Question connexe sur la suppression de cela dans une boucle foreach: stackoverflow.com/questions/1949259/…
Legolas

Si vous souhaitez supprimer des clés du tableau du tableau (tableau associatif), voir la solution sur stackoverflow.com/a/47978980/1045444
Somnath Muluk

Réponses:


2874

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.


26
@AlexandruRada Non, vous avez dit "ne l'utilisez pas" - et c'est juste un non-sens. Vous pouvez utiliser cette méthode en toute sécurité lorsque vous traitez un tableau comme ce qu'il est - un dictionnaire. Ce n'est que si vous attendez des indices numériques consécutifs que vous devez utiliser autre chose.
Konrad Rudolph

2
@Alexander Use array_splice, comme décrit dans les autres réponses.
Konrad Rudolph

1
@AlexandruRada Il n'y a aucun moyen que vous pouvez avoir array (3) { [0]=>int(0) ...lorsque vous unset($x[2])de $x = array(1, 2, 3, 4);résultat doit être var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }(il était probablement faute de frappe)
inemanja

5
unset peut avoir plusieurs arguments: void unset ( mixed $var [, mixed $... ] ) .
Константин Ван

3
array_filter est également une méthode viable. Particulièrement bon si vous ne voulez pas muter le tableau mais il ne réindexe pas non plus ce qui peut être un problème avec json_encode. php.net/manual/en/function.json-encode.php#94157
dotnetCarpenter

1359

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

43
Il convient de noter que lorsque vous utilisez array_splice (), vous devez connaître l'OFFSET, pas la clé, mais l'offset (!) De l'élément que vous souhaitez supprimer
Tom

18
@Tom: Pour un tableau régulier (qui est indexé en entier en continu), le décalage est l'index. C'est là que array_splicepeut avoir un sens (entre autres).
Stefan Gehrig

5
Oui bien sûr, mais juste quelque chose à retenir si vous trafiquez le tableau avant d'utiliser l'épissure
Tom

4
À partir d'un simple test de suppression d'une tonne d'éléments d'un gigantesque tableau, array_splice semble être beaucoup plus rapide et moins gourmand en mémoire. Cela correspond à ce que j'attendrais: array_values ​​() semble faire une copie du tableau, tandis que array_splice fonctionne en place.
Doug Kavendek

4
array_values ​​est une approche utile lorsque vous supprimez des éléments dans une boucle et que vous souhaitez que les index soient cohérents, mais que vous souhaitez ensuite les compresser après la boucle.
Rorrik

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

$ get_merged_values ​​= array_merge ($ data ['res'], $ data ['check_res']); quand j'imprime ce print_r ($ get_merged_values); il affiche ce qui suit. Array ([0] => Array ([menu_code] => 2 [menu_name] => Plant [menu_order_no] => 1) [1] => Array ([menu_code] => 3 [menu_name] => Ligne [menu_order_no]] => 2)) Mais j'ai besoin d'obtenir les valeurs de menu_code et menu_name en utilisant $ get_merged_values ​​['menu_code'] et $ get_merged_values ​​['menu_name'] respectivement, au lieu d'utiliser $ get_merged_values ​​[0] [menu_code], $ get_merged_values ​​[0 ] [nom_menu]. s'il vous plaît aidez-moi comment faire cela?
hacker cardiaque

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

4
Serait bon de préciser que cette réponse est pour la suppression d'un élément, lorsque vous connaissez la valeur, mais pas la clé. Notez qu'il supprime uniquement la PREMIÈRE instance de la valeur; pour trouver toutes les clés pour une valeur, utilisez array_keys
ToolmakerSteve


65

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.


64

De plus, pour un élément nommé:

unset($array["elementName"]);

$a = array("A"=>1, "B"=>2, "C"=>"a"); print_r($a); unset($a["B"]); print_r($a); donne (formaté): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
DefenestrationDay

Il semble que vous ne puissiez pas supprimer les éléments du tableau indexés par une chaîne (génère "Erreur fatale: impossible de supprimer les décalages de chaîne"). Je ne pense pas que ce fut toujours le cas, mais certainement depuis PHP 5.3.10 et probablement plus tôt
carpii

6
@carpii PHP peut annuler les éléments d'un tableau associatif. L'erreur fatale est provoquée lorsque vous essayez d'utiliser unset ($ var ['key']) sur une chaîne au lieu d'un tableau Par exemple: $ array = array ('test' => 'value', 'another' => ' valeur', ); unset ($ array ['test']); // Supprime l'élément "test" du tableau comme prévu $ array = 'test'; unset ($ array ['test']); // Lance "Erreur fatale: impossible de supprimer les décalages de chaîne" comme prévu
Jimbo

Ici, vous devez connaître le nom de la clé, c'est mieux: stackoverflow.com/a/52826684/1407491
Nabi KAZ

33

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

1
La array_shiftréindexation des éléments clés si elle est entière, c'est donc mauvais, vous pouvez donc l'utiliser: stackoverflow.com/a/52826684/1407491
Nabi KAZ

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

    echo $fruit;
?>

Production:

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

14
Notez que array_shiftne peut supprimer que le premier élément du tableau. de même, utilisez array_poppour supprimer le dernier élément du tableau.
Jasir

1
La réponse ne s'applique qu'au premier élément d'un tableau et ne répond pas à la question générale.
sweisgerber.dev

@sebweisgerber vous avez raison mais je ne pense pas que ce soit mauvais et j'ai besoin de déprécier cela. La question est de supprimer un élément sans mentionner de position.
Saurabh Chandra Patel

27

Pour éviter de faire une recherche, on peut jouer avec array_diff:

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

Dans ce cas, il n'est pas nécessaire de rechercher / utiliser la clé.


21

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

20

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)

19

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 ) 

Pourquoi est-ce si sous-estimé?
Fr0zenFyr

19

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

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

12

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


1
si la valeur n'est pas trouvée, elle supprimera le premier élément. ajouter un test pour le non défini: if ($ index! == false) unset ($ arr [$ index]);
MyRealNameIsBlaze

@MyRealNameIsBlaze merci, corrigé
Ahmad Mobaraki

9

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


8

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
)

À quoi array_filtersert-il?
David

supprimer les éléments falsifiés
Tebe

8

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.


8

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

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


7

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

6

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

6

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
        )

*/

6

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

5

Utilisez le code suivant:

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

4
php5: la simple exécution array_pop($arr)supprime l'entrée finale. Aucun `=` nécessaire.
Chris K

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

4

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


2

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 )

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

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

print_r($arrayName);
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.