Commentaire: Dans PHP 7.0.0 sur les plates-formes 64 bits, il n'y a aucune limite réalisable sur la longueur des lignes ; sur les systèmes 32 bits et dans les versions antérieures de PHP, les lignes ne peuvent pas dépasser 2 Go (2 147 483 647 octets).

Syntaxe

Une chaîne peut être définie par quatre de diverses manières:

• guillemets simples
• guillemets doubles
• syntaxe nowdoc (depuis PHP 5.3.0)

Citations simples

La manière la plus simple définir une chaîne, c'est la mettre entre guillemets simples (caractère " ).

Pour utiliser un guillemet simple dans une chaîne, échappez-le avec une barre oblique inverse ( \ ). Si vous devez écrire la barre oblique inverse elle-même, dupliquez-la ( \\ ). Toutes les autres utilisations de la barre oblique inverse seront interprétées comme des caractères normaux : cela signifie que si vous essayez d'utiliser d'autres séquences d'échappement telles que \r ou \n, ils seront affichés tels quels au lieu de tout comportement spécial.

écho "c'est une simple chaîne";

écho "Vous pouvez également insérer dans des lignes
caractère de nouvelle ligne comme celui-ci,
C'est bien";

// Résultats : Arnold a dit un jour : "Je reviendrai"
écho "Un jour, Arnold a dit : 'Je reviendrai.'';

Écho "Avez-vous supprimé C:\\*.* ?";

// Sorties : avez-vous supprimé C:\*.* ?
echo "Avez-vous supprimé C:\*.* ?" ;

// Sorties : ceci ne sera pas développé : \n nouvelle ligne
écho "Ceci ne sera pas développé : \n nouvelle ligne";

// Sorties : les variables $expand et $either ne sont pas développées
écho "$expand et $soit les variables ne sont pas développées";
?>

Guillemets doubles

Si la chaîne est entourée de guillemets doubles ("), PHP reconnaît les séquences d'échappement de caractères spéciaux suivantes :

Comme pour une chaîne entourée de guillemets simples, l'échappement de n'importe quel caractère affichera également le caractère d'échappement lui-même. Avant PHP 5.1.1, barre oblique inverse dans \($var) n'a pas été publié.

Hérédoc

La troisième façon de définir des chaînes consiste à utiliser la syntaxe heredoc : <<< . Après cet opérateur, vous devez préciser un identifiant, puis un saut de ligne. Vient ensuite la ligne elle-même, puis le même identifiant, fermant l'insertion.

Doubler devrait commencez par un identifiant de fermeture, c'est-à-dire il doit apparaître dans la première colonne de la ligne. De plus, l'identifiant doit suivre les mêmes règles de dénomination que toutes les autres balises PHP : contenir uniquement des caractères alphanumériques et un trait de soulignement, et ne doit pas commencer par un chiffre (les traits de soulignement sont autorisés).

Attention

Il est très important de noter que la ligne d'identification de fermeture ne doit contenir aucun autre caractère à l'exception d'un point-virgule ( ; ). Cela signifie que l'identifiant ne devrait pas être en retrait et qu'il ne peut y avoir d'espaces ou de tabulations avant ou après le point-virgule. Il est également important de comprendre que le premier caractère avant l'identifiant de fermeture doit être un caractère de nouvelle ligne tel que défini par votre système d'exploitation. Par exemple, sur les systèmes UNIX, y compris macOS, il s'agit de \n. Après l'identifiant de fermeture, une nouvelle ligne doit également commencer immédiatement.

Si cette règle n'est pas respectée et que l'identifiant de fermeture n'est pas "propre", l'identifiant de fermeture est considéré comme manquant et PHP continuera à le rechercher. Si dans ce cas l'identifiant de fermeture correct n'est jamais trouvé, cela provoquera une erreur d'analyse avec le numéro de ligne à la fin du script.

Exemple #1 Exemple de syntaxe incorrecte

classe foo (
barre $ publique =<<bar
EOT ;
// l'indentation avant l'identifiant de fermeture n'est pas autorisée
}
?>

Exemple #2 Exemple de syntaxe correcte

classe foo (
barre $ publique =<<bar
EOT ;
}
?>

Heredoc ne peut pas être utilisé pour initialiser les champs de classe.

Le texte Heredoc se comporte de la même manière qu’une chaîne entre guillemets doubles, sans les avoir.

Cela signifie que vous n'avez pas besoin d'échapper aux guillemets dans Heredoc, mais vous pouvez toujours utiliser les séquences d'échappement ci-dessus.

Les variables sont traitées, mais vous devez être aussi prudent lorsque vous utilisez des variables complexes dans Heredoc que lorsque vous travaillez avec des chaînes.<<Exemple #3 Exemple de définition de chaîne Heredoc
$str =
Exemple de ligne,
s'étendant sur plusieurs lignes,

en utilisant la syntaxe hérdocienne.
{
NEM ;
Classe foo

var $foo ;
{
var $bar ;
Fonction__construct()
}
}

$this -> foo = "Foo" ;
$ce ->

$foo = nouveau foo();<<$nom = "Nom" ; .
écho Je m'appelle "$name". Je tape $foo -> foo .
Maintenant je déduis
EOT ;
?>

( $foo -> barre [ 1 ])

Cela devrait afficher la lettre majuscule "A": \x41

Je m'appelle "Nom". Je tape Foo. Maintenant, je sors Bar2. Cela devrait afficher une lettre majuscule "A": A

Il est également possible d'utiliser la syntaxe heredoc pour transmettre des données via des arguments de fonction :

Depuis la version 5.3.0, il est devenu possible d'initialiser des variables statiques et des propriétés/constantes de classe en utilisant la syntaxe heredoc :
Exemple #5 Utiliser Heredoc pour initialiser des variables statiques
{
// Variables statiques<<fonction foo()
barre $ statique =
}

Il n'y a rien ici...
ÉTIQUETTE;
{
// Constantes/propriétés de classe<<classe foo
const BAR =

Exemple d'utilisation d'une constante<<FOOBAR ;
const BAR =
}
?>

Public $baz =

Exemple d'utilisation d'un champ

Depuis PHP 5.3.0, vous pouvez également entourer l'identifiant Heredoc de guillemets doubles : Maintenantdoc Nowdoc est le même pour les chaînes entre guillemets simples que heredoc pour les chaînes entre guillemets doubles. Nowdoc est similaire à Heredoc, mais à l'intérieur aucune substitution n'est effectuée

. Cette conception est idéale pour intégrer du code PHP ou d’autres gros blocs de texte sans avoir à y échapper. En cela, c'est un peu similaire à la construction SGML <<< en déclarant un bloc de texte qui n'est pas destiné à être traité. <<<"EOT" Nowdoc est indiqué par la même séquence

, qui est utilisé dans l'hérdoc, mais l'identifiant suivant est placé entre guillemets simples, par exemple :

$foo = nouveau foo();<<<"EOD"
.
Toutes les conditions qui s'appliquent aux identifiants heredoc s'appliquent également à nowdoc, en particulier celles qui s'appliquent à l'identifiant de fermeture.
Exemple #7 Exemple d'utilisation de nowdoc
Exemple de texte,
s'étendant sur plusieurs lignes

en utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,

Exemple de texte s'étendant sur plusieurs lignes utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement, comme \\ et \".

Exemple #8 Chaîne Nowdoc citant un exemple avec des variables

/* Exemple plus complexe avec des variables. */
ÉTIQUETTE;
{
public $foo ;
barre $ publique ;

var $foo ;
{
var $bar ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$this -> foo = "Foo" ;
$ce ->

$foo = nouveau foo();<<<"EOT"
Je m'appelle "$name". J'imprime $foo->foo.
Maintenant, j'imprime ($foo->bar).
Cela ne devrait pas afficher un "A" majuscule : \x41
EOT ;
?>

en utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,

Je m'appelle "$name". J'imprime $foo->foo. Maintenant, j'imprime ($foo->bar). Cela ne devrait pas afficher un "A" majuscule : \x41

Exemple #9 Exemple d'utilisation de données statiques

classe foo (
barre $ publique =<<<"EOT"
bar
EOT ;
}
?>

Commentaire:

Le support de nowdoc a été ajouté dans PHP 5.3.0.

Gestion des variables

Si une chaîne est spécifiée entre guillemets doubles ou en utilisant heredoc, les variables qu'elle contient sont traitées.

Il existe deux types de syntaxe : simple et complexe. Une syntaxe simple est plus simple et plus pratique. Il permet de traiter une variable, une valeur de tableau ( tableau ) ou les propriétés de l'objet ( objet

) avec un minimum d'effort.

Une syntaxe complexe peut être identifiée par les accolades entourant l’expression.

Syntaxe simple $ Si l'interprète rencontre un signe dollar (

), il capture autant de caractères que possible pour former le nom de variable correct. Si vous souhaitez spécifier la fin d'un nom, placez le nom de la variable entre accolades.

$jus = "pomme" ;

echo "Il a bu du jus $juice." . PHP_EOL ;
// Incorrect. "s" est un caractère valide pour un nom de variable, mais la variable s'appelle $juice.

echo "Il a bu du jus composé de $jus." ;
// Correct. La fin du nom de la variable est strictement indiquée entre parenthèses :
?>

en utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,

echo "Il a bu du jus composé de $( juice ) s." ;

Il a bu du jus de pomme. Il a bu du jus de . Il a bu du jus de pomme. Une syntaxe simple est plus simple et plus pratique. Il permet de traiter une variable, une valeur de tableau ( Un élément de tableau ( ) ou les propriétés de l'objet () ou la propriété de l'objet ( ] ). Dans les indices de tableau, il y a un crochet fermant (

) marque la fin de la définition de l'index. Les mêmes règles s'appliquent aux propriétés des objets qu'aux variables simples.

Exemple #10 Exemple de syntaxe simple
définir ("KOOLAID" , "koolaid1" );

$juices = array("apple" , "orange" , "koolaid1" => "purple" );
echo "Il a bu du jus $juices [ 0 ]." . PHP_EOL ;
echo "Il a bu du jus $juices [ 1 ]." . PHP_EOL ;

echo "Il a bu du jus $juices [ koolaid1 ]." . PHP_EOL ;
les gens de classe (
public $john = "John Smith" ;
public $jane = "Jane Smith" ;

public $robert = "Robert Paulsen" ;
}

Public $smith = "Smith" ;

echo "$people -> John a bu du jus $juices [ 0 ]." . PHP_EOL ;
echo " $people -> john a ensuite dit bonjour à $people -> jane ." . PHP_EOL ;
echo "$people -> la femme de John a salué $people -> robert." . PHP_EOL;
echo " $people -> Robert a salué les deux $people -> Smiths ." ; // Ne fonctionnera pas
?>

en utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,

Il a bu du jus de pomme. Il a bu du jus d'orange. Il a bu du jus violet. John Smith a bu du jus de pomme. John Smith a ensuite dit bonjour à Jane Smith. L'épouse de John Smith a salué Robert Paulsen. Robert Paulsen a salué les deux.

PHP 7.1.0 a ajouté le support négatif indices numériques.

Exemple #11 Indices numériques négatifs

$chaîne = "chaîne" ;
écho "Le caractère à l'index -2 est égal à$string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
écho "Changer le caractère en position -3 en 'o' produit la ligne suivante :$chaîne." , PHP_EOL;
?>

en utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,

Le caractère d'indice -2 est égal à n. Changer le caractère en position -3 en "o" donne la ligne suivante : fort

Pour quelque chose de plus complexe, utilisez une syntaxe complexe.

Syntaxe complexe (bouclée)

On l’appelle complexe non pas parce qu’il est difficile à comprendre, mais parce qu’il permet l’utilisation d’expressions complexes.

Toute variable scalaire, élément de tableau ou propriété d'objet mappée à une chaîne peut être représentée dans une chaîne à l'aide de cette syntaxe. Écrivez simplement l'expression de la même manière que vous le feriez en dehors de la ligne, puis enveloppez-la { Et } . Depuis { ne peut pas être échappé, cette syntaxe ne sera reconnue que lorsque $ suit directement { . Utiliser {\$ imprimer {$ .

Quelques exemples illustratifs :
// Afficher toutes les erreurs

rapport d'erreur (E_ALL);

$génial = "super" ;
// Ne fonctionne pas, affiche : C'est (génial)

echo "C'est ($génial)" ;
// Fonctionne, résultats : c'est génial

echo "C'est ($génial)" ;
écho // Travaux"Cette place est large

( $square -> width ) 00 centimètres." ;
// Fonctionne, les mots-clés cités ne fonctionnent qu'avec la syntaxe des accolades

echo "C'est ($génial)" ;
echo "Cela fonctionne : ( $arr [ "key" ]) " ;

echo "Cela fonctionne : ( $arr [ 4 ][ 3 ]) " ;
// Ceci n'est pas valide pour la même raison que $foo à l'extérieur
// lignes. En d'autres termes, cela fonctionnera toujours,
// mais comme PHP recherche d'abord la constante foo, cela entraînera
écho // erreur de niveau E_NOTICE (constante non définie)."C'est faux :

( $arr [ foo ][ 3 ]) " ;
// Travaux. Lors de l'utilisation de tableaux multidimensionnels en interne
// les lignes utilisent toujours des accolades

echo "Cela fonctionne : ( $arr [ "foo" ][ 3 ]) " ;
// Travaux.

écho echo "Cela fonctionne : " . $arr [ "foo" ][ 3 ];( $obj -> valeurs [ 3 ]-> nom ) " ;

écho "C'est la valeur de la variable nommée$nom : ($( $nom )) " ;

écho "Voici la valeur du nom de variable renvoyée par getName() :($( getName ())) " ;

écho "Voici la valeur de la variable par nom renvoyée par \$object->getName() :($( $object -> getName ())) " ;

// Ne fonctionne pas, affiche : Voici ce que renvoie getName() : (getName())
écho "Voici ce que renvoie getName() : (getName())";
?>

Il est également possible d'accéder aux propriétés des objets dans les chaînes en utilisant cette syntaxe.

classe foo (
var $bar = "Je suis bar." ;
}

$this -> foo = "Foo" ;
$barre = "barre" ;
$baz = array("foo" , "bar" , "baz" , "quux" );
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>

en utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,

Je suis bar. Je suis bar.

Commentaire:

Les fonctions, les appels de méthodes, les variables de classe statiques et les constantes de classe fonctionnent en interne {$} , à partir de PHP 5. Cependant, la valeur fournie sera traitée comme un nom de variable dans le même contexte que la ligne dans laquelle elle est définie. Utiliser des accolades simples ( {} ) ne fonctionnera pas pour accéder aux valeurs des fonctions, méthodes, constantes de classe ou variables de classe statiques.

Quelques exemples illustratifs :
// Afficher toutes les erreurs

bières de classe (
const softdrink = "bière de racine" ;
public statique $ale = "ipa" ;
}

$rootbeer = "A&W" ;
$ipa = "Alexandre Keith\"s" ;

// Cela fonctionne, affiche : Je voudrais A & W
echo "Je voudrais ($( bières :: softdrink )) \n" ;

// Cela fonctionne aussi, résultats : je voudrais celui d'Alexander Keith
echo "Je voudrais ($( bières :: $ale )) \n" ;
?>

Accéder et modifier un caractère dans une chaîne

Les caractères des chaînes peuvent être utilisés et modifiés en spécifiant leur décalage par rapport au début de la chaîne, en commençant par zéro, entre crochets après la chaîne, par exemple $str . Considérez une chaîne à cet effet comme un tableau de caractères. Et Si vous devez obtenir ou remplacer plus d'un caractère, vous pouvez utiliser les fonctions.

Commentaire: sousstr() substr_replace() Depuis PHP 7.1.0, les valeurs de décalage négatives sont prises en charge. Ils précisent le décalage par rapport à la fin de la ligne. Les décalages précédemment négatifs provoquaient une erreur de niveau E_AVIS

Commentaire: en lecture (renvoyant une chaîne vide) ou

Attention

E_AVERTISSEMENT Ils précisent le décalage par rapport à la fin de la ligne. Les décalages précédemment négatifs provoquaient une erreur de niveau.

Attention

Seul le premier caractère de la chaîne attribuée est utilisé.

Commentaire: Depuis PHP 7.1.0, l'attribution d'une chaîne vide provoquera une erreur fatale. Auparavant, dans ce cas, un octet zéro (NULL) était attribué.

Les chaînes en PHP sont des tableaux d’octets en interne. Par conséquent, l’accès ou la modification d’une chaîne avec un décalage n’est pas sûr en matière de codage multi-octets et ne doit être effectué qu’avec des chaînes en codages sur un octet, tels que ISO-8859-1.

Depuis PHP 7.1.0, l'utilisation d'un index vide provoque une erreur fatale ; auparavant, dans ce cas, la chaîne était convertie en tableau sans avertissement.
Exemple #12 Quelques exemples de chaînes
// Récupère le premier caractère de la chaîne

$str = "Ceci est un test." ;
$premier = $str [ 0 ];

// Récupère le troisième caractère de la chaîne
$troisième = $str [ 2 ];
// Récupère le dernier caractère de la chaîne

$str = "Ceci est encore un test." ;
$last = $str [ strlen ($str ) - 1 ];
// Change le dernier caractère de la ligne

?>

$str = "Regardez la mer" ; $str [ strlen ($str )- 1 ] = "e" ; Depuis PHP 5.4, le décalage dans une chaîne doit être spécifié soit sous forme d'entier, soit sous forme de chaîne contenant des chiffres, sinon un avertissement sera émis. Décalage précédemment donné par une chaîne comme 0 .

"foo"

, sans avertissement, s'est transformé en

Exemple #13 Différences entre PHP 5.3 et PHP 5.4
$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" ]));

Le résultat de l'exécution de cet exemple en PHP 5.3 :

chaîne (1) "b" bool (vrai) chaîne (1) "b" bool (vrai) chaîne (1) "a" bool (vrai) chaîne (1) "b" bool (vrai)

Commentaire:

Le résultat de l'exécution de cet exemple en PHP 5.4 : string(1) "b" bool(true) Avertissement : décalage de chaîne illégal "1.0" dans /tmp/t.php à la ligne 7 string(1) "b" bool(false) Avertissement : décalage de chaîne illégal "x" dans / tmp/t.php à la ligne 9 string(1) "a" bool(false) string(1) "b" bool(false) {} Essayer d'accéder à des variables d'autres types (à l'exclusion des tableaux ou des objets qui implémentent certaines interfaces) en utilisant ou.

Commentaire:

reviendra silencieusement NUL {} .

PHP 5.5 a ajouté la prise en charge de l'accès aux caractères dans les chaînes littérales à l'aide de la syntaxe

ou

Il existe de nombreuses fonctions utiles pour modifier les chaînes.

Les fonctions de base sont décrites dans la section sur les fonctions de chaîne, et pour la recherche et le remplacement avancés, les fonctions d'expression régulière compatibles Perl. Convertir en chaîne Une valeur peut être convertie en chaîne à l'aide d'un cast strval(). écho string(1) "b" bool(true) Avertissement : décalage de chaîne illégal "1.0" dans /tmp/t.php à la ligne 7 string(1) "b" bool(false) Avertissement : décalage de chaîne illégal "x" dans / tmp/t.php à la ligne 9 string(1) "a" bool(false) string(1) "b" bool(false) Dans les expressions où une chaîne est requise, la conversion se produit automatiquement. Cela se produit lorsque vous utilisez des fonctions imprimer.

, ou lorsque la valeur d'une variable est comparée à une chaîne. La lecture des sections Types et Manipulation de type du manuel rendra ce qui suit plus clair. Voir aussi settype() Les tableaux sont toujours convertis en chaîne Une syntaxe simple est plus simple et plus pratique. Il permet de traiter une variable, une valeur de tableau ("Tableau" écho NUL Dans les expressions où une chaîne est requise, la conversion se produit automatiquement., vous ne pouvez donc pas afficher le contenu du tableau ( ), en utilisant pour voir ce qu'il contient. Pour afficher un seul élément, utilisez quelque chose comme

echo $arr["foo"] . Voir ci-dessous pour obtenir des conseils sur la façon d'afficher/afficher tout le contenu. Pour convertir une variable de type "Objet" en nature

chaîne ou La méthode magique __toString est utilisée.

Signification est toujours converti en chaîne vide. Et Comme vous pouvez le voir ci-dessus, la conversion directe de tableaux, d'objets ou de ressources en chaîne ne fournit aucune information utile sur les valeurs elles-mêmes autres que leurs types..

Une meilleure façon de générer des valeurs pour le débogage consiste à utiliser des fonctions print_r().

var_dump()

La plupart des valeurs en PHP peuvent être converties en chaîne pour un stockage persistant. Cette méthode est appelée sérialisation et peut être effectuée à l'aide de la fonction

sérialiser() Conversion de chaînes en nombres Si la chaîne est reconnue comme une valeur numérique, la valeur et le type résultants sont déterminés comme suit. Si la chaîne ne contient aucun des caractères ".", "e" ou "E" et que la valeur du nombre se situe dans les limites des nombres entiers (définis PHP_INT_MAX ), la chaîne sera reconnue comme un entier ().

entier

). Dans tous les autres cas, il est considéré comme un nombre à virgule flottante (
flotter La valeur est déterminée par le début de la chaîne. Si la ligne commence par une valeur numérique valide, cette valeur sera utilisée. Sinon la valeur sera 0 (zéro). Une valeur numérique valide est constituée d'un ou plusieurs chiffres (pouvant contenir un point décimal), éventuellement précédés d'un signe suivi d'un exposant facultatif. L'exposant est "e" ou "E" suivi d'un ou plusieurs chiffres.
$foo = 1 + "10,5" ;
// $foo est un float (11.5)
$foo = 1 + "-1.3e3" ; // $foo est un flottant (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo est un entier (1) $foo = 1 + "bob3" ; // $foo est un entier (1)
$foo = 1 + "10 petits cochons" ;
// $foo est un entier (11)
?>

Pour plus d'informations sur cette conversion, consultez la section sur strtod(3) dans la documentation Unix.

Si vous souhaitez tester l'un des exemples de cette section, copiez-le et collez-le ainsi que la ligne suivante pour voir ce qui se passe :

echo "\$foo== $foo ; tapez : " . gettype ($foo) . "
\n" ;
?>

Ne vous attendez pas à obtenir le code d'un caractère en le convertissant en entier (comme cela se fait par exemple en C). Pour convertir les caractères en leurs codes ASCII et inversement, utilisez les fonctions ord() Et chr().

Détails d'implémentation du type de chaîne

il y a 7 ans

La documentation ne le mentionne pas, mais un point-virgule fermant à la fin de l'hérdoc est en fait interprété comme un véritable point-virgule, et à ce titre, conduit parfois à des erreurs de syntaxe.

$foo =<<abcd
FIN;
?>

Cela ne signifie pas :

foo(<<abcd
FIN;
);
// erreur de syntaxe, ";" inattendu
?>

Sans point-virgule, ça marche bien :

foo(<<abcd
FIN
);
?>

il y a 3 ans

Vous pouvez utiliser une chaîne comme un tableau de caractères (comme C)

$a = "Test du tableau de chaînes" ;

var_dump($a);
// Retourne string(17) "Test du tableau de chaînes"

var_dump($a);
// Renvoie la chaîne(1) "S"

// -- Avec conversion de tableau --
var_dump((tableau) $a);
// Retourne array(1) ( => string(17) "Test du tableau de chaînes")

var_dump((tableau) $a);
// Renvoie la chaîne (17) "S"

Norihiori

il y a 15 ans

Vous pouvez utiliser la syntaxe complexe pour placer la valeur des propriétés d'objet ET des méthodes d'objet dans une chaîne. Par exemple...
Test de classe (
public $un = 1 ;
fonction publique deux() (
retourner 2 ;
}
}
$test = nouveau Test();
echo "foo ( $test -> un ) bar ( $test -> deux ()) " ;
?>
Affichera "foo 1 bar 2".

Cependant, vous ne pouvez pas faire cela pour toutes les valeurs de votre espace de noms. Les constantes de classe et les propriétés/méthodes statiques ne fonctionneront pas car la syntaxe complexe recherche le « $ ».
Test de classe (
const UN = 1 ;
}
echo "barre foo (Test::ONE)" ;
?>
Cela affichera "foo (Test::one) bar". Les constantes et les propriétés statiques nécessitent que vous divisiez la chaîne.

il y a 3 ans

Attention, cela est cohérent avec "Conversion de chaînes en nombres":

Si ("123abc" == 123 ) écho "(intstr == int) teste incorrectement comme étant vrai.";

// Comme un côté est un nombre, la chaîne est incorrectement convertie de intstr en int, qui correspond alors au numéro de test.

// Vrai pour toutes les conditions telles que les instructions if et switch (probablement aussi les boucles while) !

// Cela pourrait constituer un risque de sécurité énorme lors du test/utilisation/enregistrement des entrées utilisateur, tout en attendant et en testant uniquement un nombre entier.

// Il semble que le seul correctif soit que 123 soit une chaîne comme "123", donc aucune conversion n'a lieu.

?>

il y a 6 ans

Les zéros non significatifs dans les chaînes ne sont (moins surprenant) pas traités comme des octaux.
Considérer:
$x = "0123" + 0 ;
$y = 0123 + 0 ;
echo "x est $x, y est $y"; // affiche "x vaut 123, y vaut 83"
autrement dit:
* les zéros non significatifs dans les littéraux numériques dans le code source sont interprétés comme "octal", cf. strtol().
* les zéros non significatifs dans les chaînes (par exemple les données soumises par l'utilisateur), lorsqu'ils sont convertis (implicitement ou explicitement) en entier, sont ignorés et considérés comme décimaux, cf. strtod().

il y a 10 ans

Voici un hack simple pour permettre aux chaînes entre guillemets et aux hérdocs de contenir des expressions arbitraires dans la syntaxe des accolades, y compris des constantes et d'autres appels de fonction :

//Déclaration de hack
fonction _expr ($v ) ( return $v ; )
$_expr = "_expr" ;

// Notre terrain de jeu
définir("qwe" , "asd");
définir("zxc", 5 );

$un= 3 ;
$b= 4 ;

fonction c($un, $b) (retour$un+ $b; }

//Usage
écho"pré{ $_expr(1 + 2 )} message\n"; // affiche "avant 3 post"
écho"pré{ $_expr(qwe)} message\n"; // affiche "pre asd post"
écho"pré{ $_expr(c($un, $b)+ zxc* 2 )} message\n"; // affiche "avant 17 post"

// La syntaxe générale est ($_expr(...))
?>

il y a 2 ans

J'ai pensé qu'il serait utile d'ajouter ce commentaire afin que l'information apparaisse au moins sur la bonne page du site PHP.

Notez que si vous avez l'intention d'utiliser une chaîne entre guillemets avec une clé associative, vous risquez de rencontrer l'erreur T_ENCAPSED_AND_WHITESPACE. Certains considèrent cela comme l’un des messages d’erreur les moins évidents.

Une expression telle que :

$fruit=tableau(
"un"=> "pomme",
"b"=> "banane",
//etc
);

Imprimer "C'est un$fruit[ "un"]"; // T_ENCAPSED_AND_WHITESPACE
?>

va certainement tomber en morceaux.

Vous pouvez le résoudre comme suit :

Dans les expressions où une chaîne est requise, la conversion se produit automatiquement."C'est un$fruit[ un] " ; // supprime la clé des guillemets
Dans les expressions où une chaîne est requise, la conversion se produit automatiquement."C'est un${ fruit[ "un"]} " ; // Syntaxe complexe
Dans les expressions où une chaîne est requise, la conversion se produit automatiquement."C'est un{ $fruit[ "un"]} " ; // Variation de syntaxe complexe
?>

J'ai une préférence personnelle pour la dernière variation car elle est plus naturelle et plus proche de ce que serait l'expression en dehors de la chaîne.

Il n'est pas clair (du moins pour moi) pourquoi PHP interprète mal le guillemet simple à l'intérieur de l'expression, mais j'imagine que cela a quelque chose à voir avec le fait que les guillemets ne font pas partie de la chaîne de valeur - une fois que la chaîne est déjà analysée, les guillemets sont juste gêner... ?

il y a 2 ans

Les deux devraient fonctionner :(

classeEssai{
public statique$VAR= "statique";
const publique VAR ="const";

Fonction publique direBonjourStatique() {
écho"Bonjour:{ $ ceci:: $VAR} " ;
}

Fonction publique direBonjourConst() {
écho"Bonjour:{ $ ceci::VAR)" ; //Erreur d'analyse : erreur de syntaxe, ")" inattendu, attente de "["
}
}

$obj= nouveauEssai();
$obj-> direBonjourStatique();
$obj-> direBonjourConst();

il y a 3 ans

Quelque chose que j'ai vécu et qui aidera sans aucun doute quelqu'un. . .
Dans mon éditeur, cela mettra en évidence la syntaxe HTML et le commentaire $ :

$html =<<<"EOD"
$commentaire
s'étendant sur plusieurs lignes,

Utiliser ceci montre tous la même couleur :

$html =<<$commentaire
s'étendant sur plusieurs lignes,

ce qui rend le travail beaucoup plus facile

il y a 11 ans

Pour sauver votre esprit, ne lisez pas les commentaires précédents sur les dates ;)

Lorsque les deux chaînes peuvent être converties en valeurs numériques (dans le test ("$a" > "$b")), les valeurs numériques résultantes sont utilisées, sinon les chaînes COMPLÈTES sont comparées caractère par caractère :

var_dump("1.22" > "01.23" ); // bool (faux)
var_dump("1.22.00" > "01.23.00" ); //bool(vrai)
var_dump("1-22-00" > "01-23-00" ); //bool(vrai)
var_dump((flotter)"1.22.00" > (flotteur)"01.23.00" ); // bool (faux)
?>

Les chaînes en PHP sont entourées de guillemets simples ou doubles. La principale différence est que vous pouvez mettre une variable entre guillemets :

Nous pouvons maintenant trouver une autre solution au problème de la leçon Variables en PHP :

$titre" ; écho "

Comment PHP trouve-t-il une variable dans une chaîne ?

C'est simple. Vous souvenez-vous des caractères qui peuvent être utilisés dans un nom de variable ? Ce sont des chiffres, des lettres et des traits de soulignement _.

PHP prend donc comme nom tout ce qui se trouve entre le symbole $ et le premier caractère interdit.

Dans le code suivant, PHP déterminera incorrectement le nom de la variable et générera une erreur :

Résultat dans le navigateur :

Remarque : Variable non définie : pricerub dans D:\OpenServer\domains\site\index.php à la ligne 3

Pour que PHP détermine correctement le nom d'une variable dans une chaîne, vous devez la placer entre accolades () :

Résultat dans le navigateur :

1499 roubles

Il n’existe pas d’opinion claire sur les guillemets à utiliser pour les chaînes ordinaires dans lesquelles rien ne doit être substitué. Cependant, de nombreux programmeurs préfèrent utiliser des guillemets simples.

Le fait est que pour beaucoup de gens, les guillemets évoquent l’association « quelque chose doit être inséré dans cette ligne ». Par conséquent, je recommande d'utiliser des guillemets simples pour le texte normal et des guillemets doubles uniquement lorsque vous devez remplacer une variable dans le texte. Exemple:

Échapper aux citations

Si vous devez mettre des guillemets dans une chaîne, il existe 2 façons de le faire :

Dans le deuxième exemple, la barre oblique inverse \ échappe au guillemet suivant afin que PHP le traite comme une chaîne.

Selon vous, que faut-il faire pour afficher uniquement des barres obliques inverses à l'écran ? Après tout, cela échappera au guillemet de clôture. C'est drôle, mais il faut écrire un deuxième slash pour échapper au premier :

Tabulation et sauts de ligne entre guillemets

La barre oblique inverse entre guillemets doubles vous permet d'échapper non seulement aux guillemets et à eux-mêmes, mais également à certains autres caractères. Les plus populaires sont la tabulation (le long espace que vous obtenez lorsque vous appuyez sur TAB) et le saut de ligne. Ils ressemblent à ceci :

Écrivez un script qui :
1. Crée une variable $type avec la valeur Game.
2. Crée une variable $name avec la valeur "World of Warcraft" (avec guillemets).
3. Affiche les deux variables à l'intérieur de la balise

. Il doit y avoir un espace entre les variables.

Les valeurs de type chaîne sont des chaînes de texte (chaînes en abrégé). Une chaîne est une séquence de zéro ou plusieurs caractères. Les caractères incluent les lettres, les chiffres, la ponctuation, les caractères spéciaux et les espaces.

Une chaîne peut être définie de quatre manières différentes :

• guillemets doubles
• guillemets simples
• syntaxe hérdocienne
• syntaxe nowdoc

Chaîne entre guillemets doubles

Chaîne entre guillemets :

Vous pouvez utiliser des séquences d'échappement dans des chaînes entre guillemets. Séquence de contrôle— ce sont des caractères spéciaux conçus pour formater la sortie de texte. Les séquences d'échappement suivantes sont disponibles en PHP :

La principale propriété des chaînes entre guillemets est la possibilité de gérer les variables à l’intérieur des chaînes.

Signe dollar : \$";

Les chaînes placées entre guillemets doubles peuvent contenir des guillemets simples :

Echo "Citation simple : "" ;

Chaîne entre guillemets simples (apostrophes)

Chaîne entre guillemets simples :

$str = "Chaîne" ; echo "Une grande ligne peut être divisée en plusieurs petites lignes pour faciliter la lecture.";

Contrairement aux chaînes entre guillemets et à la syntaxe héréditaire, les variables et les séquences de contrôle (à une exception près) entourées de guillemets simples ne sont pas traitées. Cela signifie qu'ils seront interprétés comme des caractères de chaîne normaux :

$num = 10 ; echo "Numéro : $num
Signe dollar : \$";

Pour pouvoir utiliser des guillemets simples dans une chaîne entourée de guillemets simples, vous devez les échapper à l'aide d'une barre oblique inverse (\"). Si vous devez écrire la barre oblique inverse elle-même, vous devez la dupliquer (\\) :

Echo "Utiliser des guillemets "simples" à l'intérieur" ; echo "Barre oblique inverse : \\" ;

Les chaînes placées entre guillemets simples peuvent contenir des guillemets doubles :

Echo "Citation double : "" ;

Syntaxe Hérédoc

La syntaxe Heredoc est une manière alternative d'écrire des chaînes.

Une chaîne définie à l'aide de la syntaxe Heredoc fonctionne de la même manière qu'une chaîne entourée de guillemets doubles. La différence entre Heredoc et une chaîne entre guillemets doubles est qu'avec Heredoc, il n'est pas nécessaire d'échapper aux guillemets doubles.

La syntaxe Heredoc commence par trois caractères<<< , после которых должен быть указан произвольный идентификатор (назовём его открывающим). Идентификатор может быть указан как в двойных кавычках, так и без них. Tout de suite l'identifiant doit être suivi d'une nouvelle ligne ; aucun autre caractère autre qu'une nouvelle ligne ne doit être après l'identifiant, sinon une erreur se produira. Vient ensuite le contenu de la chaîne elle-même. Après le contenu de la chaîne, sur une ligne distincte, un identifiant de fermeture doit être spécifié (le même qu'après<<<). Перед ним и после него не должно быть никаких пробелов или других символов, за исключением точки с запятой. Если это правило нарушено, то считается, что закрывающий идентификатор отсутствует и будет вызвана ошибка:

<<

Syntaxe Nowdoc

La syntaxe Nowdoc, comme Heredoc, est une manière alternative d'écrire des chaînes.

Une chaîne définie à l'aide de la syntaxe Nowdoc fonctionne de la même manière qu'une chaîne entre guillemets simples. La différence entre Nowdoc et une chaîne entre guillemets simples est qu'avec Nowdoc, il n'est pas nécessaire d'échapper aux guillemets simples.

La syntaxe de Nowdoc est similaire à Heredoc, à la seule différence que l'identifiant d'ouverture doit être placé entre guillemets simples :

$num = 10 ; écho<<<"some_id" Число: $num some_id;

Gestion des variables dans les chaînes

Il existe deux types de syntaxe pour gérer les variables dans les chaînes : simple Et difficile.

Syntaxe simple- c'est alors que le nom de la variable est indiqué tel quel dans la ligne.

Lorsque l'interpréteur rencontre un signe dollar, il commence à vérifier séquentiellement si tous les caractères suivants sont des caractères valides dans le nom de la variable. Ainsi, pour former un nom de variable valide, il capture autant de caractères que possible :

$str = "Monde !"; echo "Bonjour $str";

Syntaxe complexe- c'est à ce moment-là que le nom de la variable est placé entre accolades.

Étant donné que, pour traiter une variable dans une ligne, l'interpréteur capture autant de caractères que possible, il existe des situations où l'interprète n'est pas en mesure de déterminer indépendamment où se termine le nom de la variable :

$sport1 = "volonté" ; $sport2 = "pied" ; echo "J'aime $sport1ball et $sport2ball";

Dans ce cas, le résultat souhaité ne sera pas atteint car l'interprète considérera $sport1 comme faisant partie du nom de variable $sport1bol, qui n'existe pas.

Pour indiquer explicitement à l'interpréteur où se termine un nom de variable, vous devez mettre le nom de la variable entre accolades :

$sport1 = "volonté" ; $sport2 = "pied" ; echo "J'aime ($sport1)bol et ($sport2)bol.";

Le signe dollar peut être placé avant ou après l’accolade :

$sport1 = "volonté" ; $sport2 = "pied" ; echo "J'aime $(sport1)bol et ($sport2)bol.";

Enchaînement

La concaténation est la réunion de deux ou plusieurs chaînes en une seule chaîne plus grande. La concaténation s'effectue à l'aide de l'opérateur de concaténation - . (point). Lors de la concaténation, chaque ligne suivante est ajoutée à la fin de la précédente :

Une valeur de n'importe quel type concaténée avec une chaîne sera implicitement convertie en chaîne puis concaténée :

"; echo "Numéro : " . 1; ?>

Quel type de guillemets dois-je utiliser pour formater des chaînes : apostrophes ou guillemets classiques ?

Examinons la différence entre les guillemets doubles et simples en PHP et utilisons des exemples pour savoir quand les utiliser.

Les variables et les séquences d'échappement pour les caractères spéciaux trouvés dans les chaînes entourées de guillemets simples ne sont pas traitées. Les chaînes entourées d'apostrophes sont traitées beaucoup plus rapidement par l'interpréteur PHP que les chaînes similaires entourées de guillemets doubles.

La raison ici est simple : l'interpréteur PHP vérifie en outre les chaînes entre guillemets doubles pour la présence de variables, et si elles sont trouvées, alors au lieu du nom de la variable, sa valeur est insérée dans la chaîne. Mais une ligne entourée d'apostrophes est perçue par l'interpréteur comme du texte normal et PHP n'effectue aucune transformation dans ces lignes. Je pense qu'il est clair que le traitement des chaînes entre guillemets simples sera de toute façon plus rapide.

Tout d'abord, décrivons comment définir une chaîne, puis vérifions à quel point il sera plus rapide de traiter les chaînes entre guillemets simples.

La manière la plus simple de définir une chaîne est de la mettre entre guillemets simples ("). Pour utiliser des guillemets simples dans une chaîne entre guillemets simples, ils doivent être précédés d'une barre oblique inverse (\), c'est-à-dire échappée. Si la barre oblique inverse doit venir avant un guillemet simple ou à la fin de la ligne, vous devez le dupliquer. Si vous essayez d'échapper un autre caractère, la barre oblique inverse sera également imprimée.

Voici un exemple d'utilisation de guillemets simples :
// Sortie : chaîne simple
echo "Chaîne simple" ;
// Tirages : je suis là
echo "Je suis là" ;
// Sortie : Cela n'insérera pas : \n nouvelle ligne
echo "Cela n'insérera pas :\nnewline" ;
// Sorties : La variable $example ne sera pas non plus remplacée
echo "La variable $exemple ne sera pas non plus remplacée";

Si une chaîne est entourée de guillemets doubles ("), PHP reconnaît davantage de séquences d'échappement pour les caractères spéciaux et substitue également le nom de la variable dans la chaîne à sa valeur. Tout comme avec les guillemets simples, afin d'utiliser des guillemets doubles dans une chaîne entourée de guillemets doubles, ils doivent être précédés d'un caractère barre oblique inverse (\).
// Sortie : chaîne simple
echo "Chaîne simple" ;
Voici un exemple d'utilisation de guillemets doubles :
// Sorties : Société "Snowdrop"
echo "Société \"Perce-neige\"";
// Sortie : Cela mènera à une nouvelle ligne
echo "Cela passera à une nouvelle ligne \n";
// Sortie : La variable sera remplacée
echo "Variable $exemple";

Vous devez également vous rappeler que la séquence "\n" (nouvelle ligne), "\r" (retour chariot) concerne le texte brut, pas le HTML. Vous ne verrez donc pas de changements dans le navigateur (uniquement dans le code source de la page).
Voyons à quel point les guillemets simples sont plus rapides que les guillemets doubles. Pour les mesures, nous rédigerons un court script de test, et nous constaterons immédiatement que si vous le testez vous-même, les résultats, qui dépendent du matériel de votre PC ou serveur, seront différents.
// Renvoie l'horodatage au début de la boucle
$start = microtime(true);
// Crée une boucle pour 1 million d'itérations< 1000000; $i++) {
pour ($i = 0; $i
}
$text = "Voici une chaîne de caractères";
// Calculer le temps passé

$time = (microtime(true) - $start);
Résultat : 0,09 seconde.

Si on remplace les guillemets simples par des guillemets doubles :
$text = "Voici une chaîne de caractères";
Le résultat sera de 0,10 seconde.

Comme vous pouvez le constater, lors de l’utilisation de chaînes de texte, la différence de temps d’exécution est très faible, on pourrait même dire qu’elle n’existe pas du tout. Le plaisir commence lorsque nous essayons de combiner une chaîne et une variable.

$text = "Voici la chaîne de caractères $i";

ou

Citations simples

$text = $i."Voici une chaîne de caractères";

Résultat environ : 0,27 seconde.

La différence est assez notable. La concaténation et les guillemets doubles affectent clairement les performances lorsque des variables sont ajoutées à la chaîne.

Lorsque le serveur traite le code, il vérifie tout le contenu des guillemets doubles pour les variables, les constantes, etc. Cela prend du temps. Et le serveur traite ce qui se trouve entre les guillemets simples comme du texte prêt à l'emploi et ne se soucie pas de ce qu'il y a là. La différence entre les performances des guillemets simples et doubles est très faible, mais si vous développez un projet très chargé, quelques millisecondes économisées sont déjà une victoire.:

Guillemets doubles

Ce n'est un secret pour personne que les guillemets en PHP peuvent être simples ou doubles. Voyons quand certaines utilisations des guillemets sont plus appropriées.

La manière la plus simple de définir une chaîne consiste à placer le texte entre guillemets simples.

Une chaîne entourée de guillemets doubles reconnaît la plupart des séquences d'échappement pour les caractères spéciaux.

La différence la plus importante réside dans le fait que les guillemets doubles gèrent les variables.

Exemples d'utilisation de guillemets doubles:

Concentrons-nous sur le fait que les chaînes avec guillemets doubles gèrent les variables.

Que se passe-t-il lorsqu'une chaîne est traitée ? Interprète vérifiez chaque chaîne avec des guillemets doubles pour les variables, c'est-à-dire une analyse forcée se produit, ce qui prend du temps supplémentaire. Oui, cela ne dure souvent qu’une fraction de seconde, mais le fait lui-même doit être compris. Autrement dit, si vous comparez le traitement d'une chaîne avec différents guillemets (sans variables, bien sûr), alors une chaîne avec des guillemets simples sera certainement traitée plus rapidement.

Calculs

J'ai trouvé des calculs intéressants sur ce sujet sur le site ProfiPHP. L'auteur a écrit un script simple avec lequel il calculait le temps de traitement des chaînes.