Manuel PHP
Précédent | Chapitre 11. Les types | Suivant

# Les tableaux

Un tableau PHP est en fait une association ordonnée (littéralement, une map). Une association est un type qui fait correspondre des valeurs à des clés. Ce type est optimisé de diverses façons, qui font que vous pouvez le manipuler comme un tableau à indices réels, une liste (vecteur), ou un table de hachage (qui est une implémentation d'association), dictionnaire, collection, pile, queue et encore d'autres. Comme une valeur peut elle-même être un tableau, vous pouvez simuler facilement un arbre.

Les détails d'implémentation de ces structures sont hors du champ de ce manuel, mais vous trouverez ici un exemple de toutes ces structures.

## Syntaxe

### Créer un tableau array()

Un tableau array peut être créé avec la fonction array(). Cette fonction prend en argument des structures key => value, séparées par des virgules.

    array( [key =>]
    value , ... )
    // key est soit une chaîne de caractères
    soit un entier positif
    // value peut être n'importe quoi

Exemple 11-21. Affectations de tableaux

`<?php $arr = array("foo" => "bar", 12 => true); echo $arr["foo"]; // bar echo $arr[12]; // 1 ?>`

Une clé key est soit un entier soit une chaîne de caractères. Si une clé est la représentation standard d'un entier positif, elle sera interprétée comme tel. (i.e. '8' sera interprété comme 8, tandis que '08' sera interprété comme '08'). Les nombres à virgule flottante dans key seront transtypés en entier. Il n'y a aucune différence entre les tableaux indexés et les tableaux associatifs en PHP ; il n'y a qu'un type array, qui peut contenir soit des entiers, soit des chaînes en guise d'index.

Une valeur de tableau peut être de n'importe quel type.

Exemple 11-22. Création d'un tableau associatif

`<?php $arr = array("untableau" => array(6 => 5, 13 => 9, "a" => 42)); echo $arr["untableau"][6]; // 5 echo $arr["untableau"][13]; // 9 echo $arr["untableau"]["a"]; // 42 ?>`

Si vous omettez une clé lors de la spécification d'un tableau, l'indice maximum + 1 sera utilisé comme clé par défaut. Si aucun indice numérique n'a été généré, ce sera 0. Si vous en spécifiez une qui a déjà été assignée, la nouvelle valeur écrasera la précédente.

Exemple 11-23. Indexation automatique de tableau

`<?php // Ce tableau est identique à array(5 => 43, 32, 56, "b" => 12); // Celui ci array(5 => 43, 6 => 32, 7 => 56, "b" => 12); ?>`

Avertissement
Depuis PHP 4.3.0, le comportement de la génération des index décrit plus haut a changé. Maintenant, si vous ajoutez une rangée à un tableau dans lequel la clé maximale est négative, alors, la prochaine clé créée sera zéro (0). Avant, le nouvel index était défini à l'index maximal plus un, le même comportement que lorsque l'indice est positif.

Utiliser `TRUE` comme clé revient à utiliser le type entier de valeur 1. Utiliser `FALSE` comme clé revient à utiliser le type entier de valeur 0. Utiliser `NULL` comme clé revient à utiliser le type chaîne de caractères de valeur "". Utiliser la chaîne vide comme index va créer cet index, et ce n'est pas la même chose que d'utiliser des crochets vides.

Il n'est pas possible d'utiliser des tableaux ou des objets comme clés. Ce faisant, vous généreriez une alerte : Illegal offset type.

### La syntaxe à crochets

Vous pouvez aussi modifier un tableau existant en lui assignant simplement des valeurs.

L'assignation de valeurs de tableau se fait en spécifiant la clé entre crochets. Si vous omettez la clé ("$tableau[]"), la valeur sera ajoutée à la fin du tableau.

    $arr[key] = value;
    $arr[] = value;
    // key est soit une chaîne de caractères, soit un entier
    // value peut être n'importe quoi

Si $arr n'existe pas, il sera créé. Cela en fait une alternative pour créer un tableau. Pour modifier une valeur, assignez-lui une nouvelle valeur. Pour supprimer une valeur, utilisez la fonction unset().

Exemple 11-24. Manipuler des éléments de tableau

`<?php $arr = array(5 => 1, 12 => 2); $arr[] = 56; // Ceci revient à $arr[13] = 56; // à ce moment du script $arr["x"] = 42; // Ceci ajoute un nouvel élément // avec l'index "x" unset($arr[5]); // Ceci efface un élément du tableau unset($arr); // Ceci efface tout le tableau ?>`

> Note : Comme indiqué ci-dessus, si vous fournissez des crochets sans spécifier de clé, le plus grand index entier existant est recherché et la nouvelle clé générée est cette valeur maximum + 1. Si aucune clé entière n'existe, la valeur sera alors 0. Si vous spécifiez une clé qui est déjà existante, vous écraserez le contenu précédent.

> Avertissement
> Depuis PHP 4.3.0, la génération d'index a changé. Si vous ajoutez un élément et que la valeur maximale de la clé est négative, alors la prochaine clé générée est 0. Auparavant, c'était la plus grande valeur + 1, négative ou pas. Cela reste le comportement pour les clés positives.

> Notez que le maximum théorique n'a pas besoin d'exister au moment de la génération. Il peut simplement avoir existé dans le tableau à un moment depuis la dernière fois où le tableau a été ré-indexé. L'exemple suivant illustre bien ceci :

> Exemple 11-25. La génération automatique de clé peut utiliser un ancien maximum

> `<?php
> // Crée un simple tableau
> $array = array(1, 2, 3, 4, 5);
> print_r($array);
> // On efface tous les éléments, mais on conserve le tableau
> foreach ($array as $i => $value) {
> unset($array[$i]);
> }
> print_r($array);
> // On ajoute une valeur : notez que la nouvelle clé est 5
> // et non pas 0, comme on l'attendrait.
> $array[] = 6;
> print_r($array);
> // Re-indexation :
> $array = array_values($array);
> $array[] = 7;
> print_r($array);
> ?>`

> L'exemple ci-dessus va afficher :

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

## Fonctions pratiques

Il y a toute une panoplie de fonctions pratiques pour travailler avec les tableaux.

> Note : La fonction unset() permet d'effacer des index dans un tableau. Sachez bien que le tableau ne sera PAS ré-indexé. Si vous utilisez uniquement des index numériques (commençant à zéro et incrémentés de un), vous pouvez effectuer la ré-indexation en utilisant array_values().

> Exemple 11-26. Manipuler des éléments de tableau

> `<?php $a = array(1 => 'un', 2 => 'deux', 3 => 'trois'); unset($a[2]); /* Cela va produire un tableau qui aurait été $a = array(1 => 'un', 3 => 'trois'); et non pas $a = array(1 => 'un', 2 =>'trois'); */ $b = array_values($a); // Maintenant b est le tableau array(1 => 'un', 2 =>'trois') ?>`

L'élément de langage foreach est spécifiquement dédié aux tableaux : il permet de passer en revue simplement les valeurs d'un tableau.

## À faire et à ne pas faire avec les tableaux

### Pourquoi est-ce que $foo[bar] est invalide ?

Vous devez toujours utiliser les guillemets autour de la chaîne de caractères placée en tant qu'index du tableau. Par exemple, utilisez $foo['bar'] et non pas $foo[bar]. Mais, pourquoi $foo[bar] est faux ? Vous pourriez avoir vu la syntaxe suivante en vos vieux scripts :

Exemple 11-27. Accès aux index de tableaux, ancienne méthode

`<?php $foo[bar] = 'ennemi'; echo $foo[bar]; // etc. ?>`

Cela est mauvais, mais ça marche. Pourquoi est-ce mauvais? La raison est que PHP attend une constante entre crochets (bar) plutôt qu'une chaîne ('bar', notez les guillemets). Or, PHP pourrait définir dans le futur des constantes qui, malheureusement pour votre code, auront ce nom. En fait, cela fonctionne car la constante indéfinie est transformée en chaîne ayant la même valeur.

> Note : Cela ne signifie pas que vous devez toujours mettre les clés entre guillemets. Vous n'allez pas utiliser les guillemets avec les clés qui sont des constantes ou des variables, car cela empêchera PHP de les interpréter correctement.

> Exemple 11-28. Ne pas mettre les clés de tableaux entre guillemets

> `<?php error_reporting(E_ALL); ini_set('display_errors', true); ini_set('html_errors', false); // Tableau simple : $array = array(1, 2); $count = count($array); for ($i = 0; $i < $count; $i++) { echo "\nChecking $i : \n"; echo "Mauvais : " . $array['$i'] . "\n"; echo "Bon : " . $array[$i] . "\n"; echo "Mauvais : {$array['$i']}\n"; echo "Bon : {$array[$i]}\n"; } ?>`

> L'exemple ci-dessus va afficher :

>     Checking 0:
>     Notice: Undefined index:  $i in /Users/iboom/Desktop/CVS/docs/mysql/mysql.fr/- on line 10
>     Mauvais :
>     Bon : 1
>     Notice: Undefined index:  $i in /Users/iboom/Desktop/CVS/docs/mysql/mysql.fr/- on line 12
>     Mauvais :
>     Bon : 1

>     Checking 1:
>     Notice: Undefined index:  $i in /Users/iboom/Desktop/CVS/docs/mysql/mysql.fr/- on line 10
>     Mauvais :
>     Bon : 2
>     Notice: Undefined index:  $i in /Users/iboom/Desktop/CVS/docs/mysql/mysql.fr/- on line 12
>     Mauvais :
>     Bon : 2

D'autres exemples :

Exemple 11-29. Exemples de conflits de constantes indéfinies

`<?php
// Affichons toutes les erreurs
error_reporting(E_ALL);
$arr = array('fruit' => 'pomme', 'legume' => 'carotte');
// Correct
print $arr['fruit']; // pomme
print $arr['legume']; // carotte
// Incorrect. Cela fonctionne mais PHP affiche une alerte car
// il y a utilisation d'une constante indéfinie appelée fruit
//
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit]; // pomme
// Définissons une constante pour illustrer le problème.
// Nous créons une constante appelée fruit, qui vaut 'legume'.
define('fruit','legume');
// Notez la différence
print $arr['fruit']; // pomme
print $arr[fruit]; // carotte
// La suite est correcte si cela se passe dans une chaîne.
// Les constantes ne sont pas remplacées par leur valeur dans une chaîne
print "Bonjour $arr[fruit]"; // Bonjour pomme
// À une exception, les accolades entourant un tableau dans une chaîne
// permettent d'utiliser les constantes
print "Bonjour {$arr[fruit]}"; // Bonjour carotte
print "Bonjour {$arr['fruit']}"; // Bonjour pomme
// Ceci ne fonctionnera pas et donnera une erreur d'analyse
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Cela s'applique aussi aux autoglobales dans les chaînes
print "Bonjour $arr['fruit']";
print "Bonjour $_GET['foo']";
// La concaténation est une alternative
print "Bonjour " . $arr['fruit']; // Bonjour pomme
?>`

Lorsque vous activez l'error_reporting() pour afficher les erreurs de niveau `E_NOTICE` (en utilisant le niveau `E_ALL`) alors, vous verrez ces erreurs. Par défaut, error_reporting est trop faible pour les afficher.

Comme indiqué dans la section syntaxe, il doit y avoir une expression entre les crochets ('[' et ']'). Cela signifie que vous pouvez écrire ceci :

Exemple 11-30. Utilisation d'une expression dans un index de tableau

`<?php echo $arr[somefunc($bar)]; ?>`

Ceci est un exemple d'utilisation de retour de fonction comme index de tableau. PHP reconnaît aussi les constantes, comme la famille des E_*.

Exemple 11-31. Utilisation d'une constante dans un index de tableau

`<?php $error_descriptions[E_ERROR] = 'Une erreur fatale est survenue'; $error_descriptions[E_WARNING] = 'PHP émet une alerte'; $error_descriptions[E_NOTICE] = 'Ceci est juste une alerte informelle'; ?>`

Notez que `E_ERROR` est aussi un identifiant valide, tout comme bar dans le premier exemple. Mais le dernier exemple est identique à ceci :

Exemple 11-32. Utilisation d'une constante dans un index de tableau(2)

`<?php $error_descriptions[1] = 'Une erreur fatale est survenue'; $error_descriptions[2] = 'PHP émet une alerte'; $error_descriptions[8] = 'Ceci est juste une alerte informationnelle'; ?>`

car E_ERROR vaut 1, etc.

Comme nous l'avons déjà expliqué dans les exemples ci-dessus, $foo[bar] fonctionne mais est dangereux. Cela fonctionne car bar est identifié comme une constante. Mais si la constante n'existe pas, PHP suppose que vous souhaitez utiliser bar littéralement, sous la forme "bar", mais que vous avez oublié les guillemets.

#### Pourquoi est-ce aussi dangereux?

À l'avenir, le groupe PHP peut décider d'ajouter une constante ou un autre mot clé, ou bien vous souhaiterez aussi ajouter une constante dans votre application et vous serez bloqué. Par exemple, vous ne pouvez pas utiliser des mots comme empty et default de cette manière, car ils sont déjà réservés.

> Note : Pour insister, à l'intérieur d'une chaîne de caractères (chaîne de caractères) à guillemets doubles, il est correct de ne pas utiliser les guillemets simples dans les index et donc "$foo[bar]" est valide. Voyez les exemples ci-dessus pour plus de détails sur la syntaxe des variables dans les chaînes.

## Conversion en tableau

Pour les types scalaires (entier, nombre à virgule flottante, chaîne de caractères, booléen et ressource), convertir une valeur en tableau retourne un tableau qui contient un élément (à l'index 0) qui est la valeur originale.

Si vous convertissez un tableau en objet, vous obtiendrez des propriétés ou bien cet objet comme élément de tableau. Les clés créées sont les noms des membres avec quelques exceptions : les variables privées ont le nom de la classe ajouté au début du nom de la variable ; les variables protégées ont un '*' ajouté au début du nom de la variable. Ces valeurs ajoutées ont des octets nuls dans l'autre sens. Ceci peut avoir un comportement inattendu.

`<?php class A { private $A; // Ceci devient '\0A\0A' } class B extends A { private $A; // Ceci devient '\0B\0A' public $AA; // Ceci devient 'AA' } var_dump((array) new B()); ?>`

Ce qui précède laisse penser que nous avons 2 clés nommées 'AA', alors qu'une seule est actuellement nommée '\0A\0A'.

Si vous convertissez la valeur `NULL` en tableau, vous obtiendrez un tableau vide.

## Comparaisons de tableaux

Il est possible de comparer des tableaux grâce à la fonction array_diff() et aux opérateurs de tableaux.

## Exemples

Le type tableau de PHP est très souple. Voici quelques exemples d'utilisation :

Exemple 11-33. Utilisation des tableaux

`<?php
// ceci
$a = array( 'couleur' => 'rouge',
'gout' => 'sucre',
'forme' => 'rond',
'nom' => 'pomme',
4 // cette clé sera 0
);
// est complètement équivalent à
$a['couleur'] = 'rouge';
$a['gout'] = 'sucre';
$a['forme'] = 'rond';
$a['nom'] = 'pomme';
$a[] = 4; // cette clé sera 0
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// va créer le tableau array( 0 => 'a' , 1 => 'b' , 2 => 'c' )
// ou plus simplement array('a' , 'b' , 'c' )
?>`

Exemple 11-34. Utilisation de array()

`<?php
// Array comme correspondance
$map = array( 'version' => 4,
'OS' => 'Linux',
'langue' => 'français',
'short_tags' => TRUE
);
// valeur strictement numériques
$array = array( 7,
8,
0,
156,
-10
);
// ceci est la même chose que array( 0 => 7, 1 => 8, ...)
$switching = array( 10, // clé = 0
5 => 6,
3 => 7,
'a' => 4,
11, // clé = 6 (index maximum : 5)
'8' => 2, // clé = 8 (entier!)
'02' => 77, // clé = '02'
0 => 12 // la valeur de la clé 10 sera remplacée par 12
);
// empty array
$empty = array();
?>`

Exemple 11-35. Collection

`<?php $couleurs = array('rouge', 'bleue', 'verte', 'jaune'); foreach ( $couleurs as $couleur ){ echo "Aimez-vous la couleur $couleur?\n"; } ?>`

L'exemple ci-dessus va afficher :

    Aimez-vous la couleur rouge?
    Aimez-vous la couleur bleue?
    Aimez-vous la couleur verte?
    Aimez-vous la couleur jaune?

Changer les valeur du tableau directement est possible depuis PHP 5 en les passant par références. Les versions précédentes nécessitent cette solution :

Exemple 11-36. Collection

`<?php // PHP 5 foreach ($colors as &$color) { $color = strtoupper($color); } unset($color); /* s'assure que l'écriture suivante à $color ne modifie pas le dernier élément du tableau */ // Solution pour les anciennes versions de PHP foreach ($colors as $key => $color) { $colors[$key] = strtoupper($color); } print_r($colors); ?>`

L'exemple ci-dessus va afficher :

    Array
    (
        [0] => ROUGE
        [1] => BLEU
        [2] => VERT
        [3] => JAUNE
    )

Cet exemple crée un tableau d'index minimal 1.

Exemple 11-37. Tableau en 1

`<?php $firstquarter = array(1 => 'Janvier', 'Février', 'Mars'); print_r($firstquarter);`

L'exemple ci-dessus va afficher :

    Array
    (
        [1] => 'Janvier'
        [2] => 'Février'
        [3] => 'Mars'
    )

Exemple 11-38. Remplissage d'un tableau

`<?php // remplit un tableau avec les noms de fichiers d'un dossier $handle = opendir('.'); while ( $file = readdir($handle) ) { $files[] = $file; } closedir($handle); ?>`

Les tableaux sont ordonnés. Vous pouvez modifier l'ordre des valeurs avec de nombreuses fonctions de classement. Voyez les fonctions de tableaux pour plus d'informations. Vous pouvez compter le nombre d'éléments d'un tableau en utilisant la fonction count().

Exemple 11-39. Tri de tableaux

`<?php sort($files); print_r($files); ?>`

Comme une valeur de tableau peut être n'importe quoi, elle peut aussi être un autre tableau. Comme cela, vous pouvez avoir des tableaux multidimensionnels et récursifs.

Exemple 11-40. Tableaux multidimensionnels, et récursifs

`<?php
$fruits = array ( "fruits" => array ( "a" => "orange",
"b" => "banane",
"c" => "pomme"
),
"nombre" => array ( 1,
2,
3,
4,
5,
6,
),
"trou" => array ( "premier",
5 => "second",
"troisième"
)
);
// Exemples d'utilisations des tableaux ci-dessus
echo $fruits["trou"][5]; // affiche "second"
echo $fruits["fruits"]["a"]; // affiche "orange"
unset($fruits["trou"][0]); // supprime "premier"
// Créer un tableau multidimensionnel
$jus["pomme"]["vert"] = 'bon';
?>`

Soyez conscient que l'assignation de valeurs dans un tableau entraîne automatiquement la copie de ces valeurs. Cela signifie aussi que le pointeur interne du tableau utilisé par la fonction current() et les fonctions similaires est initialisé. Vous devez utiliser l'opérateur de référence pour copier un tableau par référence.

Exemple 11-41. Copie dans un tableau par référence

`<?php $arr1 = array(2, 3); $arr2 = $arr1; $arr2[] = 4; // $arr2 est modifié, // $arr1 vaut toujours array(2, 3) $arr3 = &$arr1; $arr3[] = 4; // maintenant $arr1 et $arr3 sont identiques ?>`

Précédent | Sommaire | Suivant
Les chaînes de caractères | Niveau supérieur | Les objets