Syntaxe d'un tableau

Un tableau peut être créé en utilisant la structure de langage array(). Il prend un nombre illimité de paramètres, chacun séparé par une virgule, sous la forme d'une paire key => value.

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

La virgule après le dernier élément d'un tableau est optionnelle et peut ne pas être ajoutée. C'est généralement ce qui est fait pour les tableaux sur une seule ligne, i.e. array(1, 2) est préféré à array(1, 2, ). Pour les tableaux sur plusieurs lignes, la virgule finale est généralement utilisée, car elle permet d'ajouter plus facilement de nouveaux éléments à la fin.

Depuis PHP 5.4, vous pouvez également utiliser la syntaxe courte, qui remplace array() par [].

La clé key peut être soit un integer, soit une chaîne de caractères. La valeur value peut être de n'importe quel type.

De plus, les modifications de type suivantes surviendront pour la clé key :

• Les chaînes de caractères contenant un entier valide seront modifiées en un type entier. I.e. la clé "8" sera actuellement stockée comme l'entier 8. D'un autre côté, "08" ne sera pas modifié, sachant que ce n'est pas un entier décimal valide.
• Les nombres à virgule flottante seront aussi modifiés en entier, ce qui signifie que la partie après la virgule sera tronquée. I.e. la clé 8.7 sera stockée sous l'entier 8.
• Les booléens seront modifiés en entier également, i.e. la clé true sera stockée sous l'entier 1 et la clé false sous l'entier 0.
• La valeur Null sera modifiée en une chaîne vide, i.e. la clé null sera stockée sous la chaîne de caractère "".
• Les tableaux et les objets ne peuvent pas être utilisés comme clé. Si vous le tentez, l'alerte suivante sera émise : Illegal offset type.

Si plusieurs éléments dans la déclaration d'un tableau utilisent la même clé, seule la dernière sera utilisée, écrasant ainsi toutes les précédentes.

array(1) {
  [1]=>
  string(1) "d"
}

Les tableaux PHP peuvent contenir des clés de type integer et string en même temps, vu que PHP ne distingue pas les tableaux indexés et les tableaux associatifs.

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

La clé key est optionnelle. Si elle n'est pas spécifiée, PHP utilisera un incrément de la dernière clé entière utilisée.

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}

Il est possible de spécifier la clé seulement pour quelques éléments et ne pas la fournir pour d'autres :

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

Accès aux éléments d'un tableau en utilisant la syntaxe à base de crochets

Les éléments d'un tableau peuvent être accédés en utilisant la syntaxe array[key].

string(3) "bar"
int(24)
string(3) "foo"

Note:

Les accolades et les crochets peuvent être utilisés pour accéder aux éléments d'un tableau (i.e. $array[42] et $array{42} feront exactement la même chose dans l'exemple ci-dessus).

Depuis PHP 5.4, il est possible de faire référence à un tableau résultant d'une fonction ou d'une méthode directement. Avant, cela n'était possible qu'en utilisant une variable temporaire.

Depuis PHP 5.5, il est possible de déréférencer un tableau littéral.

Note:

Une tentative d'accès à une clé d'un tableau qui n'a pas été définie revient à tenter d'accès à une variable non définie : une alerte de niveau E_NOTICE sera émise, et le résultat vaudra NULL.

Création/modification avec des crochets

Un tableau existant peut être modifié en y assignant explicitement des valeurs.

L'assignation d'une valeur dans un tableau est effectué en spécifiant la clé, entre crochets. La clé peut également ne pas être renseignée, sous la forme : [].

$arr[clé] = valeur;
$arr[] = valeur;
// clé peut être un entier ou une chaîne de caractères
// valeur peut être n'importe quel type

Si $arr n'existe pas lors de l'assignation, il sera créé ; c'est ainsi une façon détournée de créer un tableau. Cette pratique est cependant découragée car si $arr contient déjà quelques valeurs (i.e. string depuis la variable demandée) alors cette valeur restera en place et [] peut attendre un opérateur d'accès sur une chaîne. C'est toujours un meilleur choix que d'initialiser une variable par assignement direct.

Pour modifier une valeur en particulier, il convient d'assigner une valeur en spécifiant sa clé. Pour effacer une paire clé/valeur, il convient d'appeler la fonction unset() sur la clé désirée.

Note:

Comme dit plus haut, si aucune clé n'est spécifiée, l'indice maximal existant est repris, et la nouvelle clé sera ce nombre, plus 1 (mais au moins 0). Si aucun indice entier n'existe, la clé sera 0 (zéro).

Notez que la clé entière maximale pour cette opération n'a pas besoin d'exister dans le tableau au moment de la manipulation. Elle doit seulement avoir existé dans le tableau à un moment ou un autre depuis la dernière fois où le tableau a été ré-indexé. Voici un exemple qui illustre ce principe :

<?php
// Création d'un tableau simple.
$array = array(1, 2, 3, 4, 5);
print_r($array);

// Maintennant, on efface tous les éléments, mais on conserve le tableau :
foreach ($array as $i => $value) {
    unset($array[$i]);
}
print_r($array);

// Ajout d'un élément (notez que la nouvelle clé est 5, et non 0).
$array[] = 6;
print_r($array);

// Ré-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
)

Pourquoi $foo[bar] est incorrect ?

Utiliser toujours des guillemets autour d'un index littéral. Par exemple, $foo['bar'] est correct, alors que $foo[bar] ne l'est pas. Mais pourquoi ? il est courant de rencontrer ce genre de syntaxe dans d'anciens scripts :

C'est incorrect, mais ça fonctionne. La raison est que ce code a une constante indéfinie (bar) plutôt qu'une chaîne ('bar' - noter les guillemets). PHP peut définir plus loin une constante portant le même nom. Cela fonctionne car PHP convertit automatiquement une chaîne nue (une chaîne sans guillemets qui ne correspond à aucun symbole connu) en une chaîne qui la contient. Actuellement, s'il n'y a aucune constante nommée bar, alors PHP substituera 'bar' dans la chaîne et l'utilisera.

Note: Ceci ne signifie pas qu'il faut toujours mettre la clé entre guillemets. N'utilisez pas de guillemets avec les clés qui sont des constantes ou des variables, car cela empêcherait PHP de les interpréter.

<?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 "\nVérification de $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 :

Vérification de 0 :
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mauvais :
Bon : 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mauvais :
Bon : 1

Vérification de 1 :
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mauvais :
Bon : 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mauvais :
Bon : 2

Plus d'exemples pour expliquer ce comportement :

Lorsque error_reporting est défini afin de montrer les erreurs de type E_NOTICE (en le définissant à E_ALL, par exemple), une telle pratique devient immédiatement visible. Par défaut, error_reporting n'est pas défini pour afficher toutes les alertes.

Comme vu dans la section "syntaxe", ce qui se trouve entre crochets ('[' et ']') doit être une expression. Ceci signifie que le code ci-dessous fonctionne :

C'est un exemple d'utilisation d'une fonction retournant une valeur qui sera la clé du tableau. PHP comprend également les constantes :

Noter que E_ERROR est également un identifiant valide, tout comme bar dans le premier exemple. Mais le dernier exemple est finalement le même que celui-ci :

car E_ERROR vaut 1, etc.