<?xml version="1.0" encoding="utf-8"?>

<!-- EN-Revision: 3061900171d4ae84d532571bfd6eda823726dad4 Maintainer: yannick Status: ready -->

<!-- Reviewed: no -->

<sect1 xml:id="language.types.array">

<title>Les tableaux</title>

<para>

Pour une liste de toutes les fonctions de tableau, voir le chapitre <link linkend="ref.array">fonctions de tableau</link> dans la documentation.

</para>

<para>

Un tableau en PHP est en fait une carte ordonnée. Une carte est un type

qui associe des <emphasis>valeurs</emphasis> à des <emphasis>clés</emphasis>.

Ce type est optimisé pour différentes utilisations ; il peut être considéré

comme un tableau, une liste, une table de hachage, un dictionnaire, une

collection, une pile, une file d'attente et probablement plus. On peut avoir,

comme valeur d'un tableau, d'autres tableaux, multidimensionnels ou non.

</para>

<para>

La structure de ces données dépasse l'objet de ce manuel, mais au moins

un exemple est fourni pour chacun des cas évoqués. Pour plus d'informations,

se reporter aux différentes explications sur le sujet que l'on trouve

sur le web.

</para>

<sect2 xml:id="language.types.array.syntax">

<title>Syntaxe</title>

<sect3 xml:id="language.types.array.syntax.array-func">

<title>Syntaxe d'un tableau</title>

<para>

Un tableau peut être créé en utilisant la structure de langage

<function>array</function>. Il prend un nombre illimité de paramètres,

chacun séparé par une virgule, sous la forme d'une paire

<literal><replaceable>key</replaceable> =&gt;

<replaceable>value</replaceable></literal>.

</para>

<synopsis>

array(

<optional><replaceable>key</replaceable> =&gt; </optional><replaceable>value</replaceable>,

<optional><replaceable>key2</replaceable> =&gt; </optional><replaceable>value2</replaceable>,

<optional><replaceable>key3</replaceable> =&gt; </optional><replaceable>value3</replaceable>,

...

)</synopsis>

<!-- Do not fix the whitespace for the synopsis end element. A limitation of PhD prevents proper trimming -->

<para>

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.

<literal>array(1, 2)</literal> est préféré à <literal>array(1, 2, )</literal>.

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.

</para>

<note>

<para>

Une syntaxe de tableau courte existe qui remplace

<literal>array()</literal> par <literal>[]</literal>.

</para>

</note>

<example>

<title>Un tableau simple</title>

<programlisting role="php">

<![CDATA[

<?php

$array1 = array(

"foo" => "bar",

"bar" => "foo",

);

// Utilisant la syntaxe de tableau courte

$array2 = [

"foo" => "bar",

"bar" => "foo",

];

var_dump($array1, $array2);

?>

]]>

</programlisting>

</example>

<para>

La clé <replaceable>key</replaceable> peut être soit un <type>int</type>,

soit une &string;. La valeur <replaceable>value</replaceable> peut être

de n'importe quel type.

</para>

<para xml:id="language.types.array.key-casts">

De plus, les modifications de type suivantes surviendront pour la clé <replaceable>key</replaceable> :

<itemizedlist>

<listitem>

<simpara>

Les chaînes de caractères contenant un entier valide, sauf si le nombre

est précédé d'un signe <literal>+</literal> seront modifiées en un type

entier. C.-à-d. la clé <literal>"8"</literal> sera effectivement stockée comme

l'entier <literal>8</literal>. D'un autre côté, <literal>"08"</literal> ne sera

pas modifié, sachant que ce n'est pas un entier décimal valide.

</simpara>

</listitem>

<listitem>

<simpara>

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é <literal>8.7</literal>

sera stockée sous l'entier <literal>8</literal>.

</simpara>

</listitem>

<listitem>

<simpara>

Les booléens seront modifiés en entier également, c.-à-d. la clé

&true; sera stockée sous l'entier <literal>1</literal>

et la clé &false; sous l'entier <literal>0</literal>.

</simpara>

</listitem>

<listitem>

<simpara>

La valeur <type>Null</type> sera modifiée en une chaîne vide, c.-à-d. la clé

<literal>null</literal> sera stockée sous la chaîne de caractères <literal>""</literal>.

</simpara>

</listitem>

<listitem>

<simpara>

Les tableaux et les objets <emphasis>ne peuvent pas</emphasis> être utilisés comme clé.

Toute tentative en ce sens émettra l'alerte suivante : <literal>Illegal offset type</literal>.

</simpara>

</listitem>

</itemizedlist>

</para>

<para>

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.

</para>

<example>

<title>Exemple sur la modification de type et l'écrasement</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

1 => "a",

"1" => "b",

1.5 => "c",

true => "d",

);

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(1) {

[1]=>

string(1) "d"

}

]]>

</screen>

<para>

Vu que toutes les clés de l'exemple ci-dessus sont modifiées en l'entier

<literal>1</literal>, la valeur sera écrasée sur chaque nouvel élément,

et seul le dernier dont la valeur assignée est <literal>"d"</literal> sera

conservé.

</para>

</example>

<para>

Les tableaux PHP peuvent contenir des clés de type

<type>int</type> et <type>string</type> en même temps,

vu que PHP ne distingue pas les tableaux indexés et les tableaux associatifs.

</para>

<example>

<title>Exemple avec des clés de type <type>int</type> et <type>string</type></title>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

"foo" => "bar",

"bar" => "foo",

100 => -100,

-100 => 100,

);

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(4) {

["foo"]=>

string(3) "bar"

["bar"]=>

string(3) "foo"

[100]=>

int(-100)

[-100]=>

int(100)

}

]]>

</screen>

</example>

<para>

La clé <replaceable>key</replaceable> est optionnelle. Si elle n'est

pas spécifiée, PHP utilisera un incrément de la dernière clé entière utilisée.

</para>

<example>

<title>Tableaux indexés sans clé</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array("foo", "bar", "hello", "world");

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(4) {

[0]=>

string(3) "foo"

[1]=>

string(3) "bar"

[2]=>

string(5) "hello"

[3]=>

string(5) "world"

}

]]>

</screen>

</example>

<para>

Il est possible de spécifier la clé seulement pour quelques éléments

et ne pas la fournir pour d'autres :

</para>

<example>

<title>Exemple avec des clés seulement pour quelques éléments</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

"a",

"b",

6 => "c",

"d",

);

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(4) {

[0]=>

string(1) "a"

[1]=>

string(1) "b"

[6]=>

string(1) "c"

[7]=>

string(1) "d"

}

]]>

</screen>

<para>

Comme on peut le voir, la dernière valeur <literal>"d"</literal>

a été assignée à la clé <literal>7</literal>. Ceci est dû au fait que

la dernière clé entière la plus grande utilisée auparavant était <literal>6</literal>.

</para>

</example>

<example>

<title>Exemple complexe sur la modification de type et l'écrasement</title>

<para>

Cet exemple inclut toutes les variations de modification de type de clés

et écrasements des éléments.

</para>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

1 => 'a',

'1' => 'b', // la valeur "a" sera écrasée par "b"

1.5 => 'c', // la valeur "b" sera écrasée par "c"

-1 => 'd',

'01' => 'e', // comme ceci n'est pas un entier sous forme de chaîne, cela n'écrasera PAS la clé pour 1

'1.5' => 'f', // comme ceci n'est pas un entier sous forme de chaîne, cela n'écrasera pas la clé pour 1

true => 'g', // la valeur "c" sera écrasée par "g"

false => 'h',

'' => 'i',

null => 'j', // la valeur "i" sera écrasée par "j"

'k', // la valeur "k" est assignée à la clé 2. Ceci est dû au fait que la dernière clé entière la plus grande utilisée auparavant était 1

2 => 'l', // la valeur "k" sera écrasée par "l"

);

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

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"

}

]]>

</screen>

</example>

<example>

<title>Exemple d'index négatif</title>

<simpara>

Lorsqu'une clé entière négative <literal>n</literal> est assignée, PHP prendra soin

d'assigner la clé suivante à <literal>n+1</literal>.

</simpara>

<programlisting role="php">

<![CDATA[

<?php

$array = [];

$array[-5] = 1;

$array[] = 2;

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(2) {

[-5]=>

int(1)

[-4]=>

int(2)

}

]]>

</screen>

<warning>

<simpara>

Avant PHP 8.3.0, l'assignation d'une clé entière négative <literal>n</literal>

assignait la clé suivante à <literal>0</literal>. L'exemple précédent aurait

donc produit :

</simpara>

<informalexample>

<screen>

<![CDATA[

array(2) {

[-5]=>

int(1)

[0]=>

int(2)

}

]]>

</screen>

</informalexample>

</warning>

</example>

</sect3>

<sect3 xml:id="language.types.array.syntax.accessing">

<title>Accès aux éléments d'un tableau en utilisant la syntaxe à base

de crochets</title>

<para>

Les éléments d'un tableau peuvent être accédés en utilisant

la syntaxe <literal>array[key]</literal>.

</para>

<example>

<title>Accès aux éléments d'un tableau</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

"foo" => "bar",

42 => 24,

"multi" => array(

"dimensional" => array(

"array" => "foo"

)

)

);

var_dump($array["foo"]);

var_dump($array[42]);

var_dump($array["multi"]["dimensional"]["array"]);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

string(3) "bar"

int(24)

string(3) "foo"

]]>

</screen>

</example>

<note>

<para>

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.

<literal>$array[42]</literal> et <literal>$array{42}</literal> 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.

</para>

</note>

<example>

<title>Faire référence à un tableau à la sortie d'une fonction ou d'une méthode</title>

<programlisting role="php">

<![CDATA[

<?php

function getArray() {

return array(1, 2, 3);

}

$secondElement = getArray()[1];

var_dump($secondElement);

?>

]]>

</programlisting>

</example>

<note>

<para>

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 <constant>E_WARNING</constant> sera émise (E_NOTICE avant PHP 8.0.0),

et le résultat vaudra &null;.

</para>

</note>

<note>

<para>

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 &string; 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 <constant>E_NOTICE</constant> ;

À partir de PHP 8.0.0, ceci émet une <constant>E_WARNING</constant>.

</para>

</note>

</sect3>

<sect3 xml:id="language.types.array.syntax.modifying">

<title>Création/modification avec des crochets</title>

<para>

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

</para>

<para>

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 : <literal>[]</literal>.

</para>

<synopsis>

$arr[<replaceable>clé</replaceable>] = <replaceable>valeur</replaceable>;

$arr[] = <replaceable>valeur</replaceable>;

// <replaceable>clé</replaceable> peut être un &integer; ou une &string;

// <replaceable>valeur</replaceable> peut être n'importe quel type</synopsis>

<para>

Si lors de l'assignation <varname>$arr</varname> 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 <varname>$arr</varname>

contient déjà quelques valeurs (c.-à-d. <type>string</type> depuis la variable demandée)

alors cette valeur restera en place et <literal>[]</literal> peut attendre

un <link linkend="language.types.string.substr">opérateur d'accès

sur une chaîne</link>. C'est toujours un meilleur choix que d'initialiser

une variable par affectation directe.

</para>

<note>

<simpara>

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

</simpara>

</note>

<note>

<simpara>

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

</simpara>

</note>

<para>

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

<function>unset</function> sur la clé désirée.

</para>

<example>

<title>Utilisation des crochets avec les tableaux</title>

<programlisting role="php">

<![CDATA[

<?php

$arr = array(5 => 1, 12 => 2);

$arr[] = 56; // Identique à $arr[13] = 56;

// à cet endroit du script

$arr["x"] = 42; // Ceci ajoute un nouvel élément au

// tableau avec la clé "x"

unset($arr[5]); // Ceci efface l'élément du tableau

var_dump($arr);

unset($arr); // Ceci efface complètement le tableau

var_dump($arr);

?>

]]>

</programlisting>

</example>

<note>

<para>

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 <literal>0</literal> (zéro).

</para>

<para>

Il est à noter que la clé entière maximale pour cette opération <emphasis>n'a

pas besoin d'exister dans le tableau au moment de la manipulation</emphasis>.

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 :

</para>

<informalexample>

<programlisting role="php">

<![CDATA[

<?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);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

Array

(

[0] => 1

[1] => 2

[2] => 3

[3] => 4

[4] => 5

)

Array

(

)

Array

(

[5] => 6

)

Array

(

[0] => 6

[1] => 7

)

]]>

</screen>

</informalexample>

</note>

</sect3>

<sect3 xml:id="language.types.array.syntax.destructuring">

<title>Déstructuration de tableau</title>

<para>

Les tableaux peuvent être déstructurés en utilisant <literal>[]</literal>

(à partir de PHP 7.1.0) ou <function>list</function>.

Ces constructions peuvent être utilisées pour déstructurer un tableau en variables distinctes.

</para>

<example>

<title>Déstructuration de tableau</title>

<programlisting role="php">

<![CDATA[

<?php

$tableau_source = ['foo', 'bar', 'baz'];

[$foo, $bar, $baz] = $tableau_source;

echo $foo, PHP_EOL; // affiche "foo"

echo $bar, PHP_EOL; // affiche "bar"

echo $baz, PHP_EOL; // affiche "baz"

?>

]]>

</programlisting>

</example>

<para>

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.

</para>

<example>

<title>Déstructuration de tableau dans un foreach</title>

<programlisting role="php">

<![CDATA[

<?php

$tableau_source = [

[1, 'John'],

[2, 'Jane'],

];

foreach ($tableau_source as [$id, $name]) {

echo "{$id}: '{$name}'\n";

}

?>

]]>

</programlisting>

</example>

<para>

Les éléments du tableau seront ignorés si la variable n'est pas fournie.

Le tableau commence toujours à l'index <literal>0</literal>.

</para>

<example>

<title>Ignorer des éléments</title>

<programlisting role="php">

<![CDATA[

<?php

$tableau_source = ['foo', 'bar', 'baz'];

// Assigne l'élément situé à l'indice 2 à la variable $baz

[, , $baz] = $tableau_source;

echo $baz; // Affiche "baz"

?>

]]>

</programlisting>

</example>

<para>

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

</para>

<example>

<title>Déstructuration de tableau associatif</title>

<programlisting role="php">

<![CDATA[

<?php

$tableau_source = ['foo' => 1, 'bar' => 2, 'baz' => 3];

// Assigne l'élément situé à l'indice 'baz' à la variable $three

['baz' => $three] = $tableau_source;

echo $three, PHP_EOL; // Affiche "3"

$tableau_source = ['foo', 'bar', 'baz'];

// Assigne l'élément situé à l'indice 2 à la variable $baz

[2 => $baz] = $tableau_source;

echo $baz, PHP_EOL; // Affiche "baz"

?>

]]>

</programlisting>

</example>

<para>

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

deux variables.

</para>

<example>

<title>Permuter deux variables</title>

<programlisting role="php">

<![CDATA[

<?php

$a = 1;

$b = 2;

[$b, $a] = [$a, $b];

echo $a, PHP_EOL; // Affiche 2

echo $b, PHP_EOL; // Affiche 1

?>

]]>

</programlisting>

</example>

<note>

<para>

L'opérateur de décomposition (<literal>...</literal>) n'est pas

supporté dans les assignations.

</para>

</note>

<note>

<para>

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 <constant>E_WARNING</constant> sera émise (E_NOTICE avant PHP 8.0.0),

et le résultat vaudra &null;.

</para>

</note>

<note>

<para>

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

</para>

</note>

</sect3>

</sect2><!-- end syntax -->

<sect2 xml:id="language.types.array.useful-funcs">

<title>Fonctions utiles</title>

<para>

Il y a beaucoup de fonctions utiles pour travailler avec les tableaux.

Il est recommandé de lire la section de ce manuel sur les

<link linkend="ref.array">fonctions</link> en rapport avec les tableaux.

</para>

<note>

<para>

La fonction <function>unset</function> permet d'effacer les clés d'un tableau.

Il est à noter que le tableau ne sera <emphasis>pas</emphasis>

ré-indexé. Pour réaliser un effacement complet et une ré-indexation

du tableau, il faut utiliser la fonction

<function>array_values</function>.

</para>

<example>

<title>Effacer des éléments intermédiaires</title>

<programlisting role="php">

<![CDATA[

<?php

$a = array(1 => 'one', 2 => 'two', 3 => 'three');

/* produira un tableau comme ceci

$a = array(1 => 'one', 3 => 'three');

et NON un tableau comme ceci

$a = array(1 => 'one', 2 =>'three');

*/

unset($a[2]);

var_dump($a);

$b = array_values($a);

// Maintenant, $b vaut array(0 => 'one', 1 =>'three')

var_dump($b);

?>

]]>

</programlisting>

</example>

</note>

<para>

La structure de contrôle &foreach; existe tout spécialement

pour les tableaux. Elle fournit une manière pratique

de parcourir un tableau.

</para>

</sect2>

<sect2 xml:id="language.types.array.donts">

<title>Ce qu'il est possible de faire ou non avec un tableau</title>

<sect3 xml:id="language.types.array.foo-bar">

<title>Pourquoi <literal>$foo[bar]</literal> est incorrect ?</title>

<para>

Utiliser toujours des guillemets autour d'un index littéral. Par exemple,

<literal>$foo['bar']</literal> est correct, alors que

<literal>$foo[bar]</literal> ne l'est pas. Mais pourquoi ? il est courant

de rencontrer ce genre de syntaxe dans d'anciens scripts :

</para>

<informalexample>

<programlisting role="php">

<![CDATA[

<?php

$foo[bar] = 'enemy';

echo $foo[bar];

// etc

?>

]]>

</programlisting>

</informalexample>

<para>

C'est incorrect, mais ça fonctionne. La raison est que ce code a une constante

indéfinie (<literal>bar</literal>) plutôt qu'une &string;

(<literal>'bar'</literal> - notez les guillemets).

Cela fonctionne car PHP convertit automatiquement une <emphasis>chaîne nue</emphasis>

(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 <constant>bar</constant>,

alors PHP substituera <literal>'bar'</literal> dans la chaîne et l'utilisera.

</para>

<warning>

<simpara>

La solution de recours qui considère une constante non-définie comme une

chaîne de caractères nue est une erreur de niveau <constant>E_NOTICE</constant>.

Ceci est obsolète à partir de PHP 7.2.0, et émet une erreur de niveau

<constant>E_WARNING</constant>.

À partir de PHP 8.0.0, ceci a été retiré et lance une exception

<classname>Error</classname>.

</simpara>

</warning>

<simpara>

Ceci ne signifie pas qu'il faut <emphasis>toujours</emphasis> mettre la clé entre guillemets.

Ne pas utiliser de guillemets avec les clés qui sont des

<link linkend="language.constants">constantes</link> ou des

<link linkend="language.variables">variables</link>, car cela empêcherait PHP de

les interpréter.

</simpara>

<example>

<title>Clé entre guillemets</title>

<programlisting role="php">

<![CDATA[

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

}

?>

]]>

</programlisting>

</example>

&example.outputs;

<screen>

<![CDATA[

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

]]>

</screen>

<para>

Plus d'exemples pour expliquer ce comportement :

</para>

<example>

<title>Plus d'exemples</title>

<programlisting role="php">

<![CDATA[

<?php

// Affichons toutes les erreurs

error_reporting(E_ALL);

$arr = array('fruit' => 'apple', 'veggie' => 'carrot');

// Correct

echo $arr['fruit'], PHP_EOL; // apple

echo $arr['veggie'], PHP_EOL; // carrot

// Incorrect. Ceci ne fonctionne pas et lance une erreur PHP

// on utilise la constante nommée fruit qui est indéfinie

//

// Error: Undefined constant "fruit"

try {

echo $arr[fruit];

} catch (Error $e) {

echo get_class($e), ': ', $e->getMessage(), PHP_EOL;

}

// Ceci définit une constante pour expliquer ce qui ne va pas. La valeur 'veggie'

// est assignée à la constante nommée fruit.

define('fruit', 'veggie');

// Noter la différence maintenant

echo $arr['fruit'], PHP_EOL; // apple

echo $arr[fruit], PHP_EOL; // carrot

// Ce qui suit est correct, car c'est dans une chaîne. Les constantes ne sont pas recherchées

// dans les chaînes, et donc, aucune erreur ne sera émise

echo "Hello $arr[fruit]", PHP_EOL; // Hello apple

// Avec une exception : les accolades autour d'un tableau dans une chaîne permettent

// aux constantes d'être interprétées

echo "Hello {$arr[fruit]}", PHP_EOL; // Hello carrot

echo "Hello {$arr['fruit']}", PHP_EOL; // Hello apple

// La concaténation est une autre solution

echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple

?>

]]>

</programlisting>

</example>

<informalexample>

<programlisting role="php">

<![CDATA[

<?php

// Ceci ne fonctionnera pas, et provoquera une erreur d'analyse du type :

// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'

// Ceci s'applique aussi à l'utilisation des superglobales dans les chaînes

print "Hello $arr['fruit']";

print "Hello $_GET['foo']";

?>

]]>

</programlisting>

</informalexample>

<para>

Comme vu dans la section "<link linkend="language.types.array.syntax">syntaxe</link>",

ce qui se trouve entre crochets ('<literal>[</literal>' et

'<literal>]</literal>') doit être une expression. Ceci signifie que le code ci-dessous

fonctionne :

</para>

<informalexample>

<programlisting role="php">

<![CDATA[

<?php

echo $arr[somefunc($bar)];

?>

]]>

</programlisting>

</informalexample>

<para>

C'est un exemple d'utilisation d'une fonction retournant une valeur qui sera

la clé du tableau. PHP comprend également les constantes :

</para>

<informalexample>

<programlisting role="php">