PHP 5.4.36 Released

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 OS X, 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ù une chaî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 fonction setlocale().

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 fonction get_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() et var_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ères sera 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 
"10.5";                // $foo est un nombre à virgule flottante (11.5)
$foo "-1.3e3";              // $foo est un nombre à virgule flottante (-1299)
$foo "bob-1.3e3";           // $foo est un entier (1)
$foo "bob3";                // $foo est un entier (1)
$foo "10 Small Pigs";       // $foo est un entier (11)
$foo "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 mauvaise hypothèse.

add a note add a note

User Contributed Notes 40 notes

up
41
gtisza at gmail dot com
2 years ago
The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors.

This works:

<?php
$foo
= <<<END
abcd
END;
?>

This does not:

<?php
foo
(<<<END
abcd
END;
);
// syntax error, unexpected ';'
?>

Without semicolon, it works fine:

<?php
foo
(<<<END
abcd
END
);
?>
up
3
necrodust44 at gmail dot com
9 months ago
String conversion to numbers.

Unfortunately, the documentation is not correct.

«The value is given by the initial portion of the string. If the string starts with valid numeric data, this will be the value used. Otherwise, the value will be 0 (zero).»

It is not said and is not shown in examples throughout the documentation that, while converting strings to numbers, leading space characters are ignored, like with the strtod function.

<?php
   
echo "     \v\f    \r   1234" + 1;    // 1235
   
var_export ("\v\f    \r   1234" == "1234");    // true
?>

However, PHP's behaviour differs even from the strtod's. The documentation says that if the string contains a "e" or "E" character, it will be parsed as a float, and suggests to see the manual for strtod for more information. The manual says

«A hexadecimal number consists of a "0x" or "0X" followed by a nonempty sequence of hexadecimal digits possibly containing a radix character, optionally followed by a binary exponent.  A binary exponent consists of a 'P' or 'p', followed by an optional plus or minus sign, followed by a nonempty sequence of decimal digits, and indicates multiplication by a power of 2.»

But it seems that PHP does not recognise the exponent or the radix character.

<?php
   
echo "0xEp4" + 1;     // 15
?>

strtod also uses the current locale to choose the radix character, but PHP ignores the locale, and the radix character is always 2E. However, PHP uses the locale while converting numbers to strings.

With strtod, the current locale is also used to choose the space characters, I don't know about PHP.
up
13
chAlx at findme dot if dot u dot need
6 years ago
To save Your mind don't read previous comments about dates  ;)

When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char:

<?php
var_dump
('1.22' > '01.23'); // bool(false)
var_dump('1.22.00' > '01.23.00'); // bool(true)
var_dump('1-22-00' > '01-23-00'); // bool(true)
var_dump((float)'1.22.00' > (float)'01.23.00'); // bool(false)
?>
up
13
atnak at chejz dot com
10 years ago
Here is a possible gotcha related to oddness involved with accessing strings by character past the end of the string:

$string = 'a';

var_dump($string[2]);  // string(0) ""
var_dump($string[7]);  // string(0) ""
$string[7] === '';  // TRUE

It appears that anything past the end of the string gives an empty string..  However, when E_NOTICE is on, the above examples will throw the message:

Notice:  Uninitialized string offset:  N in FILE on line LINE

This message cannot be specifically masked with @$string[7], as is possible when $string itself is unset.

isset($string[7]);  // FALSE
$string[7] === NULL;  // FALSE

Even though it seems like a not-NULL value of type string, it is still considered unset.
up
9
dee jay simple 0 0 7 at ge mahl dot com
3 years ago
I recently discovered the joys of using heredoc with sprintf and positions. Useful if you want some code to iterate, you can repeat placeholders.

<?php

function getNumber($num = 0) {
   
$foo = rand(1,20);
    return (
$foo + $num);
}
function
getString() {
   
$foo = array("California","Oregon","Washington");
   
shuffle($foo);
    return
$foo[0];
}
function
getDiv() {
   
$num = getNumber();
   
$div = sprintf( "<div>%s</div>", getNumber(rand(-5,5)) );
    return
$div;
}
$string = <<<THESTRING
I like the state of %1\$s <br />
I picked: %2\$d as a number, <br />
I also picked %2\$d as a number again <br />
%3\$s<br />
%3\$s<br />
%3\$s<br />
%3\$s<br />
%3\$s<br />
THESTRING;

$returnText = sprintf$string, getString(),getNumber(),getDiv()  );

echo
$returnText;

?>

Expected output of the above code:

I like the state of Oregon
I picked: 15 as a number,
I also picked 15 as a number again
5

5

5

5

5
up
7
php at richardneill dot org
1 year ago
Leading zeroes in strings are (least-surprise) not treated as octal.
Consider:
  $x = "0123"  + 0;  
  $y = 0123 + 0;
  echo "x is $x, y is $y";    //prints  "x is 123, y is 83"
in other words:
* leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol().
* leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().
up
6
deminy at deminy dot net
5 years ago
Although current documentation says 'A string literal can be specified in four different ways: ...', actually there is a fifth way to specify a (binary) string:

<?php $binary = b'This is a binary string'; ?>

The above statement declares a binary string using the 'b' prefix, which is available since PHP 5.2.1. However, it will only have effect as of PHP 6.0.0, as noted on http://www.php.net/manual/en/function.is-binary.php .
up
5
og at gams dot at
7 years ago
easy transparent solution for using constants in the heredoc format:
DEFINE('TEST','TEST STRING');

$const = get_defined_constants();

echo <<<END
{$const['TEST']}
END;

Result:
TEST STRING
up
3
m021 at springtimesoftware dot com
2 years ago
Heredoc literals delete any trailing space (tabs and blanks) on each line. This is unexpected, since quoted strings do not do this. This is probably done for historical reasons, so would not be considered a bug.
up
3
lelon at lelon dot net
10 years ago
You can use the complex syntax to put the value of both object properties AND object methods inside a string.  For example...
<?php
class Test {
    public
$one = 1;
    public function
two() {
        return
2;
    }
}
$test = new Test();
echo
"foo {$test->one} bar {$test->two()}";
?>
Will output "foo 1 bar 2".

However, you cannot do this for all values in your namespace.  Class constants and static properties/methods will not work because the complex syntax looks for the '$'.
<?php
class Test {
    const
ONE = 1;
}
echo
"foo {Test::ONE} bar";
?>
This will output "foo {Test::one} bar".  Constants and static properties require you to break up the string.
up
1
headden at karelia dot ru
5 years ago
Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:

<?php

// Hack declaration
function _expr($v) { return $v; }
$_expr = '_expr';

// Our playground
define('qwe', 'asd');
define('zxc', 5);

$a=3;
$b=4;

function
c($a, $b) { return $a+$b; }

// Usage
echo "pre {$_expr(1+2)} post\n"; // outputs 'pre 3 post'
echo "pre {$_expr(qwe)} post\n"; // outputs 'pre asd post'
echo "pre {$_expr(c($a, $b)+zxc*2)} post\n"; // outputs 'pre 17 post'

// General syntax is {$_expr(...)}
?>
up
-2
Ray.Paseur often uses Gmail
9 months ago
In Example #8, above, consider the risk to the script if a programmer were to define('koolaid1', 'XYZ');  For this reason it's wise to use quotes around literal-string associative array keys.  As written without quotes, PHP should raise a Notice.
up
0
harmor
6 years ago
So you want to get the last character of a string using "String access and modification by character"?  Well negative indexes are not allowed so $str[-1] will return an empty string.

<?php
//Tested using: PHP 5.2.5

$str = 'This is a test.';

$last = $str[-1];                  //string(0) ""
$realLast = $str[strlen($str)-1];  //string(1) "."
$substr = substr($str,-1);         //string(1) "."

echo '<pre>';
var_dump($last);
var_dump($realLast);
var_dump($substr);
up
0
rkfranklin+php at gmail dot com
7 years ago
If you want to use a variable in an array index within a double quoted string you have to realize that when you put the curly braces around the array, everything inside the curly braces gets evaluated as if it were outside a string.  Here are some examples:

<?php
$i
= 0;
$myArray[Person0] = Bob;
$myArray[Person1] = George;

// prints Bob (the ++ is used to emphasize that the expression inside the {} is really being evaluated.)
echo "{$myArray['Person'.$i++]}<br>";

// these print George
echo "{$myArray['Person'.$i]}<br>";
echo
"{$myArray["Person{$i}"]}<br>";

// These don't work
echo "{$myArray['Person$i']}<br>";
echo
"{$myArray['Person'$i]}<br>";

// These both throw fatal errors
// echo "$myArray[Person$i]<br>";
//echo "$myArray[Person{$i}]<br>";
?>
up
0
bishop
8 years ago
You may use heredoc syntax to comment out large blocks of code, as follows:
<?php
<<<_EOC
    // end-of-line comment will be masked... so will regular PHP:
    echo (
$test == 'foo' ? 'bar' : 'baz');
    /* c-style comment will be masked, as will other heredocs (not using the same marker) */
    echo <<<EOHTML
This is text you'll never see!       
EOHTML;
    function defintion(
$params) {
        echo 'foo';
    }
    class definition extends nothing     {
       function definition(
$param) {
          echo 'do nothing';
       }      
    }

    how about syntax errors?; = gone, I bet.
_EOC;
?>

Useful for debugging when C-style just won't do.  Also useful if you wish to embed Perl-like Plain Old Documentation; extraction between POD markers is left as an exercise for the reader.

Note there is a performance penalty for this method, as PHP must still parse and variable substitute the string.
up
0
webmaster at rephunter dot net
9 years ago
Use caution when you need white space at the end of a heredoc. Not only is the mandatory final newline before the terminating symbol stripped, but an immediately preceding newline or space character is also stripped.

For example, in the following, the final space character (indicated by \s -- that is, the "\s" is not literally in the text, but is only used to indicate the space character) is stripped:

$string = <<<EOT
this is a string with a terminating space\s
EOT;

In the following, there will only be a single newline at the end of the string, even though two are shown in the text:

$string = <<<EOT
this is a string that must be
followed by a single newline

EOT;
up
-1
cvolny at gmail dot com
6 years ago
I commented on a php bug feature request for a string expansion function and figured I should post somewhere it might be useful:

using regex, pretty straightforward:
<?php
function stringExpand($subject, array $vars) {
   
// loop over $vars map
   
foreach ($vars as $name => $value) {
       
// use preg_replace to match ${`$name`} or $`$name`
       
$subject = preg_replace(sprintf('/\$\{?%s\}?/', $name), $value,
$subject);
    }
   
// return variable expanded string
   
return $subject;
}
?>

using eval() and not limiting access to only certain variables (entire current symbol table including [super]globals):

<?php
function stringExpandDangerous($subject, array $vars = array(), $random = true) {
   
       
// extract $vars into current symbol table
       
extract($vars);
       
       
$delim;
       
// if requested to be random (default), generate delim, otherwise use predefined (trivially faster)
       
if ($random)
           
$delim = '___' . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . '___';
        else
           
$delim = '__ASDFZXCV1324ZXCV__'// button mashing...
       
        // built the eval code
       
$statement = "return <<<$delim\n\n" . $subject . "\n$delim;\n";
       
       
// execute statement, saving output to $result variable
       
$result = eval($statement);
       
       
// if eval() returned FALSE, throw a custom exception
       
if ($result === false)
            throw new
EvalException($statement);
       
       
// return variable expanded string
       
return $result;
    }
?>

I hope that helps someone, but I do caution against using the eval() route even if it is tempting.  I don't know if there's ever a truely safe way to use eval() on the web, I'd rather not use it.
up
-1
shd at earthling dot net
5 years ago
If you want a parsed variable surrounded by curly braces, just double the curly braces:

<?php
  $foo
= "bar";
  echo
"{{$foo}}";
?>

will just show {bar}. The { is special only if followed by the $ sign and matches one }. In this case, that applies only to the inner braces. The outer ones are not escaped and pass through directly.
up
-2
Richard Neill
7 years ago
Unlike bash, we can't do
  echo "\a"       #beep!

Of course, that would be rather meaningless for PHP/web, but it's useful for PHP-CLI. The solution is simple:  echo "\x07"
up
-2
bryant at zionprogramming dot com
7 years ago
As of (at least) PHP 5.2, you can no longer convert an object to a string unless it has a __toString method. Converting an object without this method now gives the error:

PHP Catchable fatal error:  Object of class <classname> could not be converted to string in <file> on line <line>

Try this code to get the same results as before:

<?php

if (!is_object($value) || method_exists($value, '__toString')) {
   
$string = (string)$value;
} else {
   
$string = 'Object';
}

?>
up
-3
steve at mrclay dot org
6 years ago
Simple function to create human-readably escaped double-quoted strings for use in source code or when debugging strings with newlines/tabs/etc.

<?php
function doubleQuote($str) {
   
$ret = '"';
    for (
$i = 0, $l = strlen($str); $i < $l; ++$i) {
       
$o = ord($str[$i]);
        if (
$o < 31 || $o > 126) {
            switch (
$o) {
                case
9: $ret .= '\t'; break;
                case
10: $ret .= '\n'; break;
                case
11: $ret .= '\v'; break;
                case
12: $ret .= '\f'; break;
                case
13: $ret .= '\r'; break;
                default:
$ret .= '\x' . str_pad(dechex($o), 2, '0', STR_PAD_LEFT);
            }
        } else {
            switch (
$o) {
                case
36: $ret .= '\$'; break;
                case
34: $ret .= '\"'; break;
                case
92: $ret .= '\\\\'; break;
                default:
$ret .= $str[$i];
            }
        }
    }
    return
$ret . '"';
}
?>
up
-3
Liesbeth
5 years ago
If you need to emulate a nowdoc in PHP < 5.3, try using HTML mode and output capturing. This way '$' or '\n' in your string won't be a problem anymore (but unfortunately, '<?' will be).

<?php

// Start of script

ob_start(); ?>
  A text with '
quotes'
    and $$$dollars$$$.
<?php $input = ob_get_contents(); ob_end_clean();

// Do what you want with $input
echo "<pre>" . $input . "</pre>";

?>
up
-4
Michael
3 years ago
Just want to mention that if you want a literal { around a variable within a string, for example if you want your output to be something like the following:

{hello, world}

and all that you put inside the {} is a variable, you can do a double {{}}, like this:

$test = 'hello, world';
echo "{{$test}}";
up
-3
DELETETHIS dot php at dfackrell dot mailshell dot com
9 years ago
Just some quick observations on variable interpolation:

Because PHP looks for {? to start a complex variable expression in a double-quoted string, you can call object methods, but not class methods or unbound functions.

This works:

<?php
class a {
    function
b() {
        return
"World";
    }
}
$c = new a;
echo
"Hello {$c->b()}.\n"
?>

While this does not:

<?php
function b() {
    return
"World";
}
echo
"Hello {b()}\n";
?>

Also, it appears that you can almost without limitation perform other processing within the argument list, but not outside it.  For example:

<?
$true
= true;
define("HW", "Hello World");
echo
"{$true && HW}";
?>

gives: Parse error: parse error, unexpected T_BOOLEAN_AND, expecting '}' in - on line 3

There may still be some way to kludge the syntax to allow constants and unbound function calls inside a double-quoted string, but it isn't readily apparent to me at the moment, and I'm not sure I'd prefer the workaround over breaking out of the string at this point.
up
-5
Evan K
6 years ago
I encountered the odd situation of having a string containing unexpanded escape sequences that I wanted to expand, but also contained dollar signs that would be interpolated as variables.  "$5.25\n", for example, where I want to convert \n to a newline, but don't want attempted interpolation of $5.

Some muddling through docs and many obscenties later, I produced the following, which expands escape sequences in an existing string with NO interpolation.

<?php

// where we do all our magic
function expand_escape($string) {
    return
preg_replace_callback(
       
'/\\\([nrtvf]|[0-7]{1,3}|[0-9A-Fa-f]{1,2})?/',
       
create_function(
           
'$matches',
           
'return ($matches[0] == "\\\\") ? "" : eval( sprintf(\'return "%s";\', $matches[0]) );'
       
),
       
$string
   
);
}

// a string to test, and show the before and after
$before = 'Quantity:\t500\nPrice:\t$5.25 each';
$after = expand_escape($before);
var_dump($before, $after);

/* Outputs:
string(34) "Quantity:\t500\nPrice:\t$5.25 each"
string(31) "Quantity:    500
Price:    $5.25 each"
*/

?>
up
-5
saamde at gmail dot com
4 years ago
Watch out for the "unexpected T_SL" error.  This appears to occur when there is white space just after "<<<EOT" and since it's white space it's real hard to spot the error in your code.
up
-5
Denis R.
2 years ago
Hi.

I noticed that the documentation does not mention that when you have an XML element which contains a dash (-) in its name can only be accessed using the bracelets notation.
For example:
<xml version="1">
<root>
   <element-one>value4element-one</element-one>
</root>

to access the above 'element-one' using SimpleXML you need to use the following:

$simpleXMLObj->root->{'element-one'}

to retrieve the value.

Hope this helps,
Denis R.
up
-6
mcamiano at ncsu dot edu
2 years ago
Regarding the lack of complex expression interpolation, just assign an identity function to a variable and call it:

function id($arg) { return $arg; }

$expr = id;

echo "Field is: {$expr( "1 ". ucfirst('whatzit')) }";

It is slower due to an additional function call, but it does avoid the assignment of a one-shot temporary variable. When there are a lot of very simple value transformations made just for display purposes, it can de-clutter code.
up
-4
www.feisar.de
10 years ago
watch out when comparing strings that are numbers. this example:

<?php

$x1
= '111111111111111111';
$x2 = '111111111111111112';

echo (
$x1 == $x2) ? "true\n" : "false\n";

?>

will output "true", although the strings are different. With large integer-strings, it seems that PHP compares only the integer values, not the strings. Even strval() will not work here.

To be on the safe side, use:

$x1 === $x2
up
-7
&#34;Sascha Ziemann&#34;
5 years ago
Empty strings seem to be no real strings, because they behave different to strings containing data. Here is an example.

It is possible to change a character at a specific position using the square bracket notation:
<?php
$str
= '0';
$str[0] = 'a';
echo
$str."\n"; // => 'a'
?>

It is also possible to change a character with does not exist, if the index is "behind" the end of the string:
<?php
$str
= '0';
$str[1] = 'a';
echo
$str."\n"; // => 0a
?>

But if you do that on an empty string, the string gets silently converted into an array:
<?php
$str
= '';
$str[0] = 'a';
echo
$str."\n"; // => Array
?>
up
-6
Jonathan Lozinski
10 years ago
A note on the heredoc stuff.

If you're editing with VI/VIM and possible other syntax highlighting editors, then using certain words is the way forward.  if you use <<<HTML for example, then the text will be hightlighted for HTML!!

I just found this out and used sed to alter all EOF to HTML.

JAVASCRIPT also works, and possibly others.  The only thing about <<<JAVASCRIPT is that you can't add the <script> tags..,  so use HTML instead, which will correctly highlight all JavaScript too..

You can also use EOHTML, EOSQL, and EOJAVASCRIPT.
up
-8
sgbeal at googlemail dot com
3 years ago
The docs say: "Heredoc text behaves just like a double-quoted string, without the double quotes" but there is a notable hidden exception to that rule: the final newline in the string (the one before closing heredoc token) is elided. i.e. if you have:

$foo = <<<EOF
a
b
c
EOF;

the result is equivalent to "a\nb\nc", NOT "a\nb\nc\n" like the docs imply.
up
-10
Obeliks
6 years ago
Expectedly <?php $string[$x] ?> and <?php substr($string, $x, 1) ?> will yield the same result... normally!

However, when you turn on the  Function Overloading Feature (http://php.net/manual/en/mbstring.overload.php), this might not be true!

If you use this Overloading Feature with 3rd party software, you should check for usage of the String access operator, otherwise you might be in for some nasty surprises.
up
-6
Anonymous
8 months ago
$my_int = "12,140";
echo  1 + $my_int ;

Returns 13 not the expected 12141
up
-11
fmouse at fmp dot com
7 years ago
It may be obvious to some, but it's convenient to note that variables _will_ be expanded inside of single quotes if these occur inside of a double-quoted string.  This can be handy in constructing exec calls with complex data to be passed to other programs.  e.g.:

$foo = "green";
echo "the grass is $foo";
the grass is green

echo 'the grass is $foo';
the grass is $foo

echo "the grass is '$foo'";
the grass is 'green'
up
-17
Ultimater at gmail dot com
3 years ago
If you require a NowDoc but don't have support for them on your server -- since your PHP version is less than PHP 5.3.0 -- and you are in need of a workaround, I'd suggest using PHP's __halt_compiler() which is basically a knock-off of Perl's __DATA__ token if you are familiar with it.

Give this a run to see my suggestion in action:

<?php
//set $nowDoc to a string containing a code snippet for the user to read
$nowDoc = file_get_contents(__FILE__,null,null,__COMPILER_HALT_OFFSET__);
$nowDoc=highlight_string($nowDoc,true);

echo <<<EOF
<!doctype html>
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<title>NowDoc support for PHP &lt; 5.3.0</title>
<meta name="author" content="Ultimater at gmail dot com" />
<meta name="about-this-page"
content="Note that I built this code explicitly for the
php.net documenation for demonstrative purposes." />
<style type="text/css">
body{text-align:center;}
table.border{background:#e0eaee;margin:1px auto;padding:1px;}
table.border td{padding:5px;border:1px solid #8880ff;text-align:left;
background-color:#eee;}
code ::selection{background:#5f5color:white;}
code ::-moz-selection{background:#5f5;color:white;}
a{color:#33a;text-decoration:none;}
a:hover{color:rgb(3,128,252);}
</style>
</head>
<body>
<h1 style="margin:1px auto;">
<a
href="http://php.net/manual/en/language.types.string.php#example-77">
Example #8 Simple syntax example
</a></h1>
<table class="border"><tr><td>
$nowDoc
</td></tr></table></body></html>
EOF;

__halt_compiler()
//Example code snippet we want displayed on the webpage
//note that the compiler isn't actually stopped until the semicolon
;<?php
$juices
= array("apple", "orange", "koolaid1" => "purple");

echo
"He drank some $juices[0] juice.".PHP_EOL;
echo
"He drank some $juices[1] juice.".PHP_EOL;
echo
"He drank some juice made of $juice[0]s.".PHP_EOL; // Won't work
echo "He drank some $juices[koolaid1] juice.".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 drank some $juices[0] juice.".PHP_EOL;
echo
"$people->john then said hello to $people->jane.".PHP_EOL;
echo
"$people->john's wife greeted $people->robert.".PHP_EOL;
echo
"$people->robert greeted the two $people->smiths."; // Won't work
?>
up
-15
penda ekoka
7 years ago
error control operator (@) with heredoc syntax:

the error control operator is pretty handy for supressing minimal errors or omissions. For example an email form that request some basic non mandatory information to your users. Some may complete the form, other may not. Lets say you don't want to tweak PHP for error levels and you just wish to create some basic template that will be emailed to the admin with the user information submitted. You manage to collect the user input in an array called $form:

<?php
// creating your mailer
$mailer = new SomeMailerLib();
$mailer->from = ' System <mail@yourwebsite.com>';
$mailer->to = 'admin@yourwebsite.com';
$mailer->subject = 'New user request';
// you put the error control operator before the heredoc operator to suppress notices and warnings about unset indices like this
$mailer->body = @<<<FORM
Firstname = {$form['firstname']}
Lastname =
{$form['lastname']}
Email =
{$form['email']}
Telephone =
{$form['telephone']}
Address =
{$form['address']}
FORM;

?>
up
-4
espertalhao04 at hotmail dot com
1 year ago
gtisza at gmail dot com

You incorrectly stated that thee documentation doesn't refer anything about the semicolon at the end of the heredocs and nowdocs  being interpreted as a "real" semicolon.

If you read carefully, you will notice this, in the 1st sentence of the warning about heredocs:

"It is very important to note that the line with the closing identifier must contain no other characters, except a semicolon (;)."

Interesting...
It is refering about semicolons...

But wait, there is more:

http://php.net/manual/en/language.basic-syntax.instruction-separation.php
1st sentence says:
"As in C or Perl, PHP requires instructions to be terminated with a semicolon at the end of each statement."

So, here says that semicolons are statement separators, basicly...

So, if you put a "real" semicolon at the end of these examples:
<?php
    $a
=5;
   
$foo="String";
   
$bar=array();
   
$yep=null;
   
$other=func();
?>
Why shouldn't you put at the end of heredocs and nowdocs?
After all, a heredoc or a nowdoc is simply a string.

You should read more carefully the documentation first before saying any comment.

About serious questions:
I didn't read all comments here, but you can run functions inside strings and heredocs.

And you can even nest them inside {}

Example:
<?php
    $f
=function($x){$a=func_get_args();unset($a[0]);return call_user_func_array($x,$a);};
   
$d=0;
    echo
$b=<<<NUMBERS
4.0909 rounded is: {$f('round',4.0909,$d)}
Time now is:
{$f('time')}
Nested heredocs/nowdocs:
{$f('sprintf',<<<OTHER
Here is an %s of nested %s
OTHER
,
"Example",<<<'NOW'
heredocs and nowdocs
NOW
)}

NUMBERS;

/*echoes (time is system and real time relative):
4.0909 rounded is: 4
Time now is: 1386670912
Nested heredocs/nowdocs: Here is an Example of nested heredocs and nowdocs
*/
?>

It's not pretty, and is hard to read, but sometimes it is useful to confuse curious people (like minifying the code).

Warning: if any function that runs inside a string or heredoc gives a fatal error, the script MAY continue!
up
-30
Salil Kothadia
6 years ago
An interesting finding about Heredoc "syntax error, unexpected $end".
I got this error because I did not use the php close tag "?>" and I had no code after the heredoc code.

foo1.php code gives "syntax error, unexpected $end".
But in foo2.php and foo3.php, when you add a php close tag or when you have some more code after heredoc it works fine.

Example Code:
foo1.php
1. <?php
2. $str
= <<<EOD
3. Example of string
4. spanning multiple lines
5. using heredoc syntax.
6. EOD;
7.

foo2.php
1. <?php
2.
$str = <<<EOD
3. Example of string
4. spanning multiple lines
5. using heredoc syntax.
6. EOD;
7.
8. echo
$str;
9.

foo3.php
1. <?php
2.
$str = <<<EOD
3. Example of string
4. spanning multiple lines
5. using heredoc syntax.
6. EOD;
7. ?>
up
-12
benl39 at free dot fr
9 months ago
Note that :

<?php
echo 'error' == 0, '<br>'; // TRUE
echo 'error' == '0', '<br>'; // FALSE
echo '0' == 0, '<br>'; // TRUE

// So, 'error' != 'error' ?
?>
To Top