Programmation PHP/Tableaux

Un livre de Wikilivres.

Création de tableau[modifier | modifier le wikicode]

Un tableau (en anglais array) est une collection d'objet. En PHP, ces objets n'ont pas forcément le même type (cohabitation entre des entiers, des chaines…). Chaque objet est identifié par une clé appelée indice, que l'on met entre crochets (ex : $tableau[indice]).

Il existe trois manières de déclarer un tableau vide :

 $tab = [];       // depuis PHP 5.4
 $tab = {};       // moins permissif aux concaténations
 $tab = array();  // déconseillé depuis PHP 7

Pour créer un tableau non vide :

$t1 = array('champ1', 'champ2');

$t2 = ['champ1', 'champ2'];

$t3[0] = 'champ1';
$t3[1] = 'champ2';

// Affiche les trois mêmes tableaux : Array ( [0] => champ1 [1] => champ2 )
var_dump($t1);
var_dump($t2);
var_dump($t3);

Logo

print ne fonctionne pas pour les tableaux, il faut utiliser var_dump ou print_r. Par ailleurs, pour récupérer la chaine affichée par ces fonctions, utiliser print_r(MonTableau1, true).

Autres exemples :

 $tab[0] = 1;  // entier
 $tab[1] = 2.0; // flottant
 array_push($tab,'Ligne 3');
 $tab[] = 'Ligne 4';
 var_dump($tab);

Il en est de même pour les tableaux à deux dimensions.

 $tab = [];
 $tab[0][0] = '0-0';
 $tab[0][1] = '0-1';
 $tab[1][0] = '1-0';
 $tab[1][1] = '1-1';
 var_dump($tab);

On distingue deux types de tableau :

  • Le tableau standard, dont la clé est son indice (le numéro de ligne en partant de zéro). Pratique pour être parcouru par une variable compteur, ou pour être rempli dans un certain ordre.
  • Le tableau associatif, auquel on accède par le nom d'une clé en chaine de caractères.


Tableau itératifs[modifier | modifier le wikicode]

Les clés du tableaux sont des nombres. Ils ont l'avantage de pouvoir être parcourus par un compteur.

Exemple
$tab = ['val1', 'val2', 'val3'];    // $tab[0] vaut val1 /-/ $tab[1] vaut val2 /-/ etc.

for($i = 0; $i<2; $i++)
  echo $tab[$i];


Ce code affichera : val1val2.

En PHP, on peut aussi directement affecter des indices du tableau, comme suit :

Début d’un principe
Fin du principe


Notez que les indices ne sont pas typés (on pourra indifféremment utiliser $tab[1] et $tab['1']).


Tableaux associatifs[modifier | modifier le wikicode]

Ils fonctionnent de la même manière que les tableaux itératifs, sauf que l'utilisateur en choisit la clé. À chaque clé correspond une valeur (injection).

Voici un exemple de déclaration :

Exemple
$tab = ['cle1' => 'val1', 'cle2' => 'val2', 'cle3' => 'val3'];
 
print $tab['cle2'];   //affichera : val2

//parcours du tableau en boucle
foreach ($tab as $key => $value)
    print $key." : ".$value.". ";

Résultat : cle1 : val1. cle2 : val2. cle3 : val3.

Pour ne garder que les valeurs on peut utiliser implode(), qui convertit un tableau en chaine avec séparateur :

 print implode(". ", $tab).". ";

Résultat : val1. val2. val3.

Fonctions de lecture[modifier | modifier le wikicode]

  • count : cette fonction renvoie le nombre d'éléments présent dans le tableau.
Début d’un principe
Fin du principe


  • key : clé de l'élément courant du tableau, celui vers lequel le pointeur fait référence.
  • current : valeur de l'élément courant.
  • reset : valeur du premier élément.
  • end : valeur du dernier élément.
  • each : valeur de l'élément courant, et avance le pointeur au suivant.
  • prev : valeur de l'élément précédent.
  • next : valeur de l'élément suivant.
  • array_values($tab) : renvoie un tableau contenant toutes les valeurs du tableau en paramètre. S'utilise pour reconstruire des clés consécutives sans changer les valeurs.
  • array_keys($botteDeFoin, $aiguille) : renvoie un tableau contenant toutes les clés du tableau en paramètre. De plus, si une valeur est définie en paramètre deux, le résultat ne contient que les clés associées à celle-ci.
  • array_key_exists($cle, $tab) : renvoie "vrai" si la clé est dans le tableau.
  • array_key_first($tab) : renvoie la première clé d'un tableau.
  • array_key_last($tab) : renvoie la dernière clé d'un tableau.
  • array_diff($t1, $t2) : renvoie le tableau des différences entre ceux en paramètres (peut servir pour supprimer par valeur).
  • array_sum($tab) : renvoie la somme des valeurs du tableau.
  • array_intersect($t1, $t2) : intersection entre plusieurs tableaux.

Exemple[modifier | modifier le wikicode]

 $tab = ["mixte valeur<sub>1</sub>","mixte valeur<sub>2</sub>","...","mixte valeur<sub>n</sub>"];
 echo key($tab);
 echo ' : ';
 echo current($tab);

Affiche 0 : mixte valeur1

Les fonctions key() et current() peuvent accéder aux autres éléments du tableau après each() ou next().

Il existe aussi différentes méthodes liées aux tableaux, des méthodes de tri, de recherche, de concaténation de tableaux, des méthodes d'ajouts et de suppressions d'éléments, etc.

Recherches[modifier | modifier le wikicode]

  • in_array($aiguille, $botteDeFoin) : recherche de présence par valeur. Renvoie un booléen si l'élément est trouvé.
  • array_search($aiguille, $botteDeFoin) : recherche de position par valeur. Renvoie la clé de l'élément trouvé, ou false sinon.
  • array_keys($botteDeFoin, $aiguille) : recherche par clé (déjà décrit au paragraphe précédent).

Logo

php -r "var_dump(in_array(0, ['test']));" = true

Comparaison[modifier | modifier le wikicode]

Pour comparer deux tableaux :

$a1 == $a2;  // compare le contenu et la taille
$a1 === $a2; // compare le contenu, la taille et l'index

Condition[modifier | modifier le wikicode]

Un tableau vide dans une condition vaudra "faux", alors qu'un non vide vaudra "true".

Fonctions d'écriture[modifier | modifier le wikicode]

Pour manipuler des tableaux il est indispensable de connaitre les fonctions suivantes :

  • str_split($string) : convertit une chaine de caractères en tableau itératif, chaque ligne étant composée d'un caractère.
  • mb_str_split($string) : idem mais en caractères multi-octets.
  • explode($separateur, $tableau) : convertit une chaine de caractères en tableau itératif, donc le contenu correspond aux sous-chaines situées autour d'un séparateur donné.
  • implode($separateur, $tableau) : convertit un tableau en chaine de caractères. Le séparateur à placer dans la chaine est facultatif.
  • sizeof($tableau) : renvoie la taille du tableau (le nombre d'objets qu'il contient). Attention : avant PHP 7.2 cette fonction pouvait aussi remplacer strlen().
  • array_push($monTableau, $valeur) : ajoute une ligne à la fin du tableau, équivaut à $monTableau[][1] (empile).
  • array_unshift($monTableau, $valeur) : ajoute une ligne au début du tableau[2].
  • array_pop($monTableau) : retire la dernière ligne du tableau, en la renvoyant[3] (dépile).
  • array_shift($monTableau) : retire la première ligne du tableau, en la renvoyant[4].
  • array_merge($monTableau1, $monTableau2, $monTableau3...) : fusionne plusieurs tableaux[5].
  • array_merge_recursive() : idem en multidimensionnel.
  • array_replace($monTableau1, $monTableau2, $monTableau3...) : fusionne plusieurs tableaux en replaçant les clés existantes du premier par celles des autres. Cela permet par exemple de fusionner deux tableaux en préservant leurs clés.
  • array_replace_recursive() : idem en multidimensionnel.
  • array_unique($tableau) : filtre les valeurs en doublon (quelles que soient leurs clés).
  • array_filter($tableau, fonction) : filtre les lignes selon une fonction exécutée sur chaque élément. Pour injecter des variables dans la fonction, utiliser "use" (ex : array_filter($tableau, function($ligne) use($variable1){...).
  • array_column($tableau, colonne) : filtre par colonne. Renvoie uniquement les valeurs d'un champ donné pour chaque élément.
  • array_reduce($tableau, fonction) : transforme le tableau selon une fonction exécutée sur chaque élément.
  • array_map(fonction, $tableau) exécute une fonction sur chaque valeur du tableau[6]. Exemples :
    • Pour trimer chaque ligne d'un tableau : array_map('trim', $tableau)
    • Pour créer un tableau de tableau :
      array_map(function($ligne) {
          return explode('=', $ligne);
      }
      , $tableau)
      
  • array_walk($tableau, fonction) : exécute une fonction sur chaque élément (clé ou valeur).
  • array_chunk($tableau, $taille) : découpe le tableau fourni en tableaux de la taille fournie.
  • array_slice($tableau, $début, $taille) : renvoie la partie du tableau à partir de l'élément dont le numéro est le premier paramètre, de la taille en paramètre deux.
  • array_flip($tableau) : inverse les clés et valeurs. Attention : un tableau ne peut avoir que des types primitifs en clé, pas des objets (sinon c'est l'erreur Illegal offset type).
  • unset($tableau[$index]) : supprimer la ligne.
Exemple
$chaine = 'MonFichier.2016.txt';
$tab = explode('.', $chaine);    // au niveau des points, on explose la chaine (en trois)
var_dump($tab);                  /* affiche : 
  array(3) {
   [0]=> string(10) "MonFichier"
   [1]=> string(4) "2016"
   [2]=> string(3) "txt"
 }
*/

echo $tab[0]; // affiche : MonFichier
echo 'L\'extension du fichier est : '.$tab[sizeof($tab)-1]; // affiche : L'extension du fichier est : txt


Logo

Comme le premier indice du tableau est zéro, le dernier est égal à sa taille moins un.


Joindre les éléments "id" d'un tableau de tableaux
echo implode(', ', array_map(function ($ligne) {
  return $ligne['id'];
}, $tableau));


Tris[modifier | modifier le wikicode]

  • array_multisort($tableau, SORT_ASC) permet de trier un tableau dans l'ordre croissant de ses valeurs.
  • sort($tableau) : trie le tableau par valeurs croissantes, en recréant des clés numériques.
  • asort($tableau) : trie le tableau par valeurs croissantes, en conservant les clés associées.
  • arsort, fonction) : trie le tableau par valeurs décroissantes, en conservant les clés associées.
  • ksort($tableau) : trie par clés croissantes par défaut.
  • krsort($tableau) : trie par clés décroissantes par défaut.
  • usort($tableau, fonction) : trie selon une fonction donnée[7].
 Les tris croissants définis par défaut sont modifiables par des flags en deuxième paramètre.
Exemple
$array = array("name"=>"Toyota", "type"=>"Celica", "colour"=>"black", "manufactured"=>"1991");

array_multisort($array, SORT_ASC);
var_dump($array);
// array(4) { ["manufactured"]=> string(4) "1991" ["type"]=> string(6) "Celica" ["name"]=> string(6) "Toyota" ["colour"]=> string(5) "black" }
// On remarque que les majuscules sont avant les minuscules.

arsort($array);
var_dump($array);
// array(4) { ["colour"]=> string(5) "black" ["name"]=> string(6) "Toyota" ["type"]=> string(6) "Celica" ["manufactured"]=> string(4) "1991" }

asort($array);
var_dump($array);
// array(4) { ["manufactured"]=> string(4) "1991" ["type"]=> string(6) "Celica" ["name"]=> string(6) "Toyota" ["colour"]=> string(5) "black" }

sort($array);
var_dump($array);
// array(4) { [0]=> string(4) "1991" [1]=> string(6) "Celica" [2]=> string(6) "Toyota" [3]=> string(5) "black" }

ksort($array);
var_dump($array);
// array(4) { ["colour"]=> string(5) "black" ["manufactured"]=> string(4) "1991" ["name"]=> string(6) "Toyota" ["type"]=> string(6) "Celica" }


Logo

Pour trier de l'Unicode il faut utiliser le flag "SORT_LOCALE_STRING".

Exemple :

$array = ['à', 'i', 'o', 'u', 'é'];
sort($array);
print_r($array);

setlocale(LC_COLLATE, 'fr'); // parfois 'fr_FR.UTF-8'
sort($array, SORT_LOCALE_STRING);
print_r($array);

donne :

Array
(
   [0] => i
   [1] => o
   [2] => u
   [3] => à
   [4] => é
)
Array
(
   [0] => à
   [1] => é
   [2] => i
   [3] => o
   [4] => u
)

Tableaux multi-dimensionnels[modifier | modifier le wikicode]

La clé d’un tableau peut pointer sur un second tableau créant ainsi un tableau multi-dimensionnel.

Début d’un principe
Fin du principe


Résultat :

0-Hubert Gérant : hubert@example.com
1-Jean Réceptionniste : reception@example.com
NB : Dans cet exemple, une base de données serait sûrement plus adéquate.

ArrayAccess[modifier | modifier le wikicode]

Cette classe native permet de redéfinir l'opérateur d'index ([]) dans les objets qui en héritent. Par exemple, pour lui faire accepter un autre tableau ou NULL comme index, ou déclencher un évènement quand on le modifie[8].

Destructuration[modifier | modifier le wikicode]

PHP ne gère pas la destructuration avec l'opérateur égal comme le fait JavaScript ou Python (ex : x, y = getXY()). À la place, il propose plusieurs fonctions :

  • list($x, $y) : traite les variables en paramètre comme un tableau[9]. Ex : list($x, $y) = getArrayWithTwoLines();
  • compact($x, $y) : crée un tableau avec les noms des variables en paramètre comme clés, et leurs valeurs comme valeurs[10].
  • extract($tableau) : déclare et assigne une variable pour chaque ligne du tableau en paramètre, de nom la clé de la ligne, et de valeur la valeur de la ligne[11] (contraire de compact()).

Références[modifier | modifier le wikicode]