7 trucs & astuces pour manipuler les tableaux PHP 👍
En PHP, les tableaux (array en anglais) sont une structure de données incontournable. Ils peuvent être utilisés aussi bien pour mettre en place des listes, tables de hashage, piles, files d’attente, etc. Par conséquent, il est utile de savoir les utiliser efficacement. Il existe un nombre assez conséquent de fonctions pour manipuler les tableaux en PHP et je ne peux que conseiller de les avoir en tête. Elles sont d’une grande aide pour éviter de se retrouver à faire des boucles foreach à outrance ou pour améliorer les performances de vos programmes. Néanmoins, connaître la définition de ces fonctions ne garantie pas forcément de savoir les utiliser pour un cas d’usage particulier. C’est pourquoi, je propose ci-dessous 7 trucs et astuces concrets pour manipuler les tableaux en exposant des cas fréquents.
1. Réordonner les clés d’un tableau indexé numériquement
Considérons un tableau indexé numériquement auquel une valeur est supprimée :
$array = ['a', 'b', 'c', 'd'];
unset($array[2]);
print_r($array);Alors, les indexes (clés) du tableau ne sont plus consécutifs. En effet, le fait de supprimer un élément de tableau via la fonction unset préserve les clés des autres éléments (ce qui peut être un comportement recherché). L’exemple ci-dessus va afficher :
Array
(
[0] => a
[1] => b
[3] => d
)
Afin de retrouver un tableau avec des indexes consécutifs de manière simple et rapide, il est possible d’utiliser la fonction array_values :
$array = ['a', 'b', 'c', 'd'];
unset($array[2]);
$array = array_values($array);
print_r($array);L’exemple ci-dessus affichera cette fois :
Array
(
[0] => a
[1] => b
[2] => d
)
2. Supprimer un élément d’un tableau tout en ré-indexant les clés
Comme vu dans le premier cas d’usage, la fonction unset permet de supprimer des éléments d’un tableau, tout en préservant les clés des éléments restants.
Toutefois, il est parfois souhaitable de vouloir supprimer un ou plusieurs éléments tout en indéxant à nouveau les clés. Ce qui permet alors de se passer d’un appel à la fonction array_values.
Ici, l’astuce est d’utiliser la fonction array_splice qui permet notamment de supprimer une portion d’un tableau.
Avec l’exemple précédent cela donne :
$array = ['a', 'b', 'c', 'd'];
array_splice($array, 2, 1);
// Le 2e argument "2" indique la position de l’élément à supprimer
// Le 3e argument "1" indique le nombre d’éléments à supprimer
print_r($array);Cette fois l’exemple va afficher :
Array
(
[0] => a
[1] => b
[2] => d
)
Attention toutefois, il y a plusieurs points à garder en tête en utilisant la fonction array_splice :
- la fonction prend le tableau par référence, cela signifie qu’elle le modifie directement. Par conséquent, il ne faut pas assigner la valeur de retour de la fonction à la variable contenant le tableau.
- Le 2e argument de la fonction est bien la position (offset) de l’élément dans le tableau et non son index (i.e. sa clé). Attention donc à ne pas se tromper si la fonction est utilisée sur un tableau dont les indexes ne sont pas consécutifs.
3. Supprimer un ou plusieurs éléments d’un tableau à partir d’une valeur
Les deux premiers cas de cet article montrent comment supprimer un élément d’un tableau à partir d’une clé ou d’une position.
Cependant, comment supprimer un élément lorsque uniquement sa valeur est connue ?
Plusieurs solutions sont possibles, mais une des plus simple est d’utiliser array_diff.
À la base cette fonction est décrite pour retourner les éléments d’un tableaux qui ne sont pas présents dans un ou plusieurs autres tableaux. Par conséquent, il est possible de l’utiliser pour supprimer une valeur ou plusieurs valeurs présentes dans un tableau :
array = ['a', 'b', 'c', 'd'];
$array = array_diff($array, ['c']);
print_r($array);L’exemple ci-dessus va afficher :
Array
(
[0] => a
[1] => b
[3] => d
)
Les plus avisés auront compris comment supprimer plusieurs valeurs avec cette fonction :
$array = ['a', 'b', 'c', 'd'];
$array = array_diff($array, ['b', 'c']);
print_r($array);Le résultat sera cette fois :
Array
(
[0] => a
[3] => d
)
Encore une fois, plusieurs chose à noter concernant cette astuce :
- Les indexes du tableau restent inchangés pour les valeurs non supprimées. Il faudra alors utiliser array_values par exemple si il y a besoin de réordonner les indexes.
- Si les valeurs à supprimer sont présentes plusieurs fois dans le tableau, elles seront toutes supprimées.
4. Insérer un élément dans un tableau à une position donnée
Ce cas va démontrer encore une fois qu’il ne suffit pas de connaître les définitions des fonctions afin de savoir dans quel cas les utiliser.
En effet, la fonction array_splice va à nouveau être mise à contribution.
Bien que la documentation officielle PHP, la définisse de la façon suivante :
Efface et remplace une portion de tableau
Cette fonction peut servir à bien d’autres choses :
$array = ['a', 'b', 'd', 'e'];
array_splice($array, 2, 0, 'c');
// Encore une fois le 2e argument "2" indique la position où insérer la nouvelle valeur
// Le 3e argument "0" indique le nombre d’éléments à supprimer, donc aucun
// Le dernier argument "c" est la valeur à insérer
print_r($array);L’exemple ci-dessus va afficher :
Array
(
[0] => a
[1] => b
[2] => c
[3] => d
[4] => e
)
À noter que si la position donnée (i.e. le deuxième argument) dépasse la taille du tableau, alors la valeur à insérer sera tout de même ajouter à la fin du tableau.
5. Récupérer la valeur du premier élément d’un tableau
La solution à cette problématique peut paraître simple au premier abord. Effectivement, si le tableau en question est ordonné numériquement à partir de zéro, alors l’instruction suivante suffit à récupérer la valeur du premier élément du tableau :
$array = ['a', 'b', 'c', 'd'];
$value = $array[0];Cependant, comment faire si les indexes ne commencent pas à zéro ou que le tableau comporte des clés sous forme de chaîne de caractères ?
Il est possible de récupérer le premier élément d’un tableau en utilisant ce dernier comme une file d’attente, à l’aide de la fonction array_shift :
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$value = array_shift($array);
var_dump($value);
print_r($array);L’exemple ci-dessus va afficher :
string(1) "a"
Array
(
[un] => b
[deux] => c
[trois] => d
)
Les plus attentifs auront remarqué qu’en utilisant cette fonction, le tableau d’origine se voit amputé de la première valeur qui est retournée.
Toutefois, il est souvent souhaité de ne pas altérer le tableau.
Depuis la mise à disposition de la version 7.3 de PHP, il est possible de récupérer la première clé d’un tableau grâce à la fonction array_key_first. Par conséquent, afin de récupérer la valeur du premier élément d’un tableau, il est possible de procéder comme suivant :
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$value = $array[array_key_first($array)];
var_dump($value);
print_r($array);string(1) "a"
Array
(
[zero] => a
[un] => b
[deux] => c
[trois] => d
)
Attention toutefois, si le tableau d’entrée est vide, alors la fonction array_key_first va retourner la valeur null, ce qui aura pour effet de levée une E_NOTICE si aucune vérification supplémentaire n’est faite.
Avant PHP 7.3, la technique la plus efficace pour récupérer la première valeur d’un tableau quelque soit ses clés, était d’utiliser la fonction reset :
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$value = reset($array);
var_dump($value);
print_r($array);L’exemple ci-dessus va afficher :
string(1) "a"
Array
(
[zero] => a
[un] => b
[deux] => c
[trois] => d
)
Toutefois, il y a un désavantage à utiliser cette méthode. En effet, reset va réinitialiser le pointeur interne du tableau utilisé. (Voir cet article assez ancien, mais toujours utile de Nikita Popov si vous ne savez pas comment fonctionne le pointeur interne des tableaux : https://nikic.github.io/2012/03/28/Understanding-PHPs-internal-array-implementation.html).
En général, ce fait ne pose pas de problème, mais si c’est le cas, alors il est possible de contourner le problème en appelant reset dans une fonction personnalisée :
$getFirstValue = function($arrayCopy) {
return reset($arrayCopy);
};
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$value = $getFirstValue($array);
var_dump($value);
print_r($array);L’exemple ci-dessus va produire le même résultat :
string(1) "a"
Array
(
[zero] => a
[un] => b
[deux] => c
[trois] => cd
)
Cette fois le pointeur interne du tableau n’est pas altéré. Cependant, une copie du tableau est alors créé, ce qui peut être coûteux en performance si le tableau est volumineux.
Dans ce cas, une simple boucle foreach peut alors faire l’affaire :
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
foreach ($array as $value) {
break;
}
var_dump($value);
print_r($array);string(1) "a"
Array
(
[zero] => a
[un] => b
[deux] => c
[trois] => d
)
Comme toutes les autres solutions, celle-ci a également son inconvénient. Une E_NOTICE sera levée si le tableau $array est vide.
6. Récupérer la valeur du dernier élément d’un tableau
Une fois la récupération du premier élément d’un tableau maîtrisée, il peut être utile de savoir comment récupérer la valeur du dernier élément.
De même, si le tableau est indexé numériquement, à partir de zéro et de manière consécutive, alors la solution est plutôt simple à mettre en place.
En utilisant la fonction count, il est possible de savoir le nombre d’éléments dans un tableau. Par conséquent, en soustrayant 1 à ce résultat, l’index du dernier élément est obtenu :
$array = ['a', 'b', 'c', 'd'];
$value = $array[count($array) - 1];
var_dump($value);
print_r($array);L’exemple ci-dessus va afficher :
string(1) "d"
Array
(
[0] => a
[1] => b
[2] => c
[3] => d
)
Encore une fois, cette méthode ne fonctionnera donc pas si les indexes ne commencent pas à zéro ou que le tableau comporte des clés sous forme de chaîne de caractères.
Tout comme pour récupérer le premier élément d’un tableau, il est possible de dépiler le dernier élément en utilisant ce dernier comme une pile, à l’aide de la fonction array_pop :
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$value = array_pop($array);
var_dump($value);
print_r($array);L’exemple ci-dessus va afficher :
string(1) "d"
Array
(
[zero] => a
[un] => b
[deux] => c
)
Comme pour array_shift, en utilisant cette fonction, le tableau d’origine est altérer. En effet, la valeur retournée est supprimée du tableau.
Depuis la version 7.3 de PHP, il est également possible de récupérer la dernière clé d’un tableau grâce à la fonction array_key_last. Pour récupérer la valeur du dernier élément d’un tableau, il est possible de procéder ainsi :
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$value = $array[array_key_last($array)];
var_dump($value);
print_r($array);string(1) "d"
Array
(
[zero] => a
[un] => b
[deux] => c
[trois] => d
)
Attention toutefois, si le tableau d’entrée est vide, alors la fonction array_key_last va retourner la valeur null, ce qui aura pour effet de levée une E_NOTICE si aucune vérification supplémentaire n’est faite.
Antérieurement à PHP 7.3, la technique la plus efficace pour récupérer la dernière valeur d’un tableau était d’utiliser la fonction end :
$array = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$value = end($array);
var_dump($value);
print_r($array);string(1) "d"
Array
(
[zero] => a
[un] => b
[deux] => c
[trois] => d
)
De la même manière que lors de l’utilisation de reset, la fonction end modifie la position du pointeur du tableau. Ce qui peut être un effet non désirable.
7. Tester si deux tableaux sont égaux
Pour cette problématique, il n’est pas forcément nécessaire d’avoir recours à une fonction. Les opérateurs peuvent suffire à tester l’égalité de deux tableaux.
La documentation de PHP fournit une page détaillée sur les opérateurs de tableaux.
L’opérateur égalité, noté « == », permet de tester si deux tableaux contiennent les mêmes paires clés/valeurs peut importe leur ordre et leur type :
$array1 = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$array2 = ['trois' => 'd', 'deux' => 'c', 'un' => 'b', 'zero' => 'a'];
$array3 = ['a', 'b', 'c', 'd'];
var_dump($array1 == $array2);
var_dump($array1 == $array3);
$array4 = [0, 1, 2, 3];
$array5 = ['0', '1', '2', '3'];
var_dump($array4 == $array5);L’exemple ci-dessus va afficher :
bool(true)
bool(false)
bool(true)
Ensuite, l’opérateur identique, noté « === » permet de tester si deux tableaux contiennent les mêmes paires clés/valeurs dans le même ordre et du même type :
$array1 = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$array2 = ['trois' => 'd', 'deux' => 'c', 'un' => 'b', 'zero' => 'a'];
$array3 = ['a', 'b', 'c', 'd'];
var_dump($array1 === $array2);
var_dump($array1 === $array3);
$array4 = [0, 1, 2, 3];
$array5 = ['0', '1', '2', '3'];
var_dump($array4 === $array5);
$array6 = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
var_dump($array1 === $array6);Cette fois-ci, la sortie affichera :
bool(false)
bool(false)
bool(false)
bool(true)
En revanche, si l’objectif est de tester deux tableaux uniquement sur leurs valeurs sans tenir compte des clés, la fonction array_diff peut être utilisée. En effet, cette fonction retourne les valeurs du premier tableau passé en paramètre qui ne sont pas présentes dans les tableaux suivants.
Par conséquent, si le résultat de array_diff est un tableau vide, alors cela signifie que les tableaux comparés contiennent les mêmes valeurs, peut importe leur ordre et leur clé :
$array1 = ['zero' => 'a', 'un' => 'b', 'deux' => 'c', 'trois' => 'd'];
$array2 = ['a', 'b', 'c', 'd'];
$array3 = ['b', 'a', 'd', 'c'];
$array4 = ['c', 'd', 'e', 'f'];
var_dump(empty(array_diff($array1, $array2)));
var_dump(empty(array_diff($array2, $array3)));
var_dump(empty(array_diff($array1, $array4)));L’exemple ci-dessus va afficher :
bool(true)
bool(true)
bool(false)
Conclusion
Il existe encore bien d’autres cas d’utilisations et occasions de manipuler les fonctions relatives au tableau en PHP. N’hésitez pas à partager les vôtres en commentaire 😉