lundi 8 septembre 2014

Balises PHP
Lorsque PHP traite un fichier, il cherche les balises d'ouverture et de fermeture (<?php et ?>) qui délimitent le code qu'il doit interpréter. De cette manière, cela permet à PHP d'être intégré dans toutes sortes de documents, car tout ce qui se trouve en dehors des balises ouvrantes / fermantes de PHP est ignoré.
PHP autorise aussi des balises ouvrantes dites "courtes" (<? et ?>) que nous vous conseillons vivement de ne pas utiliser car elles ne sont seulement disponibles que lors de l'activation de la directive de configuration short_open_tag du php.ini, ou si PHP a été configuré avec l'option --enable-short-tags .
Si un fichier est purement du code PHP, il est préférable de ne pas placer la balise de fermeture à la fin du fichier. Ceci permet d'éviter d'oublier un espace ou une nouvelle ligne après la balise de fermeture de PHP, ce qui causerait des effets non voulus car PHP commencera à afficher la sortie, ce qui n'est souvent pas ce qui est désiré.
<?php
echo "Bonjour le monde !";

// ... encore du code

echo "Dernière instruction";

// le script se termine ici, sans la balise de fermeture PHP

Échappement depuis du HTML
Tout ce qui se trouve en dehors d'une paire de balises ouvrantes/fermantes est ignoré par l'analyseur PHP, ce qui permet d'avoir des fichiers PHP mixant les contenus. Ceci permet à PHP d'être contenu dans des documents HTML, pour créer par exemple des templates.
< p>Ceci sera ignoré par PHP et affiché au navigateur.</p>
<?php echo 'Alors que ceci sera analysé par PHP.'; ?>
<p>Ceci sera aussi ignoré par PHP et affiché au navigateur.</p>
Ceci fonctionne comme prévu parce que lorsque l'interpréteur PHP rencontre la balise fermante ?>, il commence simplement à afficher ce qu'il rencontre (mise à part s'il est immédiatement suivi d'une nouvelle ligne : voir l'instruction de séparation) jusqu'à ce qu'il rencontre une autre balise ouvrante même si PHP se trouve au milieu d'une instruction conditionnelle, au quel cas, l'interpréteur va déterminer la condition à prendre en compte avant de prendre une décision sur ce qui doit être afficher. Voir le prochain exemple.
Utilisation de structures avec des conditions
Exemple #1 Echappement avancé en utilisant des conditions
<?php if ($expression == true): ?>
  Ceci sera affiché si l'expression est vrai.
<?php else: ?>
  Sinon, ceci sera affiché.
<?php endif; ?>
Dans cet exemple, PHP va ignorer les blocs où la condition n'est pas remplie, même si ils sont en dehors des balises ouvrantes/fermantes de PHP. PHP va les ignorer suivant la condition vu que l'interpréteur PHP va passer les blocs contenant ce qui n'est pas remplie par la condition.
Pour afficher de gros blocs de texte, il est plus efficace de sortir du mode d'analyse de PHP plutôt que d'envoyer le texte via la fonction echo ou print.
Il y a quatre paires différentes de balises ouvrantes / fermantes qui peuvent être utilisées dans PHP. Deux de ces balises, <?php ?> et <script language="php"> </script>, sont toujours disponibles. Les deux autres sont les balises courtes et les balises du style ASP, et peuvent être activées ou désactivées depuis le fichier de configuration php.ini. Cependant, malgré le fait que des personnes trouvent les balises courtes et les balises du style ASP pratiques, elles sont moins portables et donc, généralement, non recommandées.
Note:
Notez également que si vous intégrez PHP dans des documents XML ou XHTML, vous devez utiliser les balises <?php ?> pour rester conforme aux standards.
Exemple #2 Balises d'ouvertures et de fermetures PHP
1.  <?php echo 'Si vous voulez réaliser des documents XHTML ou XML, faites comme ceci'; ?>

2.  <script language="php">
        echo 'quelques éditeurs (comme FrontPage)
                 n\'aiment pas ce genre d\'instructions';
    </script>

3.  <? echo 'ceci est le plus simple, une instruction SGML'; ?>
    <?= expression ?> Ceci est la version courte pour "<? echo expression ?>"

4.  <% echo 'Vous pouvez optionnellement utiliser les balises ASP-style'; %>
    <%= $variable; # Ceci est la version courte pour "<% echo . . ." %>
Bien que les balises vues dans les exemples un et deux sont toutes les deux disponibles, l'exemple un est le plus communément utilisé et le plus recommandé des deux.
Les balises courtes (troisième exemple) ne sont disponibles que s'elles ont été activées via la directive short_open_tag du fichier de configuration php.ini, ou si PHP a été configuré avec l'option --enable-short-tags .
Les balises du style ASP (quatrième exemple) sont uniquement disponibles lorsqu'elles sont activées via la directive asp_tags du fichier de configuration php.ini.
Note:
L'utilisation des balises courtes doit être bannie lors de développements d'applications ou de bibliothèques qui sont destinées à être redistribuées, ou déployées sur des serveurs qui ne sont pas sous votre contrôle, car les balises courtes peuvent ne pas être supportées sur le serveur cible. Pour réaliser du code portable, qui peut être redistribué, n'utilisez jamais les balises courtes.
Note:
En PHP 5.2 et antérieures, l'analyseur n'autorisait pas un tag ouvrant <?php comme seul élément d'une page. Ceci est permis à compter de la version 5.3 de PHP lorsqu'il y a un ou plusieurs espaces après la balise ouvrante.
Note:
Depuis PHP 5.4, le tag echo court <?= est toujours reconnu et valide, suivant la configuration de l'option short_open_tag.

Séparation des instructions
Comme en C ou en Perl, PHP requiert que les instructions soient terminées par un point-virgule à la fin de chaque instruction. La balise fermante d'un bloc de code PHP implique automatiquement un point-virgule ; vous n'avez donc pas besoin d'utiliser un point-virgule pour terminer la dernière ligne d'un bloc PHP. La balise fermante d'un bloc inclura immédiatement un caractère de nouvelle ligne si un est présent.
Exemple #1 Séparation des instructions
<?php
    echo 'Ceci est un test';
?>

<?php echo 'Ceci est un test' ?>

<?php echo 'Oubli de la balise fermante';
Note:
La balise fermante d'un bloc PHP à la fin d'un fichier est optionnelle, et parfois, il est utile de l'omettre lors de l'utilisation de la fonction include ou de la fonction require, car les espaces non désirés n'apparaîtront pas à la fin des fichiers, et ainsi, vous pourrez toujours ajouter des en-têtes à la réponse plus tard. C'est utile également si vous voulez utiliser l'affichage du buffer et que vous ne voulez pas voir d'espaces blancs ajoutés à la fin des parties générées par les fichiers inclus.

PHP supporte 8 types basiques.
4 types scalaires :
2 types composés :
Et finalement, 2 types spéciaux :
Ce manuel introduit également quelques pseudo-types pour des raisons de lisibilité :
Et la pseudo-variable $....
Ce manuel peut toutefois contenir des références au type "double". Considérez ce type comme étant un type "float". Les deux noms n'existent que pour des raisons historiques.
Le type d'une variable n'est pas toujours défini par le programmeur ; il peut être défini par PHP au moment de l'exécution, suivant le contexte dans lequel la variable est utilisée.
Note: Pour vérifier le type et la valeur d'une expression, utilisez la fonction var_dump().
Pour afficher une représentation humainement lisible d'un type aux fins de déboguage, utilisez la fonction gettype(). Pour vérifier un certain type, n'utilisez pas la fonction gettype(), mais plutôt les fonctions is_type. Voici quelques exemples :
<?php
$a_bool = TRUE;   // un booléen
$a_str  = "foo";  // une chaîne de caractères
$a_str2 = 'foo';  // une chaîne de caractères
$an_int = 12;     // un entier

echo gettype($a_bool); // affiche :  boolean
echo gettype($a_str);  // affiche :  string

// Si c'est un entier, incrément de 4
if (is_int($an_int)) {
    $an_int += 4;
}

// Si $a_bool est une chaîne de caractères, on l'affiche
if (is_string($a_bool)) {
    echo "String: $a_bool";
}
?>
Pour forcer la conversion d'une variable en un certain type, vous pouvez transtyper (cast) la variable ou utiliser la fonction settype().
Notez qu'une variable peut être évaluée avec différentes valeurs dans certaines situations, suivant son type à un moment donné. Pour plus d'informations, lisez la section sur le transtypage. La table de comparaison des types peut également être très utile, montrant différents exemples.

Booléen

C'est le type le plus simple. Un booléen représente une valeur de vérité. Il peut valoir TRUE ou FALSE.

Syntaxe

Pour spécifier un booléen littéral, utilisez le mot-clé TRUE ou FALSE. Les deux sont insensibles à la casse.
<?php
$foo = True; // assigne la valeur TRUE à $foo
?>
Typiquement, le résultat d'un opérateur qui retourne un booléen, passé ensuite à une structure de contrôle.
<?php
// == est un opérateur qui teste
// l'égalité et retourne un booléen
if ($action == "show_version") {
    echo "La version est 1.23";
}

// ceci n'est pas nécessaire...
if ($show_separators == TRUE) {
    echo "<hr>\n";
}

// ...à la place, vous pouvez utiliser, avec la même signification :
if ($show_separators) {
    echo "<hr>\n";
}
?>

Conversion en booléen

Pour convertir explicitement une valeur en booléen, utilisez (bool) ou (boolean). Cependant, dans la plupart des cas, le transtypage n'est pas nécessaire, sachant qu'une valeur sera automatiquement convertie si un opérateur, une fonction ou une structure de contrôle demandent un argument de type booléen.
Voir aussi le transtypage.
Lors d'une conversion en booléen, les valeurs suivantes sont considérées comme FALSE :
Toutes les autres valeurs sont considérées comme TRUE (y compris toutes les ressources).
Avertissement
-1 est considéré comme TRUE, comme tous les nombres différents de zéro (négatifs ou positifs) !
<?php
var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)
var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)
?>

Les entiers

Un entier est un nombre appartenant à la classe ℤ = {..., -2, -1, 0, 1, 2, ...}.
Voir aussi :

Syntaxe

Les entiers peuvent être spécifiés en notation décimale (base 10), hexadécimale (base 16), octale (base 8), ou binaire (base 2) optionnellement précédée d'un signe (- ou +).
Les entiers littéraux binaires sont disponibles depuis PHP 5.4.0.
Pour utiliser la notation octale, précédez le nombre d'un 0 (zéro). Pour utiliser la notation hexadécimale, précédez le nombre d'un 0x. Pour utiliser la notation binaire, précédez le nombre d'un 0b.
Exemple #1 Les entiers littéraux
<?php
$a = 1234; // un nombre décimal
$a = -123; // un nombre négatif
$a = 0123; // un nombre octal (équivalent à 83 en décimal)
$a = 0x1A; // un nombre héxadecimal (équivalent à 26 en décimal)
$a = 0b11111111; // un nombre binaire (équivalent à 255 en decimal)
?>
Formellement, la structure d'un entier littéral est : 
decimal     : [1-9][0-9]*
            | 0
 
hexadecimal : 0[xX][0-9a-fA-F]+
 
octal       : 0[0-7]+
 
integer     : [+-]?decimal
            | [+-]?hexadecimal
            | [+-]?octal
            | [+-]?binary
La taille d'un entier est dépendant de la plate-forme, cependant, une valeur maximale d'environ 2 milliards est habituelle (cela correspond à 32 bits signés). Les plateformes 64-bit ont habituellement une valeur maximale d'environ 9E18. PHP ne supporte pas les entiers non-signés. La taille d'un entier peut être déterminée en utilisant la constante PHP_INT_SIZE, et la valeur maximale, en utilisant la constante PHP_INT_MAX depuis PHP 4.4.0 et PHP 5.0.5.
Avertissement
Si un nombre invalide est fourni dans un entier octal (i.e. 8 ou 9), le reste du nombre est ignoré.
Exemple #2 Bizarrerie avec les valeurs octales
<?php
var_dump(01090); // 010 octal = 8 décimales
?>

Débordement d'entier

Si PHP rencontre un nombre supérieur au maximal d'un entier, il sera interprété comme un nombre décimal. De la même façon, une opération qui résulte en un nombre supérieur au nombre maximal d'un entier, retournera un nombre décimal.
Exemple #3 Dépassement d'entier sur un système 32-bit
<?php
$large_number = 2147483647;
var_dump($large_number);                     // int(2147483647)

$large_number = 2147483648;
var_dump($large_number);                     // float(2147483648)

$million = 1000000;
$large_number =  50000 * $million;
var_dump($large_number);                     // float(50000000000)
?>
Exemple #4 Dépassement d'entier sur un système 64-bit
<?php
$large_number = 9223372036854775807;
var_dump($large_number);                     // int(9223372036854775807)

$large_number = 9223372036854775808;
var_dump($large_number);                     // float(9.2233720368548E+18)

$million = 1000000;
$large_number =  50000000000000 * $million;
var_dump($large_number);                     // float(5.0E+19)
?>
Il n'y a pas d'opérateur de division entière en PHP. 1/2 contient en fait, float(0.5). La valeur peut être convertie en un entier en l'arrondissant, en utilisant la fonction round().
<?php
var_dump(25/7);         // float(3.5714285714286) 
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7));  // float(4) 
?>

Conversion en entier

Pour convertir explicitement une valeur en un entier, utilisez soit le mot-clé (int), soit (integer). Cependant, dans la plupart des cas, ce mot-clé n'est pas nécessaire vu qu'une valeur sera automatiquement convertie si un opérateur, une fonction ou une structure de contrôle demande un entier en guise d'argument. Une valeur peut également être convertie en un entier en utilisant la fonction intval().
Si une resource est convertie vers un integer, alors le résultat sera l'identifiant unique de la resource assigné par PHP à l'exécution.
Voir aussi le transtypage.

Depuis un booléen

FALSE correspond à 0 (zéro), et TRUE correspond à 1 (un).

Depuis un nombre à virgule flottante

Lorsque l'on convertit un nombre décimal en un entier, le nombre sera arrondi vers zéro.
Si le nombre à virgule flottante est au delà des limites des entiers (habituellement, +/- 2.15e+9 = 2^31 sur les plate-formes 32-bit et +/- 9.22e+18 = 2^63 sur les plate-formes 64-bit), le résultat sera indéfini, sachant que le nombre à virgule flottante n'a pas une précision suffisante pour donner un résultat entier exact. Aucune alerte n'est émise lorsque ce comportement survient !
Avertissement
Ne convertissez jamais une fraction inconnue en un entier, ceci peut engendrer un résultat inattendu.
<?php
echo (int) ( (0.1+0.7) * 10 ); // Affiche 7 !
?>
Voir aussi la section sur les alertes concernant la précision des nombres à virgule flottante.

Depuis des chaînes de caractères

Voir la section sur la conversion des chaînes en nombres

Depuis d'autres types

Attention
Le comportement de la conversion en un entier est indéfini depuis les autres types. Ne rapporter aucun comportement observé, sachant qu'ils peuvent changer sans avertissement.

Nombres décimaux

Les nombres décimaux, (aussi connus comme nombres à virgule flottante, "floats", "doubles", ou "real numbers") peuvent être spécifiés en utilisant les syntaxes suivantes :
<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>
Formellement : 
LNUM          [0-9]+
DNUM          ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM [+-]?(({LNUM} | {DNUM}) [eE][+-]? {LNUM})
La taille d'un nombre décimal est dépendant de la plate-forme, cependant, un nombre maximal de ~1.8e308 avec une précision sur 14 chiffres est une valeur commune (format 64 bits IEEE).
Avertissement

Précision des nombres décimaux

Les nombres décimaux ont une précision limitée. Même s'ils dépendent du système, PHP utilise le format de précision des décimaux IEEE 754, qui donnera une erreur maximale relative de l'ordre de 1.11e-16 (dûe aux arrondis). Les opérations arithmétiques non-élémentaires peuvent donner des erreurs plus importantes et bien sûr les erreurs doivent être prises en compte lorsque plusieurs opérations sont liées.
Aussi, les nombres rationnels exactement représentables sous forme de nombre à virgule flottante en base 10, comme 0.1 ou 0.7, n'ont pas de représentation exacte comme nombres à virgule flottante en base 2, utilisée en interne, et ce quelle que soit la taille de la mantisse. De ce fait, ils ne peuvent être convertis sans une petite perte de précision. Ceci peut mener à des résultats confus: par exemple, floor((0.1+0.7)*10) retournera normalement 7 au lieu de 8 attendu, car la représentation interne sera quelque chose comme 7.9999999999999991118....
Ainsi, ne faites jamais confiance aux derniers chiffres d'un nombre décimal, mais aussi, ne comparez pas l'égalité de 2 nombres décimaux directement. Si vous avez besoin d'une haute précision, les fonctions mathématiques de précision et les fonctions gmp sont disponibles.
Pour une explication "simple", reportez-vous au » guide relatif aux nombres à virgule flottante.

Conversion en un nombre décimal

Pour plus d'informations sur la conversion de chaînes en nombres décimaux, voir la section sur la conversion de chaînes en nombres décimaux. Pour les valeurs d'autres types, la conversion est effectuée en convertissant tout d'abord la valeur en un entier, puis, en nombre décimal. Voir la section sur la conversion en entier pour plus d'informations. Une notice est émise si un objet est converti en nombre décimal.

Comparing floats

Comme dit dans la note ci-dessus, le test d'égalité des valeurs de nombres décimaux est problématique, en raison de la façon dont ils sont représentés en interne. Cependant, il existe des façons de réaliser cette comparaison.
Pour tester l'égalité de valeurs de nombres décimaux, une borne supérieure de l'erreur relative à l'arrondi est utilisée. Cette valeur est connue comme étant l'epsilon de la machine, ou le unit roundoff, et est la différence la plus petite acceptable dans les calculs.
$a et $b sont égaux sur 5 nombres après la virgule.
<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;

if(abs($a-$b) < $epsilon) {
    echo "true";
}
?>

NaN

Quelques opérations numériques peuvent donner comme résultat une valeur représentée par la constante NAN. Ce résultat représente une valeur indéfinie ou non représentable lors de calculs avec des nombres à virgule flottante. Toute comparaison, même stricte de cette valeur avec une autre valeur, y compris cette constante elle-même, donnera une valeur de FALSE.
En raison du fait que NAN représente tout nombre de valeur différente, NAN ne doit pas être comparé à d'autres valeurs, y compris cette constante elle-même, et à la place, elle doit être vérifiée en utilisant la fonction is_nan().

Les chaînes de caractères 

Une chaîne de caractères est une série de caractères, où un caractère est la même chose qu'un octet. De ce fait, PHP ne supporte que les jeux de caractères comportant 256 caractères différents, et, donc, n'a pas de support natif pour l'Unicode. Reportez-vous aux détails sur le type chaîne de caractères pour plus d'informations.
Note: Une chaîne de caractères peut être d'une taille allant jusqu'à plus de 2Go (2147483647 octets maximum).

Syntaxe 

Une chaîne de caractères littérale peut être spécifiée de 4 façons différentes :

Entourée de guillemets simples 

La façon la plus simple de spécifier une chaîne de caractères est de l'entourer de guillemets simples (le caractère').
Pour spécifier un guillemet simple littéral, vous devrez l'échapper à l'aide d'un antislash (\). Pour spécifier un antislash littéral, doublez-le (\\). Notez que si vous tentez d'échapper n'importe quel autre caractère, l'antislash s'affichera, ce qui signifie que les autres séquences auquelles vous êtes éventuellement habitués (comme \r ou\n) s'afficheront telles quelles, sans avoir une quelconque signification particulière.
Note: Contrairement aux syntaxes avec double guillemets et heredoc, les variables et les séquences d'échappement pour les caractères spéciaux ne seront pas interprétées lorsqu'elles figurent dans une chaîne de caractères entourée de guillemets simples.
<?php
echo 'ceci est une chaîne simple';

echo 'Vous pouvez également ajouter des nouvelles lignes
dans vos chaînes
de cette façon';

// Affiche : Arnold a dit : "I'll be back"
echo 'Arnold a dit : "I\'ll be back"';

// Affiche : Voulez-vous supprimer C:\*.*?
echo 'Voulez-vous supprimer C:\\*.*?';

// Affiche : Voulez-vous supprimer C:\*.*?
echo 'Voulez-vous supprimer C:\*.*?';

// Affiche : Ceci n'affichera pas \n de nouvelle ligne
echo 'Ceci n\'affichera pas \n de nouvelle ligne';

// Affiche : Les variables ne seront pas $traitees $ici
echo 'Les variables ne seront pas $traitees $ici';
?>

Entourée de guillemets doubles 

Si la chaîne de caractères est entourée de guillemets doubles ("), PHP interprétera plus de séquences d'échappement comme des caractères spéciaux :
Caractères échappés
Séquence
Signification
\n
Fin de ligne (LF ou 0x0A (10) en ASCII)
\r
Retour à la ligne (CR ou 0x0D (13) en ASCII)
\t
Tabulation horizontale (HT or 0x09 (9) en ASCII)
\v
Tabulation verticale (VT ou 0x0B (11) en ASCII) (depuis PHP 5.2.5)
\e
échappement (ESC or 0x1B (27) en ASCII) (depuis PHP 5.4.0)
\f
Saut de page (FF ou 0x0C (12) en ASCII) (depuis PHP 5.2.5)
\\
Antislash
\$
Signe dollar
\"
Guillemet double
\[0-7]{1,3}
La séquence de caractères correspondant à cette expression rationnelle est un caractère, en notation octale
\x[0-9A-Fa-f]{1,2}
La séquence de caractères correspondant à cette expression rationnelle est un caractère, en notation hexadécimale
De la même façon que pour les chaînes entourées de guillemets simples, l'échappement de tout autre caractère affichera l'antislash. Avant PHP 5.1.1, l'antislash de \{$var} n'était pas affiché.
La fonctionnalité la plus intéressante des chaînes entourées de guillemets doubles est que les noms de variables seront interprétés. Voir la documentation sur l'analyse des chaînes de caractères pour plus de détails.

Syntaxe Heredoc 

Une 3ème façon de délimiter une chaîne de caractères est la syntaxe Heredoc : <<<. Après cet opérateur, un identifiant est fourni, suivi d'une nouvelle ligne. La chaîne en elle-même vient ensuite, suivie du même identifiant pour fermer la notation.
L'identifiant de fin doit commencer à la première colonne de la ligne. De plus, l'identifiant doit suivre les mêmes règles que n'importe quel autre libellé PHP : il ne doit contenir que des caractères alphanumériques et des soulignés, et doit commencer par un caractère non numérique ou un souligné ("underscore").
Avertissement
Il est très important de noter que la ligne contenant l'identifiant de fin ne doit contenir aucun autre caractère, mis à part un point-virgule (;). Cela signifie en particulier que l'identifiant ne doit pas être indenté, et qu'il ne doit y avoir aucun espace ou tabulation avant ou après le point-virgule. Il est également important de garder à l'esprit que le premier caractère avant l'identifiant de fermeture doit être une nouvelle ligne telle que définie par le système d'exploitation ; sur les systèmes Unix, incluant Mac OSX, il s'agit du caractère \n. Le délimiteur de fermeture doit aussi être suivi d'une nouvelle ligne.
Si cette règle n'est pas respectée et que l'identifiant de fermeture n'est pas "propre", il ne sera pas considéré comme identifiant de fermeture, et PHP continuera à en chercher un. Si un identifiant de fermeture "propre" n'est pas trouvé avant la fin du fichier courant, une erreur d'analyse sera émise à la dernière ligne.
Heredoc ne peut être utilisé pour initialiser les proriétés d'une classe. Depuis PHP 5.3, cette limitation ne s'applique qu'aux Heredoc qui contiennent des variables.
Exemple #1 Exemple invalide
<?php
class foo {
    public $bar = <<<EOT
bar
    EOT;
}
?>
Heredoc se comporte exactement comme une chaîne entourée de guillemets doubles, sans les guillemets doubles. Cela signifie que les guillemets dans une syntaxe Heredoc n'ont pas besoin d'être échappés, mais que les codes d'échappement listés plus haut peuvent toujours être utilisés. Les variables seront interprétées, mais les mêmes attentions doivent être prises lorsque vous utilisez des variables complexes dans une syntaxe Heredoc qu'avec les autres types de chaînes.
Exemple #2 Exemple de chaînes Heredoc
<?php
$str = <<<EOD
Exemple de chaîne
sur plusieurs lignes
en utilisant la syntaxe Heredoc.
EOD;

/* Exemple plus complexe, avec des variables. */
class foo
{
    var $foo;
    var $bar;

    function foo()
    {
        $this->foo = 'Foo';
        $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
}

$foo = new foo();
$name = 'MyName';

echo <<<EOT
Mon nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques {$foo->bar[1]}.
Et ceci devrait afficher un 'A' majuscule : \x41
EOT;
?>
L'exemple ci-dessus va afficher :
Mon nom est "MyName". J'affiche quelques Foo.
Maintenant, j'affiche quelques Bar2.
Et ceci devrait afficher un 'A' majuscule : A
Il est aussi possible d'utiliser la syntaxe Heredoc pour passer des données en paramètre à une fonction :
Exemple #3 Exemple d'utilisation de Heredoc pour passer des arguments
<?php
var_dump(array(<<<EOD
foobar!
EOD
));
Depuis PHP 5.3.0, il est possible d'initialiser les variables statiques et les propriétés ou constantes de classes avec la syntaxe Heredoc :
Exemple #4 Utilisation de Heredoc pour initialiser des valeurs statiques
<?php
// Variables statiques
function foo()
{
    static $bar = <<<LABEL
Nothing in here...
LABEL;
}

// Constantes et propriétés de classe
class foo
{
    const BAR = <<<FOOBAR
Constant example
FOOBAR;

    public $baz = <<<FOOBAR
Property example
FOOBAR;
}
?>
Depuis PHP 5.3.0, l'identifiant de début de syntaxe Heredoc peut éventuellement être écrit entre guillemets doubles :
Exemple #5 Utilisation des guillemets doubles avec Heredoc
<?php
echo <<<"FOOBAR"
Hello World!
FOOBAR;
?>

Nowdoc 

Nowdoc est aux chaînes entourées de guillemets simples ce qu'Heredoc est aux chaînes entourées de guillemets doubles. Un Nowdoc est spécifié de manière similaire à un Heredoc, mais aucune analyse n'est effectuée dans une construction Nowdoc. Cette syntaxe est idéale pour embarquer du code PHP ou d'autres larges blocs de texte, sans avoir besoin d'échapper quoi que ce soit. Elle partage quelques fonctionnalités avec la syntaxe SGML <![CDATA[ ]]>, en ce qu'elle déclare un bloc de texte qui ne doit pas être analysé.
Nowdoc est identifié avec la même séquence <<< utilisée par Heredoc, mais l'identifiant qui suit est entouré de guillemets simples, comme <<<'EOT'. Toutes les règles concernant les identifiants Heredoc s'appliquent également aux identifiants Nowdoc, et, tout particulièrement, celles concernant la forme de l'identifiant de fin.
Exemple #6 Exemples de chaînes Nowdoc
<?php
$str = <<<'EOD'
Exemple de chaîne
sur plusieurs lignes
en utilisant la syntaxe Nowdoc.
EOD;

/* Exemple complexe, avec des variables. */
class foo
{
    public $foo;
    public $bar;

    function foo()
    {
        $this->foo = 'Foo';
        $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
}

$foo = new foo();
$name = 'MyName';

echo <<<'EOT'
Mom nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques {$foo->bar[1]}.
Ceci ne devrait pas afficher un 'A' : \x41
EOT;
?>
L'exemple ci-dessus va afficher :
Mom nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques {$foo->bar[1]}.
Ceci ne devrait pas afficher un 'A' : \x41
Note:
Contrairement à Heredoc, Nowdoc peut être utilisé dans n'importe quel contexte de données statiques. L'exemple typique est l'initialisation de proriétés ou de constantes de classe :
Exemple #7 Exemple avec des données statiques
<?php
class foo {
    public $bar = <<<'EOT'
bar
EOT;
}
?>
Note:
Le support de la syntaxe Nowdoc a été ajouté en PHP 5.3.0.

Analyse des variables 

Lorsqu'une chaîne de caractères est spécifiée entre guillemets doubles ou en Heredoc, les variables qu'elle contient sont interprétées.
Il existe 2 types de syntaxes : une simple et une complexe. La syntaxe simple est la plus commune et la plus pratique. Elle fournit une façon d'embarquer une variable, une valeur de tableau, ou une propriété d'objet dans une chaîne avec un minimum d'effort.
La syntaxe complexe se reconnaît à l'utilisation d'accolades autour de l'expression.
Syntaxe simple
Si un signe dollar ($) est rencontré, l'analyseur prendra autant de caractères que possible pour former un nom de variable valide. Vous pouvez entourer le nom de la variable avec des accolades, pour spécifier explicitement la fin de celui-ci.
<?php
$juice = "pomme";

echo "Il a bu du jus de $juice.".PHP_EOL;

// Invalide. "s" est un caractère valide dans un nom de variable, mais la variable est $juice.
echo "Il a bu du jus constitué de $juices.";
?>
L'exemple ci-dessus va afficher :
Il a bu du jus de pomme.
Il a bu du jus constitué de .
De la même façon, un index d'un tableau ou une propriété d'un objet peut être analysé. Avec les indices de tableaux, le crochet fermant (]) marque la fin de l'index. Les mêmes règles sont appliquées aux propriétés d'objets que pour les simples variables.
Exemple #8 Exemple de la syntaxe simple
<?php
$juices = array("pomme", "poire", "koolaid1" => "raisin");

echo "Il a bu du jus de $juices[0].".PHP_EOL;
echo "Il a bu du jus de $juices[1].".PHP_EOL;
echo "Il a bu du jus de $juices[koolaid1].".PHP_EOL;

class people {
    public $john = "John Smith";
    public $jane = "Jane Smith";
    public $robert = "Robert Paulsen";
    
    public $smith = "Smith";
}

$people = new people();

echo "$people->john a bu du jus de $juices[0].".PHP_EOL;
echo "$people->john a dit bonjour à $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
echo "$people->robert a dit bonjour aux $people->smiths."; // Ne fonctionne pas
?>
L'exemple ci-dessus va afficher :
Il a bu du jus de pomme.
Il a bu du jus de poire.
Il a bu du jus de raisin.
John Smith a bu du jus de pomme.
John Smith a dit bonjour à Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen a dit bonjour aux .
Pour tout ce qui est plus complexe, vous devriez utiliser la syntaxe complexe.
Syntaxe complexe
Cette syntaxe est appelée complexe, non pas parce qu'elle est complexe, mais parce qu'elle permet l'utilisation d'expressions complexes.
Toute variable scalaire, tableau, ou attribut d'objet représentable en tant que chaîne de caractères peut être utilisé avec cette syntaxe. Écrivez simplement l'expression de la même façon qu'elle apparaitrait à l'extérieur de la chaîne et, ensuite, entourez-là des caractères { et }. Sachant que le caractère { ne peut pas être échappé, cette syntaxe ne sera reconnue que lorsque le caractère $ suit immédiatement le caractère {. Utilisez {\$ pour afficher littéralement {$. Voici quelques exemples pour éclaircir ceci :
<?php
// Montre toutes les erreurs
error_reporting(E_ALL);

$great = 'fantastic';

// Ne fonctionne pas, affiche : This is { fantastic}
echo "This is { $great}";

// Fonctionne, affiche : This is fantastic
echo "This is {$great}";
echo "This is ${great}";

// Fonctionne
echo "This square is {$square->width}00 centimeters broad."; 

// Fonctionne, les clés entourées de guillemets simples ne fonctionnent qu'avec la syntaxe à accolades
echo "This works: {$arr['key']}";

// Fonctionne
echo "This works: {$arr[4][3]}";

// Ceci est faux pour la même raison pour laquelle $foo[bar] est faux à l'extérieur d'une chaîne.
// En d'autres termes, ceci fonctionnera, mais uniquement parce que PHP cherchera d'abord
// une constante nommée foo ; une erreur de niveau E_NOTICE (constante indéfinie) sera émise.
echo "This is wrong: {$arr[foo][3]}"; 

// Fonctionne. Lors de l'utilisation de tableaux multidimensionnels, utilisez toujours
// les accolades autour du tableau lorsqu'il se trouve dans la chaîne
echo "This works: {$arr['foo'][3]}";

// Fonctionne.
echo "This works: " . $arr['foo'][3];

echo "This works too: {$obj->values[3]->name}";

echo "This is the value of the var named $name: {${$name}}";

echo "This is the value of the var named by the return value of getName(): {${getName()}}";

echo "This is the value of the var named by the return value of \$object->getName(): {${$object->getName()}}";

// Ne fonctionne pas, affiche : This is the return value of getName(): {getName()}
echo "This is the return value of getName(): {getName()}";
?>
Il est également possible d'accéder aux propriétés de classes en utilisant des variables contenues dans des chaînes, en utilisant cette syntaxe.
<?php
class foo {
    var $bar = 'I am bar.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar}\n";
echo "{$foo->$baz[1]}\n";
?>
L'exemple ci-dessus va afficher :
I am bar.
I am bar.
Note:
Les appels aux fonctions, méthodes, variables statiques de classes, ainsi qu'aux constantes de classes à l'intérieur de {$} fonctionnent depuis PHP 5. Cependant, la valeur accédée sera interprétée comme le nom d'une variable dans le contexte où la chaîne est définie. L'utilisation de simples accolades ({}) ne fonctionnera pas pour accéder à la valeur retournée par des fonctions, méthodes, ou les valeurs de constantes et de variables statiques de classes.
<?php
// Affichage de toutes les erreurs.
error_reporting(E_ALL);

class beers {
    const softdrink = 'rootbeer';
    public static $ale = 'ipa';
}

$rootbeer = 'A & W';
$ipa = 'Alexander Keith\'s';

// Ceci fonctionne ; Affiche : I'd like an A & W
echo "I'd like an {${beers::softdrink}}\n";

// Ceci fonctionne également ; Affiche : I'd like an Alexander Keith's
echo "I'd like an {${beers::$ale}}\n";
?>

Accès et modification d'une chaîne, par caractère 

On peut accéder à, et modifier un, caractère d'une chaîne de caractères en spécifiant sa position (à partir de 0) en utilisant la même syntaxe que pour les tableaux, comme pour la variable $str[42]. Il convient dans ce cas de voir une chaîne de caractères comme un tableau. Les fonctions substr() et substr_replace() peuvent être utilisées lorsque vous voulez extraire ou remplacer plus d'un caractère.
Note: On peut également accéder à une chaîne en utilisant des accolades, comme ceci : $str{42}.
Avertissement
Écrire à une position hors de l'intervalle existant fait que la chaîne est complétée par des espaces jusqu'à cette position. Les positions sont toujours converties en valeur entière. Les types de positions invalides produisent une alerte E_NOTICE. Les positions négatives produisent une alerte E_NOTICE en écriture, mais retournent une chaîne vide en lecture. Seul le premier caractère d'une chaîne assignée est utilisé. Assigner une chaîne vide assigne le caractère NULL.
Avertissement
En interne, les chaînes PHP sont des tableaux d'octets. Aussi, l'accès ou la modification d'une chaîne en utilisant les crochets d'un tableau n'est pas multi-octets, et ne doit être utilisé qu'avec les chaînes dont l'encodage est sur un seul octet, comme ISO-8859-1.
Exemple #9 Quelques exemples de chaînes
<?php
// Récupération du premier caractère d'une chaîne
$str = 'This is a test.';
$first = $str[0];

// Récupération du troisième caractère d'une chaîne
$third = $str[2];

// Récupération du dernier caractère d'une chaîne
$str = 'This is still a test.';
$last = $str[strlen($str)-1]; 

// Modification du dernier caractère d'une chaîne
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';

?>
Depuis PHP 5.4, la position dans une chaîne doit être un entier, ou des chaînes pouvant être converties en entier, sinon, une alerte sera émise. Auparavant, une position comme "foo" était transformée silencieusement en 0.
Exemple #10 Différences entre PHP 5.3 et PHP 5.4
<?php
$str = 'abc';

var_dump($str['1']);
var_dump(isset($str['1']));

var_dump($str['1.0']);
var_dump(isset($str['1.0']));

var_dump($str['x']);
var_dump(isset($str['x']));

var_dump($str['1x']);
var_dump(isset($str['1x']));
?>
Résultat de l'exemple ci-dessus en PHP 5.3 :
string(1) "b"
bool(true)
string(1) "b"
bool(true)
string(1) "a"
bool(true)
string(1) "b"
bool(true)
Résultat de l'exemple ci-dessus en PHP 5.4 :
string(1) "b"
bool(true)
 
Warning: Illegal string offset '1.0' in /tmp/t.php on line 7
string(1) "b"
bool(false)
 
Warning: Illegal string offset 'x' in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false)
Note:
Accèder à des variables d'autres types (pas des tableaux ni des objets implémentant les interfaces appropriées) en utilisant [] ou {} retournera silencieusement NULL.
Note:
PHP 5.5 ajout le support pour l'accès aux caractères dans une chaîne de caractères littérales en utilisant la syntaxe [] ou {}.

Fonctions et opérateurs utiles 

Les chaîne de caractères peuvent être concaténées en utilisant l'opérateur '.' (point). Notez que l'opérateur '+' (addition) ne fonctionnera pas. Reportez-vous aux opérateurs de chaînes pour plus d'informations.
Il existe de nombreuses fonctions utiles pour la manipulation de chaîne de caractères.
Reportez-vous à la section sur les fonctions de chaînes de caractères pour plus de précisions, et à la section sur les expressions rationnelles ou sur les expressions rationnelles compatibles Perl pour des fonctionnalités de recherches et remplacements avancés.
Il existe également des fonctions pour les URL, et des fonctions pour chiffrer/déchiffrer des chaînes de caractères (mcrypt et mhash).
Et pour finir, vous pouvez également consulter fonctions "type de caractères".

Conversion en chaîne de caractères 

Une valeur peut être convertie en une chaîne de caractères en utilisant le mot-clé (string) ou la fonction strval(). La conversion en chaîne de caractères est automatiquement effectuée dans le contexte d'une expression où unechaîne de caractères est nécessaire. Ceci survient notamment lors de l'utilisation des fonctions echo ou print, ou lorsqu'une variable est comparée à une chaîne. Les sections sur les types et sur le transtypage expliquent ce qui suit de manière plus détaillée. Reportez-vous également à la fonction settype().
Une valeur booléenne TRUE est convertie en la chaîne "1". Une valeur booléenne FALSE est convertie en "" (une chaîne vide). Ceci permet les conversions vers et depuis une chaîne et un booléen.
Un entier ou un nombre décimal est converti en une chaîne de caractères représentant le nombre de façon textuelle (y compris l'exposant pour les nombres à virgule flottante). Les nombres à virgule flottante peuvent être convertis en utilisant la notation exponentielle (4.1E+6).
Note:
Le point décimal est défini dans la locale du script (catégorie LC_NUMERIC). Reportez-vous à la fonctionsetlocale().
Les tableaux sont toujours convertis en la chaîne "Array" ; à cause de cela, echo et print ne peuvent pas afficher par eux-même le contenu d'un tableau. Pour afficher un seul élément, utilisez une syntaxe comme echo $arr['foo']. Voir ci-dessous pour des astuces permettant d'afficher le contenu complet.
Les objets en PHP <5.2 sont convertis en la chaîne "Object id#1", où 1 est un chiffre pouvant varier. Pour afficher les valeurs des propriétés de l'objet (à des fins de déboguage, par exemple), lisez le paragraphe ci-dessous. Pour récupérer le nom de la classe de l'objet, utilisez la fonction get_class(). Notez qu'à partir de PHP 5, la méthode__toString est utilisée lorsqu'elle peut s'appliquer.
Les ressources sont toujours converties en chaînes de la forme "Resource id #1", où 1 est l'identifiant assigné à la ressource par PHP lors de l'exécution. Alors qu'il ne faut pas se fier à cette structure, car susceptible d'évoluer, elle sera néanmoins unique pour une ressource donnée durant toute la durée d'exécution du script courant (ie une requête web ou un processus CLI). Pour récupérer le type d'une ressource, utilisez la fonctionget_resource_type().
NULL est toujours converti en une chaîne vide.
Au vu de tout cela, la conversion d'un tableau, d'un objet, ou d'une ressource, en une chaîne de caractères ne fournit aucune information utile sur une valeur, mis à part son type. Reportez-vous aux fonctions print_r() etvar_dump() pour inspecter plus efficacement les contenus de ces types.
La plupart des valeurs en PHP peuvent également être converties en chaîne de caractères afin de les stocker. Cette méthode est appelée "linéarisation", et est effectuée par la fonction serialize(). Si le moteur PHP a été compilé avec le support WDDX, les valeurs PHP peuvent également être linéarisées en XML.

Conversion de chaînes en nombres 

Lorsqu'une chaîne de caractères est évaluée dans un contexte numérique, la valeur et le type résultants sont déterminés comme suit.
Si la chaîne de caractères ne contient aucun '.', 'e', ou 'E', et que la valeur numérique est dans l'intervalle de représentation des entiers (notamment, qu'elle est plus petite que PHP_INT_MAX), alors la chaîne de caractèressera transformée en entier. Dans les autres cas, elle sera interprétée comme un nombre décimal.
La valeur est fournie par la portion initiale de la chaîne de caractères. Si la chaîne de caractères commence par une donnée numérique valide, ce sera la valeur utilisée. Sinon, la valeur sera de 0 (zéro). Une donnée numérique valide est un signe optionnel, suivi par un ou plusieurs chiffres (contenant, optionnellement, un point décimal), suivi par, éventuellement, un exposant. L'exposant est un 'e' ou 'E' suivi par un ou plusieurs chiffres.
<?php
$foo = 1 + "10.5";                // $foo est un nombre à virgule flottante (11.5)
$foo = 1 + "-1.3e3";              // $foo est un nombre à virgule flottante (-1299)
$foo = 1 + "bob-1.3e3";           // $foo est un entier (1)
$foo = 1 + "bob3";                // $foo est un entier (1)
$foo = 1 + "10 Small Pigs";       // $foo est un entier (11)
$foo = 4 + "10.2 Little Piggies"; // $foo est un nombre à virgule flottante (14.2)
$foo = "10.0 pigs " + 1;          // $foo est un nombre à virgule flottante (11)
$foo = "10.0 pigs " + 1.0;        // $foo est un nombre à virgule flottante (11)
?>
Pour plus d'informations à propos de cette conversion, reportez-vous au manuel Unix de la fonction strtod(3).
Pour tester un des exemples de cette section, copiez/collez l'exemple et insérez la ligne suivante pour voir ce qu'il se passe :
<?php
echo "Le type de \$foo==$foo; est " . gettype ($foo) . "<br />\n";
?>
Ne vous attendez pas à récupérer le code d'un caractère en le convertissant en entier, comme cela est fait en C. Utilisez les fonctions ord() et chr() pour convertir entre caractères et codes ASCII.

Détails sur le type "chaîne de caractères" 

Le type string en PHP est implémenté sous la forme d'un tableau d'octets accompagné d'un entier indiquant la longueur du buffer. Il n'a aucune information sur la traduction octet/caractère, laissant cette tâche au programmeur. Il n'y a aucune limitation sur les valeurs pouvant être présentes dans une chaîne ; en particulier, les octets dont la valeur est 0 (“NUL bytes”) sont autorisés à n'importe quel endroit de la chaîne (cependant, quelques fonctions, indiquées dans ce manuel comme n'étant pas “sécurisées au niveau binaire”, peuvent ignorer tous les octets après un octet nul.)
La nature même du type "chaîne de caractères" explique qu'il n'existe pas de type “byte” en PHP - les chaînes de caractères jouent ce rôle. Les fonctions qui ne retournent pas de données textuelles - par exemple, des données arbitraires lues depuis un socket réseau - continueront de retourner des chaînes de caractères.
PHP ne dictant aucun encodage spécifique pour les chaînes de caractères, on pourrait se demander comment les chaînes littérales sont codés. Par exemple, est-ce que la chaîne "á" équivaut à la chaîne "\xE1" (ISO-8859-1),"\xC3\xA1" (UTF-8, C form), "\x61\xCC\x81" (UTF-8, D form) ou à une autre des représentations possibles ? La réponse est que la chaîne sera encodée suivant l'encodage courant du script. Aussi, si le script est écrit en ISO-8859-1, alors, la chaîne sera encodée en ISO-8859-1 ; et ainsi de suite. Toutefois, ceci n'est pas vrai si Zend Multibyte est activé ; dans ce cas, le script peut être écrit dans n'importe quel encodage (qui sera explicitement déclaré, ou bien détecté), puis sera converti en un encodage interne, qui sera utilisé pour les chaînes littérales. Notez qu'il existe des contraintes sur l'encodage du script (ou sur l'encodage interne, si Zend Multibyte est activé) - cela signifie quasiment toujours que l'encodage utilisé doit être un sur-ensemble compatible d'ASCII, comme UTF-8 ou ISO-8859-1. Notez cependant que les encodages dépendant de l'état, où les mêmes valeurs de l'octet peuvent être utilisées dans des états de décalage initial et non-initial, peuvent être problématiques.
Bien évidemment, pour être utiles, les fonctions qui opèrent sur du texte peuvent devoir faire des hypothèses sur la façon dont est encodé la chaîne de caractères. Malheureusement, ces hypothèses ne sont pas les mêmes suivant les fonctions de PHP :
  • Certaines fonctions supposent que la chaîne est encodée en utilisant un (quelconque) encodage à un seul octet, mais n'ont pas besoin d'interpréter ces octets sous la forme de caractères. C'est actuellement le cas, par exemple, pour les fonctions substr(), strpos(), strlen() et strcmp(). Une autre façon de voir ces fonctions est qu'elles opèrent sur les buffers mémoires ; autrement dit, qu'elles fonctionnent avec les octets et leurs positions.
  • D'autres fonctions reçoivent l'encodage de la chaîne en paramètre, éventuellement en assumant un encodage par défaut si ce n'est pas le cas. C'est le cas de la fonction htmlentities() ainsi que de la majorité des fonctions de l'extension mbstring.
  • D'autres utilisent la locale courante (voir la fonction setlocale()), mais opèrent octets par octets. C'est le cas des fonctions strcasecmp(), strtoupper(), ou ucfirst(). Cela signifie qu'elles ne peuvent être utilisées qu'avec les encodages sur un seul octet, et si l'encodage correspond à la locale. Par exemple, strtoupper("á") peut retourner "Á" si la locale est correctement positionnée et si á est encodé sur un seul octet. Si la chaîne est encodée en UTF-8, le résultat correct ne sera pas retourné, et la chaîne résultante pourra être (ou non) corrompue, suivant la locale courante.
  • Enfin, elles peuvent juste supposer que la chaîne utilise un encodage spécifique, comme UTF-8. C'est le cas de la plupart des fonctions de l'extension intl ainsi que de celles de l'extension PCRE (dans ce dernier cas, uniquement lorsque le modificateur u est utilisé). Bien que ce soit en raison de leur buts spécifiques, la fonction utf8_decode() assume un encodage UTF-8 et la fonction utf8_encode() pré-suppose un encodage ISO-8859-1.
Pour conclure, le fait d'écrire un programme correct en utilisant Unicode dépend de l'utilisation ou non de fonctions qui ne fonctionnent pas en Unicode, et qui corrompront très certainement les données ; il conviendra donc d'utiliser des fonctions qui fonctionnent correctement, générallement depuis les extensions intl et mbstring. Cependant, l'utilisation de fonctions qui peuvent gérer des encodages Unicode n'est que le commencement. Quelques soient les fonctions fournies par le langage, il est essentiel de connaître les spécifications de l'Unicode. Par exemple, un programme qui assume qu'il n'y a que des caractères en majuscule et en minuscule fait une 

Les tableaux 

Un tableau en PHP est en fait une carte ordonnée. Une carte est un type qui associe des valeurs en clés. Ce type est optimisé pour différentes utilisations ; il peut être considéré comme un tableau, une liste, une table de hashage, 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.
La structure de ces données dépasse l'objet de ce manuel, mais vous trouverez au moins un exemple pour chacun des cas évoqués. Pour plus d'informations, reportez-vous aux différentes explications sur le sujet que l'on trouve sur le web.

Syntaxe 

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 [].
Exemple #1 Un tableau simple
<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
);

// depuis PHP 5.4
$array = [
    "foo" => "bar",
    "bar" => "foo",
];
?>
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 pour la clé key peuvent survenir :
  • 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" se 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 utilise la même clé, seule la dernière sera utilisée, écrasant ainsi toutes les précédentes.
Exemple #2 Exemple sur la modification de type et l'écrasement
<?php
$array = array(
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d",
);
var_dump($array);
?>
L'exemple ci-dessus va afficher :
array(1) {
  [1]=>
  string(1) "d"
}
Vu que toutes les clés de l'exemple ci-dessus sont modifiées en l'entier 1, la valeur sera écrasée sur chaque nouvel élément, et seul le dernier dont la valeur assignée est "d" sera conservé.
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.
Exemple #3 Exemple avec des clés de type integer et string
<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);
var_dump($array);
?>
L'exemple ci-dessus va afficher :
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.
Exemple #4 Tableaux indexés sans clé
<?php
$array = array("foo", "bar", "hello", "world");
var_dump($array);
?>
L'exemple ci-dessus va afficher :
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 :
Exemple #5 Exemple avec des clés seulement pour quelques éléments
<?php
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);
?>
L'exemple ci-dessus va afficher :
array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}
Comme vous pouvez le voir, la dernière valeur "d" a été assignée à la clé 7. Ceci est du au fait que le dernier entier le plus grand utilisé auparavant était 6.

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].
Exemple #6 Accès aux éléments d'un tableau
<?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"]);
?>
L'exemple ci-dessus va afficher :
string(3) "bar"
int(24)
string(3) "foo"
Note:
Les parenthèses 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éférencer un tableau littéral.
Exemple #7 Faire référence à un tableau à la sortie d'une fonction ou d'une méthode
<?php
function getArray() {
    return array(1, 2, 3);
}

// Depuis PHP 5.4
$secondElement = getArray()[1];

// Avant PHP 5.4
$tmp = getArray();
$secondElement = $tmp[1];

// ou
list(, $secondElement) = getArray();
?>
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.
<?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

unset($arr);    // Ceci efface complètement le tableau
?>
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
)

Fonctions utiles 

Il y a beaucoup de fonctions utiles pour travailler avec les tableaux. Nous vous invitons à lire la section de ce manuel sur les fonctions en rapport avec les tableaux.
Note:
La fonction unset() permet d'effacer les clés d'un tableau. Soyez attentif sur le fait que le tableau ne sera pasré-indexé. Si vous voulez réaliser un effacement complet et une ré-indexation de votre tableau, vous devez utiliser la fonction array_values().
<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* produira un tableau comme ceci
   $a = array(1 => 'one', 3 => 'three');
   et NON un tableau comme ceci
   $a = array(1 => 'one', 2 =>'three');
*/

$b = array_values($a);
// Maintenant, $b vaut array(0 => 'one', 1 =>'three')
?>
La structure de contrôle foreach existe tout spécialement pour les tableaux. Elle fournit une manière pratique de parcourir un tableau.

Ce qu'il est possible de faire ou non avec un tableau 

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'ancien script :
<?php
$foo[bar] = 'enemy';
echo $foo[bar];
// etc
?>
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.

Les tableaux 

Un tableau en PHP est en fait une carte ordonnée. Une carte est un type qui associe des valeurs en clés. Ce type est optimisé pour différentes utilisations ; il peut être considéré comme un tableau, une liste, une table de hashage, 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.
La structure de ces données dépasse l'objet de ce manuel, mais vous trouverez au moins un exemple pour chacun des cas évoqués. Pour plus d'informations, reportez-vous aux différentes explications sur le sujet que l'on trouve sur le web.

Syntaxe 

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 [].
Exemple #1 Un tableau simple
<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
);

// depuis PHP 5.4
$array = [
    "foo" => "bar",
    "bar" => "foo",
];
?>
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 pour la clé key peuvent survenir :
  • 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" se 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 utilise la même clé, seule la dernière sera utilisée, écrasant ainsi toutes les précédentes.
Exemple #2 Exemple sur la modification de type et l'écrasement
<?php
$array = array(
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d",
);
var_dump($array);
?>
L'exemple ci-dessus va afficher :
array(1) {
  [1]=>
  string(1) "d"
}
Vu que toutes les clés de l'exemple ci-dessus sont modifiées en l'entier 1, la valeur sera écrasée sur chaque nouvel élément, et seul le dernier dont la valeur assignée est "d" sera conservé.
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.
Exemple #3 Exemple avec des clés de type integer et string
<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);
var_dump($array);
?>
L'exemple ci-dessus va afficher :
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.
Exemple #4 Tableaux indexés sans clé
<?php
$array = array("foo", "bar", "hello", "world");
var_dump($array);
?>
L'exemple ci-dessus va afficher :
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 :
Exemple #5 Exemple avec des clés seulement pour quelques éléments
<?php
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);
?>
L'exemple ci-dessus va afficher :
array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}
Comme vous pouvez le voir, la dernière valeur "d" a été assignée à la clé 7. Ceci est du au fait que le dernier entier le plus grand utilisé auparavant était 6.

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].
Exemple #6 Accès aux éléments d'un tableau
<?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"]);
?>
L'exemple ci-dessus va afficher :
string(3) "bar"
int(24)
string(3) "foo"
Note:
Les parenthèses 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éférencer un tableau littéral.
Exemple #7 Faire référence à un tableau à la sortie d'une fonction ou d'une méthode
<?php
function getArray() {
    return array(1, 2, 3);
}

// Depuis PHP 5.4
$secondElement = getArray()[1];

// Avant PHP 5.4
$tmp = getArray();
$secondElement = $tmp[1];

// ou
list(, $secondElement) = getArray();
?>
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.
<?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

unset($arr);    // Ceci efface complètement le tableau
?>
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
)

Fonctions utiles 

Il y a beaucoup de fonctions utiles pour travailler avec les tableaux. Nous vous invitons à lire la section de ce manuel sur les fonctions en rapport avec les tableaux.
Note:
La fonction unset() permet d'effacer les clés d'un tableau. Soyez attentif sur le fait que le tableau ne sera pasré-indexé. Si vous voulez réaliser un effacement complet et une ré-indexation de votre tableau, vous devez utiliser la fonction array_values().
<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* produira un tableau comme ceci
   $a = array(1 => 'one', 3 => 'three');
   et NON un tableau comme ceci
   $a = array(1 => 'one', 2 =>'three');
*/

$b = array_values($a);
// Maintenant, $b vaut array(0 => 'one', 1 =>'three')
?>
La structure de contrôle foreach existe tout spécialement pour les tableaux. Elle fournit une manière pratique de parcourir un tableau.

Ce qu'il est possible de faire ou non avec un tableau 

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'ancien script :
<?php
$foo[bar] = 'enemy';
echo $foo[bar];
// etc
?>
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 :
<?php
// Affichons toutes les erreurs
error_reporting(E_ALL);

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

// Correct
print $arr['fruit'];  // apple
print $arr['veggie']; // carrot

// Incorrect.  Ceci fonctionne mais PHP émettera une erreur de type E_NOTICE car
// on utilise la constante nommée fruit qui est indéfinie
// 
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit];    // apple

// Ceci définit une constante pour expliquer ce qu'il ne va pas. La valeur 'veggie'
// est assignée à la constante nommée fruit.
define('fruit', 'veggie');

// Noter la différence maintenant
print $arr['fruit'];  // apple
print $arr[fruit];    // carrot

// Ce qui squit est correct, car c'est dans une chaîne. Les constantes ne sont pas recherchées
// dans les chaînes, et donc, aucune alerte E_NOTICE ne sera émise
print "Hello $arr[fruit]";      // Hello apple

// Avec une exception : les parenthèses autour d'un tableau dans une chaîne permettent
// aux constantes d'être interprétées
print "Hello {$arr[fruit]}";    // Hello carrot
print "Hello {$arr['fruit']}";  // Hello apple

// Ceci ne fonctionnera pas, et en résultera une erreur d'analyse, comme ceci :
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Ceci arrive lors de l'utilisation d'une supergloables dans les chaînes
print "Hello $arr['fruit']";
print "Hello $_GET['foo']";

// La concaténation est une autre solution
print "Hello " . $arr['fruit']; // Hello apple
?>
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 :
<?php
echo $arr[somefunc($bar)];
?>
C'est un exemple d'utilisation d'une fonction retournant une valeur qui sera la clé du tableau. PHP comprend également les constantes :
<?php
$error_descriptions[E_ERROR]   = "A fatal error has occured";
$error_descriptions[E_WARNING] = "PHP issued a warning";
$error_descriptions[E_NOTICE]  = "This is just an informal notice";
?>
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 :
<?php
$error_descriptions[1] = "A fatal error has occured";
$error_descriptions[2] = "PHP issued a warning";
$error_descriptions[8] = "This is just an informal notice";
?>
car E_ERROR vaut 1, etc.
Alors, pourquoi est-ce une mauvaise pratique ?
Dans le futur, les développeurs PHP peuvent vouloir ajouter une autre constante ou un autre mot clé, ou bien une constante dans une autre partie du code qui peut interférer. Par exemple, il est toujours incorrect d'utiliser le motempty et default, sachant que ce sont des mots réservés.
Note: Pour être plus clair, dans une chaîne entourée de guillemets doubles, il est valide de ne pas entourer les indexes d'un tableau avec des guillemets, et donc, "$foo[bar]" est valide. Voir les exemples ci-dessous pour plus détails mais aussi la section sur l'analyse des variables dans les chaînes.

Conversion en un tableau 

Pour tous les types : entier, nombre décimal, chaîne de caractères, booléen et ressource, le fait de convertir une valeur en un tableau résulte en un tableau contenant un seul élément dont l'indexe vaut zéro et la valeur, une valeur scalaire convertie. En d'autres termes, (array)$scalarValue est exactement la même chose quearray($scalarValue).
Si un objet est converti en un tableau, le résultat sera un tableau dont les éléments sont les propriétés de l'objet. Les clés sont les noms des membres, avec une légère exception : les variables ayant un nom sous forme d'entier sont inaccessible; les variables privées auront le nom de la classe ajouté au nom de la variable ; les variables protégées auront un '*' ajouté au nom de la variable. Ce comportement peut amener à des résultats inattendus :
<?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());
?>
Ici, on pourrait penser qu'il y a 2 clés nommées 'AA', alors qu'une est actuellement nommée '\0A\0A'.
La conversion de NULL en un tableau résultat en un tableau vide.

Comparaison 

Il est possible de comparer plusieurs tableaux avec la fonction array_diff() ainsi qu'avec les opérateurs de tableaux.

Exemples 

Le type tableau en PHP est vraiment versatile. Voici quelques exemples :
<?php
// This
$a = array( 'color' => 'red',
            'taste' => 'sweet',
            'shape' => 'round',
            'name'  => 'apple',
             4        // la clé sera 0
          );

// est strictement équivalent à
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name']  = 'apple';
$a[]        = 4;        // la clé sera 0

$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// Après exécution du code ci-dessus, $a sera le tableau
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round', 
// 'name' => 'apple', 0 => 4), et $b sera le tableau
// array(0 => 'a', 1 => 'b', 2 => 'c'), ou simplement array('a', 'b', 'c').
?>
Exemple #8 Utilisation de array()
<?php
// Tableau comme carte de propriétés
$map = array( 'version'    => 4,
              'OS'         => 'Linux',
              'lang'       => 'english',
              'short_tags' => true
            );

// clés numériques strictes
$array = array( 7,
                8,
                0,
                156,
                -10
              );
// est identique à array(0 => 7, 1 => 8, ...)

$switching = array(         10, // clé = 0
                    5    =>  6,
                    3    =>  7, 
                    'a'  =>  4,
                            11, // clé = 6 (l'indice entier maximal est 5)
                    '8'  =>  2, // clé = 8 (intier !)
                    '02' => 77, // clé = '02'
                    0    => 12  // la valeur 10 sera écrasée par la valeur 12
                  );

// empty array
$empty = array();
?>
Exemple #9 Collection
<?php
$colors = array('rouge', 'bleu', 'verte', 'jaune');

foreach ($colors as $color) {
    echo "Aimez-vous la couleur $color ?\n";
}

?>
L'exemple ci-dessus va afficher :
Aimez-vous la couleur rouge ?
Aimez-vous la couleur bleu ?
Aimez-vous la couleur verte ?
Aimez-vous la couleur jaune ?
La modification directe de valeurs d'un tableau est possible depuis PHP 5 en le passant par référence. Avant cette version, nous devions utiliser l'astuce suivante :
Exemple #10 Modification d'un élément dans la boucle
<?php
// PHP 5
foreach ($colors as &$color) {
    $color = strtoupper($color);
}
unset($color); /* On s'assure que les écritures suivantes
sur $color ne modifie pas le dernier élément du tableau */

// Astuce pour les anciennes versions
foreach ($colors as $key => $color) {
    $colors[$key] = strtoupper($color);
}

print_r($colors);
?>
L'exemple ci-dessus va afficher :
Array
(
    [0] => ROUGE
    [1] => BLEU
    [2] => VERTE
    [3] => JAUNE
)
Cet exemple crée un tableau, dont l'indexation commence à 1.
Exemple #11 Indexation commençant à 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 #12 Remplissage d'un tableau
<?php
// Remplit un tableau avec tous les éléments d'un dossier
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
    $files[] = $file;
}
closedir($handle); 
?>
Les tableaux sont ordonnés. L'ordre peut être modifié en utilisant plusieurs fonctions. Voir la section sur lesfonctions sur les tableaux pour plus d'informations. La fonction count() peut être utilisée pour compter le nombre d'éléments d'un tableau.
Exemple #13 Tri d'un tableau
<?php
sort($files);
print_r($files);
?>
Sachant que la valeur d'une tableau peut être n'importe quoi, elle peut aussi être un autre tableau. Ceci permet la création de tableaux récursifs et de tableaux multidimensionnels.
Exemple #14 Tableaux récursifs et multidimensionnels
<?php
$fruits = array ( "fruits"  => array ( "a" => "orange",
                                       "b" => "banana",
                                       "c" => "apple"
                                     ),
                  "numbers" => array ( 1,
                                       2,
                                       3,
                                       4,
                                       5,
                                       6
                                     ),
                  "holes"   => array (      "first",
                                       5 => "second",
                                            "third"
                                     )
                );

// Quelques exemples pour retrouver les valeurs dans le tableau ci-dessus 
echo $fruits["holes"][5];    // affiche "second"
echo $fruits["fruits"]["a"]; // affiche "orange"
unset($fruits["holes"][0]);  // efface "first"

// Création d'un tableau multidimensionnel
$juices["apple"]["green"] = "good"; 
?>
L'assignation d'un tableau induit toujours la copie des valeurs. Utilisez l'opérateur de référence pour copier 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
?>
add a note add a note

Les objets 

Initialisation des objets 

Pour créer un nouvel objet, utilisez le mot clé new afin d'instancier une classe :
<?php
class foo
{
    function do_foo()
    {
        echo "Doing foo.";
    }
}

$bar = new foo;
$bar->do_foo();
?>
Pour une discussion complète, voir le chapitre sur les classes et les objets.

Conversion en un objet 

Si un objet est converti en un objet, il ne sera pas modifié. Si une valeur de n'importe quel type est convertie en un objet, une nouvelle instance de la classe interne stdClass sera créée. Si la valeur est NULL, la nouvelle instance sera vide. La conversion d'un tableau en objet fera que les clés deviendront les proriétés, et les valeurs des clés, deviennent les valeurs des proriétés. Pour n'importe quel autre type, un membre appelé scalar contiendra la valeur.
<?php
$obj = (object) 'ciao';
echo $obj->scalar;  // Affiche : 'ciao'
?>
add a note add a note

Us

Les ressources 

Une ressource est une variable spéciale, contenant une référence vers une ressource externe. Les ressources sont créées et utilisées par des fonctions spéciales. Voir l'appendice pour une liste de toutes ces fonctions ainsi que les types de ressource correspondants.
Voir aussi la fonction get_resource_type().

Conversion en ressource 

Sachant qu'une ressource représente un fichier ouvert, une connexion à une base de données, une image, etc..., la conversion en une ressource n'a pas de sens.

Libération des ressources 

Sachant qu'une ressource qui n'a plus aucune référence est détectée automatiquement et est libérée par le collecteur, il est rarement nécessaire de libérer la mémoire manuellement.
Note: Les connexions persistantes aux bases de données sont des exceptions à cette règle. Elles ne sont pasdétruites par le collecteur. Voir la section sur les connexions persistantes pour plus d'informations

NULL 

La valeur spéciale NULL représente une variable sans valeur. NULL est la seule valeur possible du type NULL.
Une variable est considérée comme null si :
o    elle s'est vue assigner la constante NULL.
o    elle n'a pas encore reçu de valeur.
o    elle a été effacée avec la fonction unset().

Syntaxe 

Il y a une seule valeur de type null, et c'est la constante insensible à la casse NULL.
<?php
$var = NULL;
?>
Voir aussi les fonctions is_null() et unset().

Transtyper vers NULL 

Transtyper une variable vers null en utilisant la syntaxe (unset) $var n'effacera pas la variable, ni écrasera sa valeur. Ca ne fera que retourner la valeur NULL



Publié par à Aucun commentaire:
Inscription à : Articles (Atom)