Einfache Syntax

Wenn der Interpreter auf ein Dollarzeichen ($) stößt, greift er auf so viele Zeichen wie möglich zurück, um einen gültigen Variablennamen zu bilden. Wenn Sie das Ende eines Namens angeben möchten, schließen Sie den Variablennamen in geschweifte Klammern ein.

$beer = "Heineken" ;
echo „$beer“s Geschmack ist großartig“ ; // funktioniert, „““ ist ein ungültiges Zeichen für einen Variablennamen
echo „Er hat ein paar $Biere getrunken“ ; // funktioniert nicht, „s“ ist ein gültiges Zeichen für einen Variablennamen
echo „Er hat ein paar $(beer)s getrunken“ ; // funktioniert
echo „Er hat ein paar Bier getrunken“; // funktioniert
?>

Ein Array-Element ( Array) oder Objekteigenschaft ( Objekt). In Array-Indizes gibt es eine schließende eckige Klammer ( ] ) markiert das Ende der Indexdefinition. Für Objekteigenschaften gelten die gleichen Regeln wie für einfache Variablen, allerdings können sie nicht wie bei Variablen ausgetrickst werden.

// In diesen Beispielen geht es speziell um die interne Verwendung von Arrays
// Linien. Schließen Sie außerhalb von Zeichenfolgen immer die Zeichenfolgenschlüssel Ihres Schlüssels ein
// Array in Anführungszeichen setzen und keine äußeren Zeichenfolgen (Klammern) verwenden.

// Lassen Sie uns alle Fehler anzeigen
error_reporting(E_ALL);

$fruits = array("Strawberry" => "Red" , "Banana" => "Yellow" );

// Funktioniert, aber beachten Sie, dass es außerhalb der in Anführungszeichen gesetzten Zeichenfolge anders funktioniert
Echo „Eine Banane ist $Früchte.“;

//Funktioniert
Echo „Eine Banane ist ($fruits["banana"]).“;

// Funktioniert, aber PHP sucht, wie unten beschrieben, zuerst nach
// konstante Banane.
Echo „Eine Banane ist ($fruits).“;

// Funktioniert nicht, verwenden Sie geschweifte Klammern. Dies führt zu einem Verarbeitungsfehler.
Echo „Eine Banane ist $fruits["banana"].“;

// Funktioniert
echo „Eine Banane ist“. $fruits [ "Banane" ] . "." ;

// Funktioniert
Echo „Dieses Quadrat ist $square->width Meter breit.“;

// Das ____ funktioniert nicht. Eine Lösung finden Sie in der komplexen Syntax.
Echo „Dieses Quadrat ist $square->width00 Zentimeter breit.“;
?>

Für komplexere Aufgaben können Sie eine komplexe Syntax verwenden.

Komplexe (geschweifte) Syntax

Diese Syntax wird nicht deshalb als komplex bezeichnet, weil sie schwer zu verstehen ist, sondern weil sie die Verwendung komplexer Ausdrücke ermöglicht.

Tatsächlich können Sie mit dieser Syntax jeden Wert, der sich im Namespace befindet, in eine Zeile einfügen. Sie schreiben den Ausdruck einfach auf die gleiche Weise wie außerhalb der Zeile und schließen ihn dann in ( und ) ein. Da Sie „(“ nicht maskieren können, wird diese Syntax nur erkannt, wenn $ unmittelbar auf ( folgt. (Verwenden Sie „(\$“ oder „\($“, um „($“) zu maskieren. Einige anschauliche Beispiele:

// Lassen Sie uns alle Fehler anzeigen
error_reporting(E_ALL);

$great = "fantastisch" ;

// Funktioniert nicht, wird ausgegeben: Das ist (fantastisch)
echo „Das ist ($great)“ ;

// Funktioniert, druckt: Das ist fantastisch
echo „Das ist ($great)“ ;
echo „Das ist $(großartig)“ ;

// Funktioniert
Echo „Dieses Quadrat ist ($square->width)00 Zentimeter breit.“;

// Funktioniert
Echo „Es funktioniert: ($arr)“;

// Dies ist aus demselben Grund ungültig, aus dem $foo außerhalb ungültig ist
// Linien. Mit anderen Worten, es wird immer noch funktionieren,
// aber da PHP zuerst nach der Konstante foo sucht, wird dies dazu führen
// Levelfehler E_NOTICE (undefinierte Konstante).
Echo „Das ist falsch: ($arr)“;

// Funktioniert. Bei Verwendung mehrdimensionaler Arrays im Inneren
// Zeilen verwenden immer geschweifte Klammern
Echo „Das funktioniert: ($arr[“foo“])“;

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

Echo „Sie können sogar ($obj->values->name) schreiben“;

Echo „Dies ist der Wert der Variablen mit dem Namen $name: ($($name))“;
?>

Zeichen in Zeichenfolgen können verwendet und geändert werden, indem ihr Abstand vom Anfang der Zeichenfolge, beginnend bei Null, in geschweiften Klammern nach der Zeichenfolge angegeben wird. Hier sind einige Beispiele:

// Erstes Zeichen der Zeichenfolge abrufen
$str = "Dies ist ein Test." ;
$first = $str ( 0 );

// Holen Sie sich das dritte Zeichen der Zeichenfolge
$dritte = $str ( 2 );

// Das letzte Zeichen der Zeichenfolge abrufen
$str = „Es ist immer noch ein Test.“;
$last = $str ( strlen ($str ) - 1 );

// Letztes Zeichen der Zeile ändern
$str = „Schau auf das Meer“;
$str ( strlen ($str ) - 1 ) = "self" ;

?>

Stringfunktionen und Operatoren

String-Operatoren

Verschiedene Programmiersprachen verwenden unterschiedliche Operatoren für die Zeichenfolgenverkettung (Verknüpfung). Pascal verwendet beispielsweise den „+“-Operator. Die Verwendung des „+“-Operators zum Verketten von Zeichenfolgen in PHP ist falsch: Wenn die Zeichenfolgen Zahlen enthalten, wird anstelle der Verkettung der Zeichenfolgen die Addition zweier Zahlen ausgeführt.

PHP verfügt über zwei Operatoren, die eine Verkettung durchführen.

Der erste ist der Verkettungsoperator („"), der die Verkettung der linken und rechten Argumente zurückgibt.

Der zweite ist ein Zuweisungsoperator mit Verkettung, der das rechte Argument an das linke anhängt.

Lassen Sie uns ein konkretes Beispiel geben:

$a = "Hallo" ;
$b = $a . "Welt!" ; // $b enthält die Zeichenfolge „Hello World!“ - Das ist eine Verkettung

$a = "Hallo" ;
$a .= "Welt!" ; // $a enthält die Zeichenfolge „Hello World!“ - Dies ist eine Aufgabe mit Verkettung
?>

String-Vergleichsoperatoren

Es wird nicht empfohlen, die Vergleichsoperatoren == und != zum Vergleichen von Zeichenfolgen zu verwenden, da diese eine Typkonvertierung erfordern. Beispiel:

$x = 0 ;
$y=1;
if ($x == "" ) Echo "

x – leere Zeichenfolge

Dieses Skript teilt uns mit, dass $x eine leere Zeichenfolge ist. Dies liegt daran, dass die leere Zeichenfolge („“) zuerst als 0 und erst dann als „leer“ behandelt wird. In PHP werden Operanden nur dann als Strings verglichen, wenn es sich bei beiden um Strings handelt. Ansonsten werden sie als Zahlen verglichen. In diesem Fall wird jede Zeichenfolge, die PHP nicht in eine Zahl umwandeln kann (einschließlich einer leeren Zeichenfolge), als 0 behandelt.

Beispiele für String-Vergleiche:

$x = "String" ;
$y = "String" ;
$ z = "Linie" ;
if ($x == $z) echo "

String X entspricht String Z

Um Verwirrung und Typkonvertierung zu vermeiden, wird empfohlen, beim Vergleich von Zeichenfolgen den Äquivalenzoperator zu verwenden. Mit dem Äquivalenzoperator können Sie Zeichenfolgen immer korrekt vergleichen, da er Werte sowohl nach Wert als auch nach Typ vergleicht:

$x = "String" ;
$y = "String" ;
$ z = "Linie" ;
if ($x == = $z) echo "

String X entspricht String Z

Kommentar: In PHP 7.0.0 gibt es auf 64-Bit-Plattformen keine erreichbaren Beschränkungen für die Zeilenlänge auf 32-Bit-Systemen und in früheren Versionen von PHP dürfen Zeilen nicht größer als 2 GB (2147483647 Bytes) sein.

Syntax

Eine Zeichenfolge kann auf vier verschiedene Arten definiert werden:

• Einzelzitate
• Anführungszeichen
• nowdoc-Syntax (seit PHP 5.3.0)

Einzelzitate

Der einfachste Weg, eine Zeichenfolge zu definieren, besteht darin, sie in einfache Anführungszeichen zu setzen (das Zeichen). " ).

Um ein einfaches Anführungszeichen innerhalb einer Zeichenfolge zu verwenden, maskieren Sie es mit einem Backslash ( \ ). Wenn Sie den Backslash selbst schreiben müssen, duplizieren Sie ihn ( \\ ). Alle anderen Verwendungen des Backslashs werden als normale Zeichen interpretiert. Dies bedeutet, dass, wenn Sie versuchen, andere Escape-Sequenzen zu verwenden, z \R oder \N, werden sie unverändert ausgegeben und weisen kein besonderes Verhalten auf.

Echo „Das ist eine einfache Zeichenfolge“;

Echo „Sie können auch in Zeilen einfügen
Newline-Zeichen wie dieses,
es ist in Ordnung";

// Ausgaben: Arnold hat einmal gesagt: „Ich komme wieder“
Echo „Eines Tages sagte Arnold: ‚Ich komme wieder.‘“;

Echo „Haben Sie C:\\*.* gelöscht?“;

// Ausgaben: Haben Sie C:\*.* gelöscht?
echo „Haben Sie C:\*.* gelöscht?“ ;

// Ausgaben: Dies wird nicht erweitert: \n neue Zeile
Echo „Dies wird nicht erweitert: \n newline“;

// Ausgaben: $expand- und $either-Variablen werden nicht erweitert
Echo „$expand- und $either-Variablen werden nicht erweitert“;
?>

Anführungszeichen

Wenn die Zeichenfolge in doppelte Anführungszeichen (") eingeschlossen ist, erkennt PHP die folgenden Sonderzeichen-Escape-Sequenzen:

Wie bei einer in einfache Anführungszeichen eingeschlossenen Zeichenfolge wird beim Escapezeichen eines beliebigen Zeichens auch das Escapezeichen selbst ausgegeben. Vor PHP 5.1.1 Backslash ein \($var) wurde nicht veröffentlicht.

Heredoc

Die dritte Möglichkeit, Zeichenfolgen zu definieren, ist die Verwendung der Heredoc-Syntax: <<< . Nach diesem Operator müssen Sie einen Bezeichner und dann einen Zeilenvorschub angeben. Danach kommt die Zeile selbst und dann derselbe Bezeichner, der die Einfügung abschließt.

Linie muss Beginnen Sie mit einem Schlussbezeichner, d. h. es muss in der ersten Spalte der Zeile erscheinen. Darüber hinaus muss der Bezeichner denselben Namensregeln folgen wie alle anderen Tags in PHP: Er darf nur alphanumerische Zeichen und einen Unterstrich enthalten und darf nicht mit einer Zahl beginnen (Unterstriche sind zulässig).

Aufmerksamkeit

Es ist sehr wichtig zu beachten, dass die abschließende Bezeichnerzeile keine anderen Zeichen außer einem Semikolon enthalten darf ( ; ). Das bedeutet, dass die ID sollte nicht eingerückt werden und dass vor oder nach dem Semikolon keine Leerzeichen oder Tabulatoren stehen dürfen. Es ist auch wichtig zu verstehen, dass das erste Zeichen vor dem Schlussbezeichner das von Ihrem Betriebssystem definierte Zeilenumbruchzeichen sein muss. Auf UNIX-Systemen, einschließlich macOS, ist dies beispielsweise der Fall \N. Nach dem Schlussbezeichner muss auch unmittelbar eine neue Zeile beginnen.

Wenn diese Regel verletzt wird und der Schlussbezeichner nicht „sauber“ ist, wird der Schlussbezeichner als fehlend betrachtet und PHP wird weiter danach suchen. Wenn in diesem Fall nie der richtige Abschlussbezeichner gefunden wird, führt dies zu einem Parsing-Fehler mit der Zeilennummer am Ende des Skripts.

Beispiel Nr. 1 Beispiel für falsche Syntax

Klasse foo(
öffentliche $bar =<<Bar
EOT;
// Einrückung vor dem Schlussbezeichner ist nicht erlaubt
}
?>

Beispiel #2 Beispiel für korrekte Syntax

Klasse foo(
öffentliche $bar =<<Bar
EOT;
}
?>

Heredoc kann nicht zum Initialisieren von Klassenfeldern verwendet werden. Ab PHP 5.3 gilt diese Einschränkung nur für Heredocs, die Variablen enthalten.

Heredoc-Text verhält sich genauso wie eine Zeichenfolge in doppelten Anführungszeichen, ohne diese zu haben. Das bedeutet, dass Sie in Heredoc keine Escape-Anführungszeichen benötigen, Sie können aber trotzdem die oben genannten Escape-Sequenzen verwenden. Variablen werden verarbeitet, Sie müssen jedoch bei der Verwendung komplexer Variablen in Heredoc genauso vorsichtig sein wie bei der Arbeit mit Zeichenfolgen.

Beispiel Nr. 3 Beispiel für eine Heredoc-String-Definition

$str =<<Beispielzeile,
über mehrere Zeilen,
unter Verwendung der Heredoc-Syntax.
EOD;

Klasse foo
{
var $foo ;
var $bar ;

Funktion__construct()
{
$this -> foo = "Foo" ;
$this ->
}
}

$foo = new foo();
$name = "Name" ;

Echo<<Mein Name ist „$name“. Ich tippe $foo -> foo .
Jetzt schließe ich( $foo -> bar [ 1 ]) .
Dies sollte den Großbuchstaben „A“ ausgeben: \x41
EOT;
?>

Mein Name ist „Name“. Ich tippe Foo. Jetzt gebe ich Bar2 aus. Dies sollte einen Großbuchstaben „A“ ausgeben: A

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

Seit Version 5.3.0 ist es möglich, statische Variablen und Klasseneigenschaften/Konstanten mithilfe der Heredoc-Syntax zu initialisieren:

Beispiel #5 Verwendung von Heredoc zum Initialisieren statischer Variablen

// Statische Variablen
Funktion foo()
{
statisch $bar =<<Hier ist nichts...
ETIKETT;
}

// Konstanten/Klasseneigenschaften
Klasse foo
{
const BAR =<<Beispiel für die Verwendung einer Konstante
FOOBAR;

Öffentlich $baz =<<Beispiel für die Verwendung eines Feldes
FOOBAR;
}
?>

Ab PHP 5.3.0 können Sie den Heredoc-Bezeichner auch in doppelte Anführungszeichen setzen:

Nowdoc

Nowdoc ist für Zeichenfolgen in einfachen Anführungszeichen dasselbe wie Heredoc für Zeichenfolgen in doppelten Anführungszeichen. Nowdoc ähnelt Heredoc, ist jedoch darin enthalten Es werden keine Auswechslungen vorgenommen. Dieses Design eignet sich ideal zum Einbetten von PHP-Code oder anderen großen Textblöcken, ohne diesen entkommen zu müssen. Darin ähnelt es ein wenig dem SGML-Konstrukt indem ein Textblock deklariert wird, der nicht zur Verarbeitung vorgesehen ist.

Nowdoc wird durch die gleiche Reihenfolge angezeigt <<< , das in Heredoc verwendet wird, der folgende Bezeichner jedoch in einfache Anführungszeichen gesetzt wird, zum Beispiel: <<<"EOT" . Alle Bedingungen, die für Heredoc-Bezeichner gelten, gelten auch für Nowdoc, insbesondere diejenigen, die für den Schlussbezeichner gelten.

Beispiel Nr. 7 Beispiel für die Verwendung von nowdoc

Echo<<<"EOD"
Beispieltext,
über mehrere Zeilen hinweg
unter Verwendung der Nowdoc-Syntax. Backslashes werden immer wörtlich behandelt,
zum Beispiel \\ und \".
EOD;

Das Ergebnis der Ausführung dieses Beispiels:

Beispiel für mehrzeiligen Text mit Nowdoc-Syntax. Backslashes werden immer wörtlich behandelt, z. B. \\ und \".

Beispiel Nr. 8 Nowdoc-String-Zitat-Beispiel mit Variablen

/* Komplexeres Beispiel mit Variablen. */
Klasse foo
{
öffentliches $foo ;
öffentliche $bar ;

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

$foo = new foo();
$name = "Name" ;

Echo<<<"EOT"
Mein Name ist „$name“. Ich gebe $foo->foo aus.
Jetzt drucke ich ($foo->bar).
Dies sollte kein großes „A“ ausgeben: \x41
EOT;
?>

Das Ergebnis der Ausführung dieses Beispiels:

Mein Name ist „$name“. Ich gebe $foo->foo aus. Jetzt drucke ich ($foo->bar). Dies sollte kein großes „A“ ausgeben: \x41

Beispiel Nr. 9 Beispiel für die Verwendung statischer Daten

Klasse foo(
öffentliche $bar =<<<"EOT"
Bar
EOT;
}
?>

Kommentar:

Nowdoc-Unterstützung wurde in PHP 5.3.0 hinzugefügt.

Umgang mit Variablen

Wenn eine Zeichenfolge in doppelten Anführungszeichen oder mithilfe von Heredoc angegeben wird, werden die darin enthaltenen Variablen verarbeitet.

Es gibt zwei Arten von Syntax: einfache und komplexe. Eine einfache Syntax ist einfacher und bequemer. Es ermöglicht die Verarbeitung einer Variablen, eines Array-Werts ( Array) oder Objekteigenschaften ( Objekt) mit minimalem Aufwand.

Komplexe Syntax erkennt man an den geschweiften Klammern, die den Ausdruck umgeben.

Einfache Syntax

Wenn der Dolmetscher auf ein Dollarzeichen stößt ( $ ), werden so viele Zeichen wie möglich erfasst, um den korrekten Variablennamen zu bilden. Wenn Sie das Ende eines Namens angeben möchten, schließen Sie den Variablennamen in geschweifte Klammern ein.

$saft = "Apfel" ;

echo „Er hat etwas Saft getrunken.“ . PHP_EOL ;

// Falsch. „s“ ist ein gültiges Zeichen für einen Variablennamen, aber die Variable heißt $juice.
echo „Er hat Saft aus $ Juices getrunken.“ ;

// Richtig. Das Ende des Variablennamens wird strikt durch Klammern angegeben:
echo „Er hat Saft aus $(saft) getrunken.“ ;
?>

Das Ergebnis der Ausführung dieses Beispiels:

Er trank etwas Apfelsaft. Er trank etwas Saft aus … Er trank Apfelsaft.

Ein Array-Element ( Array) oder Objekteigenschaft ( Objekt). In Array-Indizes gibt es eine schließende eckige Klammer ( ] ) markiert das Ende der Indexdefinition. Für Objekteigenschaften gelten die gleichen Regeln wie für einfache Variablen.

Beispiel Nr. 10 Einfaches Syntaxbeispiel

define ("KOOLAID" , "koolaid1" );
$juices = array("apple" , "orange" , "koolaid1" => "purple" );

echo „Er hat ein paar $juices [ 0 ] Juice getrunken.“ . PHP_EOL ;
echo „Er hat ein paar $juices [ 1 ] Saft getrunken.“ . PHP_EOL ;
echo „Er hat ein paar $juices [koolaid1] Saft getrunken.“ . PHP_EOL ;

Klasse Leute (
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Öffentlich $smith = "Smith" ;
}

$people = neue Leute();

echo „$people -> John hat ein paar $juices [ 0 ] Saft getrunken.“ . PHP_EOL ;
echo „ $people -> john sagte dann Hallo zu $people -> jane .“ . PHP_EOL ;
echo „$people -> Johns Frau begrüßte $people -> Robert.“ . PHP_EOL;
echo „ $people -> robert begrüßte die beiden $people -> smiths .“ ; // Funktioniert nicht
?>

Das Ergebnis der Ausführung dieses Beispiels:

Er trank etwas Apfelsaft. Er trank etwas Orangensaft. Er trank etwas lila Saft. John Smith trank etwas Apfelsaft. John Smith begrüßte dann Jane Smith. John Smiths Frau begrüßte Robert Paulsen.

Unterstützung für PHP 7.1.0 hinzugefügt Negativ numerische Indizes.

Beispiel #11 Negative numerische Indizes

$string = "string" ;
Echo „Das Zeichen am Index -2 ist gleich$string [- 2 ]." , PHP_EOL ;
$string [- 3 ] = "o" ;
Echo „Das Ändern des Zeichens an Position -3 in ‚o‘ erzeugt die folgende Zeile:$string." , PHP_EOL;
?>

Das Ergebnis der Ausführung dieses Beispiels:

Das Zeichen mit Index -2 ist gleich n. Wenn Sie das Zeichen an Position -3 in „o“ ändern, erhalten Sie die folgende Zeile: strong

Für alles, was komplexer ist, verwenden Sie eine komplexe Syntax.

Komplexe (geschweifte) Syntax

Es wird nicht deshalb als komplex bezeichnet, weil es schwer zu verstehen ist, sondern weil es die Verwendung komplexer Ausdrücke ermöglicht.

Mit dieser Syntax kann jede skalare Variable, jedes Array-Element oder jede Objekteigenschaft, die einer Zeichenfolge zugeordnet ist, in einer Zeichenfolge dargestellt werden. Schreiben Sie den Ausdruck einfach auf die gleiche Weise, wie Sie es außerhalb der Zeile tun würden, und schließen Sie ihn dann ein { Und } . Weil das { kann nicht maskiert werden, diese Syntax wird nur erkannt, wenn $ folgt direkt { . Verwenden {\$ zu drucken {$ . Ein paar anschauliche Beispiele:

// Alle Fehler anzeigen
error_reporting(E_ALL);

$great = "großartig" ;

// Funktioniert nicht, gibt aus: Das ist (großartig)
echo „Das ist ( $great )“ ;

// Funktioniert, gibt aus: Das ist großartig
echo „Das ist ($great)“;

// Funktioniert
Echo „Dieser Platz ist breit( $square -> width ) 00 Zentimeter." ;

// Funktioniert, in Anführungszeichen gesetzte Schlüsselwörter funktionieren nur mit der Syntax in geschweiften Klammern
echo „Das funktioniert: ( $arr [ „key“ ]) „ ;

// Funktioniert
echo „Das funktioniert: ( $arr [ 4 ][ 3 ])“ ;

// Dies ist aus demselben Grund ungültig wie $foo außerhalb
// Linien. Mit anderen Worten, es wird immer noch funktionieren,
// aber da PHP zuerst nach der Konstante foo sucht, wird dies dazu führen
// Levelfehler E_NOTICE (undefinierte Konstante).
Echo "Das ist nicht richtig:( $arr [ foo ][ 3 ]) " ;

// Funktioniert. Bei interner Verwendung mehrdimensionaler Arrays
// Zeilen verwenden immer geschweifte Klammern
echo "Das funktioniert: ( $arr [ "foo" ][ 3 ]) " ;

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

Echo „Das funktioniert auch:( $obj -> Werte [ 3 ] -> Name ) " ;

Echo „Dies ist der Wert der genannten Variablen$name : ($( $name )) " ;

Echo „Dies ist der Wert der benannten Variablen, wie er von der Funktion getName() zurückgegeben wird:($( getName ())) " ;

Echo „Dies ist der Wert der Variablen nach Namen, die \$object->getName() zurückgibt:($( $object -> getName ())) " ;

// Funktioniert nicht, gibt aus: Das gibt getName() zurück: (getName())
Echo „Das gibt getName() zurück: (getName())“;
?>

Mit dieser Syntax ist es auch möglich, auf Objekteigenschaften innerhalb von Strings zuzugreifen.

Klasse foo(
var $bar = „Ich bin bar.“ ;
}

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

Das Ergebnis der Ausführung dieses Beispiels:

Ich bin Bar. Ich bin Bar.

Kommentar:

Funktionen, Methodenaufrufe, statische Klassenvariablen und Klassenkonstanten funktionieren intern {$} , beginnend mit PHP 5. Der bereitgestellte Wert wird jedoch im selben Kontext wie die Zeile, in der er definiert ist, als Variablenname behandelt. Mit einzelnen geschweiften Klammern ( {} ) funktioniert nicht für den Zugriff auf die Werte von Funktionen, Methoden, Klassenkonstanten oder statischen Klassenvariablen.

// Alle Fehler anzeigen
error_reporting(E_ALL);

Klasse Biere (
const softdrink = "rootbeer" ;
public static $ale = "ipa" ;
}

$rootbeer = "A & W" ;
$ipa = „Alexander Keith\“s“ ;

// Das funktioniert, gibt aus: I would like A & W
echo „Ich hätte gerne ($( beers :: softdrink )) \n“ ;

// Das funktioniert auch, gibt aus: I would like Alexander Keith's
echo „Ich hätte gerne ($( beers :: $ale )) \n“ ;
?>

Auf ein Zeichen in einer Zeichenfolge zugreifen und es ändern

Zeichen in Zeichenfolgen können verwendet und geändert werden, indem ihr Abstand vom Anfang der Zeichenfolge, beginnend bei Null, in eckigen Klammern nach der Zeichenfolge angegeben wird, beispielsweise $str . Stellen Sie sich eine Zeichenfolge zu diesem Zweck als eine Reihe von Zeichen vor. Wenn Sie mehr als ein Zeichen abrufen oder ersetzen müssen, können Sie die Funktionen verwenden substr() Und substr_replace().

Kommentar: Ab PHP 7.1.0 werden negative Offsetwerte unterstützt. Sie geben den Versatz vom Zeilenende an. Zuvor verursachten negative Offsets einen Pegelfehler E_NOTICE beim Lesen (Rückgabe einer leeren Zeichenfolge) oder E_WARNUNG beim Schreiben (die Zeile unverändert lassen).

Kommentar: Auf ein Zeichen in einer Zeichenfolge kann auch mit geschweiften Klammern zugegriffen werden, beispielsweise $str(42) .

Aufmerksamkeit

Wenn Sie versuchen, an einen Offset zu schreiben, der über die Zeilengrenzen hinausgeht, wird die Zeichenfolge bis zu diesem Offset mit Leerzeichen aufgefüllt. Nicht ganzzahlige Typen werden in ganzzahlige Typen konvertiert. Der falsche Offset-Typ führt zu einem Pegelfehler E_WARNUNG. Es wird nur das erste Zeichen der zugewiesenen Zeichenfolge verwendet. Ab PHP 7.1.0 führt die Zuweisung einer leeren Zeichenfolge zu einem schwerwiegenden Fehler. Bisher wurde in diesem Fall ein Nullbyte (NULL) zugewiesen.

Aufmerksamkeit

Strings in PHP sind intern Arrays von Bytes. Daher ist der Zugriff auf oder die Änderung einer Zeichenfolge an einem Offset nicht sicher bei Multibyte-Kodierung und sollte nur mit Zeichenfolgen in Einzelbyte-Kodierung wie ISO-8859-1 durchgeführt werden.

Kommentar: Seit PHP 7.1.0 führte die Verwendung eines leeren Index zuvor zu einem schwerwiegenden Fehler. In diesem Fall wurde der String ohne Warnung in ein Array konvertiert.

Beispiel Nr. 12 Einige Beispielzeichenfolgen

// Erstes Zeichen der Zeichenfolge abrufen
$str = "Dies ist ein Test." ;
$first = $str [ 0 ];

// Holen Sie sich das dritte Zeichen der Zeichenfolge
$third = $str [ 2 ];

// Das letzte Zeichen der Zeichenfolge abrufen
$str = "Dies ist immer noch ein Test." ;
$last = $str [ strlen ($str ) - 1 ];

// Letztes Zeichen der Zeile ändern
$str = "Schau dir das Meer an" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

Ab PHP 5.4 muss der Offset in einem String entweder als Ganzzahl oder als String mit Ziffern angegeben werden, andernfalls wird eine Warnung ausgegeben. Zuvor durch eine Zeichenfolge wie angegebener Offset „foo“, ohne Vorwarnung verwandelte sich in 0 .

Beispiel Nr. 13 Unterschiede zwischen PHP 5.3 und 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" ]));
?>

Das Ergebnis der Ausführung dieses Beispiels in PHP 5.3:

string(1) „b“ bool(true) string(1) „b“ bool(true) string(1) „a“ bool(true) string(1) „b“ bool(true)

Das Ergebnis der Ausführung dieses Beispiels in PHP 5.4:

string(1) „b“ bool(true) Warnung: Unzulässiger String-Offset „1.0“ in /tmp/t.php in Zeile 7 string(1) „b“ bool(false) Warnung: Unzulässiger String-Offset „x“ in / tmp/t.php in Zeile 9 string(1) „a“ bool(false) string(1) „b“ bool(false)

Kommentar:

Der Versuch, über Variablen anderer Typen (ausgenommen Arrays oder Objekte, die bestimmte Schnittstellen implementieren) auf Variablen zuzugreifen oder {} wird stillschweigend zurückkehren NULL.

Kommentar:

PHP 5.5 hat Unterstützung für den Zugriff auf Zeichen in String-Literalen mithilfe der Syntax hinzugefügt oder {} .

Es gibt viele nützliche Funktionen zum Ändern von Zeichenfolgen.

Grundlegende Funktionen werden im Abschnitt über Zeichenfolgenfunktionen beschrieben. Für erweiterte Suchen und Ersetzen stehen Perl-kompatible reguläre Ausdrucksfunktionen zur Verfügung.

In String konvertieren

Ein Wert kann mithilfe eines Casts in einen String umgewandelt werden (Zeichenfolge), oder Funktionen strval(). Bei Ausdrücken, bei denen eine Zeichenfolge erforderlich ist, erfolgt die Konvertierung automatisch. Dies geschieht, wenn Sie Funktionen verwenden Echo oder drucken oder wenn der Wert einer Variablen mit einer Zeichenfolge verglichen wird. Das Lesen der Abschnitte „Typen“ und „Typmanipulation“ im Handbuch wird Folgendes klarer machen. siehe auch settype().

Arrays werden immer in String konvertiert „Array“, sodass Sie den Inhalt des Arrays nicht anzeigen können ( Array), mit Echo oder drucken um zu sehen, was es enthält. Um ein einzelnes Element anzuzeigen, verwenden Sie etwas wie echo $arr["foo"]. Nachfolgend finden Sie Tipps zum Anzeigen/Anzeigen aller Inhalte.

Um eine Typvariable zu konvertieren "Objekt" im Typ Zeichenfolge Es wird die magische Methode __toString verwendet.

Bedeutung NULL wird immer in den leeren String konvertiert.

Wie Sie oben sehen können, liefert die direkte Konvertierung von Arrays, Objekten oder Ressourcen in einen String keine nützlichen Informationen über die Werte selbst außer ihren Typen. Eine bessere Möglichkeit, Werte zum Debuggen auszugeben, ist die Verwendung von Funktionen print_r() Und var_dump().

Die meisten Werte in PHP können zur dauerhaften Speicherung in einen String umgewandelt werden. Diese Methode wird Serialisierung genannt und kann mithilfe der Funktion durchgeführt werden serialisieren().

Konvertieren von Zeichenfolgen in Zahlen

Wenn die Zeichenfolge als numerischer Wert erkannt wird, werden der resultierende Wert und der resultierende Typ wie folgt bestimmt.

Wenn die Zeichenfolge keines der Zeichen „.“, „e“ oder „E“ enthält und der Wert der Zahl innerhalb der Grenzen von Ganzzahlen liegt (definiert PHP_INT_MAX), wird die Zeichenfolge als Ganzzahl erkannt ( ganze Zahl). In allen anderen Fällen wird es als Gleitkommazahl betrachtet ( schweben).

Der Wert wird durch den Anfang der Zeichenfolge bestimmt. Wenn die Zeile mit einem gültigen numerischen Wert beginnt, wird dieser Wert verwendet. Andernfalls ist der Wert 0 (Null). Ein gültiger numerischer Wert besteht aus einer oder mehreren Ziffern (die einen Dezimalpunkt enthalten können), optional mit vorangestelltem Vorzeichen, gefolgt von einem optionalen Exponenten. Der Exponent ist „e“ oder „E“, gefolgt von einer oder mehreren Ziffern.

$foo = 1 + "10,5" ; // $foo ist ein Float (11.5)
$foo = 1 + "-1.3e3" ; // $foo ist ein Float (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo ist eine Ganzzahl (1)
$foo = 1 + "bob3" ; // $foo ist eine Ganzzahl (1)
$foo = 1 + "10 kleine Schweine" ; // $foo ist eine Ganzzahl (11)
$foo = 4 + "10.2 kleine Schweinchen" ; // $foo ist ein Float (14.2)
$foo = "10.0 Schweine" + 1 ; // $foo ist float (11)
$foo = "10.0 Schweine" + 1.0 ; // $foo ist float (11)
?>

Weitere Informationen zu dieser Konvertierung finden Sie im Abschnitt zu strtod(3) in der Unix-Dokumentation.

Wenn Sie eines der Beispiele in diesem Abschnitt testen möchten, kopieren Sie es und fügen Sie es sowie die folgende Zeile ein, um zu sehen, was passiert:

echo "\$foo== $foo ; Typ: " . gettype ($foo) . "
\N" ;
?>

Erwarten Sie nicht, den Code eines Zeichens zu erhalten, indem Sie es in eine Ganzzahl umwandeln (wie es beispielsweise in C geschieht). Verwenden Sie die Funktionen, um Zeichen in ihre ASCII-Codes und zurück umzuwandeln ord() Und chr().

Details zur Implementierung des String-Typs

vor 7 Jahren

In der Dokumentation wird zwar nicht erwähnt, aber ein schließendes Semikolon am Ende des Heredoc wird tatsächlich als echtes Semikolon interpretiert und führt daher manchmal zu Syntaxfehlern.

$foo =<<A B C D
ENDE;
?>

Das tut nicht:

foo(<<A B C D
ENDE;
);
// Syntaxfehler, unerwartet ";"
?>

Ohne Semikolon funktioniert es gut:

foo(<<A B C D
ENDE
);
?>

Vor 3 Jahren

Sie können ein stringähnliches Array von Zeichen verwenden (wie C).

$a = „String-Array-Test“;

var_dump($a);
// Return string(17) „String-Array-Test“

var_dump($a);
// Rückgabezeichenfolge(1) „S“

// -- Mit Array-Umwandlung --
var_dump((array) $a);
// Array(1) zurückgeben ( => string(17) „String-Array-Test“)

var_dump((array) $a);
// Rückgabezeichenfolge (17) „S“

Norihiori

vor 1 Jahr

Jeder einzelne Ausdruck, wie komplex er auch sein mag, der mit $ beginnt (d. h. eine Variable), kann in eine Zeichenfolge in doppelte Anführungszeichen () eingebettet werden:

Echo „Der Ausdruck ( $h -> q ()[ „x)“ ]-> p (9 == 0 ? 17 : 42 )) wird genauso gut geparst wie „. $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 ) . "tut." ;

?>

vor 2 Jahren

Beides sollte funktionieren :(

Klassentest (
public static $VAR = "static" ;
public const VAR = "const" ;

Öffentliche Funktion sayHelloStatic() (
echo "Hallo: ( $this :: $VAR ) " ;
}

Öffentliche Funktion sayHelloConst() (
echo "Hallo: ( $this ::VAR) " ; //Parse-Fehler: Syntaxfehler, unerwartetes „)“, erwartet „[“
}
}

$obj = new Testing();
$obj -> sayHelloStatic();
$obj -> sayHelloConst ();

Vor 14 Jahren

Sie können die komplexe Syntax verwenden, um den Wert sowohl von Objekteigenschaften als auch von Objektmethoden in eine Zeichenfolge einzufügen. Zum Beispiel...
KlassePrüfen{
öffentlich$ eins= 1 ;
öffentliche Funktionzwei() {
zurückkehren2 ;
}
}
$test= neuPrüfen();
Echo„foo{ $test-> eins} Bar{ $test-> zwei()} " ;
?>
Gibt „foo 1 bar 2“ aus.

Sie können dies jedoch nicht für alle Werte in Ihrem Namensraum tun. Klassenkonstanten und statische Eigenschaften/Methoden funktionieren nicht, da die komplexe Syntax nach dem „$“ sucht.
KlassePrüfen{
constEINS= 1 ;
}
Echo„foo (Test::ONE) bar“;
?>
Dadurch wird „foo (Test::one) bar“ ausgegeben. Bei Konstanten und statischen Eigenschaften müssen Sie die Zeichenfolge aufteilen.

vor 6 Jahren

Führende Nullen in Zeichenfolgen werden (wenig überraschend) nicht als Oktalwerte behandelt.
Halten:
$x = „0123“ + 0;
$y = 0123 + 0;
echo „x ist $x, y ist $y“; //gibt „x ist 123, y ist 83“ aus
mit anderen Worten:
* Führende Nullen in numerischen Literalen im Quellcode werden als „oktal“ interpretiert, vgl. strtol().
* Führende Nullen in Zeichenfolgen (z. B. vom Benutzer übermittelte Daten) werden bei der (impliziten oder expliziten) Umwandlung in eine Ganzzahl ignoriert und als Dezimalzahl betrachtet, vgl. strtod().

Vor 3 Jahren

Beachten Sie Folgendes im Zusammenhang mit „String-Konvertierung in Zahlen“:

Wenn („123abc“== 123 ) Echo„(intstr == int) wird fälschlicherweise als wahr getestet.“;

// Da eine Seite eine Zahl ist, wird die Zeichenfolge fälschlicherweise von intstr in int konvertiert, das dann mit der Testzahl übereinstimmt.

// True für alle Bedingungen wie if- und switch-Anweisungen (wahrscheinlich auch while-Schleifen)!

// Dies könnte ein großes Sicherheitsrisiko darstellen, wenn Benutzereingaben getestet/verwendet/speichert werden, während nur eine ganze Zahl erwartet und getestet wird.

// Es scheint, dass die einzige Lösung darin besteht, dass 123 eine Zeichenfolge wie „123“ ist, sodass keine Konvertierung erfolgt.

?>

vor 10 Jahren

Hier ist ein einfacher Hack, um zuzulassen, dass in doppelte Anführungszeichen gesetzte Zeichenfolgen und Heredocs beliebige Ausdrücke in der Syntax mit geschweiften Klammern enthalten, einschließlich Konstanten und anderen Funktionsaufrufen:

// Hack-Deklaration
Funktion_expr($v) (zurückkehren$v; }
$_expr= „_expr“;

// Unser Spielplatz
definieren(„qwe“, „asd“);
definieren(„zxc“, 5 );

$a= 3 ;
$b= 4 ;

Funktion C($a, $b) (zurückkehren$a+ $b; }

//Verwendung
Echo"Vor{ $_expr(1 + 2 )} Beitrag\n"; // gibt „pre 3 post“ aus
Echo"Vor{ $_expr(qwe)} Beitrag\n"; // gibt „pre asd post“ aus
Echo"Vor{ $_expr(C($a, $b)+ zxc* 2 )} Beitrag\n"; // gibt „pre 17 post“ aus

// Allgemeine Syntax ist ($_expr(...))
?>

Vor 11 Jahren

Um Ihren Verstand zu schonen, lesen Sie keine vorherigen Kommentare zu Terminen ;)

Wenn beide Zeichenfolgen in numerische Zeichen konvertiert werden können (im Test „$a“ > „$b“), werden die resultierenden numerischen Zeichen verwendet, andernfalls werden VOLLSTÄNDIGE Zeichenfolgen Zeichen für Zeichen verglichen:

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((schweben)"1.22.00" > (schweben)"01.23.00" ); //bool(false)
?>

vor 2 Jahren

Ich denke, dass es hilfreich wäre, diesen Kommentar hinzuzufügen, damit die Informationen zumindest auf der richtigen Seite der PHP-Site erscheinen.

Beachten Sie, dass bei Verwendung einer Zeichenfolge in doppelten Anführungszeichen mit einem assoziativen Schlüssel möglicherweise der Fehler T_ENCAPSED_AND_WHITESPACE auftritt. Manche betrachten dies als eine der weniger offensichtlichen Fehlermeldungen.

Ein Ausdruck wie:

$Frucht=array(
"A"=> "Apfel",
"B"=> "Banane",
//usw
);

Drucken "Das ist ein$Frucht[ "A"]"; // T_ENCAPSED_AND_WHITESPACE
?>

wird definitiv auseinanderfallen.

Sie können es wie folgt beheben:

drucken"Das ist ein$Frucht[ A] " ; // Anführungszeichen für den Schlüssel aufheben
drucken"Das ist ein${ Obst[ "A"]} " ; // Komplexe Syntax
drucken"Das ist ein{ $Frucht[ "A"]} " ; // Komplexe Syntaxvariation
?>

Persönlich bevorzuge ich die letzte Variante, da sie natürlicher ist und dem Ausdruck außerhalb der Zeichenfolge näher kommt.

Es ist (zumindest für mich) nicht klar, warum PHP das einfache Anführungszeichen innerhalb des Ausdrucks falsch interpretiert, aber ich kann mir vorstellen, dass es etwas damit zu tun hat, dass Anführungszeichen nicht Teil der Wertzeichenfolge sind – sobald die Zeichenfolge bereits analysiert wird, sind es nur noch die Anführungszeichen im Weg stehen...?

Hallo liebe Programmieranfänger. Lassen Sie uns weiterhin die Elemente untersuchen, aus denen es besteht.

In diesem Artikel erfahren Sie, was PHP-Operatoren sind. Tatsächlich kennen wir einige von ihnen fast seit unserer Kindheit, kennen sie jedoch nur als Zeichen (+, -, =, !, ?).

In PHP werden sie alle Operatoren genannt, was ziemlich logisch ist, da sie eine bestimmte Aktion oder Operation ausführen.

Man könnte sogar sagen, dass alle druckbaren Zeichen, die kein Buchstabe oder keine Zahl sind, in PHP Operatoren sind. Aber das ist noch nicht alles, denn es gibt Operatoren, die aus Buchstaben bestehen.

Beginnen wir der Reihe nach.

Rechenzeichen

Arithmetische Operatoren werden verwendet, um Operationen mit Zahlen durchzuführen.

+ ist der Additionsoperator;
— — Subtraktionsoperator;
/ - Divisionsoperator;
* — Multiplikationsoperator;
% ist der Operator zur Ermittlung des Restes bei der Division;
++ – Operator zum Erhöhen um eins (Inkrement);
— — — um einen Operator verringern (Dekrementieren)

Beim Schreiben wird üblicherweise ein Leerzeichen vor und nach dem Operator gesetzt. Dies geschieht ausschließlich, um das Lesen des Codes zu erleichtern, obwohl dieser Platz keinen Einfluss hat und Sie bei Bedarf auch darauf verzichten können.

Komplexe Ausdrücke werden nach den Regeln der Arithmetik zusammengesetzt, d. h. Multiplikation und Division haben Vorrang vor Addition und Subtraktion, und wenn beide im Ausdruck vorhanden sind, werden letztere in Klammern gesetzt.

Echo (6 + 7) * (7 + 8); // 195
?>

Bei der Division einer ganzen Zahl durch eine ganze Zahl wird das Ergebnis automatisch in eine reelle Zahl (Gleitkommazahl) umgewandelt, wenn ein Rest erhalten wird.

Echo 8 / 3 ; //2.66666666666
?>

Die Anzahl der für eine Bruchzahl gedruckten Ziffern hängt von dem Wert ab, der in der Precision-Direktive in der Datei php.ini festgelegt ist. Normalerweise sind dies 12 Zeichen, den Punkt nicht mitgerechnet.

Der %-Operator wird üblicherweise verwendet, um zu bestimmen, ob eine Zahl ohne Rest durch eine andere teilbar ist oder nicht.

Echo 53328 % 4 ; //0
?>

Es werden Operationen mit arithmetischen Operatoren, mit Ausnahme von Inkrement und Dekrement, aufgerufen binär, da es sich um zwei Operanden handelt (Term + Term, Dividend / Divisor usw.)

Es werden die Aktionen Inkrementieren und Dekrementieren aufgerufen einstellig, da es sich um einen Operanden handelt. Gibt es noch mehr? bedingter Betrieb, was drei Operanden umfasst.

Die Inkrementierungs- (++) und Dekrementierungsoperatoren (- -) gelten nur für Variablen.

Variablentyp Integer (ganze Zahlen)

$next = 3 ;
echo +$next; // 4
?>

Zeichenfolge vom Variablentyp

$next = "abc";
echo $next; // abd
?>

Der Buchstabe „d“ wird anstelle des Buchstabens „c“ gedruckt, da er im Alphabet an nächster Stelle steht und wir den Wert der Variablen um eins erhöht haben.

Die Beispiele zeigen Aktionen mit Inkrementierung, und auf die gleiche Weise können Sie Aktionen mit Dekrementierung ausführen.

Bitweise Operatoren

Bitweise Operatoren sind für die Arbeit mit Binärdaten konzipiert. Wenn jemand keine Ahnung hat, was es ist, werde ich es erklären. Binärzahlen sind Zahlen wie 1001000011100000111000.

Da solche Daten bei der Website-Entwicklung fast nie verwendet werden, werden wir nicht näher darauf eingehen. Ich zeige Ihnen nur, wie sie aussehen, damit Sie sich vorstellen können, womit Sie es zu tun haben, wenn Sie auf solche Symbole stoßen.

& - bitweise Verbindung UND (und);
~ – bitweise Negation (nicht);
| — bitweise Vereinigung ODER (oder);
^ – bitweise Eliminierung OR (xor);
<< — сдвиг влево битового значения операнда;
>> — den Bitwert des Operanden nach rechts verschieben;

Es ist sehr wahrscheinlich, dass Sie auf diese Operatoren stoßen, da Binärdaten bei der Entwicklung von Computergrafikprogrammen weit verbreitet sind. Aber um sie zu studieren, muss jemand, wenn er es braucht, einen separaten Kurs zu einer anderen Ressource belegen.

Vergleichsoperatoren

Vergleichsoperatoren sind logische Operatoren und werden zum Vergleichen von Variablen verwendet. Arrays und Objekte können damit nicht verglichen werden.

> – Operator größer als;
=> – größer-gleich-Operator;
< — оператор меньше;
<= — оператор меньше или равно;
== — Gleichheitsoperator;
!= – Ungleichheitsoperator;
=== – Äquivalenzoperator (Wert und Typ der Variablen sind gleich);
!== – Nichtäquivalenzoperator;

Als Ergebnis des Vergleichs wird entweder einer auf dem Bildschirm angezeigt, der „true“ (wahr) entspricht, oder ein leerer String, der „false“ (falsch) entspricht.

Echo 1 > 0 ; // 1
Echo 1< 0 ; // пустая строка
Echo 1 => 0 ; // 1
Echo 1 == 1 ; // 1
?>

Daher werden Vergleichsoperatoren als solche fast nie verwendet. Ihr Hauptzweck besteht darin, in Verbindung mit der if-Anweisung zu arbeiten.

Bedingte Anweisungen if, else, elseif.

Bedingungsoperatoren werden so genannt, weil sie dazu dienen, eine bestimmte Bedingung zu testen, abhängig davon, welche bestimmte Aktion ausgeführt wird.

Die if-Anweisung verwendet eine boolesche Variable oder einen booleschen Ausdruck als Argument. Wenn die Bedingung wahr ist, wird das Ergebnis angezeigt, wenn nicht, wird eine leere Zeile angezeigt.

if ($next< $nexT)
{
echo „Niederschlagswahrscheinlichkeit“; // Ausgabe Niederschlag möglich
}
?>

$next = „Luftfeuchte 80 %“;
$nexT = „Luftfeuchte 90 %“;
if ($next > $nexT)
{
echo „Niederschlagswahrscheinlichkeit“; // Eine leere Zeile ausgeben
}
?>

Wenn das Programm zwei Aktionen angeben muss, von denen eine ausgeführt wird, wenn der Wert wahr ist, und die andere, wenn der Wert falsch ist, wird zusammen mit der if-Anweisung die else-Anweisung verwendet

$next = „Luftfeuchte 80 %“;
$nexT = „Luftfeuchte 90 %“;
if ($next > $nexT)
{
echo „Niederschlagswahrscheinlichkeit“;
}
anders
{
echo „Kein Niederschlag erwartet“;
}
?>

In diesem Fall wird „Niederschlag ist nicht zu erwarten“ angezeigt, und wenn Sie im Ausdruck das Vorzeichen „Mehr“ in „Weniger“ ändern, wird „Niederschlag ist möglich“ angezeigt. Auf diese Weise prüfen Bedingungsoperatoren eine Bedingung und geben entsprechend das richtige Ergebnis aus.

Sehr oft müssen mehr als zwei Bedingungen festgelegt werden, und um sie dann nacheinander zu überprüfen, wird der Operator elseif verwendet.

if ($next > $nexT)
{
echo „Ich verstehe“;
}
elseif ($next<= $nexT)
{
Echo „Schnee“;
}
elseif ($next >= $nexT)
{
Echo „Regen“;
}
elseif ($next == $nexT)
{
Echo „Dürre“;
}
anders
{
echo „Niederschlagswahrscheinlichkeit“;
}
?>

Dieses Programm gibt „Snow“ aus. Wenn keine der Bedingungen zutrifft, wird „Chance of Precipitation“ angezeigt.

Eine if-Anweisung kann beliebig viele elseif-Blöcke enthalten, jedoch nur eine else-Anweisung.

Eine alternative Aufnahmemöglichkeit ist erlaubt – ohne geschweifte Klammern. In diesem Fall enden die Zeilen der if-, else-, elseif-Anweisungen mit einem Doppelpunkt und die gesamte Konstruktion endet mit dem Schlüsselwort (Operator) endif.

$next = „Luftfeuchte 50 %“;
$nexT = „Luftfeuchte 60 %“;
if ($next<= $nexT):

Echo „Schnee“;

elseif ($next >= $nexT):

Echo „Regen“;

elseif ($next == $nexT):

Echo „Dürre“;

anders:

echo „Niederschlagswahrscheinlichkeit“;
endif ;
?>

Logische Operatoren

Logische Operatoren ähneln bitweisen Operatoren. Der Unterschied besteht darin, dass erstere mit logischen Variablen und letztere mit Zahlen arbeiten.

Logische Operatoren werden in Fällen verwendet, in denen Sie mehrere Bedingungen kombinieren müssen, wodurch die Anzahl der if-Anweisungen verringert wird, was wiederum die Wahrscheinlichkeit von Fehlern im Code verringert.

&& - Verbindungskonjunktion UND;
und - auch UND, aber mit niedrigerer Priorität;
|| - trennende Konjunktion OR;
oder - auch ODER, aber mit niedrigerer Priorität;
xor – exklusives ODER;
! - Verweigerung;

Niedrigere Priorität bedeutet, dass bei Vorhandensein beider Operatoren derjenige mit der höheren Priorität zuerst ausgeführt wird.

In Zukunft werden wir anhand von Beispielen komplexerer Skripte näher auf logische Operatoren eingehen.

Aufgabenverwalter

Der Zuweisungsoperator = weist den Wert des rechten Operanden dem linken Operanden zu.

$next = „Hallo“
echo „Hallo“ // Hallo
?>

Operatorpunkt

Der Punktoperator trennt den ganzzahligen Teil einer Zahl vom gebrochenen Teil und fügt mehrere Zeichenfolgen und eine Zahl zu einer ganzen Zeichenfolge zusammen.

$next = 22 ;
echo „Heute danach“ .$next. „Frost wird erwartet“; // Heute nach 22 Uhr wird Frost erwartet
?>

Klammeroperator

Wie in der Mathematik gibt der Klammeroperator der darin eingeschlossenen Aktion Vorrang.

Die in Klammern eingeschlossenen Daten werden zuerst ausgeführt und dann der Rest.

Operator mit geschweiften Klammern

Es gibt drei Möglichkeiten oder sogar Stile, geschweifte Klammern in PHP zu platzieren.

1. BSD-Stil – Klammern sind linksbündig.

if ($next)
{

}

2. GNU-Stil – Klammern werden vom linken Rand eingerückt ausgerichtet

if ($next)
{
echo „Hallo liebe Programmieranfänger“;
}

3. K&R-Stil – Klammern werden in der Operatorzeile geöffnet

if ($next)(
echo „Hallo liebe Programmieranfänger“;
}

Von Anfang an müssen Sie einen der Stile auswählen und in Zukunft beim Schreiben von Skripten nur noch diesen verwenden. Dabei spielt es überhaupt keine Rolle, welchen Stil Sie bevorzugen. Es ist wichtig, dass es im gesamten Programm einheitlich ist.

Ich denke, das reicht für den Moment. Grundsätzlich können nicht nur Zeichen, sondern auch Funktionen und andere Elemente Operatoren sein, daher ist es sehr schwierig und sinnlos, sie alle aufzulisten.

Es reicht aus, eine Vorstellung von den grundlegenden Grundlagen zu haben. Und den Rest analysieren wir anhand praktischer Beispiele.

Ein Ire läuft weinend über den Flughafen Scheremetjewo. Einer der Mitarbeiter beschloss, mitzufühlen:
— Vermisst du deine Heimat?
- Gar nicht. Ich habe gerade mein gesamtes Gepäck verloren
- Wie konnte das passieren?
- Ich verstehe mich selbst nicht. Anscheinend habe ich den Stecker richtig eingesteckt

Im letzten Beitrag haben wir uns die Syntax der bedingten Anweisung in PHP angesehen. In dieser Anmerkung werden wir über Operatorklammern sprechen. Sie werden ihnen ständig begegnen. Dies ist ein Grundkonzept jeder Programmiersprache.

Wikipedia hilft uns bei der Beantwortung der Frage, was Operatorklammern sind:

Operatorklammern- Klammern oder Befehle, die einen Befehlsblock in einer Programmiersprache definieren, der als Ganzes, als ein Befehl wahrgenommen wird.

Pascal verwendet die folgende Konstruktion, um Operatorklammern zu bezeichnen: beginnen…. Ende. In C-ähnlichen Sprachen (einschließlich PHP) werden Operatorklammern durch Symbole beschrieben {…} .

Diese. Mit anderen Worten: Mehrere in Operatorklammern eingeschlossene Befehle werden als ein Befehl behandelt.

Im Artikel über Bedingungen in PHP gab es ein Beispiel:

$b) ( echo „Variable A ist größer als B“; ) else ( echo „Variable B ist größer als A“; ) ?>

In diesem Beispiel werden Operatorklammern zweimal verwendet. Sie rahmen die Betreiber ein

• Echo„Variable A ist größer als B“;
• Echo„Variable B ist größer als A“;

In diesem Beispiel gibt es nur eine Anweisung in Klammern, daher entspricht dies dem Schreiben wie folgt:

$b) echo „Variable A ist größer als B“; else echo „Variable B ist größer als A“; ?>

Syntax:

If (Bedingung) Ausdruck 1; sonst Ausdruck 2;

Nehmen wir an, wir möchten eine weitere Zeile auf dem Bildschirm anzeigen, wenn eine Bedingung nicht erfüllt ist. Lassen Sie uns jetzt auch die Werte unserer Variablen ändern $a war > $b. Ändern wir unseren Code:

$b) echo „Variable A ist größer als B.“; else echo „Variable B ist größer als A.“; echo „Ja..ja, A ist tatsächlich kleiner als B.“; ?>

Lass es uns tun... Was sehen wir auf dem Bildschirm:

Variable A ist größer als B. Ja..ja, A ist tatsächlich kleiner als B.

Irgendwo liegt hier ein Fehler vor. Wie Sie vielleicht schon erraten haben, besteht der springende Punkt darin, dass der Code ausgeführt wird, da unsere Bedingung wahr ist (a > b):

Echo „Variable A ist größer als B.“;

Im Thread anders Wir haben nur einen Ausdruck:

Echo „Variable B ist größer als A.“;

Der folgende Ausdruck wird unabhängig von der Bedingung ausgeführt. So:

$b) echo „Variable A ist größer als B.“; else echo „Variable B ist größer als A.“; echo „Ja..ja, A ist tatsächlich kleiner als B.“; ?>

Jetzt verwenden wir Operatorklammern und kombinieren zwei Ausdrücke in der Verzweigung anders:

$b) ( echo „Variable A ist größer als B.“; ) else ( echo „Variable B ist größer als A.“; echo „Ja..ja, A ist tatsächlich kleiner als B.“; ) ?>

Der Code ist viel klarer geworden. Jetzt PHP versteht, dass zwei Zeilen gedruckt werden müssen, wenn die Bedingung ($a > $b) nicht erfüllt ist. Und wenn die Bedingung wahr ist – nur eine.

Mein großes Geschenk für dich Beratung– Verwenden Sie immer Operatorklammern, auch wenn Sie nicht mehrere Operatoren in einem Block zusammenfassen müssen. Die Sache ist die:

• Der Code ist auf diese Weise einfacher zu lesen. Wenn wir einen kurzen Blick auf den Code werfen, sehen wir seine einzelnen Blöcke und keine Vinaigrette aus Buchstaben und Zahlen.
• Oftmals müssen Änderungen am alten Code vorgenommen werden. Wenn Sie keine Operatorklammern hatten und (wie in unserem Fall) Code hinzugefügt haben, ist die Logik des Programms falsch. Möglicherweise bemerken Sie es nicht einmal sofort.