Atelier PHP - Leçon N° 05 : Tableaux

Un tableau PHP est une variable pouvant contenir d'autres variables. C'est en fait un système d'associations ordonnées (map) qui fait correspondre des valeurs à des clés. Une clé est une valeur, unique dans une liste donnée, permettant de retrouver une valeur ou une ensemble de valeurs dans une liste (Exemple : le N° de Sécurité sosiale est une clé permettant de retrouver votre situation familliale, date et lieu de naissance...)
Comme il peut contenir des variables, c'est un aussi 'contener', qui est optimisé de façon à ce que les données qu'il contient puissent être facilement manipulées.

Un tableau à indices réels,
Une liste de correspondances (fait correspondre un élément d'une liste à un élément d'une autre liste),
Un dictionnaire,
Une collection d'éléments,
Une pile (en informatique, une pile (stack), est un ensemble de valeurs entreposées dynamiquement, et arrangées de telle sorte que l'on puisse à tout moment, extraire soit la dernière entreposée, soit la prémière entreposée et encore dans la pile)
Les données relatives à une file d'attente (même définition que pour une pile)

Comme une valeur peut elle-même être un tableau, ce système permet facilement de représenter des données sous forme d'arbres (généalogie, organigrammes...)

PHP 4 (mais pas PHP 3) inclut une structure de contrôle foreach, comme en Perl ou d'autres langages. C'est un moyen simple de passer en revue les valeurs (et éventuellement les clés) d'un tableau.
Il y a deux syntaxes possibles : la seconde est une extension mineure mais pratique de la première:

<?php
foreach(array_expression as $value) commandes
foreach(array_expression as $key => $value) commandes
?>

La première forme passe en revue le tableau array_expression. A chaque itération, la valeur de l'élément courant est assignée à $value et le pointeur interne de tableau est avancé d'un élément (ce qui fait qu'à la prochaine itération, on accédera à l'élément suivant).
La deuxième forme fait exactement la même chose, mais c'est la clé de l'élément courant qui est assigné à la variable $key. Lorsque foreach démarre, le pointeur interne de fichier est automatiquement ramené au premier élément du tableau. Cela signifie que vous n'aurez pas à faire appel à reset(); avant foreach.
Note : De plus, notez que foreach travaille sur une copie du tableau spécifié, et pas sur le tableau lui-même. Par conséquent, le pointeur de tableau n'est pas modifié, comme il le serait avec le fonction each() , et les modifications faites dans le tableau ne seront pas prises en compte dans le tableau original.
Note 1 : Le fonction each(nom_de_tableu) Retourne chaque paire clé/valeur d'un tableau.
Note 2 : foreach n'accepte pas l'opérateur de supppression des erreurs @. Vous pouvez remarquer que les exemples suivants fonctionnent de manière identique :

<?php
reset($arr);
while (list(, $value) = each ($arr))
{
echo "Valeur: $value";
}
//---------------------------------------
foreach ($arr as $value)
{
echo "Valeur: $value";
}
?>

Remarque : list(nom_de_tableau) transforme une liste de variables en tableau
Les exemples suivants sont aussi fonctionnellement identiques :

<?php
reset($arr);
while (list($key, $value) = each ($arr))
{
echo "Clé: $key; Valeur: $value \n";
}
//---------------------------------------
foreach ($arr as $key => $value)
{
echo "Clé: $key; Valeur: $value \n";
}
?>

Voici quelques exemples de plus :
---------------------------------------------------
Exemple 1: valeurs seules

<?php
$a = array (1, 2, 3, 17);
foreach ($a as $v)
{
print "Valeur courante de \$a: $v.\n";
}
?>

---------------------------------------------------
Exemple 2: valeurs (avec la clé correspondante)

<?php
$a = array (1, 2, 3, 17);
$i = 0; /* pour l'illustration uniquement */
foreach($a as $v)
{
print "\$a[$i] => $v.\n";
}
?>

---------------------------------------------------
Exemple 3: clé et valeur

<?php
$a = array ("un" => 1,"deux" => 2,"trois" => 3,"dix-sept" => 17 );
foreach($a as $k => $v)
{
print "\$a[$k] => $v.\n";
}
?>

---------------------------------------------------
Exemple 4: tableaux multi-dimensionnels

<?php
$a[0][0] = "a";
$a[0][1] = "b";
$a[1][0] = "y";
$a[1][1] = "z";
foreach($a as $v1)
{
    foreach ($v1 as $v2)
    {
        print "$v2\n";
    }
}
?>

---------------------------------------------------
Exemple 5: tableaux dynamique

<?php
foreach(array(1, 2, 3, 4, 5) as $v)
{
print "$v\n";
}
?>

On les appelle tableaux multidimensionnels par analogie avec les autres langages, en fait en php les tableaux multidimensionnels n'existent pas, par contre on a la possibilité de mettre un tableau dans une cellule d'un tableau, ce qui est un concept assez fondamentalement différent. ceci provoque une bien meilleure souplesse et une meilleure utilisation de la mémoire:
Soit le tableau suivant :

$events = array("1914"=> array 
    ("Juin" => array ("23" => "Innauguration canal de Kiev par Hitler",
	                  "28" => "Archiduc Ferdinand  assassiné à Sarajevo" )
   , "July" => array ("26" => "Mobilisation en Autriche",
                      "28" => "L'Autriche déclare la guerre à la Serbie" ))
, "1918" => array 
   ( "November" => array ("11" => "Armistice signée ",
              			  "16" => "retrait des troupes allemandes"))) ;

Si l'on utilisait les tableaux multidimensionnels "standards", pour réaliser un tableau de dates comme ci-dessus, il faudrait un tableau tridimentionnel de dimensions:
nombre d'années x nombre de mois x nombre de jours
ce qui provoquerait (suivant les langages) une immobilisation mémoire importante, alors qu'ici il n'y a jamais de place perdue

*	Fonction	Description
	array_change_key_case	Retourne un tableau dont toutes les clés ont été forcées en majuscules ou minuscules.
	array_chunk	Sépare un tableau en tableaux de taille inférieure
	array_count_values	Compte le nombre de valeurs dans un tableau
	array_diff	Calcule la différence entre deux tableaux
x	array_fill	Remplit un tableau avec une même valeur (PHP 5)
	array_filter	Filtre les éléments d'un tableau
	array_flip	Remplace les clés par les valeurs, et les valeurs par les clés
	array_intersect	Calcule l'intersection de tableaux
	array_key_exists	Cherche si une valeur ou une clé existe dans le tableau
	array_keys	Retourne toutes les clés d'un tableau
	array_map	Applique une fonction sur des tableaux
	array_merge_recursive	Combine plusieurs tableaux ensembles, récursivement
	array_merge	Rassemble plusieurs tableaux dans un autre tableau
x	array_multisort	Tri multi-dimensionnel
x	array_pad	Complète un tableau jusqu'à la longueur spécifiée, avec une valeur.
	array_pop	Dépile un élément de la fin d'un tableau
x	array_push	Empile un ou plusieurs éléments à la fin d'un tableau
	array_rand	Prend une ou plusieurs valeurs, au hasard dans un tableau
	array_reduce	Réduit itérativement un tableau
	array_reverse	Renverse l'ordre des éléments d'un tableau
	array_search	Recherche dans un tableau la clé associée à une valeur
x	array_shift	Dépile (enlève) un ou plusieurs élément au début d'un tableau
	array_slice	Extrait une portion de tableau
	array_splice	Efface et remplace une portion de tableau
	array_sum	Calcule la somme des valeurs du tableau
	array_unique	Dédoublonne un tableau
x	array_unshift	Empile (rajoute) un ou plusieurs éléments au début d'un tableau
	array_values	Retourne les valeurs d'un tableau réindexées avec des entiers
x	array_walk	Exécute une fonction sur chacun des membres d'un tableau.
x	array	Crée un tableau
x	arsort	Trie un tableau en ordre inverse
x	asort	Trie un tableau en ordre
x	compact	Crée un tableau contenant les variables et leur valeur
	count	Compte le nombre d'éléments d'un tableau
x	current	Transforme une variable en tableau
	each	Retourne chaque paire clé/valeur d'un tableau
	end	Positionne le pointeur de tableau en fin de tableau
	extract	Importe les variables dans la table des symboles
	in_array	Indique si une valeur appartient à un tableau
	key	Retourne une clé d'un tableau associatif
x	krsort	Trie un tableau en sens inverse et suivant les clés
x	ksort	Trie un tableau suivant les clés
x	list	Transforme une liste de variables en tableau
x	natcasesort	Tri d'un tableau avec l'algorithme à "ordre naturel" insensible à la casse
x	natsort	Tri d'un tableau avec l'algorithme à "ordre naturel"
	next	Avance le pointeur interne d'un tableau
	pos	Retourne l'élément courant d'un tableau
	prev	Recule le pointeur courant de tableau
x	range	Crée un tableau contenant un intervalle d'éléments
	reset	Remet le pointeur interne de tableau au début
x	rsort	Trie en ordre inverse
x	shuffle	Mélange les éléments d'un tableau
	sizeof	Retourne le nombre d'élément d'un tableau
x	sort	Trie le tableau
x	uasort	Trie d'un tableau en utilisant une fonction de comparaison définie par l'utilisateur.
x	uksort	Trie un tableau par ses clés en utilisant une fonction de comparaison définie par l'utilisateur
x	usort	Trie un tableau en utilisant une fonction de comparaison définie par l'utilisateur
	is_array()	Pour savoir si une variable est un tableau
x	explode()	array explode ( string separator, string string [, int limit]) Retourne un tableau qui contient les éléments d'une chaîne contenant des délimiteurs
x	implode()	string implode ( string glue, array pieces) Retourne une chaîne constituée de tous les éléments du tableau, pris dans l'ordre, transformés en chaîne, et séparés par le séparateur
x	split()	array split ( string pattern, string string [, int limit]) Scinde une chaîne en un tableau, grâce à une expression régulière.
x	join()	string join ( string glue, array pieces) Regroupe tous les éléments d'un tableau dans une chaîne, avec une chaîne de jointure.

Autres exemples :
Un grand nombre de fonctions sont disponibles pour faire des opérations sur des tableaux :
Par exemple,

la fonction array_flip() pour intervertir les clés et les valeurs

<?php
$music = array("Classique" => "Chopin",
"Variétés" => "Dalida",
"Jazz" =>"Armstrong");
// On inverse les cléfs etles valeurs
$flippedArray = array_flip($music);
?>
La fonction array_flip en action
Nom du fichier : exercises_05\lesson_05_h_array_flip.php
La fonction array_merge() combine plusieurs tableaux en un seul

<?php
$politiques = array("France_president" => "Chirac",
"UK_premier_ministre" => "Blair",
"Espagne_roi_" =>"Carlos");
$sportifs = array("Velo" => "Amstrong",
"Foot" => "Cantona");
// On réunit les deux tableaux
$célébrités = array_merge($politiques, $sportifs);
?>
La fonction array_merge en action
Nom du fichier : exercises_05\lesson_05_i_array_merge.php
La fonction array_diff() accepte 2 ou plus tableaux comme arguments, et renvoie un tableau contenant toutes les valeurs du premier tableau qui ne sont pas dans les autres

<?php
// creation des tableaux
$tableau_1 = array(8, 12, 21, 28);
$tableau_2 = array(1, 4, 7, 8, 15, 67, 29, 22);
$tableau_3 = array(1, 4, 7, 8, 15, 67, 29, 28);
$tableau_diff = array_diff($tableau_1, $tableau_2, $tableau_3);
// renvoie ("12", "21")
?>
La fonction array_diff en action
Nom du fichier : exercises_05\lesson_05_k_array_diff.php
La fonction array_intersect() renvoie les valeurs qui sont présentes à la fois dans tous les tableaux passés en argument.

<?php
$tableau_1 = array(71, 14, 21, 28, 45, 78, 89, 56);
$tableau_2 = array(17, 14, 21, 28, 23, 56, 45, 78, 94);
$tableau_3 = array(17, 14, 26, 28, 23, 56, 45, 78, 94);
$intersection = array_intersect($tableau_1, $tableau_2, $tableau_3);
// renvoie ("14,28,45,78,56")
?>
La fonction array_intersect en action
Nom du fichier : exercises_05\lesson_05_m_array_intersect.php
La fonction array_sum() ajoute les éléments d'un tableau et renvoie la somme

<?php
$tableau_1 = array(71, 14, 21, 28, 45, 78, 89, 56.75);
$maSomme = array_sum($tableau_1);
// returns 402,75
?>

La fonction array_sum en action

Nom du fichier : exercises_05\lesson_05_n_array_sum.php

La fonction array_count_values() calcule le nombre de fois où chaque valeur apparaît

<?php
$cars_rented = array("Clio", "Twingo", "Laguna", "Laguna", "Clio", "Laguna", "Velsatis");
$cars_rented_count = array_count_values($cars_rented);
?>
La fonction array_count_values en action
Nom du fichier : exercises_05\lesson_05_o_array_count_values.php
La fonction array_rand() renvoie une ou plusieurs clés au hasard

<?php
$fruits = array("pomme", "poire", "pêche", "abricot", "fraise", "cassis","melon");
$troisFruits = array_rand($fruits, 3);
//renvoie trois fruits au hasard
?>
La fonction array_rand en action
Nom du fichier : exercises_05\lesson_05_p_array_rand.php
Et finalement la fonction très utile qui permet d'exécuter une fonction construite par soi-même sur chaque élément du tableau. L'exemple suivant permet d'appliquer un format spécifique à chaque élément du tableau :

<?php
$mesChiffres = array(1, 567, 1.6777777777777, 0.031, 100.1, -98.6);
$mesChiffresFormattés = array();
// Fonction pour formatter les nombres
function format($num)
{
global $mesChiffresFormattés ;
$mesChiffresFormattés[] = sprintf("%1.2f", $num);
}
//éxécute la function format() sur chaque élément du tableau
array_walk($mesChiffres, "format");
//le tableau $mesChiffresFormattés va contenir ("1.00", "567.00", "1.68", "0.03", "100.10","-98.60")
?>
La fonction array_walk en action
Nom du fichier : exercises_05\lesson_05_q_array_walk.php

Leçon N° 05 : Tableaux

Introduction

Initialisation des tableaux

La boucle foreach

Tableaux multidimensionnels

Tableaux dans les chaines de caractères

Fonctions spécifiques utilisables avec les tableaux