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, c.-à-d. 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.

Note:

Une syntaxe de tableau courte existe qui remplace array() par [].

La clé key peut être soit un int, 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 décimal valide, sauf si le nombre est précédé d'un signe + seront modifiées en un type entier. C.-à-d. la clé "8" sera effectivement stockée sous 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. C.-à-d. la clé 8.7 sera stockée sous l'entier 8.
• Les booléens seront modifiés en entier également, c.-à-d. 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, c.-à-d. la clé null sera stockée sous la chaîne de caractères "".
• Les tableaux et les objets ne peuvent pas être utilisés comme clé. Toute tentative en ce sens émettra l'alerte suivante : 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 int 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 plus grande clé entière utilisée auparavant.

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

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

array(2) {
  [-5]=>
  int(1)
  [-4]=>
  int(2)
}

array(2) {
  [-5]=>
  int(1)
  [0]=>
  int(2)
}

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:

Avant PHP 8.0.0, les crochets et accolades pouvaient être utilisés de façon interchangeable pour accéder aux éléments d'un tableau (e.g. $array[42] et $array{42} feraient tous deux la même chose dans l'exemple ci-dessus). La syntaxe avec les accolades a été rendue obsolète en PHP 7.4.0 et n'est plus supportée à partir de PHP 8.0.0.

Note:

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

Note:

Faire référence à un tableau à la sortie d'une fonction ou d'une méthode d'une valeur scalaire qui n'est pas une chaîne de caractères génère null. Avant PHP 7.4.0, ceci ne générait pas de message d'erreur. À partir de PHP 7.4.0, ceci émet une E_NOTICE ; À partir de PHP 8.0.0, ceci émet une E_WARNING.

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ée 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 lors de l'assignation $arr n'existe pas ou est défini à null ou false, 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 (c.-à-d. 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 affectation directe.

Note: À partir de PHP 7.1.0, l'application de l'opérateur d'index vide sur une chaîne lève une erreur fatale. Auparavant, la chaîne aurait été convertie silencieusement en tableau.

Note: À partir de PHP 8.1.0, créer un nouveau tableau à partir de false est obsolète. Créer un nouveau tableau depuis null et les valeurs indéfinies est toujours autorisé.

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

Il est à noter 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);

// Maintenant, 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
)

Déstructuration de tableau

Les tableaux peuvent être déstructurés en utilisant [] (à partir de PHP 7.1.0) ou list(). Ces constructions peuvent être utilisées pour déstructurer un tableau en variables distinctes.

La déstructuration de tableau peut être utilisée dans un foreach pour déstructurer un tableau multidimensionnel tout en itérant sur celui-ci.

Les éléments du tableau seront ignorés si la variable n'est pas fournie. Le tableau commence toujours à l'index 0.

À partir de PHP 7.1.0, les tableaux associatifs peuvent aussi être déstructurés. Cela permet de sélectionner plus facilement le bon élément dans les tableaux à indexation numérique, car l'index peut être explicitement spécifié.

La déstructuration de tableau peut être utilisée pour permuter facilement deux variables.

Note:

L'opérateur de décomposition (...) n'est pas supporté dans les assignations.

Note:

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

Note:

La déstructuration d’une valeur scalaire affecte null à toutes les variables.

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 de caractères ('bar' - il est à noter la présence des guillemets). 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. Par exemple, s'il n'y a aucune constante nommée bar, alors PHP substituera 'bar' dans la chaîne et l'utilisera.

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

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 :

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.