Il est de bon ton de se souhaiter la bonne année. Mais vous, et vous seul, pourrez faire en sorte que cette année soit bonne, meilleure que celle qui vient de s'écouler. Apprenez à ne compter que sur vous, car personne n'est plus qualifié que vous-même pour bâtir, réparer ou améliorer votre propre vie. Personne ne fera les choses à votre place. D'ailleurs, tout ce que les autres peuvent faire, c'est souhaiter que vous le fassiez. Et ne croyez pas que tout ceux qui vous entourent vous apporteront des solutions : certains font juste partie de vos problèmes. Transformez vos résolutions en actes, et dans douze mois, retournez-vous et souriez-vous fièrement : C'était long. C'était difficile. Mais ça y est : 2017 était une bonne année, merci Moi.

PHP - MySQL [Retour au menu]
Les tableaux

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

Cet exemple définit une variable Fruit contenant un nombre indéterminé de fruits. $Fruit[] = "Abricot"; veut simplement dire que le premier élément du tableau contient "Abricot". Et comme on répète la même instruction plus bas, on ne remplace pas Abricot par Banane, mais Banane va se placer à la prochaine place libre dans le tableau Fruit.

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

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

$Truc[]="poule"; // sous-entendu $Truc[0]
$Truc[]="renard"; // sous-entendu $Truc[1]
echo $Truc; // il affiche le mot "Array"
echo $Truc[]; //Fatal error: Cannot use [] for reading
echo $Truc[0]; // poule
echo $Truc[1]; // renard
echo $Truc[2]; // RIEN

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 )

for ($Commode=1; $Commode<=6; $Commode++) {
for ($Tiroir=1; $Tiroir<=4; $Tiroir++) {
$Comptage++;
$Rangement[$Commode][$Tiroir]="Chaussette".$Comptage;
}
}
print_r($Rangement);
Array ( [1] => Array ( [1] => Chaussette1 [2] => Chaussette2 [3] => Chaussette3 [4] => Chaussette4 ) [2] => Array ( [1] => Chaussette5 [2] => Chaussette6 [3] => Chaussette7 [4] => Chaussette8 ) [3] => Array ( [1] => Chaussette9 [2] => Chaussette10 [3] => Chaussette11 [4] => Chaussette12 ) [4] => Array ( [1] => Chaussette13 [2] => Chaussette14 [3] => Chaussette15 [4] => Chaussette16 ) [5] => Array ( [1] => Chaussette17 [2] => Chaussette18 [3] => Chaussette19 [4] => Chaussette20 ) [6] => Array ( [1] => Chaussette21 [2] => Chaussette22 [3] => Chaussette23 [4] => Chaussette24 ) )

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

Guillemets ou apostrophes reviennent au même

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

each permet de déplacer un pointeur tout au long d'un tableau. la fonction each renvoie elle-même un tableau avec 2 éléments : le 0 contient l'index (le numéro de l'élément courant), et le 1 contient l'élément lui-même.

$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

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

Il suffit simplement de créer une variable (ici $Tagada) , et à chaque tour de boucle, l'élément suivant du tableau sera injecté dans $Tagada, écrasant la précédente.

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é

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

-