Les tableaux

Autres fonctions :

array_diff : Permet de soustraire un tableau à un autre
array_intersect : Permet de retrouver les éléments communs à 2 tableaux

Un tableau est simplement un ensemble de variables stockées dans une "super variable", numérotée de 0 à X

Exemple simple

$Fruit[] = "Abricot";
$Fruit[] = "Banane";
echo $Fruit[0]; // Affiche Abricot
echo $Fruit[1]; // Affiche Banane

• Constatons que même si les chaînes de caractères n'ont pas le même nombre de lettres, le tableau fonctionne tout à fait correctement
• Le premier élément d'un tableau est 0 et pas 1

ATTENTION :
echo $Fruit;
afficherait
array

echo $Fruit[];
Renverrait carrément une erreur.

On aurait pu tout aussi bien écrire :

$Fruit[0] = "Abricot";
$Fruit[1] = "Banane";
echo $Fruit[0]; // Affiche Abricot
echo $Fruit[1]; // Affiche Banane

Il peut même y avoir des "trous" :

$Fruit[0] = "Abricot";
$Fruit[2] = "Cacahuète";
echo $Fruit[0]; // Affiche Abricot
echo $Fruit[1]; // N'affiche rien, même pas un espace
echo $Fruit[2]; // Affiche Cacahuète

On peut mélanger des chiffres et des lettres sans problème :

$Fruit[0] = "Abricot";
$Fruit[1] = 33;

On peut avoir des tableaux très volumineux :

$Fruit[999999] = "Abricot";

remplir plusieurs éléments de tableau avec la fonction array()

Pour remplir plusieurs éléments de tableau d'un seul coup :

$Fruit = array("Abricot","Banane","Cacahuète","Pomme");
echo $Fruit[1]; // Affiche Banane

Affichage d'un tableau de manière lisible : print_r

Une fonction bien sympathique pour les phases de test : Ne pas se prendre la tête avec le contenu des tableaux :

$input = array("Tagada" ,999, "Ah ahhh", "", $Rien);
$input[222] = "OK!";
$input[] = 4000;
$input[89] = "Dernière minute";
print_r($input);

va afficher exactement la ligne suivante :

Array ( [0] => Tagada [1] => 999 [2] => Ah ahhh [3] => [4] => [222] => OK! [223] => 4000 [89] => Dernière minute )

Supprimer les doublons d'un tableau

PHP regorge de fonctions bien utiles : Une élimination directe de doublons avec array_unique

           N°:  0 1 2 3 4 5 6 7 8 9
$input = array (1,1,1,1,2,4,5,5,3,2);
$result = array_unique ($input);
print_r($result);

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

Il reconnait même les différents types :

$input = array (100,"100",666);
$result = array_unique ($input);
print_r($result);

Donne :

Array ( [0] => 100 [2] => 666 )

Connaître le nombre d'éléments d'un tableau : sizeof

$Fruit[0] = "Abricot";
$Fruit[6] = "";
$Fruit[267] = 0;
echo sizeof($Fruit);

Donne 3

Forcer un tableau à commencer à 1 avec le signe =>

Il n'est pas toujours pratique d'avoir des tableaux qui commencent à 0. Pour le forcer à commencer à 1, on procède ainsi :

$Fruit = array(1 =>"Abricot","Banane","Cacahuète","Pomme");
echo $Fruit[1]; // Affiche Abricot

Evidemment, on peut le faire commencer à ce qu'on veut :

$Fruit = array(8 =>"Abricot","Banane","Cacahuète","Pomme");
echo $Fruit[10]; // Affiche Cacahuète

On peut ainsi avoir des initialisations des plus exotiques :

$Fruit = array("Abricot",7=>"Banane","Cacahuète",88=>"Pomme");
echo "0 : $Fruit[0] <BR>";
echo "1 : $Fruit[1] <BR>";
echo "7 : $Fruit[7] <BR>";
echo "8 : $Fruit[8] <BR>";
echo "88 : $Fruit[88] ";

Affiche :

0 : abricot
1 :
7 : Banane
8 : Cacahuète
88 : Pomme

Assignation de noms à la place d'index

Première façon d'écrire :

$BonFruit = array(   
                     'couleur' => 'rouge'
                   , 'gout'    => 'sucre'
                   , 'forme'   => 'rond'
                   , 'nom'     => 'pomme'
                   , 'juteux' // l'index est 0
                  );
echo $BonFruit['gout'];
echo BonFruit [0] // juteux

Affiche sucre

Deuxième façon d'écrire la même chose ():

$BonFruit['couleur'] = 'rouge';
$BonFruit['gout'] = 'sucre';
$BonFruit['forme'] = 'rond';
$BonFruit['nom'] = 'pomme';
$BonFruit[] = 'juteux'; // cette clé sera 0
echo $BonFruit['forme'];
echo $BonFruit[0]; // juteux
echo $BonFruit[1]; // renvoie une erreur

déplacer un pointeur tout au long d'un tableau avec each

$Fruit = array("Abricot","Banane",56=>"Cacahuète","Fraise");
$Caisse = each($Fruit); // se positionne sur le 1er élément : abricot
echo "Caisse0: $Caisse[0] <BR>"; // 0
echo "Caisse1: $Caisse[1] <BR>"; // Abricot
$Caisse = each($Fruit); // avance d'un élément : Banane
echo "Caisse0: $Caisse[0] <BR>"; // 1
echo "Caisse1: $Caisse[1] <BR>"; // banane
$Caisse = each($Fruit); // avance d'un élément : Cacahuète
echo "Caisse0: $Caisse[0] <BR>"; // 56
echo "Caisse1: $Caisse[1] <BR>"; // Cacahuète
$Caisse = each($Fruit); // avance d'un élément : Fraise
echo "Caisse0: $Caisse[0] <BR>"; // 57
echo "Caisse1: $Caisse[1] <BR>"; // Fraise
$Caisse = each($Fruit); // avance d'un élément, et donc pointe sur plus rien
echo "Caisse0: $Caisse[0] <BR>"; // rien du tout
echo "Caisse1: $Caisse[1] <BR>"; // rien du tout

• Il serait idiot de demander l'affichage simplement de $Caisse sans préciser si c'est l'élément 0 ou 1, il afficherait simplemant array

Affiche :

Caisse0: 0
Caisse1: abricots
Caisse0: 1
Caisse1: Banane
Caisse0: 56
Caisse1: Cacahuète
Caisse0: 57
Caisse1: Fraise
Caisse0:
Caisse1:

Autre méthode, plus simple (PHP4 seulement) : foreach

foreach($Fruit as $Tagada)
  {
  echo "$Tagada<br>";
  }

placer les éléments d'un tableau dans des variables avec list

list permet de placer les éléments d'un tableau dans des variables distinctes :

$Fruit = array("Abricot","Banane", 39=>"Cacahuète");
list($Un, $Deux, $Trois) = $Fruit;
echo "$Un <BR>"; // Abricot
echo "$Deux <BR>"; // Banane
echo "$Trois <BR>"; // Rien, car le 3 est vide, et c'est le 39 qui contient Cacahuète

J'aurais pensé que l'inverse :
$Un = "Table";
$Deux = "Chaise";
$Trois = "Armoire";
$Fruit = array(); // que cette ligne existe ou pas, l'erreur persiste
$Fruit = list($Un,$Deux,$Trois);
aurait fonctionné, mais apparemment pas.

Parcourir tous les éléments d'un tableau dont on ignore la taille

Grâce à l'utilisation combinée de each et list, nous allons pouvoir afficher tous les éléments d'un tableau dont la taille est inconnue. Par exemple, un tableau qui se serait rempli avec le contenu d'un fichier. Dans notre exemple, nous allons remplir d'abord le tableau à la main, mais le principe est le même.

Comme nous l'avons vu avec l'exemple de each, ce pointeur avance chaque fois d'un élément chaque fois qu'on l'appelle. Il s'agit donc de tester si l'élément courant ne seraitt pas par hasard vide, auquel cas on est à la fin du tableau et on peut donc s'arrêter. Quoi de plus naturel que d'utiliser while dans ce cas ?

Nous allons la jouer fine : nous savons que list permet de répartir dans des variables distinctes le contenu d'un tableau d'un seul coup, donc :

$Fruit = array("Abricot","Banane", 39=>"Cacahuète");
list($LeNumero,$LeFruit) = each($Fruit)

Stockerait 0 (le premier index) dans $LeNumero, et Abricot dans $LeFruit.

mais donc, on ne sait toujours pas combien de fois on doit écrire la ligne

list($LeNumero,$LeFruit) = each($Fruit)

Voici que notre fameux while entre en scène. On pourrait écrire :

while(each($Fruit) <> "")
  {
  echo "OK <BR>"
  }

Ca marche : a chaque tour de boucle, la fonction each avance d'un élément dans le tableau. Mais y'a un problème : dans cet exemple, on se contente d'afficher OK : Moi, je voudrais afficher le nom de chaque fruit... On pourrait dans la boucle incrémenter un compteur, comme ceci :

$Fruit = array("Abricot","Banane", 39=>"Cacahuète", "Fraise");
$Compteur = 0;
while(each($Fruit) <> "")
  {
  echo "$Fruit[$Compteur] <BR>";
  $Compteur ++;
  }

C'est parfait. Le seul petit problème est qu'un moment, l'indice saute directement à 39, ce qui fait que quand on arrive au 3ème élément, $Fruit[2] est bien = à "" (Vide), et donc la boucle s'arrête.

Une solution plus élégante consiste à chaque passage du While, copier les 2 données de chaque élément (l'index et le nom du fruit) dans 2 variables distinctes pour pouvoir les réafficher (oui, parce qu'on ne peut pas faire un 2ème appel à each sans que l'on passe à l'élément suivant), vous allez comprendre :

$Fruit = array("Abricot","Banane", 39=>"Cacahuète", "Fraise");
while((list($LeNumero,$LeFruit) = each($Fruit)) <> "")
  {
  echo "$LeNumero : $LeFruit<br>";
  }

L'astuce consiste à d'une même volée assigner each($Fruit)dans list($LeNumero,$LeFruit) - Je rappelle que = est un opérateur d'affectation, et pas de comparasion. L'opérateur de comparaison serait ==. Et donc, cette affectation list($LeNumero,$LeFruit) = each($Fruit)est immédiatement comparée à vide (<> "") .

Si ce n'est pas égal à vide, on peut alors récupérer les 2 variables $LeNumero et $LeFruit sans avoir besoin de relire le tableau avec each, qui nous aurait propulsé à l'élément suivant. Ainsi, nous allons parcourir le tableau, élément par élément, et, contrairement au compteur qui s'arrête au premier trou, each, lui, passe sans problème du numéro 1 à 39, ce qui donne le résultat suivant :

0 : abricot
1 : Banane
39 : Cacahuète
40 : Fraise

Et pour terminer, comble du raffinement, nous savons que While (1) est une expression correcte qui veut dire "OK, on continue". 0 ou vide arrête la boucle. Ainsi, il n'est pas nécessaire de dire :

while((list($LeNumero,$LeFruit) = each($Fruit)) <> "")

Mais la simple ligne :

while (list($LeNumero,$LeFruit) = each($Fruit))

Suffit : En effet, dès qu'on affecte "" (rien) à list($LeNumero,$LeFruit), le while est forcément faux, et la boucle s'arrête. Le code final est donc celui-ci :

$Fruit = array("Abricot","Banane", 39=>"Cacahuète", "Fraise");
while (list($LeNumero,$LeFruit) = each($Fruit))
  {
  echo "$LeNumero : $LeFruit<br>";
  }

Qui donne toujours :

0 : abricot
1 : Banane
39 : Cacahuète
40 : Fraise

Remise à 0 du pointeur avec reset ()

$Fruit = array("Ananas", "Banane", "Cacahuète", "Pomme");
$Repas = each ($Fruit);
$Repas = each ($Fruit);
$Repas = each ($Fruit);
echo $Repas[1]; // Cacahuète
echo reset($Fruit); // Ananas

Affichage de l'élément actuel avec pos ($NomTableau)

$Fruit = array("Ananas", "Banane", "Cacahuète", "Pomme");
$Repas = each ($Fruit);
$Repas = each ($Fruit);
$Repas = each ($Fruit);
echo pos($Repas); // Cacahuète

Normalement, la fonction corrélative key devrait renvoyer le numéro d'index de cacahuète (2), mais il me renvoie 1, j'ai pas compris pourquoi...

echo key($Repas);

Pour avancer ou reculer d'un élément : next - prev

Je trouve cette fonction plus pratique que each. Démonstration :

$Fruit = array("Ananas", "Banane", "Cacahuète", "Pomme");
$Repas = reset ($Fruit); ' On pointe sur le premier élément
echo $Repas; // Ananas
$Repas = next ($Fruit); ' On arrive sur le 2ème élément
echo $Repas; // Banane

Contrairement à each qui nécessitait le transfert des deux choses dans un autre tableau (l'indice et l'élément), comme ceci :

$Fruit = array("Abricot","Banane",56=>"Cacahuète","Fraise");
$Caisse = each($Fruit); // se positionne sur le 1er élément : abricot
echo "Caisse0: $Caisse[0] <BR>"; // 0
echo "Caisse1: $Caisse[1] <BR>"; // Abricot

next, quant à lui est nettement plus simple, puisqu'il transfère le simple contenu dans une simple variable scalaire, comme reset d'ailleurs, comme ceci :

$Fruit = array("Ananas", "Banane", "Cacahuète", "Pomme");
$Repas = reset ($Fruit);
echo $Repas; // Ananas
$Repas = next ($Fruit);
echo $Repas; // Banane

La fonction corrélative prev fonctionne exactement comme next. Si on est sur le premier élément et qu'on essaie encore de reculer, aucune erreur ne sera générée, mais le contenu sera vide.

Aller au premier enregistrement avec reset

$Fruit = array("Ananas", "Banane", "Cacahuète", "Pomme");
$Repas = reset ($Fruit);
echo $Repas; // Pomme

Aller au dernier enregistrement avec end

$Fruit = array("Ananas", "Banane", "Cacahuète", "Pomme");
$Repas = end ($Fruit);
echo $Repas; // Pomme

Convertir une chaîne de texte en éléments de tableau avec explode

Soit la chaîne de caractères "Un;Deux;Trois", il s'agit de la splitter en 3 éléments distincts d'un tableau, en utilisant le point-virgule comme séparateur :

$Armoire = explode (";" , "Un;Deux;Trois");
echo "$Armoire[0] <BR>"; // Un
echo "$Armoire[1] <BR>"; // Deux
echo "$Armoire[2] <BR>"; // Trois

Et l'inverse : Transformer plusieurs éléments d'un tableau en une chaîne de caractères avec implode

Soit un tableau composé de 3 éléments : One, Two et Three. Il s'agit de concaténer ces 3 éléments dans la variable $Truc, en séparant chaque élément par un / :

$Armoire[] = "One";
$Armoire[] = "Two";
$Armoire[] = "Three";
$Truc = implode ("/" , $Armoire);
echo $Truc;

Tris dans les tableaux avec sort et rsort

Les tris sont d'une simplicité enfantine : sort trie dans l'ordre croissant, et rsort dans l'ordre inverse (Reverse Sort):

$Prenom = array("Bernard", "Daniel", "Charles", "André");
sort($Prenom);
echo $Prenom[0];
echo $Prenom[1];
echo $Prenom[2];
echo $Prenom[3];
echo "<BR>";
rsort($Prenom);
echo $Prenom[0];
echo $Prenom[1];
echo $Prenom[2];
echo $Prenom[3];

Affiche :

AndréBernardCharlesDaniel
DanielCharlesBernardAndré

• Attention : Le tableau est trié directement sur lui-même

Inversion de l'ordre des éléments d'un tableau

Il ne s'agit pas d'un tri alphabétique, mais d'une inversion totale des éléments d'un tableau :

$Periode = array ("Matin", "Midi", "Aprèsmidi", "Soir" );
krsort($Periode);
echo reset ($Periode);
echo next($Periode);
echo next($Periode);
echo next($Periode);

Affichera :

SoirAprèsmidiMidiMatin

Attention : L'exemple suivant :

$Periode = array ("Matin", "Midi", "Aprèsmidi", "Soir" );
krsort($Periode);
echo $Periode[0];
echo $Periode[1];
echo $Periode[2];
echo $Periode[3];

Affichera toujours

MatinMidiAprèsmidiSoir

Puisque les indices ont suivi : Le Matin est toujours le 0, mais il est maintenant tout à la fin...

-