Mon tableau de test :

$tab = array(array(5,6,2),array(3,7,1),array(1,5,9),array(3,8,8),array(1,2,3),array(7,4,4),array(4,2,10));

Deuxième fonction de tri sur le troisième élément :

function cmp2($a,$b) {
    if ($a[2] == $b[2])
        return 0;
    return ($a[2] > $b[2]) ? -1 : 1;
}

Le signe supérieur > permet de faire un tri décroissant ; pour un tri croissant, il faut le changer en <.
Première fonction de tri sur le deuxième élément :

function cmp1($a,$b) {
    if ($a[1] == $b[1])
        return cmp2($a,$b);
    return ($a[1] > $b[1]) ? -1 : 1;
}

De plus, on peut tout-à-fait choisir de faire un tri décroissant sur la deuxième colonne et croissant sur la troisème !
la procédure de tri :

usort($tab, "cmp1");

Ma fonction d'affichage :

foreach($tab as $elem) {
    echo $elem[0], " ", $elem[1], " ", $elem[2], "<br />";
}

Principe : usort trie le tableau $tab avec la fonction cmp1() qui prend pour argument deux entrées du tableau et renvoie 0, -1, +1 selon que la première entrée soit égale, supérieure ou inférieure à la deuxième (sur le deuxième élément). Évidemment, en cas d'égalité on appelle cmp2() pour faire le test sur le troisième élément.

Si les valeurs sont issues d'une requête MySQL, alors on peut utiliser la fonction RAND() au sein de la clause ORDER BY :

SELECT ...  FROM ... WHERE ... ORDER BY RAND()

En PHP, la fonction shuffle() mélange les éléments du tableau. Attention à ne pas oublier d'initialiser le générateur de nombre aléatoire avec srand() :

srand(time()); 
shuffle($tab);

count() et sizeof() retournent le nombre d'éléments d'un tableau.

echo count($tab);
echo sizeof($tab);

Attention, si $tab n'est pas un tableau, count() retourne 1, si $tab n'est pas défini, count() retourne 0.

Attention, avec ces fonctions, une chaîne de caractères n'est pas considérée comme un tableau de caractères.

• isset($tab) : retourne TRUE si la variable $tab est définie
• is_array($tab) : retourne TRUE si la variable $tab est un tableau
• count($tab) : retourne le nombre d'éléments du tableau $tab, si $tab est un tableau

if(isset($tab) && is_array($tab) && count($tab)) {
    foreach($tab as $elem) {
        echo $elem, "<br>";
    }
}

De la même façon que l'on supprime une variable scalaire ou un tableau entier, on utilise pour supprimer un élément particulier de tableau la structure du langage unset(). Par exemple si $tab2dim est un tableau à 2 dimensions et que l'on veut supprimer l'élément [4][3], on écrira :

unset($tab2dim[4][3]) ;

Il est également possible de dépiler le premier élément d'un tableau et de récupérer la valeur de l'élément enlevé en utilisant la fonction array_shift(). Dans le cas d'un tableau non associatif, les éléments sont déplacés vers la gauche, ce qui signifie que l'élément qui avait auparavant l'indice 1 a maintenant l'indice 0, et ainsi de suite.

$montab = array("el1", "el2", "el3") ;
$el = array_shift($montab) ; // $el vaut "el1"
// $montab est maintenant de la forme (0=>"el2", 1=>"el3")

De la même façon, il existe la fonction array_pop() qui dépile le dernier élément et retourne sa valeur

echo "<pre>";
print_r($_POST);
echo "</pre>";

La fonction print_r() permet d'afficher le contenu d'un tableau de dimension quelconque pour le contrèle des données. Autant dire qu'elle est utile pour le développeur PHP pour chercher une erreur de saisie dans un tableau !

Vous pouvez également utiliser la fonction var_dump() qui retourne les informations structurées d'une variable, y compris son type et sa valeur. La même chose que print_r() en plus complet.

On déclare une variable de type tableau via la fonction array() (qui retourne un tableau).

Exemple:

$tab = array();

Lors de la déclaration, il est possible d'affecter des valeurs au tableau.

Exemple tableau numérique :

$tab = array("un", "deux", "trois");

Exemple tableau associatif :

$tab = array('nom' => "Martin",'prénom' => "Pierre",'email' => "martin.pierre@la-bas.fr");

On peut ajouter un élément à la fin d'un tableau comme suit :

$tab[] = $valeur;

On peut ajouter un élément à un indice particulier comme suit :

$tab[$indice-1] = $valeur

Attention : les indices commencent à zéro (0), ainsi le 10ème élément a pour indice 9.

On peut ajouter un ou plusieurs éléments à la fin d'un tableau avec la fonction array_push(). Cette fonction retourne true si l'opération a réussi, ou false en cas d'échec. Elle prend en paramètre le tableau et un ou plusieurs éléments à lui ajouter. Ces éléments peuvent être de tout type (nombre, chaîne, tableau, objet...) :

array_push($tab, $elem1);
array_push($tab, $elem2, $elem3, $elem4);

Pour insérer un élément au milieu d'un tableau, on utilise les fonctions array_slice() qui extrait une portion de tableau, array_push() qui empile un ou plusieurs éléments à la fin d'un tableau et array_merge() qui fusionne un ou plusieurs tableaux.
Exemple d'utilisation :

//Soit le tableau contenant pomme, poire, pêche, kiwi. On veut insérer abricot au milieu de ce tableau
$tab = array ("pomme", "poire", "pêche", "kiwi");
$tab1 = array_slice ($tab, 0, 2); //Récupère pomme et poire
$tab2 = array_slice ($tab, 2); //Récupère tous les éléments à partir de l'indice 2
array_push ($tab1, "abricot"); //Ajoute à la fin du tableau l'élément abricot
$tab = array_merge ($tab1, $tab2); //Fusionne les deux tableaux
echo '<pre>';
print_r($tab); //Affiche Array([0] => pomme [1] => poire [2] => abricot [3] => pêche [4] => kiwi)
echo '</pre>';

Bien sur, on peut insérer un élément à n'importe quelle position, ce code n'est qu'un exemple.

Un tableau dit "numérique" ne contient pas forcément de valeurs numériques, ce peut être des chaînes de caractères, ou d'autres types encore.

Un tableau numérique est une simple liste énumérative d'éléments, qui peuvent être eux mêmes des tableaux.

Exemples de tableaux numériques :

$tab = array(1, 5, "neuf", "poire", 512);
$tab2 = array($nom, "ton prénom = $prenom", array($email1, $email2));

Dans un tableau numérique, les éléments sont référencés par leurs indices :

echo $tab[2];/* affiche "neuf" */

Un tableau associatif se distingue d'un tableau numérique par la présence de clés qui permettent de référencer les éléments stockés dans le tableau.

Exemple de tableau associatif :

$tab = array("nom" => "Martin", "email" => "martin@ici.fr");

Dans un tableau associatif, les éléments sont référencés par leurs clés, c'est là toute la différence avec les tableaux numériques :

echo $tab = $tab["nom"];/* affiche "Martin" */

La fonction array_fill($debut, $quantite, $element) retourne un tableau rempli de $quantite fois la valeur $element. Les indices du tableau commencent à $debut.

Exemple :

$tab = array_fill(0, 100, "toto");

Cet exemple crée un tableau $tab de 100 éléments. Les valeurs sont toutes "toto". Et l'indice de départ est zéro (0).

La fonction array_keys() retourne dans un tableau la liste des clés du tableau associatif passé en argument à la fonction.

Exemple:

$personne = array("nom" => "Martin", "prénom" => "Jacques");
$clefs = array_keys($personne);
/* $clefs vaut : array("nom", "prénom"); */

On peut rajouter un argument optionnel à la fonction array_keys() afin de ne renvoyer que les clés associées à une certaine valeur en particulier.

Exemple:

$tab = array("DRH" => "Jean", "Webmaster" => "Jean", "PDG" => "Bob");
$clefs = array_keys($tab, "Jean");
/* $clefs vaut : array("DRH", "Webmaster"); */

Note : si le tableau passé en argument n'est pas un tableau associatif, mais un tableau numérique, alors les indices seront renvoyés à la place des clés.

La fonction array_values() retourne un tableau numérique contenant la liste des valeurs associées aux clés du tableau associatif passé en argument à la fonction.

Exemple :

$tab = array("moi" => "Bob", "lui" = "Maurice", "elle" => "Hélène");
$valeurs = array_values($tab);
/* $valeurs vaut : array("Bob", "Maurice", "Hélène") */

Pour "retourner" un tableau, on utilise la fonction array_reverse() qui retourne un nouveau tableau dont l'ordre des éléments est l'inverse de celui du tableau d'origine passé en argument à la fonction.

Exemple d'un tableau numérique :

$tab = array("bleu", "blanc", "rouge");
$inverse = array_reverse($tab); 
/* $inverse vaut : array("rouge", "blanc", "bleu") */

Exemple d'un tableau associatif :

$tab = array("nom" => "Martin", "email" => "martin@par-ici.fr");
$inverse = array_reverse($tab);
/* $inverse vaut : array("email" => "martin@par-ici.fr", "nom" => "Martin") */

La fonction in_array($valeur, $tab) retourne true si la valeur $valeur a été trouvée dans le tableau $tab. Même si le type de la variable $valeur ne correspond pas au type de la valeur trouvée dans $tab.

Exemple :

$tab = array(2003, "12.5");
if(in_array(2003, $tab) && in_array(12.5, $tab)) {
    echo "Trouvé !";
}
/* affiche "Trouvé !" */

Pour tenir compte du type de variable et ainsi interdire les casts implicites, il faut ajouter un paramètre booléen optionnel valant true.

Exemple :

$tab = array(2003, "12.5");
if(in_array(2003, $tab, true) && in_array(12.5, $tab, true)) {
    echo "Trouvé !";
} else {
    echo "Echec";
}
/* affiche "Echec" */

Pour rassembler plusieurs tableaux en un seul, on utilise la fonction array_merge() qui retourne un tableau qui est le résultat de la fusion de tous les tableaux passés en paramètre.

Exemple :

$tab1 = array(1, 10 ,53, 102);
$tab2 = array("soleil" => "très chaud", "mercure" => "très pres du soleil", "pluton" => "lointaine et froide");
$total = array_merge($tab1, $tab2);

Les valeurs sont ajoutées les unes à la suite des autres dans le tableau résultat. Dans le cas où les mêmes clés seraient trouvées dans plusieurs des tableaux d'origine, c'est la dernière valeur rencontrée qui sera prise en compte (car il ne peut pas y avoir de doublons sur les clés).

La fonction array_rand() retourne l'indice d'une valeur choisie au hasard dans le tableau passé en argument à la fonction.

Exemple :

$tab = ("moi", "lui", "elle", "toi");
$indice = array_rand($tab);
echo $tab[$indice];

En passant l'argument optionel $nbr à la fonction, valant le nombre de valeurs à choisir au hasard, la fonction array_rand() retourne un tableau numérique des indices de $nbr valeurs choisies au hasard.

Exemple :

$tab = ("moi", "lui", "elle", "toi");
$indices = array_rand($tab, 2);
foreach($indices as $i) {
    echo $tab[$i];
}

Note : ne pas oublier d'initialiser le générateur de nombres aléatoires avec srand() avant d'utiliser la fonction array_rand().

Exemple :

srand((double)microtime()*10000000);

La fonction array_flip() retourne un tableau issu du traitement de celui passé en argument. Le traitement est le suivant : les clés du tableau d'origine sont remplacées par leurs valeurs, et les valeurs, par les clés associées.

Exemple :

$tab = array("nom" => "Martin", "prénom" => "Pierre");
$flip = array_flip($tab);
/* $flip vaut : array("Martin" => "nom", "Pierre" => "prénom") */

Attention : seules les valeurs dont le type est compatible pour devenir clés seront interchangées avec leurs clés. Ces types sont : entier et chaîne de caractères. Ainsi, les nombres à virgule, les objets et autres... ne seront pas inversés.

De plus, dans le cas où le tableau d'origine possède plusieurs clés dont les valeurs sont identiques, seule la dernière sera utilisée. Ainsi les autres clés seront perdues.

C'est donc une fonction à utiliser avec beaucoup de prudence.

Les fonctions array_key_exists($key, $tab) et isset($tab[$key]) retourne true si la clé $key existe dans le tableau $tab.

Exemples :

$tab = array("nom" => "Martin");
if(array_key_exists("nom", $tab)) {
    echo "Ok";
}
/* afffiche "Ok" */
if(isset($tab["nom"])) {
    echo "Ok";
}
/* afffiche "Ok" */

A noter que isset() renverra false si null est la valeur associée à la clé

Avec la fonction array_unique() qui retourne un tableau issu de celui passé en argument à la fonction, mais sans doublon.

Les clés sont préservées.

Seules les permières instances des valeurs sont conservées.

La fonction range($debut, $fin) retourne un tableau formé de toutes les valeurs entières ou caractères comprises entre $debut et $fin.

Exemple avec des entiers :

$entiers = range(0, 10);
/* $entiers vaut : array(0,1,2,3,4,5,6,7,8,9,10) */

Exemple avec des caractères :

$lettres = range('a', 'z');
/* $lettres vaut : array('a', 'b', 'c', 'd', ... 'z') */

Le pas par défaut est 1. On peut le changer en passant l'argument optionnel $pas à la fonction range().

Exemple avec des entiers :

$entiers = range(0, 50, 10);
/* $entiers vaut : array(0, 10, 20, 30, 40, 50) */

Pour forcer un tableau à commencer avec l'indice 1, il suffit d'attribuer au premier élément du tableau la clé 1 :

$tab = array(1 => "pomme", "cerise");
//Donnera $tab[1] = "pomme" et $tab[2] = "cerise";

En création dynamique :

...
$tab = array();
$i = 1;
while(condition) {
    $tab[$i] = une_valeur;
}

La fonction explode($delim, $str) permet de scinder la chaîne $str en une multitude de sous-chaînes qui composeront le tableau retourné par la fonction. Les sous-chaînes sont délimitées par le séparateur $delim dans la chaîne $str.

Exemple :

<?
$str = "451;2001;45;987;51";
$tab = explode(";",$str);
print_r($tab);
?>

Ainsi le tableau $tab contient 5 éléments.

$tableau= array("voiture", "moto", "bateau", "avion");
print_r($tableau); // Donne le tableau indicé suivant : Array ( [0] => voiture [1] => moto [2] => bateau [3] => avion )
unset($tableau[2]); // On supprime un élémént du tableau
print_r($tableau); // Donne le tableau indicé suivant : Array ( [0] => voiture [1] => moto [3] => avion )

Nous remarquons que, avec le unset(), nous avons supprimé le deuxième élément et qu'il existe donc un trou dans les clés (le 2).

$tableau = array_values($tableau); // Réindice le tableau
print_r($tableau); // Donne Array ( [0] => voiture [1] => moto [2] => avion )

Nous disposons ici d'un tableau associatif clé=>valeur ; avec array_values, nous pouvons recalculer le tableau et l'indicer numériquement.

$tableau= array('taco'=>"voiture", 'deux-roues'=>"moto", 'flotte'=>"bateau", 'vole'=>"avion");

$tableau = array_values($tableau);//permet de réindicé le tableau
print_r($tableau);//donne Array ( [0] => voiture [1] => moto [2] => bateau [3] => avion )

Pour savoir si un élément d'un tableau est inclus dans un autre tableau, nous pouvons utiliser plusieurs méthodes dont les suivantes :

1. Avec une boucle for et la fonction in_array() qui indique si une valeur appartient à un tableau.

   Comparaison effectuée selon la méthode 1

   Sélectionnez

   $tab1 = array(1,5,8,15,35,45);
   $tab2 = array(2,6,18,35,50);
   for($i = 0; $i < count($tab1); $i++) // Tant que l'on peut parcourir le premier tableau
   {                        
       if (in_array($tab1[$i],$tab2)) //On teste si l'élément à l'index $i est dans le deuxième tableau
       {
             return (TRUE); // Renvoie TRUE
       }                        
   }

2. Avec la fonction array_intersect() qui retourne un tableau contenant toutes les valeurs du premier tableau qui sont présentes dans tous les autres.

   Comparaison effectuée selon la méthode 2

   Sélectionnez

   $tab1 = array(1,5,8,15,35,45);
   $tab2 = array(2,6,18,35,50);
   if(count (array_intersect($tab, $tab2)) > 0) //Si le tableau renvoyé n'est pas vide
   {
       return TRUE; //Renvoie TRUE
   }

Soit le tableau suivant :

$produits = array(
    array(
        'id'  => 18,
        'qte' => 3
    ),
    array(
        'id'  => 26,
        'qte' => 1
    )
);

• Par la méthode GET :

  Transmission

  Sélectionnez

  echo '<a href="page_de_reception.php?panier=' . urlencode(serialize($produits)) . '">page_de_reception</a>';

  Récupération

  Sélectionnez

  if(get_magic_quotes_gpc())
  {
      $produits = unserialize(stripslashes($_GET['panier']));
  }
  else
  {
      $produits = unserialize($_GET['panier']);
  }
  print_r($produits);

  Attention : la méthode GET n'est pas la plus appropriée pour faire transiter un tableau. D'une part parce qu'elle est visible par l'utilisateur et d'autre part parce que la taille de la requête est limitée en caractères (dépend de l'implémentation).

• Par la méthode POST :

  Transmission

  Sélectionnez

  <form method="post" action=" page_de_reception.php">
      <input type="hidden" name="panier" value="<?php echo urlencode(serialize($produits)); ?>" />
      <input type="submit" value="Soumettre" />
  </form>

  Récupération

  Sélectionnez

  $produits = unserialize(urldecode($_POST['panier']));
  print_r($produits);

• Utilisation des sessions :

  Transmission

  Sélectionnez

  session_start();
  $_SESSION['panier'] = $produits;

  Récupération

  Sélectionnez

  session_start();
  print_r($_SESSION['panier']);

Remarque : le mécanisme de sérialisation/désérialisation est effectuée en interne par PHP, c'est pourquoi vous n'avez nul besoin d'y faire vous-même explicitement appel manuellement (fonctions serialize et unserialize). Cette méthode est conseillée parce que le mécanisme de session permet de cacher les données mais également d'y avoir accès sur l'ensemble des scripts que composent votre site.

Peu de bases de données permettent de mettre dans un champ de table un tableau. Pour mettre un tableau en base, il faut le sérialiser.

$tableau = array("moto","voiture","vélo");
$tableau_serialize = serialize($tableau);
print_r($tableau_serialize);
// Affiche a:3:{i:0;s:4:"moto";i:1;s:7:"voiture";i:2;s:5:"vélo";}

À noter que cette fonction n'est utilisable qu'à partir de PHP 4.0.7 et qu'il n'est pas possible de linéariser les objets internes de PHP. Pour récupérer ce tableau sérialisé et retrouver le tableau de départ, il faut utilisez la fonction unserialize().

$tableau = unserialize($tableau_serialize);
print_r($tableau);//Array ( [0] => moto [1] => voiture [2] => vélo )

Il est à noter qu'on utilise le même système pour passer un tableau dans des cookies.