Strings (Zeichenketten)

Ein String stellt eine Kette von Zeichen dar, in der ein Zeichen gleichbedeutend mit einem Byte ist. Das bedeutet, es gibt exakt 256 mögliche Zeichen. Es impliziert zudem, dass PHP keine native Unterstützung von Unicode bietet. Siehe auch Details zum String-Typ.

Hinweis: Unter 32-bit-Versionen kann ein String bis zu 2GB (maximal 2147483647 Bytes) groß werden.

Syntax

Ein String-Literal kann auf vier unterschiedliche Arten spezifiziert werden:

Einfache Anführungszeichen

Der einfachste Weg einen String anzugeben, ist ihn mit einfachen Anführungszeichen (das Zeichen ') zu umschließen.

Um ein einfaches Anführungszeichen hierin anzugeben, fügen sie einen Backslash (\) vor dem Zeichen ein. Um einen Backslash als Zeichen anzugeben, verdoppeln Sie ihn (\\). Alle anderen Instanzen von Backslash werden als buchstäblicher Backslash behandelt: Das bedeutet, dass die anderen Escape-Sequenzen, die Sie vielleicht gewohnt sind, wie \r oder \n, buchstäblich wie angegeben ausgegeben werden und keine besondere Bedeutung haben.

Hinweis: Im Gegensatz zu den doppelten Anführungszeichen- und Heredoc-Notationen werden Variablen und Escape-Sequenzen für Sonderzeichen nicht aufgelöst (ersetzt), wenn sie in einem mit einfachen Anführungszeichen umschlossenen String erscheinen.

<?php
echo 'dies ist ein einfacher String';

echo
'Sie können auch Zeilenumbrüche
in dieser Art angeben,
dies ist okay so'
;

// Gibt aus: Arnold sagte einst: "I'll be back"
echo 'Arnold sagte einst: "I\'ll be back"';

// Ausgabe: Sie löschten C:\*.*?
echo 'Sie löschten C:\\*.*?';

// Ausgabe: Sie löschten C:\*.*?
echo 'Sie löschten C:\*.*?';

// Ausgabe: Dies erzeugt keinen: \n Zeilenumbruch
echo 'Dies erzeugt keinen: \n Zeilenumbruch';

// Ausgabe: Variablen werden $ebenfalls $nicht ersetzt
echo 'Variablen werden $ebenfalls $nicht ersetzt';
?>

Doppelte Anführungszeichen

Wenn der String in doppelte Anführungszeichen (") eingeschlossen wird, interpretiert PHP zusätzliche Escape-Sequenzen für Sonderzeichen:

Maskierte Zeichen
Sequenz Bedeutung
\n Zeilenumbruch (LF or 0x0A (10) in ASCII)
\r Wagenrücklauf (CR or 0x0D (13) in ASCII)
\t horizontaler Tabulator (HT or 0x09 (9) in ASCII)
\v vertikaler Tabulator (VT or 0x0B (11) in ASCII)
\e Escape-Zeichen (ESC or 0x1B (27) in ASCII)
\f Seitenvorschub (FF or 0x0C (12) in ASCII)
\\ Backslash (Rückstrich)
\$ Dollar-Zeichen
\" doppeltes Anführungszeichen
\[0-7]{1,3} Oktal: die Folge von Zeichen, die auf den regulären Ausdruck [0-7]{1,3} passt, ist ein Zeichen in oktaler Notation (z. B. "\101" === "A"), die stillschweigend überläuft, um in ein Byte zu passen (z. B. "\400" === "\000")
\x[0-9A-Fa-f]{1,2} Hexadezimal: die Folge von Zeichen, die auf den regulären Ausdruck [0-9A-Fa-f]{1,2} passt, ist ein Zeichen in hexadezimaler Schreibweise (z. B. "\x41" === "A")
\u{[0-9A-Fa-f]+} Unicode: die Folge von Zeichen, die auf den regulären Ausdruck [0-9A-Fa-f]+ passt, ist ein Unicode-Codepunkt, der in der Zeichenkette als UTF-8-Darstellung des Codepunkts ausgegeben wird. Die geschweiften Klammern in der Zeichenkette sind erforderlich (z. B. "\u{41}" === "A")

Wie bei Strings in einfachen Anführungszeichen wird beim Maskieren aller anderen Zeichen der Backslash mit ausgegeben.

Das Auflösen von Variablen-Namen ist eine der wichtigsten Besonderheiten von in doppelten Anführungszeichen angegebenen Strings. Siehe hierzu String-Parsing für weitere Details.

Heredoc

Eine dritte Möglichkeit, Strings zu begrenzen, stellt die Heredoc-Syntax dar: <<<. Nach diesem Operator wird ein beliebiger Bezeichner angegeben, dann eine neue Zeile. Hiernach folgt der eigentliche String und abschließend erneut der Bezeichner, um die Auszeichnung abzuschließen.

Der schließende Bezeichner darf durch Leerzeichen oder Tabulatoren eingerückt sein, wobei in diesem Fall die Einrückung aus allen Zeilen des Doc-Strings entfernt wird. Vor PHP 7.3.0 muss der schließende Bezeichner in der ersten Spalte der Zeile beginnen.

Außerdem muss der schließende Bezeichner den gleichen Benennungsregeln folgen wie jeder andere Bezeichner in PHP: Er darf nur alphanumerische Zeichen sowie Unterstriche enthalten und muss mit einem nicht-numerischen Zeichen oder einem Unterstrich beginnen.

Beispiel #1 Grundlegendes Heredoc-Beispiel ab PHP 7.3.0

<?php
// keine Einrückung
echo <<<END
a
b
c
\n
END;

// vier Leerzeichen Einrückung
echo <<<END
a
b
c
END;

Das oben gezeigte Beispiel erzeugt mit PHP 7.3 folgende Ausgabe:

      a
     b
    c

  a
 b
c

Wenn der schließende Bezeichner weiter eingerückt ist als alle Zeilen des Textkörpers, wird ein ParseError ausgelöst:

Beispiel #2 Der schließende Bezeichner darf nicht weiter eingerückt sein, als die Zeilen des Textkörpers

<?php
echo <<<END
a
b
c
END;

Das oben gezeigte Beispiel erzeugt mit PHP 7.3 folgende Ausgabe:

PHP Parse error:  Invalid body indentation level (expecting an indentation level of at least 3) in example.php on line 4

Wenn der schließende Bezeichner eingerückt ist, können auch Tabulatoren verwendet werden, allerdings dürfen Tabulatoren und Leerzeichen in Bezug auf die Einrückung des schließenden Bezeichners und die Einrückung des Textkörpers (bis zum schließenden Bezeichner) nicht miteinander vermischt werden. In jedem dieser Fälle wird ein ParseError ausgelöst. Diese Whitespace-Einschränkungen wurden aufgenommen, weil die Vermischung von Tabulatoren und Leerzeichen für die Einrückung die Lesbarkeit beeinträchtigt.

Beispiel #3 Unterschiedliche Einrückung für den Bezeichner, der den Textkörper (Leerzeichen) schließt

<?php
// Der gesamte folgende Code funktioniert nicht.

// Unterschiedliche Einrückung für den Bezeichner (Tabulatoren), der den
// Textkörper (Leerzeichen) schließt
{
echo <<<END
a
END;
}

// Vermischung von Leerzeichen und Tabulatoren im Textkörper
{
echo <<<END
a
END;
}

// Vermischung von Leerzeichen und Tabulatoren in der Endmarkierung
{
echo <<<END
a
END;
}

Das oben gezeigte Beispiel erzeugt mit PHP 7.3 folgende Ausgabe:

PHP Parse error:  Invalid indentation - tabs and spaces cannot be mixed in example.php line 8

Der schließende Bezeichner für den Textkörper muss nicht von einem Semikolon oder Zeilenumbruch gefolgt werden. Zum Beispiel ist der folgende Code ist ab PHP 7.3.0 erlaubt:

Beispiel #4 Fortsetzen eines Ausdrucks nach einem schließenden Bezeichner

<?php
$values
= [<<<END
a
b
c
END, 'd e f'];
var_dump($values);

Das oben gezeigte Beispiel erzeugt mit PHP 7.3 folgende Ausgabe:

array(2) {
  [0] =>
  string(11) "a
  b
    c"
  [1] =>
  string(5) "d e f"
}
Warnung

Wenn der schließende Bezeichner am Anfang einer Zeile gefunden wurde, dann kann er unabhängig davon, ob er Teil eines anderen Wortes war, als schließender Bezeichner betrachtet werden und führt zu einem ParseError.

Beispiel #5 Ein schließender Bezeichner im Textkörper der Zeichenkette führt zu einem ParseError

<?php
$values
= [<<<END
a
b
END ING
END
, 'd e f'];

Das oben gezeigte Beispiel erzeugt mit PHP 7.3 folgende Ausgabe:

PHP Parse error:  syntax error, unexpected identifier "ING", expecting "]" in example.php on line 6

Um dieses Problem zu vermeiden, ist es ratsam, die einfache Regel zu befolgen: etwas, das im Textkörper vorkommt, nicht als schließenden Bezeichner wählen.

Warnung

Vor PHP 7.3.0 ist es sehr wichtig, darauf zu achten, dass die Zeile mit dem schließenden Bezeichner keine anderen Zeichen außer einem Semikolon (;) enthalten darf. Das heißt insbesondere auch, dass der Bezeichner nicht eingerückt werden darf und dass es vor oder nach dem Semikolon auch keine Leerzeichen oder Tabulatoren geben darf. Zudem muss das erste Zeichen vor dem schließenden Bezeichner ein Zeilenumbruch sein, so wie er vom Betriebssystem definiert wird. In UNIX-Systemen, inlusive macOS, ist dies \n. Auf den schließenden Bezeichner muss ebenfalls ein Zeilenumbruch folgen.

Wenn diese Regel gebrochen wird und der schließende Bezeichner nicht valide ist, wird er nicht als Bezeichner angenommen und PHP wird weiter nach einem solchen schließenden Bezeichner suchen. Wird kein gültiger schließender Bezeichner vor dem Dateiende gefunden, gibt PHP einen auf die letzte Zeile der Datei weisenden Parser-Fehler aus.

Beispiel #6 Ungültiges Beispiel vor PHP 7.3.0

<?php
class foo {
public
$bar = <<<EOT
bar
EOT;
}
// Identifier must not be indented
?>

Beispiel #7 Gültiges Beispiel, auch vor PHP 7.3.0

<?php
class foo {
public
$bar = <<<EOT
bar
EOT;
}
?>

Heredocs, die Variablen enthalten, können nicht für die Initialisierung von Klasseneigenschaften verwendet werden.

Heredoc-Text verhält sich genau wie ein String in doppelten Anführungsstrichen, ohne die doppelten Anführungszeichen. Das bedeutet, dass Anführungszeichen in einem Heredoc nicht maskiert werden müssen, aber die oben aufgeführten Maskierungscodes können trotzdem verwendet werden. Variablen werden aufgelöst, aber wenn komplexe Variablen innerhalb eines Heredocs verwendet werden, ist die gleiche Vorsicht geboten wie bei Strings.

Beispiel #8 Beispiel für das Notieren von Heredoc-Strings

<?php
$str
= <<<EOD
Ein Beispiel für einen String, der sich
unter Verwendung der heredoc-Syntax
über mehrere Zeilen erstreckt.
EOD;

/* Ein komplexeres Beispiel mit Variablen. */
class foo
{
var
$foo;
var
$bar;

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

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

echo <<<EOT
Mein Name ist "$name". Ich gebe etwas $foo->foo aus.
Jetzt gebe ich etwas
{$foo->bar[1]} aus.
Dies sollte ein großes 'A' ausgeben: \x41
EOT;
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Mein Name ist "MeinName". Ich gebe etwas Foo aus.
Jetzt gebe ich etwas Bar2 aus.
Dies sollte ein großes 'A' ausgeben: A

Es ist auch möglich, die Heredoc-Syntax zu verwenden, um Daten an Funktionsargumente zu übergeben:

Beispiel #9 Beispiel für Heredoc in Argumenten

<?php
var_dump
(array(<<<EOD
foobar!
EOD
));
?>

Es ist möglich, statische Variablen und Klasseneigenschaften/Konstanten mit Hilfe der Heredoc-Syntax zu initialisieren:

Beispiel #10 Verwendung von Heredoc zur Initialisierung von statischen Werten

<?php
// Statische Variablen
function foo()
{
static
$bar = <<<LABEL
Hier steht nichts drin...
LABEL;
}

// Klasseneigenschaften/Konstanten
class foo
{
const
BAR = <<<FOOBAR
Beispiel für eine Konstante
FOOBAR;

public
$baz = <<<FOOBAR
Beispiel für eine Eigenschaft
FOOBAR;
}
?>

Der öffnende Heredoc-Bezeichner kann optional in doppelte Anführungszeichen gesetzt werden:

Beispiel #11 Verwendung von doppelten Anführungszeichen in Heredoc

<?php
echo <<<"FOOBAR"
Hallo Welt!
FOOBAR;
?>

Nowdoc

Nowdocs sind für Strings in einfachen Anführungszeichen das, was Heredocs für Strings in doppelten Anführungszeichen sind. Ein Nowdoc wird ähnlich wie ein Heredoc angegeben, aber es wird kein Parsing innerhalb eines Nowdocs durchgeführt. Das Konstrukt ist ideal für die Einbettung von PHP-Code oder anderen großen Textblöcken ohne maskieren zu müssen. Es hat einige Eigenschaften mit dem <![CDATA[ ]]>-Konstrukt in SGML gemeinsam, indem es einen Textblock deklariert, der nicht geparst werden soll.

Ein Nowdoc wird mit der gleichen <<<-Sequenz identifiziert, die für Heredocs verwendet wird, aber der nachfolgende Bezeichner wird in einfachen Anführungszeichen eingeschlossen, z. B. <<<'EOT'. Alle Regeln für Heredoc-Bezeichner gelten auch für Nowdoc-Bezeichner, insbesondere die hinsichtlich des Aussehens des schließenden Bezeichners.

Beispiel #12 Nowdoc-Beispiel für das Notieren von Strings

<?php
echo <<<'EOD'
Ein Beispiel für einen String, der sich über mehrere Zeilen erstreckt
unter Verwendung der Nowdoc-Syntax. Backslashes werden immer als
Buchstaben behandelt,
z. B. \\ und \'.
EOD;

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Ein Beispiel für einen String, der sich über mehrere Zeilen erstreckt
unter Verwendung der Nowdoc-Syntax. Backslashes werden immer als
Buchstaben behandelt,
z. B. \\ und \'.

Beispiel #13 Nowdoc Beispiel für Strings mit Variablen

<?php
class foo
{
public
$foo;
public
$bar;

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

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

echo <<<'EOT'
Mein Name ist "$name". Ich gebe etwas $foo->foo aus.
Jetzt gebe ich etwas {$foo->bar[1]} aus.
Dies sollte ein großes 'A' ausgeben: \x41
EOT;
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Mein Name ist "$name". Ich gebe etwas $foo->foo aus.
Jetzt gebe ich etwas {$foo->bar[1]} aus.
Dies sollte ein großes 'A' ausgeben: \x41

Beispiel #14 Beispiel für statische Daten

<?php
class foo {
public
$bar = <<<'EOT'
bar
EOT;
}
?>

Parsing (Analyse) von Variablen

Wenn ein string in doppelten Anführungszeichen oder mit Heredoc angegeben wird, werden darin Variablen geparst.

Es gibt zwei Arten von Syntax: eine einfache und eine komplexe Syntax. Die einfache Syntax ist die gebräuchlichste und bequemste. Sie bietet eine Möglichkeit, eine Variable, einen Array-Wert oder eine Objekt-Eigenschaft mit minimalem Aufwand in einen String einzubetten.

Die komplexe Syntax erkennt man an den geschweifte Klammern, die den Ausdruck umgeben.

Einfache Syntax

Wenn ein Dollarzeichen ($) vorkommt, nimmt der Parser gierig so viele Token wie möglich, um einen gültigen Variablennamen zu bilden. Schließen Sie den Variablennamen in geschweifte Klammern ein, um das Ende des Namens explizit anzugeben.

<?php
$juice
= "apple";

echo
"He drank some $juice juice." . PHP_EOL;

// Unbeabsichtigt. "s" ist ein gültiges Zeichen für einen Variablennamen,
// also bezieht sich dies auf $juices, nicht auf $juice.
echo "He drank some juice made of $juices." . PHP_EOL;

// Geben Sie das Ende des Variablennamens explizit an, indem Sie die Referenz
// in geschweifte Klammern einschließen.
echo "He drank some juice made of {$juice}s.";

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

He drank some apple juice.
He drank some juice made of .
He drank some juice made of apples.

In ähnlicher Weise kann ein Array-Index oder eine Objekt-Eigenschaft geparst werden. Bei Array-Indizes markiert die schließende eckige Klammer (]) das Ende des Indexes. Für Objekteigenschaften gelten die gleichen Regeln wie für einfache Variablen.

Beispiel #15 Beispiel für einfache Syntax

<?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 $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
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

He drank some apple juice.
He drank some orange juice.
He drank some purple juice.
John Smith drank some apple juice.
John Smith then said hello to Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen greeted the two .

Seit PHP 7.1.0 werden auch negative numerische Indizes unterstützt.

Beispiel #16 Negative numerische Indizes

<?php
$string
= 'string';
echo
"Das Zeichen an Index -2 ist $string[-2].", PHP_EOL;
$string[-3] = 'o';
echo
"Die Änderung des Zeichens an Index -3 auf o ergibt $string.", PHP_EOL;
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Das Zeichen an Index -2 ist n.
Die Änderung des Zeichens an Index -3 auf o ergibt strong.

Für alles, das komplexer ist, sollten Sie die komplexe Syntax verwenden.

Komplexe (geschweifte) Syntax

Diese Syntax wird nicht komplex genannt, weil sie komplex ist, sondern weil sie die Verwendung komplexer Ausdrücke erlaubt.

Jede skalare Variable, jedes Array-Element oder jede Objekteigenschaft mit einer String-Darstellung kann über diese Syntax eingebunden werden. Der Ausdruck wird so geschrieben, wie er auch außerhalb des Strings erscheinen würde, und dann von { und } umschlossen. Da { nicht maskiert werden kann, wird diese Syntax nur erkannt werden, wenn das $ unmittelbar auf das { folgt. Verwenden Sie {\$, um ein wörtliches {$ zu erhalten. Einige Beispiele, um es zu verdeutlichen:

<?php
// Alle Fehler anzeigen
error_reporting(E_ALL);

$great = 'fantastisch';

// Wird nicht funktionieren, Ausgabe: Das ist { fantastisch}
echo "Das ist { $great}";

// Funktioniert, Ausgabe: Das ist fantastisch
echo "Das ist {$great}";

// Funktioniert
echo "Dieses Quadrat ist {$square->width}00 Zentimeter breit.";


// Funktioniert, Anführungszeichen funktionieren nur mit der geschweiften Klammer
echo "Das funktioniert: {$arr['key']}";


// Funktioniert
echo "Das funktioniert: {$arr[4][3]}";

// Dies ist aus demselben Grund falsch, aus dem $foo[bar] außerhalb eines
// Strings falsch ist. PHP sucht zunächst nach einer Konstante namens foo und
// gibt einen Fehler aus, wenn sie nicht gefunden wird. Wenn sie gefunden
// wird, wird ihr Wert (und nicht "foo" selbst) für den Array-Index verwendet.
echo "Das ist falsch: {$arr[foo][3]}";

// Funktioniert. Verwenden Sie bei mehrdimensionalen Arrays immer geschweifte
// Klammern um die Arrays, wenn diese innerhalb von Strings stehen
echo "Das funktioniert: {$arr['foo'][3]}";

// Funktioniert.
echo "Das funktioniert: " . $arr['foo'][3];

echo
"Das funktioniert auch: {$obj->values[3]->name}";

echo
"Das ist der Wert der Variable namens $name: {${$name}}";

echo
"Das ist der Wert der Variable, die durch den Rückgabewert von getName() benannt wurde: {${getName()}}";

echo
"Das ist der Wert der Variable, die durch den Rückgabewert von \$object->getName() benannt wurde: {${$object->getName()}}";

// Wird nicht funktionieren, Ausgabe: Das ist der Rückgabewert von getName(): {getName()}
echo "Das ist der Rückgabewert von getName(): {getName()}";

// Wird nicht funktionieren, Ausgabe: C:\folder\{fantastic}.txt
echo "C:\folder\{$great}.txt"
// Funktioniert, Ausgabe: C:\folder\fantastic.txt
echo "C:\\folder\\{$great}.txt"
?>

Es ist mit dieser Syntax auch möglich, über Variablen innerhalb von Strings auf Klasseneigenschaften zuzugreifen.

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

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

I am bar.
I am bar.

Hinweis:

Der Wert, auf den von Funktionen, Methodenaufrufen, statischen Klassenvariablen, und Klassenkonstanten innerhalb von {$} zugegriffen wird, wird als der Name einer Variablen in dem Bereich interpretiert, in dem der String definiert ist. Die Verwendung von einzelnen geschweiften Klammern ({}) funktioniert nicht für den Zugriff auf die Rückgabewerte von Funktionen oder Methoden oder die Werte von Klassenkonstanten oder statischen Klassenvariablen.

<?php
// Alle Fehler anzeigen
error_reporting(E_ALL);

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

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

// Das funktioniert; Ausgabe: Ich hätte gerne ein A & W
echo "Ich hätte gerne ein {${beers::softdrink}}\n";

// Das funktioniert auch; Ausgabe: Ich hätte gerne ein Alexander Keith's
echo "Ich hätte gerne ein {${beers::$ale}}\n";
?>

Zugriff auf Strings und Änderung von Zeichen

Auf ein Zeichen in einem String kann zugegriffen und es kann geändert werden, indem seine Position (von 0 an) hinter dem String mit Hilfe von Array-Klammern angegeben wird, z. B. $str[42]. In diesem Fall ist es hilfreich, sich einen String als ein Array von Zeichen vorzustellen. Die Funktionen substr() und substr_replace() können verwendet werden, wenn mehr als ein Zeichen extrahiert oder ersetzt werden soll.

Hinweis: Seit PHP 7.1.0 werden auch negative String-Offsets unterstützt. Diese geben den Offset vom Ende des Strings an. Früher verursachten negative Offsets beim Lesen eine E_NOTICE-Meldung aus (was einen leeren String ergibt) und beim Schreiben eine E_WARNING-Meldung (was den String unangetastet lässt).

Hinweis: Vor PHP 8.0.0 konnte für den gleichen Zweck auch mit Klammern auf Strings zugegriffen werden, wie in $str{42}. Diese Syntax mit geschweiften Klammern ist seit PHP 7.4.0 veraltet und wird seit PHP 8.0.0 nicht mehr unterstützt.

Warnung

Das Schreiben an einen Offset außerhalb des vorhandenen Bereichs bewirkt, dass der String bis zu dieser Position mit Leerzeichen aufgefüllt wird. Nicht-ganzzahlige Offsets werden in einen ganzzahligen Wert umgewandelt. Bei ungültigen Offset-Typen wird eine E_WARNING ausgegeben. Nur das erste Zeichen eines zugewiesenen Strings wird verwendet. Seit PHP 7.1.0 führt die Zuweisung eines leeren Strings zu einem schwerwiegenden Fehler. Vorher wurde ein NULL-Byte zugewiesen.

Warnung

Intern sind PHP-Strings Byte-Arrays. Folglich ist der Zugriff auf einen String oder dessen Änderung mit Array-Klammern nicht Multi-Byte-sicher und sollte nur mit Strings erfolgen, die in einer Ein-Byte-Kodierung wie ISO-8859-1 vorliegen.

Hinweis: Seit PHP 7.1.0 führt die Anwendung des leeren Indexoperators auf einen leeren String zu einem fatalen Fehler. Zuvor wurde der leere String stillschweigend in ein Array umgewandelt.

Beispiel #17 Einige String-Beispiele

<?php
// Ermitteln des ersten Zeichens eines Strings.
$str = 'Das ist ein Test.';
$first = $str[0];

// Ermitteln des dritten Zeichens eines Strings.
$third = $str[2];

// Ermitteln das letzten Zeichens eines Strings.
$str = 'Das ist immer noch ein Test.';
$last = $str[strlen($str)-1];

// Ändern des letzten Zeichens eines Strings.
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';

?>

String-Offsets müssen entweder Integer oder Integer-ähnliche Strings sein, andernfalls wird eine Warnung ausgelöst.

Beispiel #18 Beispiel für unzulässige String-Offsets

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

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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)

Hinweis:

Der Zugriff auf Variablen anderer Typen (ohne Arrays oder Objekte, die entsprechende Schnittstellen implementieren) mit [] oder {} gibt stillschweigend null zurück.

Hinweis:

Auf Zeichen innerhalb von String-Literalen kann mit [] oder {} zugegriffen werden.

Hinweis:

Der Zugriff auf Zeichen innerhalb von String-Literalen mit der {}-Syntax ist seit PHP 7.4 veraltet und wurde in PHP 8.0 entfernt.

Nützliche Funktionen und Operatoren

Strings können mit dem Punkt-Operator '.' verkettet werden. Es ist zu beachten, dass der Additions-Operator '+' in diesem Fall nicht funktioniert. Siehe String-Operatoren für mehr Informationen.

Es gibt eine Reihe nützlicher Funktionen für die String-Manipulation.

Siehe den Abschnitt String-Funktionen für allgemeine Funktionen und die Funktionen für Perl-kompatible reguläre Ausdrücke für erweiterte Funktionen zum Suchen und Ersetzen.

Außerdem gibt es Funktionen für URL-Strings und Funktionen zum Verschlüsseln/Entschlüsseln von Strings (Sodium und Hash).

Siehe zudem auch die Zeichentyp-Funktionen.

Umwandlung in String

Ein Wert kann mit dem Schlüsselwort (string) oder der Funktion strval() in einen String umgewandelt werden. Die Umwandlung in einen String erfolgt automatisch im Kontext eines Ausdrucks, in dem ein String erforderlich ist. Dies geschieht z. B. bei der Verwendung der Funktionen echo oder print oder wenn eine Variable mit einem String verglichen wird. In den Abschnitten über Typen und Typ-Manipulationen werden die folgenden Punkte näher erläutert. Siehe auch die Funktion settype().

Ein bool true -Wert wird in den String "1" umgewandelt. bool false wird in "" (den leeren String) umgewandelt. Dies ermöglicht es, zwischen bool- und String-Werten hin und her zu konvertieren.

Ein Int oder Float wird in einen String umgewandelt, der die Zahl textuell darstellt (einschließlich des Exponententeil bei Floats). Gleitkommazahlen können mit der Exponentialschreibweise umgewandelt werden (4.1E+6).

Hinweis:

Seit PHP 8.0.0 ist das Dezimalpunktzeichen immer ein Punkt ("."). Vor PHP 8.0.0 wird das Dezimalpunktzeichen in der Locale des Skripts definiert (Kategorie LC_NUMERIC). Siehe die Funktion setlocale().

Arrays werden immer in String-"Arrays" umgewandelt; aus diesem Grund können echo und print nicht von sich aus den Inhalt eines Arrays anzeigen. Um ein einzelnes Element anzuzeigen, verwendet man eine Konstruktion wie echo $arr['foo']. Siehe unten für Tipps zur Anzeige des gesamten Inhalts.

Um Objekte in Strings umzuwandeln, muss die magische Methode __toString verwendet werden.

Ressourcen werden immer mit der Struktur "Resource id #1" in Strings umgewandelt, wobei 1 die Ressourcennummer ist, die der Ressource von PHP zur Laufzeit zugewiesen wird. Obwohl man sich nicht auf die genaue Struktur dieses Strings verlassen sollte und sie sich ändern kann, wird sie für eine bestimmte Ressource innerhalb der Lebensdauer eines ausgeführten Skripts (d. h. einer Web-Anfrage oder eines CLI-Prozesses) immer eindeutig sein und wird nicht wiederverwendet. Um den Typ einer Ressource zu erhalten, kann die Funktion get_resource_type() verwendet werden.

null wird immer in einen leeren String umgewandelt.

Wie oben erwähnt, liefert die direkte Umwandlung eines Arrays, Objekts oder einer Ressource in einen String keine nützlichen Informationen über den Wert, die über seinen Typ hinausgehen. Um den Inhalt dieser Typen zu ermitteln, siehe die Funktionen print_r() und var_dump().

Die meisten PHP-Werte können zur dauerhaften Speicherung auch in Strings umgewandelt werden. Diese Methode wird Serialisierung genannt und wird von der Funktion serialize() durchgeführt.

Details zum String-Typ

Der Typ string ist in PHP als ein Array von Bytes und einem Integer, der die Länge des Puffers angibt, implementiert. Er hat keine Informationen darüber, wie diese Bytes in Zeichen umgewandelt werden; diese Aufgabe wird dem Programmierer überlassen. Es gibt keine Beschränkungen für die Werte, aus denen der String bestehen kann; insbesondere Insbesondere sind Bytes mit dem Wert 0 ("NUL-Bytes") in der Zeichenkette erlaubt (allerdings können einige Funktionen, die in diesem Handbuch als nicht "binärsicher" eingestuft werden, die Strings an Bibliotheken weitergeben, die Daten nach einem NUL-Byte ignorieren).

Diese Eigenschaft des String-Typs erklärt, warum es in PHP keinen separaten "Byte"-Typ gibt - Strings übernehmen diese Rolle. Funktionen, die keine textuellen Daten zurückgeben - zum Beispiel beliebige Daten, die von einem Netzwerksocket gelesen werden - geben immer noch Strings zurück.

Da PHP keine spezifische Kodierung für Strings vorschreibt, könnte man sich fragen, wie String-Literale kodiert werden. Ist zum Beispiel der String "á" äquivalent zu "\xE1" (ISO-8859-1), "\xC3\xA1" (UTF-8, C-Form), "\x61\xCC\x81" (UTF-8, D-Form) oder zu irgendeiner anderen möglichen Darstellung? Die Antwort lautet, dass der String auf die Art und Weise kodiert wird, wie er in der Skriptdatei kodiert ist. Wenn das Skript also in ISO-8859-1 geschrieben ist, wird die Zeichenkette in ISO-8859-1 kodiert und so weiter. Das gilt jedoch nicht, wenn Zend-Multibyte aktiviert ist; in diesem Fall kann das Skript in einer beliebigen Kodierung geschrieben werden (die explizit deklariert ist oder erkannt wird) und dann in eine bestimmte interne Kodierung konvertiert werden, welche dann die Kodierung ist, die für die String-Literale verwendet wird. Es ist zu beachten, dass es einige Beschränkungen für die Kodierung des Skripts gibt (oder für die interne Kodierung gibt, sollte Zend-Multibyte aktiviert sein) - das bedeutet fast immer, dass diese Kodierung eine kompatible Obermenge von ASCII sein sollte, wie z. B. UTF-8 oder ISO-8859-1. Es ist jedoch zu beachten, dass zustandsabhängige Kodierungen, bei denen dieselben Byte-Werte sowohl im Anfangszustand als auch im Nicht-Anfangszustand verwendet werden können, problematisch sein können.

Um nützlich zu sein, müssen Funktionen, die mit Text arbeiten, natürlich Annahmen darüber treffen, wie der String kodiert ist. Leider gibt es in diesem Punkt viele Unterschiede zwischen den PHP-Funktionen:

  • Einige Funktionen gehen davon aus, dass der String in einer (beliebigen) Ein-Byte-Kodierung kodiert ist, aber sie müssen diese Bytes nicht als bestimmte Zeichen interpretieren. Dies ist z. B. der Fall bei substr(), strpos(), strlen() oder strcmp(). Eine andere Möglichkeit, sich diese Funktionen vorzustellen, ist, dass sie mit Speicherpuffern arbeiten, d. h. sie arbeiten mit Bytes und Byte-Offsets.
  • Anderen Funktionen wird die Kodierung des Strings übergeben, eventuell nehmen sie auch einen Standardwert an, wenn keine solche Information angegeben wird. Dies ist der Fall bei htmlentities() und den meisten der Funktionen in der mbstring-Erweiterung.
  • Andere verwenden die aktuelle Locale (siehe setlocale()), arbeiten aber Byte für Byte.
  • Letztendlich können sie einfach davon ausgehen, dass der String eine bestimmte Kodierung verwendet, normalerweise UTF-8. Dies ist der Fall bei den meisten Funktionen in der intl-Erweiterung und in der PCRE-Erweiterung (im letzteren Fall nur, wenn der Modifikator u verwendet wird).

Letztlich bedeutet dies, dass das Schreiben korrekter Programme mit Unicode davon abhängt, Funktionen, die nicht funktionieren und die Daten höchstwahrscheinlich beschädigen, sorgfältig zu vermeiden und stattdessen die Funktionen zu verwenden, die sich korrekt verhalten. Im Allgemeinen sind das die Funktionen der intl- und mbstring-Erweiterungen. Die Verwendung von Funktionen, die Unicode-Kodierungen verarbeiten können, ist jedoch nur der Anfang. Unabhängig von den Funktionen, die die Sprache zur Verfügung stellt, ist es wichtig, die Unicode-Spezifikation zu kennen. Ein Programm, das zum Beispiel davon ausgeht, dass es nur Groß- und Kleinbuchstaben gibt, geht von einer falschen Annahme aus.

add a note add a note

User Contributed Notes 26 notes

up
370
John
7 years ago
I've been a PHP programmer for a decade, and I've always been using the "single-quoted literal" and "period-concatenation" method of string creation. But I wanted to answer the performance question once and for all, using sufficient numbers of iterations and a modern PHP version. For my test, I used:

php -v
PHP 7.0.12 (cli) (built: Oct 14 2016 09:56:59) ( NTS )
Copyright (c) 1997-2016 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies

------ Results: -------

* 100 million iterations:

$outstr = 'literal' . $n . $data . $int . $data . $float . $n;
63608ms (34.7% slower)

$outstr = "literal$n$data$int$data$float$n";
47218ms (fastest)

$outstr =<<<EOS
literal$n$data$int$data$float$n
EOS;
47992ms (1.64% slower)

$outstr = sprintf('literal%s%s%d%s%f%s', $n, $data, $int, $data, $float, $n);
76629ms (62.3% slower)

$outstr = sprintf('literal%s%5$s%2$d%3$s%4$f%s', $n, $int, $data, $float, $data, $n);
96260ms (103.9% slower)

* 10 million iterations (test adapted to see which of the two fastest methods were faster at adding a newline; either the PHP_EOL literal, or the \n string expansion):

$outstr = 'literal' . $n . $data . $int . $data . $float . $n;
6228ms (reference for single-quoted without newline)

$outstr = "literal$n$data$int$data$float$n";
4653ms (reference for double-quoted without newline)

$outstr = 'literal' . $n . $data . $int . $data . $float . $n . PHP_EOL;
6630ms (35.3% slower than double-quoted with \n newline)

$outstr = "literal$n$data$int$data$float$n\n";
4899ms (fastest at newlines)

* 100 million iterations (a test intended to see which one of the two ${var} and {$var} double-quote styles is faster):

$outstr = 'literal' . $n . $data . $int . $data . $float . $n;
67048ms (38.2% slower)

$outstr = "literal$n$data$int$data$float$n";
49058ms (1.15% slower)

$outstr = "literal{$n}{$data}{$int}{$data}{$float}{$n}"
49221ms (1.49% slower)

$outstr = "literal${n}${data}${int}${data}${float}${n}"
48500ms (fastest; the differences are small but this held true across multiple runs of the test, and this was always the fastest variable encapsulation style)

* 1 BILLION iterations (testing a completely literal string with nothing to parse in it):

$outstr = 'literal string testing';
23852ms (fastest)

$outstr = "literal string testing";
24222ms (1.55% slower)

It blows my mind. The double-quoted strings "which look so $slow since they have to parse everything for \n backslashes and $dollar signs to do variable expansion", turned out to be the FASTEST string concatenation method in PHP - PERIOD!

Single-quotes are only faster if your string is completely literal (with nothing to parse in it and nothing to concatenate), but the margin is very tiny and doesn't matter.

So the "highest code performance" style rules are:

1. Always use double-quoted strings for concatenation.

2. Put your variables in "This is a {$variable} notation", because it's the fastest method which still allows complex expansions like "This {$var['foo']} is {$obj->awesome()}!". You cannot do that with the "${var}" style.

3. Feel free to use single-quoted strings for TOTALLY literal strings such as array keys/values, variable values, etc, since they are a TINY bit faster when you want literal non-parsed strings. But I had to do 1 billion iterations to find a 1.55% measurable difference. So the only real reason I'd consider using single-quoted strings for my literals is for code cleanliness, to make it super clear that the string is literal.

4. If you think another method such as sprintf() or 'this'.$var.'style' is more readable, and you don't care about maximizing performance, then feel free to use whatever concatenation method you prefer!
up
96
gtisza at gmail dot com
12 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
22
garbage at iglou dot eu
7 years ago
You can use string like array of char (like C)

$a = "String array test";

var_dump($a);
// Return string(17) "String array test"

var_dump($a[0]);
// Return string(1) "S"

// -- With array cast --
var_dump((array) $a);
// Return array(1) { [0]=> string(17) "String array test"}

var_dump((array) $a[0]);
// Return string(17) "S"

- Norihiori
up
9
Ray.Paseur sometimes uses Gmail
5 years ago
md5('240610708') == md5('QNKCDZO')

This comparison is true because both md5() hashes start '0e' so PHP type juggling understands these strings to be scientific notation.  By definition, zero raised to any power is zero.
up
19
og at gams dot at
16 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
vseokdog at gmail dot com
4 years ago
Don't forget about new E_WARNING and E_NOTICE errors from PHP 7.1.x: they have been introduced when invalid strings are coerced using operators expecting numbers (+ - * / ** % << >> | & ^) or their assignment equivalents. An E_NOTICE is emitted when the string begins with a numeric value but contains trailing non-numeric characters, and an E_WARNING is emitted when the string does not contain a numeric value.

Example:
$foo = 1 + "bob-1.3e3"; 
$foo = "10.2 pigs " + 1.0;
Will produce: Warning: A non-numeric value encountered

Read more: https://www.php.net/manual/en/migration71.other-changes.php
up
17
lelon at lelon dot net
19 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
4
sideshowAnthony at googlemail dot com
8 years ago
Something I experienced which no doubt will help someone . . .
In my editor, this will syntax highlight HTML and the $comment:

$html = <<<"EOD"
<b>$comment</b>
EOD;

Using this shows all the same colour:

$html = <<<EOD
<b>$comment</b>
EOD;

making it a lot easier to work with
up
10
chAlx at findme dot if dot u dot need
15 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
8
headden at karelia dot ru
14 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
6
steve at mrclay dot org
15 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
1
nospam at nospam dot com
7 years ago
Beware that consistent with "String conversion to numbers":

<?php

if ('123abc' == 123) echo '(intstr == int) incorrectly tests as true.';

// Because one side is a number, the string is incorrectly converted from intstr to int, which then matches the test number.

// True for all conditionals such as if and switch statements (probably also while loops)!

// This could be a huge security risk when testing/using/saving user input, while expecting and testing for only an integer.

// It seems the only fix is for 123 to be a string as '123' so no conversion happens.

?>
up
1
mark at manngo dot net
7 years ago
I though that it would be helpful to add this comment so that the information at least appears on the right page on the PHP site.

Note that if you intend to use a double-quoted string with an associative key, you may run into the T_ENCAPSED_AND_WHITESPACE error. Some regard this as one of the less obvious error messages.

An expression such as:

<?php
    $fruit
=array(
       
'a'=>'apple',
       
'b'=>'banana',
       
//    etc
   
);

    print
"This is a $fruit['a']";    //    T_ENCAPSED_AND_WHITESPACE
?>

will definitely fall to pieces.

You can resolve it as follows:

<?php
   
print "This is a $fruit[a]";    //    unquote the key
   
print "This is a ${fruit['a']}";    //    Complex Syntax
   
print "This is a {$fruit['a']}";    //    Complex Syntax variation
?>

I have a personal preference for the last variation as it is more natural and closer to what the expression would be like outside the string.

It’s not clear (to me, at least) why PHP misinterprets the single quote inside the expression but I imagine that it has something to do with the fact quotes are not part of the value string — once the string is already being parsed the quotes just get in the way … ?
up
3
php at richardneill dot org
11 years 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
4
Richard Neill
16 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
0
necrodust44 at gmail dot com
10 years 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
3
atnak at chejz dot com
19 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
-3
jonijnm at example dot com
6 years ago
Both should work :(

<?php

class Testing {
    public static
$VAR = 'static';
    public const VAR =
'const';
   
    public function
sayHelloStatic() {
        echo
"hello: {$this::$VAR}";
    }
   
    public function
sayHelloConst() {
        echo
"hello: {$this::VAR}"; //Parse error:  syntax error, unexpected '}', expecting '['
   
}
}

$obj = new Testing();
$obj->sayHelloStatic();
$obj->sayHelloConst();
up
-3
shd at earthling dot net
14 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
-3
rkfranklin+php at gmail dot com
16 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
-2
webmaster at rephunter dot net
18 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
-4
bishop
17 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
-5
cvolny at gmail dot com
15 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
-7
Hayley Watson
6 years ago
Any single expression, however complex, that starts with $ (i.e., a variable) can be {}-embedded in a double-quoted string:

<?php

echo "The expression {$h->q()["x}"]->p(9 == 0 ? 17 : 42)} gets parsed just as well as " . $h->q()["x}"]->p(9 == 0 ? 17 : 42) . " does.";

?>
up
-20
M. H. S.
4 years ago
<?php

// Its A Example for "Heredoc":

$n = 10;

$var_heredoc = <<<HEREDOC

Its A String For "
$var_heredoc" variable.

heredoc can expanding variables.
(example:
$n)

if you want not expanding, you need print " \ " befor variable.
(example: /
$n)

heredoc can use " /n, /t, /r, ... ".

heredoc = the string of double-qoutation;

        HEREDOC; -> its bad closing of heredoc!

HEREDOC;
// its a good closing of heredoc!

?>
up
-3
greenbluemoonlight at gmail dot com
3 years ago
<?php
\\Example # 10 Simple Syntax - Solution for the last "echo" line.

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

    public
$smith = "Smith";
}

$people = new people();

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
\\Outputs: Robert Paulsen greeted the two

/**Solution:**\

echo "$people->robert greeted the two $people->smith\x08s";

\\Will work
\\Outputs: Robert Paulsen greeted the two Smiths

?>
To Top