Programmation PHP/Tableaux

Fonctions

Structures de contrôle

Programmation PHP

Introduction
Installer PHP
Composer
IDE
Bases du langage
Programmation avancée
Apprendre par l'exemple
- AJAX
1. Sommaire en Ajax
2. Mise à jour périodique d'un cadre
- Mini CMS
Extensions PHP
- cURL
- DOMDocument
- JSON
- MING
- SPL
Bibliothèques externes
- ADODB
- DOMPDF
- FPDF
- PHPExcel
- PHPMailer
- PHPWord
- RabbitMQ
Cadriciels
- CakePHP
- PEAR
- Symfony
- Frameworks de tests
  - PHPUnit
  - SimpleTest
  - Behat
Logiciels métier
Problèmes connus

Version imprimable

[ Modifier le sommaire ]

Fonctions

Structures de contrôle

Création de tableau

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

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

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 :

Principe

$tab[0] = 1;
$tab[99] = 3;

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

Tableaux associatifs

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

count : cette fonction renvoie le nombre d'éléments présent dans le tableau.

Principe

$tab = [1, 2, 3, 4];
print count($tab); //affiche 4

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

 $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

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

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

Comparaison

Pour comparer deux tableaux :

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

Condition

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

Fonctions d'écriture

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

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

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

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

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

Principe

$indiv[] = [
    'nom' => 'Hubert', 
    'poste' => 'Gérant', 
    'Email' => 'hubert@example.com', 
    'idBureau' => 1
];

$indiv[] = [
    'nom' => 'Jean', 
    'poste' => 'Réceptionniste', 
    'Email' => 'reception@example.com', 
    'idBureau' => 1
];

$indiv[] = [
    'nom' => 'Amélie', 
    'poste' => 'Président', 
    'Email' => 'contact@example2.com', 
    'idBureau' => 2
];

$affBureau = 1;

foreach ($indiv as $no => $data) {
    if ($data['idBureau'] == $affBureau) {
        echo $no .'-'. $data['nom'] .' <i>'. $data['poste'] .'</i> : '. $data['Email'] .'<br />';
    }
}

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

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

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

[1] ttp://php.net/manual/fr/function.array-push.php

[2] ttp://php.net/manual/fr/function.array-unshift.php

[3] ttp://php.net/manual/fr/function.array-pop.php

[4] ttp://php.net/manual/fr/function.array-shift.php

[5] ttp://php.net/manual/fr/function.array-merge.php

[6] ttp://php.net/manual/fr/function.array-map.php

[7] ttp://php.net/manual/fr/function.usort.php

[8] ttp://php.net/manual/fr/class.arrayaccess.php

[9] ttp://php.net/manual/fr/function.list.php

[10] ttp://php.net/manual/fr/function.compact.php

[11] ttp://php.net/manual/fr/function.extract.php

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]