PHP
Manipulation d'un tableau

Suppression d'éléments d'un tableau

Supprimer un élément dans un tableau, par exemple l’élément avec l’index 1.

$fruit = array("bananas", "apples", "peaches");
unset($fruit[1]);

Cela supprimera les pommes de la liste, mais notez que unset ne modifie pas les index des éléments restants. Donc, $fruit contient maintenant les index 0 et 2 .

Pour un tableau associatif, vous pouvez supprimer comme ceci:

$fruit = array('banana', 'one'=>'apple', 'peaches');

print_r($fruit);
/*
    Array
    (
        [0] => banana
        [one] => apple
        [1] => peaches
    )
*/

unset($fruit['one']); 

Maintenant, $ fruit est

print_r($fruit);

/*
Array
(
    [0] => banana
    [1] => peaches
)
*/

Notez que

unset($fruit);

désélectionne la variable et supprime donc tout le tableau, ce qui signifie qu'aucun de ses éléments n'est plus accessible.

Suppression d'éléments terminaux

array_shift () - Décale un élément du début du tableau.

Exemple:

  $fruit = array("bananas", "apples", "peaches");
  array_shift($fruit);
  print_r($fruit);

Sortie:

 Array
(
    [0] => apples
    [1] => peaches
)

array_pop () - Désactive l'élément à la fin du tableau.

Exemple:

  $fruit = array("bananas", "apples", "peaches");
  array_pop($fruit);
  print_r($fruit);

Sortie:

 Array
(
    [0] => bananas
    [1] => apples
)

Filtrage d'un tableau

Pour filtrer les valeurs d'un tableau et obtenir un nouveau tableau contenant toutes les valeurs correspondant à la condition du filtre, vous pouvez utiliser la fonction array_filter .

Filtrage des valeurs non vides

Le cas le plus simple de filtrage est de supprimer toutes les valeurs "vides":

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$non_empties = array_filter($my_array); // $non_empties will contain [1,2,3,4,5,6,7,8]; 

Filtrage par rappel

Cette fois, nous définissons notre propre règle de filtrage. Supposons que nous voulons obtenir uniquement des nombres pairs:

$my_array = [1,2,3,4,5,6,7,8];

$even_numbers = array_filter($my_array, function($number) {
    return $number % 2 === 0;   
});

La fonction array_filter reçoit le tableau à filtrer en tant que premier argument, et un rappel définissant le prédicat de filtre en tant que second argument.

$numbers = [16,3,5,8,1,4,6];

$even_indexed_numbers = array_filter($numbers, function($index) {
    return $index % 2 === 0;
}, ARRAY_FILTER_USE_KEY);

Index dans un tableau filtré

Notez que array_filter conserve les clés de tableau d'origine. Une erreur commune serait d'essayer une utilisation for boucle sur le tableau filtré:

<?php

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array); 

error_reporting(E_ALL); // show all errors and notices

// innocently looking "for" loop
for ($i = 0; $i < count($filtered); $i++) {
   print $filtered[$i];
}

/*
Output:
1
Notice: Undefined offset: 1
2
Notice: Undefined offset: 3
3
Notice: Undefined offset: 5
4
Notice: Undefined offset: 7
*/

Cela se produit parce que les valeurs qui étaient sur les positions 1 (il y avait 0 ), 3 ( null ), 5 (chaîne vide '' ) et 7 (tableau vide [] ) ont été supprimées avec leurs clés d’index correspondantes.

Si vous devez parcourir le résultat d'un filtre sur un tableau indexé, vous devez d'abord appeler array_values sur le résultat de array_filter afin de créer un nouveau tableau avec les index corrects:

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array); 
$iterable = array_values($filtered);

error_reporting(E_ALL); // show all errors and notices

for ($i = 0; $i < count($iterable); $i++) {
   print $iterable[$i];
}

// No warnings!

Ajouter un élément au début du tableau

Parfois, vous voulez ajouter un élément au début d'un tableau sans modifier aucun des éléments actuels ( ordre ) du tableau . Chaque fois que c'est le cas, vous pouvez utiliser array_unshift() .

array_unshift() ajoute les éléments passés au array_unshift() du tableau. Notez que la liste des éléments est ajoutée dans son intégralité, de sorte que les éléments ajoutés au début restent dans le même ordre. Toutes les clés de tableau numérique seront modifiées pour commencer à compter à partir de zéro alors que les touches littérales ne seront pas touchées.

^{Tiré de la documentation de PHP pour array_unshift() .}

Si vous souhaitez atteindre cet objectif, tout ce que vous devez faire est le suivant:

$myArray = array(1, 2, 3);

array_unshift($myArray, 4);

Cela va maintenant ajouter 4 comme premier élément de votre tableau. Vous pouvez le vérifier en:

print_r($myArray);

^{Cela retourne un tableau dans l'ordre suivant: 4, 1, 2, 3 .}

Comme array_unshift force le tableau à réinitialiser les paires clé-valeur alors que le nouvel élément laisse les clés suivantes n+1 il est préférable de créer un nouveau tableau et d’ajouter le tableau existant au tableau nouvellement créé.

Exemple:

$myArray = array('apples', 'bananas', 'pears');
$myElement = array('oranges');
$joinedArray = $myElement;

foreach ($myArray as $i) {
  $joinedArray[] = $i;
}

Sortie ($ joinArray):

Array ( [0] => oranges [1] => apples [2] => bananas [3] => pears ) 

Eaxmple / Demo

Liste blanche seulement quelques clés de tableau

Lorsque vous ne souhaitez autoriser que certaines clés dans vos tableaux, en particulier lorsque le tableau provient de paramètres de requête, vous pouvez utiliser array_intersect_key avec array_flip .

$parameters = ['foo' => 'bar', 'bar' => 'baz', 'boo' => 'bam'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_intersect_key($parameters, array_flip($allowedKeys));

// $filteredParameters contains ['foo' => 'bar', 'bar' => 'baz]

Si la variable parameters ne contient aucune clé autorisée, la variable filteredParameters sera constituée d'un tableau vide.

Depuis PHP 5.6, vous pouvez également utiliser array_filter pour cette tâche, en passant le drapeau ARRAY_FILTER_USE_KEY comme troisième paramètre:

$parameters  = ['foo' => 1, 'hello' => 'world'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_filter(
    $parameters,
    function ($key) use ($allowedKeys) {
        return in_array($key, $allowedKeys);
    },
    ARRAY_FILTER_USE_KEY
);

L'utilisation de array_filter offre la flexibilité supplémentaire d'effectuer un test arbitraire par rapport à la clé, par exemple $allowedKeys pourrait contenir des modèles de regex au lieu de chaînes simples. Il indique également plus explicitement l'intention du code que array_intersect_key() combiné avec array_flip() .

Tri d'un tableau

Il existe plusieurs fonctions de tri pour les tableaux en php:

Trier()

Trier un tableau par ordre croissant de valeur.

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
sort($fruits);
print_r($fruits);

résulte en

Array
(
    [0] => Apfel
    [1] => Banane
    [2] => Orange
    [3] => Zitrone
)

rsort ()

Trier un tableau par ordre décroissant de valeur.

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
rsort($fruits);
print_r($fruits);

résulte en

Array
(
    [0] => Zitrone
    [1] => Orange
    [2] => Banane
    [3] => Apfel
)

un tri()

Trier un tableau par ordre croissant de valeur et préserver les indécies.

$fruits = [1 => 'lemon', 2 => 'orange',  3 => 'banana', 4 => 'apple'];
asort($fruits);
print_r($fruits);

résulte en

Array
(
    [4] => apple
    [3] => banana
    [1] => lemon
    [2] => orange
)

arsort ()

Trier un tableau par ordre décroissant de valeur et préserver les indécies.

$fruits = [1 => 'lemon', 2 => 'orange',  3 => 'banana', 4 => 'apple'];
arsort($fruits);
print_r($fruits);

résulte en

Array
(
    [2] => orange
    [1] => lemon
    [3] => banana
    [4] => apple
)

ksort ()

Trier un tableau par ordre croissant de clé

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
ksort($fruits);
print_r($fruits);

résulte en

Array
(
    [a] => orange
    [b] => banana
    [c] => apple
    [d] => lemon
)

krsort ()

Trier un tableau dans l'ordre décroissant par clé.

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
krsort($fruits);
print_r($fruits);

résulte en

Array
(
    [d] => lemon
    [c] => apple
    [b] => banana
    [a] => orange
)

natsort ()

Trier un tableau d'une manière que ferait un être humain (ordre naturel).

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natsort($files);
print_r($files);

résulte en

Array
(
    [4] => File2.stack
    [0] => File8.stack
    [2] => file7.stack
    [3] => file13.stack
    [1] => file77.stack
)

natcasesort ()

Trier un tableau comme le ferait un être humain (ordre naturel), mais en tenant compte de la casse

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natcasesort($files);
print_r($files);

résulte en

Array
(
    [4] => File2.stack
    [2] => file7.stack
    [0] => File8.stack
    [3] => file13.stack
    [1] => file77.stack
)

mélanger ()

Mélange un tableau (trié au hasard).

$array = ['aa', 'bb', 'cc'];
shuffle($array);
print_r($array);

Comme écrit dans la description, il est aléatoire, donc voici seulement un exemple dans ce qu'il peut en résulter

Array
(
    [0] => cc
    [1] => bb
    [2] => aa
)

usort ()

Trier un tableau avec une fonction de comparaison définie par l'utilisateur.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = [3, 2, 5, 6, 1];
usort($array, 'compare');
print_r($array);

résulte en

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)

uasort ()

Trier un tableau avec une fonction de comparaison définie par l'utilisateur et conserver les clés.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['a' => 1, 'b' => -3, 'c' => 5, 'd' => 3, 'e' => -5];
uasort($array, 'compare');
print_r($array);

résulte en

Array
(
    [e] => -5
    [b] => -3
    [a] => 1
    [d] => 3
    [c] => 5
)

uksort ()

Trier un tableau à l'aide de clés avec une fonction de comparaison définie par l'utilisateur.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['ee' => 1, 'g' => -3, '4' => 5, 'k' => 3, 'oo' => -5];

uksort($array, 'compare');
print_r($array);

résulte en

Array
(
    [ee] => 1
    [g] => -3
    [k] => 3
    [oo] => -5
    [4] => 5
)

Echanger des valeurs avec des clés

array_flip fonction array_flip échangera toutes les clés avec ses éléments.

$colors = array(
    'one' => 'red',
    'two' => 'blue',
    'three' => 'yellow',
);

array_flip($colors); //will output

array(
    'red' => 'one',
    'blue' => 'two',
    'yellow' => 'three'
)

Fusionner deux tableaux dans un tableau

$a1 = array("red","green");
$a2 = array("blue","yellow");
print_r(array_merge($a1,$a2));

/*
    Array ( [0] => red [1] => green [2] => blue [3] => yellow )
*/

Tableau associatif:

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2));
/*
    Array ( [a] => red [b] => yellow [c] => blue )
*/

1. Fusionne les éléments d’un ou de plusieurs tableaux pour que les valeurs de un soient ajoutées à la fin du précédent. Il retourne le tableau résultant.
2. Si les tableaux d'entrée ont les mêmes clés de chaîne, la valeur ultérieure de cette clé remplacera la précédente. Si, toutefois, les tableaux contiennent des clés numériques, la valeur ultérieure ne remplacera pas la valeur d'origine, mais sera ajoutée.
3. Les valeurs du tableau d'entrée avec des clés numériques seront renumérotées avec des clés d'incrémentation à partir de zéro dans le tableau de résultats.