PHP syntax and semantics

Das Syntax und Semantik von Php, a Programmiersprache, bilden Sie eine Reihe von Regeln, die definieren, wie ein PHP -Programm geschrieben und interpretiert werden kann.

Überblick

Historisch gesehen war die Entwicklung von PHP etwas willkürlich. Um dem entgegenzuwirken, hat die PHP -Framework -Interop -Gruppe (Abb.) Die erstellt Empfehlung von PHP Standards (PSR) Dokumente, die seit 2009 dazu beigetragen haben, mehr Standardisierung in die Sprache zu bringen.^[1] Die modernen Codierungsstandards sind in PSR-1 (Basic Coding Standard) enthalten^[2] und PSR-2 (Codierungsstil-Handbuch).^[3]

Schlüsselwörter

Einige Schlüsselwörter repräsentieren Dinge, die wie Funktionen aussehen, manche sehen aus wie Konstanten, aber es handelt sich tatsächlich um Sprachkonstrukte. Es ist verboten, Schlüsselwörter als Konstanten, Klassennamen, Funktionen oder Methoden zu verwenden. Die Verwendung von Variablennamen ist zulässig, kann aber verwirrend sein.^[4]

Grundlegende Sprachkonstrukte

PHP folgt im Allgemeinen C Syntaxmit Ausnahmen und Verbesserungen für die Hauptverwendung in Web Entwicklung, was stark gebraucht wird von String Manipulation. PHP -Variablen müssen durch vorangestellt werden "$". Dies ermöglicht PHP durchzuführen String -Interpolation in doppelt zitiert Saiten, wo Backslash wird als ein Escape-Zeichen. Es erfolgt keine Flucht oder Interpolation an Strings, die von begrenzt wurden Einzelzitate. PHP unterstützt auch einen C-ähnlich Sprintf Funktion. Der Code kann in Funktionen modularisiert werden, die mit Schlüsselwort definiert sind Funktion. PHP unterstützt eine optionale objektorientierter Codierungsstil mit Klassen, die von der gekennzeichnet sind Klasse Stichwort. In den Klassen definierte Funktionen werden manchmal genannt Methoden. Kontrollstrukturen enthalten: wenn, während, tun/während, zum, für jeden, und Schalter. Aussagen werden von einem Semikolon beendet, nicht durch Linienende.^[5]

Grenzwerte

Der PHP -Prozessor analysiert nur Code innerhalb seines Grenzwerte. Alles, was außerhalb seiner Abgrenzer ist, wird direkt an die Ausgabe gesendet und nicht von PHP analysiert. Die einzigen offenen/engen Trennzeichen, die von PSR-1 zugelassen werden^[6] sind "" und "?>" oder = und ?>.

Der Zweck der abgrenzenden Tags besteht darin, den PHP-Code von Nicht-Php-Daten (hauptsächlich HTML) zu trennen. Obwohl in der Praxis selten selten, wird PHP Code ausführen, der in jede Datei eingebettet ist, die an ihren Interpreter übergeben wurde, einschließlich Binärdateien wie PDF- oder JPEG -Dateien oder in Serverprotokolldateien.^[7][8] Alles außerhalb der Abgrenzer wird vom PHP -Parser ignoriert und als Ausgabe durchgesetzt.^[9]

Diese empfohlenen Trennzeichen erstellen korrekt gebildet Xhtml und andere Xml Unterlagen.^[10] Dies kann hilfreich sein, wenn die Quellcode -Dokumente während des Lebens der Software jemals auf andere Weise verarbeitet werden müssen.

Wenn eine ordnungsgemäße XML -Validierung kein Problem darstellt und eine Datei nur PHP -Code enthält, ist es vorzuziehen, das PHP -Schließen wegzulassen (Abschluss (?>) Tag am Ende der Datei.^[11]

Nicht empfohlene Tags

Auf einigen Servern können andere Trennzeichen verwendet werden, obwohl die meisten nicht mehr unterstützt werden.^[12] Beispiele sind:

• "" und ""(in Php7 entfernt)
• Kurze Eröffnungs -Tags () (konfiguriert mit dem Short_open_tag Ini -Einstellung)
  • Eine besondere Form der Tag ist =, was die nächste Aussage automatisch widerspricht. Vor PHP 5.4.0 wurde auch mit dieser gesteuert Short_open_tag, ist aber immer in späteren Versionen erhältlich.
• ASP Style -Tags (<% oder <%=) (in Php7 entfernt)

Variablen und Kommentare

Variablen werden mit a vorangestellt Dollarsymbol und ein Typ muss nicht im Voraus angegeben werden. Im Gegensatz zu Funktionen und Klassennamen sind Variablennamen Fallempfindlichkeit. Beide doppelt zitiert ("" ") und Heredoc Strings ermöglichen die Fähigkeit, den Wert einer Variablen in die Zeichenfolge einzubetten.^[13] Wie in C können Variablen sein gießen zu einem bestimmten Typ durch Präfix des Typs in Klammern. PHP behandelt Newlines wie Whitespace, in der Art von a Freiformsprache. Das Verkettung Bediener ist . (Punkt). Auf Arrayelemente werden zugegriffen und festgelegt mit eckige Klammern sowohl assoziative Arrays und indizierte Arrays. Geschweifte Klammern Kann verwendet werden, um auf Arrayelemente zuzugreifen, aber nicht zuzuweisen.

PHP hat drei Arten von Kommentarsyntax: / * *// was als Blockkommentare dient und // ebenso gut wie # die für Inline -Kommentare verwendet werden.^[14] Viele Beispiele verwenden die drucken Funktion anstelle der Echo Funktion. Beide Funktionen sind nahezu identisch; Der Hauptunterschied ist das drucken ist langsamer als Echo Da ersterer einen Status zurückgibt, der angibt, ob er erfolgreich war oder nicht zusätzlich zu Text zur Ausgabe, während der letztere keinen Status zurückgibt und den Text nur für die Ausgabe zurückgibt.^[15]

Einfachste Programm

Das Übliche "Hallo Welt"Code -Beispiel für PHP ist:^[16]

 Echo "Hallo Welt!\n"; ?> 

Das obige Beispiel gibt Folgendes aus:

Hallo Welt!

Anstatt zu verwenden und die echo Anweisung, eine optionale "Verknüpfung" ist die Verwendung von = Anstatt von die implizit Daten wiedergibt. Zum Beispiel:

 <html>   <Kopf>   <Titel>Php "Hallo, Welt!" ProgrammTitel>   Kopf>   <Karosserie>   <p>="Hallo Welt!"?>p>   Karosserie> html> 

Das obige Beispiel zeigt auch, dass Text, der nicht in umschließenden PHP -Tags enthalten ist, direkt ausgegeben wird.

Betreiber

PHP unterstützt: Rechenzeichen, Zuordnungsbetreiber, Bitgewise -Operatoren, Vergleichsoperatoren, Fehlersteuerungsoperatoren, Ausführungsoperatoren, Inkrement-/Dekrement -Operatoren, logische Operatoren, String -Operatoren, Array -Operatoren, Bedingte Zuweisungsoperatoren.^[17]

Kontrollstrukturen

Bedingte Aussagen

Ansonsten

Die Syntax eines PHP Wenn ... sonst Aussage ist wie folgt:

wenn (Bedingung) {  // Aussagen; } elseif (Bedingung2) {  // Aussagen; } anders {  // Aussagen; } 

Für einzelne Aussagen können die Klammern weggelassen werden und das, wenn sie optional zu einer einzigen Zeile kondensiert werden:

wenn (Bedingung) etwas tun(); elseif (Bedingung2) mach etwas anderes(); anders doyetathirdthing(); 

Ternäre Operatoren

$ ABS = $ Wert > = 0 ? $ Wert : -$ Wert; /* Gleichwertig */ wenn ($ Wert > = 0) {  $ ABS = $ Wert; } anders {  $ ABS = -$ Wert; } 

Elvis -Betreiber

Da PHP 5.3 unterstützt Elvis -Betreiber (?:), in dem es möglich ist, den mittleren Teil des ternären Operators wegzulassen.

$ c = $ a ?: $ b;  /* Gleichwertig */ $ c = $ a ? $ a : $ b; 

Null -Koalescing -Operator

Seit Version 7.0 PHP unterstützt auch Null -Koalescing -Operator (?).

$ a = $ b ? $ c; /* Gleichwertig */ $ a = Ausgabe($ b) ? $ b : $ c; 

Seit Version 7.4 PHP unterstützt auch Null -Koalescing -Operator mit dem ?? = Syntax.

$ a ?? = $ b; /* Gleichwertig */ $ a = $ a ? $ b; 

Sicherer Navigationsbetreiber

Seit Version 8.0 PHP unterstützt auch Sicherer Navigationsbetreiber (?->).

$ variable = $ Objekt?->Methode(); /* Gleichwertig */ $ variable =  $ Objekt ! == Null ? $ Objekt->Methode() : Null; 

Schalter

Ein Beispiel für die Syntax eines PHP Schaltanweisung ist wie folgt:

Schalter (Expr) {  Fall 0:  // Aussagen;  Unterbrechung;  Fall 1:  // Aussagen;  Unterbrechung;  Fall 2:  // Aussagen;  Unterbrechung;  Ursprünglich:  // Aussagen; } 

Beachten Sie das, anders als in C, Werte in Fallanweisung können irgendein Typ sein, nicht nur Ganzzahlen.^[18]

Passen

Php 8 führt die vor match Ausdruck.^[19] Der Match -Ausdruck ähnelt konzeptionell a switch Erklärung und ist für einige Anwendungsfälle kompakter.^[20]

Echo passen (1) {  0 => "Foo",  1 => 'Bar',  2 => "Baz", }; //> Bar 

Schleifen

Für Schleife

Die PHP -Syntax von a Für Schleife ist wie folgt:

zum (Initialisierung; Bedingung; nachträglich) {  // Aussagen; } 

While-Schleife

Die Syntax für einen PHP while-Schleife ist wie folgt:

während (Bedingung) {  // Aussagen; } 

Machen während der Schleife

Die Syntax für einen PHP machen während der Schleife ist wie folgt:

tun {  // Aussagen; } während (Bedingung); 

Für jede Schleife

Die Syntax für einen PHP für jeden Schleife lautet wie folgt:

für jeden ($ set wie $ Wert) {  // Aussagen; } 

Alternative Syntax für Kontrollstrukturen

PHP bietet eine alternative Syntax unter Verwendung von Kolons anstelle der Standard-Curly-Brace-Syntax (von ", anstatt" von "von" von "zu standhalten.{...}"). Diese Syntax beeinflusst die folgenden Kontrollstrukturen: wenn, während, zum, für jeden, und Schalter. Die Syntax variiert nur geringfügig von der Curly-Brace-Syntax. In jedem Fall die Eröffnungsklammer ({) wird durch einen Dickdarm ersetzt (:) und die enge Klammer wird durch ersetzt durch endif;, Ende;, Ende;, Endforeach;, oder Endschalter;, beziehungsweise.^[21] Das Mischen von Syntaxstilen innerhalb desselben Steuerblocks wird nicht unterstützt. Ein Beispiel für die Syntax für eine wenn/elseif Aussage lautet wie folgt:

wenn (Bedingung):  // Code hier elseif (Bedingung):  // Code hier anders:  // Code hier Endif; 

Dieser Stil wird manchmal als Template -Syntax bezeichnet, da er bei der Kombination von PHP und HTML oder JavaScript für die bedingte Ausgabe häufig leichter zu lesen ist:

<html>  wenn ($ tag == 'Donnerstag'): ?>  <div>Morgen ist Freitag!div>  elseif ($ tag == 'Freitag'): ?>  <div>Tgifdiv>  anders: ?>  <div>Pfuidiv>  Endif; ?> html> 

Ausnahmebehandlung

Die Fahrzeit -Ausnahmebehandlung in PHP wird von C ++ geerbt.^[22]

Funktion Inv($ x) {  wenn ($ x == 0) {  Wurf Neu Ausnahme('Durch Null teilen');  }  Rückkehr 1 / $ x; } Versuchen {  Echo Inv(2); // druckt 0,5  Echo Inv(0); // eine Ausnahme werfen  Echo Inv(5); // wird nicht laufen } Fang (Ausnahme $ e) {  Echo  $ e->GetMessage(); // Drucke Division von Null druckt  } // Ausführung fortsetzen Echo "Hallo"; // druckt Hallo 

Datentypen

Skalartypen

PHP unterstützt vier Skalartypen: bool, int, schweben, Saite.^[23]

Boolesche

PHP hat einen Eingeborenen Boolesche Typ, benannt ""bool", ähnlich wie die nativen Booleschen Typen in Java und C ++. Unter Verwendung der Conversionsregeln des Booleschen Typs werden ungleich Nullwerte als interpretiert als Stimmt und null als FALSCH, wie in Perl. Beide Konstanten Stimmt und FALSCH sind unempfindlich.^[24]

Ganze Zahl

PHP speichert ganze Zahlen in einem plattformabhängigen Bereich. Dieser Bereich beträgt normalerweise die von 32-Bit- oder 64-Bit-Zahlen.^[25] Ganzzahlvariablen können mit Dezimalzahl (positiv und negativ) zugeordnet werden. Oktal und hexadezimal Notationen.

$ a = 1234; // Dezimalzahl $ b = 0321; // Oktalzahl (entspricht 209 Dezimalzahl) $ c = 0x1b; // Hexadezimalzahl (entspricht 27 Dezimalzahl) $ d = 0B11; // Binärzahl (entspricht 3 Dezimalzahl) $ e = 1_234_567; // Dezimalzahl (ab PHP 7.4.0) 

Schweben

Reale Nummern werden auch in einem plattformspezifischen Bereich gespeichert. Sie können mit verwendet werden schwimmender Punkt Notation oder zwei Formen von wissenschaftliche Schreibweise.^[26]

$ a = 1.234; $ b = 1.2e3;  // 1200 $ c = 7E-5;  // 0,00007 $ d = 1_234.567; // ab PHP 7.4.0 

Saite

PHP unterstützt Saiten, die mit einzelnen Zitaten, Doppelzitaten, nowdoc oder verwendet werden können Heredoc Syntax.^[27]

Doppelzitierte Zeichenfolgen unterstützen variable Interpolation:

$ Alter = '23'; Echo "John ist $ Alter Jahre alt "; // John ist 23 Jahre alt 

Curly Braces Syntax:^[28]

$ f = "Sqrt"; $ x = 25; Echo "a$ xc \ n";  // Warnung: Undefinierte Variable $ xc Echo "a{$ x}c\n"; // druckt a25c Echo "a$ {x}c\n"; // druckt auch A25C Echo "$ f($ x) ist {$ f($ x)}\n"; // druckt SQRT (25) 5 

Besondere Typen

PHP unterstützt zwei spezielle Typen: Null, Ressource. Das Null Der Datentyp stellt eine Variable dar, die keinen Wert hat. Der einzige Wert in der Null Datentyp ist NULL. Das NULL Konstante ist nicht fallempfindlich.^[29] Variablen der "Ressource"Typ repräsentiert Verweise auf Ressourcen aus externen Quellen. Diese werden normalerweise durch Funktionen aus einer bestimmten Erweiterung erstellt und können nur mit Funktionen aus derselben Erweiterung verarbeitet werden. Beispiele umfassen Datei-, Bild- und Datenbankressourcen.^[23]

Zusammengesetzte Typen

PHP unterstützt vier zusammengesetzte Typen: Array, Objekt, abrufbar, wiederholbar.

Array

Arrays können gemischte Elemente jeglicher Art enthalten, einschließlich Ressourcen, Objekten.^[30] Mehrdimensionale Arrays werden erstellt, indem Arrays als Array-Elemente zugewiesen werden. PHP hat keinen echten Array -Typ. PHP -Arrays sind nativ spärlich und assoziativ. Indexierte Arrays sind einfach Hashes, die Ganzzahlen als Schlüssel verwenden.

Indexiertes Array:

$ Saison = ["Herbst", "Winter", "Frühling", "Sommer"];   Echo $ Saison[2]; // Frühling 

Assoziatives Array:

$ Gehalt = ["Alex" => 34000, "Rechnung" => 43000, "Jim" => 28000];   Echo $ Gehalt["Rechnung"]; // 43000 

Mehrdimensionales Array:

$ mark = [  "Alex" => [  "Biologie" => 73,  "Geschichte" => 85  ],  "Jim" => [  "Biologie" => 86,  "Geschichte" => 92  ] ]; Echo $ mark["Jim"]["Geschichte"];  // 92 

Objekt

Das Objekt Datentyp ist eine Kombination aus Variablen, Funktionen und Datenstrukturen in der Objekt orientierte Programmierung Paradigma.

Klasse Person {  // ... } $ Person = Neu Person(); 

Abrufbar

Seit Version 5.3 PHP hat erstklassige Funktionen Das kann verwendet werden, z. als Argument für eine andere Funktion.

Funktion Läufer(abrufbar $ Funktion, gemischt ...$ args) {  Rückkehr $ Funktion(...$ args); } $ f = fn($ x, $ y) => $ x ** $ y; Funktion Summe(int|schweben ...$ args) {  Rückkehr Array_sum($ args); } Echo Läufer(fn($ x) => $ x ** 2, 2); // Drucke 4 Echo Läufer($ f, 2, 3); // Drucke 8 Echo Läufer('Summe', 1, 2, 3, 4); // Drucke 10 

Wiederholbar

Wiederholbar Typ zeigt an, dass eine Variable mit verwendet werden kann für jeden Schleife.^[31] Es kann jeder sein Array oder Generator oder Objekt, dass die Implementierung der Spezialinnere implementiert ist Durchquert werden^[32] Schnittstelle.

Funktion Printquares(wiederholbar $ Daten) {  für jeden ($ Daten wie $ Wert) {  Echo ($ Wert ** 2) . "" ";  }  Echo "\n"; } // Array  $ Array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Generator  $ generator = Funktion (): Generator {  zum ($ i = 1; $ i <= 10; $ i++) {  Ertrag  $ i;  } }; // Objekt $ Arrayiterator = Neu Arrayiterator[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); Printquares($ Array);  // 1 4 9 16 25 36 49 64 81 100 Printquares($ generator());  // 1 4 9 16 25 36 49 64 81 100 Printquares($ Arrayiterator); // 1 4 9 16 25 36 49 64 81 100 

Gewerkschaftstypen

Gewerkschaftstypen wurden in PHP 8.0 eingeführt^[33]

  Funktion Foo(Saite|int $ foo): Saite|int {} 

Funktionen

PHP hat Hunderte von Basisfunktionen und Tausende mehr aus Erweiterungen. Vor der PHP -Version 5.3.0 sind Funktionen nicht erstklassige Funktionen und kann nur mit ihrem Namen verwiesen werden, während PHP 5.3.0 Schließungen einführt.^[34] Benutzerdefinierte Funktionen können jederzeit und ohne prototypisiert erstellt werden.^[34] Funktionen können in Codeblöcken definiert werden, die eine Laufzeitentscheidung darüber ermöglichen, ob eine Funktion definiert werden sollte oder nicht. Es gibt kein Konzept der lokalen Funktionen. Funktionsaufrufe müssen Klammern mit Ausnahme der mit dem PHP aufgerufenen Konstruktorfunktionen der Argumentklassen verwenden Neu Bediener, wo Klammern optional sind.

Eine Beispielfunktionsdefinition ist Folgendes:

Funktion hallo($ Ziel='Welt') {  Echo "Hallo $ Ziel!\n"; } hallo(); // Ausgibt "Hallo Welt!" hallo("Wikipedia"); // Ausgibt "Hallo Wikipedia!" 

Funktionsaufrufe können über Variablen getätigt werden, wobei der Wert einer Variablen den Namen der aufgerufenen Funktion enthält. Dies ist im folgenden Beispiel dargestellt:

Funktion hallo() {  Rückkehr 'Hallo'; } Funktion Welt() {  Rückkehr "Welt!"; } $ function1 = 'hallo'; $ function2 = 'Welt'; Echo "{$ function1()} {$ function2()}"; 

Ein Standardwert für Parameter kann in der Funktionsdefinition zugewiesen werden, aber vor PHP 8.0 unterstützte nicht Namens Parameter oder Parametersprung.^[35] Einige Kern -PHP -Entwickler haben öffentlich Enttäuschung über diese Entscheidung geäußert.^[36] Andere haben Workarounds für diese Einschränkung vorgeschlagen.^[37]

Benannte Argumente

Benannte Argumente wurden in PHP 8.0 eingeführt

Funktion Energie($ Base, $ exp) {  Rückkehr $ Base ** $ exp; } // Positionsargumente verwenden: Echo Energie(2, 3); // Drucke 8 // benannte Argumente verwenden: Echo Energie(Base: 2, Exp: 3); // Drucke 8 Echo Energie(Exp: 3, Base: 2); // Drucke 8 

Typdeklaration

Die Angabe der Arten von Funktionsparametern und Funktionsrückgabewerten wurde seit PHP 7.0 unterstützt.^[38]

Rückgabetyp Deklaration:

Funktion Summe($ a, $ b): schweben  {  Rückkehr $ a + $ b; } var_dump(Summe(1, 2)); // druckt float (3) 

Parameter Typisierung:

Funktion Summe(int $ a, int $ b) {  Rückkehr $ a + $ b; } var_dump(Summe(1, 2));  // Drucke int (3) var_dump(Summe(1.6, 2.3)); // Drucke int (3) 

Strenge Typisierung

Ohne strenge typisierte typisierte:

$ f1 = fn ($ a, $ b): int => $ a + $ b; $ f2 = fn (int $ a, int $ b) => $ a + $ b; var_dump($ f1(1.3, 2.6)); // Drucke int (3) var_dump($ f1(1, '2'));  // Drucke int (3) var_dump($ f2(1.3, 2.6)); // Drucke int (3) var_dump($ f2(1, '2'));  // Drucke int (3) 

Mit strenger Tipptypen:

erklären(strict_types=1);  $ f1 = fn ($ a, $ b): int => $ a + $ b; $ f2 = fn (int $ a, int $ b) => $ a + $ b; var_dump($ f1(1.3, 2.6)); // Fataler Fehler: Der Rückgabewert muss vom Typ int sein, float zurückgegeben var_dump($ f1(1, '2'));  // Drucke int (3) var_dump($ f2(1.3, 2.6)); // Fataler Fehler: Argument Nr. 1 ($ A) muss vom Typ int sein, float gegeben var_dump($ f2(1, '2'));  // Fataler Fehler: Argument Nr. 2 ($ B) muss vom Typ int, Zeichenfolge angegeben sein 

Anonyme Funktionen

PHP unterstützt True Anonyme Funktionen Ab Version 5.3.^[34] In früheren Versionen unterstützte PHP nur Quasi-anonyme Funktionen durch die create_function () Funktion.

$ x = 3; $ func = Funktion($ z) { Rückkehr $ z * 2; }; Echo $ func($ x); // Drucke 6 

Seit Version 7.4 PHP unterstützt auch Pfeilfunktionen Syntax (=>).^[39]

$ x = 3; $ func = fn($ z) => $ z * 2; Echo $ func($ x); // Drucke 6 

Schließungen

Verschlüsse verfolgen

$ add = fn($ x) => fn($ y) => $ y + $ x; /* Gleichwertig */ $ add = Funktion ($ x) {  Rückkehr Funktion ($ y) verwenden ($ x) {  Rückkehr $ y + $ x;  }; }; 

Verwendung

$ f = $ add(5); Echo $ f(3);  // Drucke 8 Echo $ add(2) (4);  // Drucke 6 

Generatoren

Mit Generatoren können wir Code schreiben, mit dem Foreach über einen Datensatz iteriert wird, ohne ein Array im Speicher erstellen zu müssen, was zu Speicheraufwand oder einer erheblichen Verarbeitungszeit für die Generation führen kann.

Objekte

Basic Objekt orientierte Programmierung Die Funktionalität wurde in Php 3 hinzugefügt.^[40] Die Objektbearbeitung wurde für PHP 5 vollständig umgeschrieben, wobei die Funktionssatz und die Verbesserung der Leistung erweitert wurden.^[41] In früheren Versionen von PHP wurden Objekte wie wie primitive Typen.^[41] Der Nachteil dieser Methode war, dass das gesamte Objekt kopiert wurde, wenn eine Variable zugewiesen oder als Parameter an eine Methode übergeben wurde. Im neuen Ansatz werden Objekte auf handhabenund nicht nach Wert. PHP 5 wurde privat und geschützt eingeführt Mitgliedsvariablen und Methoden zusammen mit Abstrakte Klassen und endgültige Klassen ebenso gut wie Abstrakte Methoden und endgültige Methoden. Es wurde auch eine Standardmethode zur Erklärung eingeführt Konstrukteure und Zerstörerähnlich wie bei anderen objektorientierten Sprachen wie z. C ++und ein Standard Ausnahmebehandlung Modell. Außerdem PHP 5 hinzugefügt Schnittstellen und ermöglicht die Implementierung mehrerer Schnittstellen. Es gibt spezielle Schnittstellen, die es Objekten ermöglichen, mit dem Laufzeitsystem zu interagieren. Objekte Implementierung ArrayAccess kann mit Array -Syntax und verwendet werden Objekte Implementierung Iterator oder Iteratoraggregate kann mit dem foreach verwendet werden Sprachkonstrukt. Die statische Methode und Klassenvariable Funktionen in Zend Engine 2 funktionieren nicht so, wie manche erwarten würden. Es gibt kein Virtuelle Tabelle Merkmal im Motor so Statische Variablen sind mit einem Namen anstelle einer Referenz zur Kompilierungszeit gebunden.^[42]

Dieses Beispiel zeigt, wie eine Klasse definiert wird. Foo, das erbt vom Unterricht Bar. Die Methode MystaticMethod ist eine öffentliche statische Methode, die aufgerufen werden kann Foo :: mystaticMethod ();.

Klasse Foo erweitert Bar {  Funktion __konstruieren()  {  $ Doo = "Wah Dee Dee";  }  Öffentlichkeit statisch Funktion MystaticMethod()  {  $ Dee = "Dee Dee Dum";  } } 

Wenn der Entwickler eine Kopie eines Objekts mit dem reservierten Wort erstellt KlonDer Zend -Motor prüft, ob a __Klon() Die Methode wurde definiert oder nicht. Wenn nicht, ruft es einen Standard an __Klon() die die Eigenschaften des Objekts kopieren. Wenn ein __Klon() Die Methode ist definiert, dann ist sie dafür verantwortlich, die erforderlichen Eigenschaften im erstellten Objekt festzulegen. Für den Einfachheit halber liefert der Engine eine Funktion, die die Eigenschaften des Quellobjekts importiert, sodass der Programmierer mit einer By-Wert-Replik des Quellobjekts beginnen und nur Eigenschaften überschreibt, die geändert werden müssen.^[43]

Züge

// Die Vorlage Merkmal Tsingleton {  Privatgelände statisch $ _instance = Null;  Privatgelände Funktion __konstruieren() {} // muss einen privaten Standardkonstruktor haben und sich bewusst sein, ihn nicht in der Klasse zu öffnen  Öffentlichkeit statisch Funktion bekomme Instanz()  {  wenn (Null === selbst::$ _instance) {  selbst::$ _instance = Neu selbst();  }  Rückkehr selbst::$ _instance;  } } Klasse Frontcontroller {  verwenden Tsingleton; } // kann auch in bereits erweiterten Klassen verwendet werden Klasse Webseite erweitert Someclass {  verwenden Tsingleton; } 

Merkmal Tbounding {  Öffentlichkeit $ x, $ y, $ width, $ Höhe; } Merkmal Tmovable {  Öffentlichkeit Funktion ziehen nach($ x, $ y)  {  //…  } } Merkmal Tressizelbar {  Öffentlichkeit Funktion Größenänderung($ newwidth, $ newheight)  {  //…  } } Klasse Rechteck {  verwenden Tbounding, Tmovable, Tressizelbar;  Öffentlichkeit Funktion Füllfarbe($ Farbe)  {  //…  } } 

Siehe auch

• Hypertext -Markup -Sprache (HTML)
• Template Engine (Web)

Verweise