Was ist das?

Dies ist eine Sammlung von Fragen, die hin und wieder zur Syntax in PHP auftauchen. Dies ist auch ein Community-Wiki, daher ist jeder eingeladen, an der Pflege dieser Liste teilzunehmen.

Warum ist das?

Früher war es schwierig, Fragen zu Operatoren und anderen Syntax-Token zu finden.¹
Die Hauptidee besteht darin, Links zu vorhandenen Fragen zum Stapelüberlauf zu haben, damit wir sie leichter referenzieren und nicht über Inhalte aus dem PHP-Handbuch kopieren können.

Hinweis: Seit Januar 2013 unterstützt der Stapelüberlauf Sonderzeichen . Umgeben Sie die Suchbegriffe einfach mit Anführungszeichen, z[php] "==" vs "==="

Was soll ich hier machen?

Wenn Sie hier von jemandem darauf hingewiesen wurden, weil Sie eine solche Frage gestellt haben, finden Sie unten die jeweilige Syntax. Die mit dem PHP-Handbuch verknüpften Seiten zusammen mit den verknüpften Fragen werden Ihre Frage dann wahrscheinlich beantworten. Wenn ja, werden Sie aufgefordert, die Antwort zu bewerten. Diese Liste ist nicht als Ersatz für die Hilfe anderer gedacht.

Die Liste

Wenn Ihr bestimmtes Token unten nicht aufgeführt ist, finden Sie es möglicherweise in der Liste der Parser-Token .

& Bitweise Operatoren oder Referenzen

• Was bedeutet es, eine PHP-Funktion mit einem kaufmännischen Und zu starten?
• Grundlegendes zum PHP & (kaufmännisches Und, bitweises und) Operator
• PHP "&" Operator
• Unterschied zwischen & und && in PHP
• Was bedeutet "&" hier in PHP?
• Was bedeutet "&" in diesem Fall?
• Was bedeutet das "&" in PHP?
• Was bedeutet diese Signatur (&) in PHP?
• Wie funktioniert der Operator "&" in einer PHP-Funktion?
• Was bedeutet & in & 2 in PHP?
• Wann sollte ich einen bitweisen Operator verwenden?
• Muss jemals ein kaufmännisches Und vor einem Objekt verwendet werden? (& $)

=& Verweise

• Referenzzuweisungsoperator in PHP, = &
• Was bedeuten die Operatoren "= &" und "& =" in PHP?
• Was machen die Operatoren '& =' und '= &'?
• Was bedeutet = & in PHP?

&= Bitweise Operatoren

• Was bedeuten die Operatoren "= &" und "& =" in PHP?
• Was machen die Operatoren '& =' und '= &'?

&& Logische Operatoren

• 'AND' vs '&&' als Operator
• Unterschied zwischen & und && in PHP
• Gibt es einen Unterschied zwischen den Operatoren "und" und "&&" in PHP?
• PHP - und / oder Schlüsselwörter

% Rechenzeichen

• Was bedeutet das Prozentzeichen in PHP?
• Was ist der PHP-Operator% und wie verwende ich ihn in Beispielen aus der Praxis?

!! Logische Operatoren

• Verdoppeln Sie nicht (!!) Operator in PHP

@ Fehlerkontrolloperatoren

• Was ist die Verwendung des @ -Symbols in PHP?
• Symbol 'At' vor Variablenname in PHP: @ $ _ POST
• PHP-Funktionen und @ -Funktionen
• Soll ich @ in meinem PHP-Code verwenden?
• Was bedeutet @ in PHP?

?: Ternärer Operator

• Was sind die PHP-Operatoren "?" und ":" angerufen und was machen sie?
• ?: Operator (der 'Elvis-Operator') in PHP
• Wo kann ich über Bedingungen lesen, die mit "?" und ":" (Doppelpunkt)?
• Verwenden von PHP 5.3 ?: Operator

?? Null-Koaleszenz-Operator (seit PHP 7)

• C # 's Null-Koaleszenz-Operator (??) in PHP

?string ?int ?array ?bool ?float Nullable Rückgabetypdeklaration (seit PHP 7.1)

• Nullable Rückgabetypdeklaration

: Alternative Syntax für Kontrollstrukturen , Ternary Operator

• Was ist ":" in PHP?
• Was bedeutet ":" in PHP?

:: Scope Resolution Operator

• Was bedeuten zwei Doppelpunkte in PHP?
• Was bedeutet der PHP-Token-Name T_PAAMAYIM_NEKUDOTAYIM?
• Was ist der Unterschied zwischen :: (Doppelpunkt) und -> (Pfeil) in PHP?
• Was genau sind späte statische Bindungen in PHP?
• static :: staticFunctionName ()
• Unerwartetes T_PAAMAYIM_NEKUDOTAYIM, erwartet T_NS_Separator

\ Namespaces

• Backslash in PHP - was bedeutet das?
• Was macht ein \ (Backslash) in PHP (5.3+)?

-> Klassen und Objekte

• Wie heißt der PHP-Operator "->" und wie sagt man das, wenn man Code laut vorliest?
• Wo verwenden wir den Objektoperator "->" in PHP?
• Was ist der Unterschied zwischen :: (Doppelpunkt) und -> (Pfeil) in PHP?
• Was bedeutet die PHP-Syntax $ var1 -> $ var2?
• Was bedeutet "->" in PHP?

=> Arrays

• Was bedeutet "=>" in PHP?
• Verwendung von => in PHP
• Was bedeutet $ k => $ v in foreach ($ ex als $ k => $ v)?

^ Bitweise Operatoren

• Wie funktioniert der bitweise Operator XOR ('^')?
• Was bedeutet ^ in PHP?

>> Bitweise Operatoren

• Was bedeutet >> in PHP?

<< Bitweise Operatoren

• Seltsames Druckverhalten in PHP?

<<< Heredoc oder Nowdoc

• Was bedeutet <<< END in PHP?
• PHP-Ausdruck <<< EOB
• Was bedeutet "<<<" in PHP?
• Verwenden von <<< CON in PHP
• Was ist diese Art von Syntax in PHP?

= Zuweisungsoperatoren

• Die 3 verschiedenen sind gleich

== Vergleichsoperatoren

• Wie unterscheiden sich die Vergleichsoperatoren PHP-Gleichheit (== Doppelgleich) und Identität (=== Dreifachgleich)?
• PHP! = Und == Operatoren
• Die 3 verschiedenen sind gleich
• Typ-Jonglieren und (strenge) Vergleiche größer / kleiner als in PHP

=== Vergleichsoperatoren

• Was bedeutet "==="?
• Wie unterscheiden sich die Vergleichsoperatoren PHP-Gleichheit (== Doppelgleich) und Identität (=== Dreifachgleich)?
• Die 3 verschiedenen sind gleich
• Typ-Jonglieren und (strenge) Vergleiche größer / kleiner als in PHP

!== Vergleichsoperatoren

• Was bedeutet! == Vergleichsoperator in PHP?
• Gibt es einen Unterschied zwischen! == und! = In PHP?

!= Vergleichsoperatoren

• PHP! = Und == Operatoren
• Gibt es einen Unterschied zwischen! == und! = In PHP?
• Vergleichen ,! == versus! =
• Was ist der Unterschied zwischen <> und! =

<> Vergleichsoperatoren

• PHP-Operator <>
• PHPs <> Operator
• Was ist der Unterschied zwischen <> und! =
• Typ-Jonglieren und (strenge) Vergleiche größer / kleiner als in PHP

<=> Vergleichsoperatoren (seit PHP 7.0)

• Raumschiff-Betreiber (Drei-Wege-Vergleich)

| Bitweise Operatoren

• Was ist der Unterschied zwischen dem | und || Betreiber?
• Was bedeutet die Verwendung eines einzelnen Rohrs? ' In einem Funktionsargument tun?

|| Logische Operatoren

• Was ist der Unterschied zwischen dem | und || Betreiber?
• PHP - und / oder Schlüsselwörter
• Was genau macht || bedeuten?
• Das Verhalten des Operators oder in PHP

~ Bitweise Operatoren

• Was bedeutet dieser ~ Operator hier?

+ Arithmetische Operatoren , Array-Operatoren

• + Operator für Array in PHP?

+=und -= Zuweisungsoperatoren

• Wofür wird + = verwendet?
• Was bedeutet "$ page - = 1" in meinem PHP-Dokument?

++und -- Inkrementieren / Dekrementieren von Operatoren

• Inkrementieren verstehen
• Antworte unten

.= Zuweisungsoperatoren

• Was ist der Unterschied zwischen. = Und + = in PHP?
• Eine Zeile von PHP verstehen

. String-Operatoren

• Unterschied zwischen Punkt und Komma bei der Verkettung mit Echo und Rückkehr?
• Was tut ein . (Punkt) in PHP tun?

, Funktionsargumente

• Unterschied zwischen Punkt und Komma bei der Verkettung mit Echo und Rückkehr?

, Variable Deklarationen

• Was bedeuten Kommas in einer Variablendeklaration?

$$ Variablenvariablen

• Was bedeutet $$ (Dollar Dollar oder doppelter Dollar) in PHP?
• Was ist "$$" in PHP
• $ function () und $$ Variable

` Ausführungsoperator

• Wie heißen die Backticks?

<?= Kurze offene Tags

• Was bedeutet dieses Symbol in PHP <? =
• Was bedeutet '<? =' In PHP?
• Was bedeutet <? =?

[] Arrays (kurze Syntax seit PHP 5.4)

• PHP-Arrays ... Was ist / sind die Bedeutung (en) einer leeren Klammer?
• Was ist die Bedeutung von []
• Php array_push () vs myArray []
• Was bedeutet [] beim Lesen von einem PHP-Array?
• Abkürzung für Arrays: Literal $var = []leeres Array

<? Tags öffnen und schließen

• Sind PHP Short Tags akzeptabel?

... Argument entpacken (seit PHP 5.6)

** Potenzierung (seit PHP 5.6)

# Einzeiliger Kommentar im Shell-Stil

• Kann ich Hashes für Kommentare in PHP verwenden?

:? Nullable Rückgabetypen

• PHP-Methode Argumenttyp Hinweis mit Fragezeichen (? Typ)

?-> NullSafe-Operatoraufrufe

• Was bedeutet dieses Symbol "? ->" in PHP, innerhalb eines Objekts oder eines Nullwerts

Inkrementieren / Dekrementieren von Operatoren

++ Inkrementierungsoperator

-- Dekrementierungsoperator

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

Diese können vor oder nach der Variablen stehen.

Wenn vor den Variablen setzen, wird die Zunahme / Abnahme Operation auf die Variable erfolgt erst dann wird das Ergebnis zurückgegeben. Wenn nach der Variablen gesetzt, wird die Variable zuerst zurückgegeben, dann wird die Inkrementierungs- / Dekrementierungsoperation ausgeführt.

Zum Beispiel:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

Live Beispiel

Im obigen Fall ++$iwird verwendet, da es schneller ist. $i++hätte die gleichen Ergebnisse.

Das Vorinkrementieren ist etwas schneller, da es die Variable wirklich inkrementiert und danach das Ergebnis "zurückgibt". Nach dem Inkrementieren wird eine spezielle Variable erstellt, der den Wert der ersten Variablen kopiert und erst nach Verwendung der ersten Variablen durch den Wert der zweiten ersetzt.

Sie müssen jedoch verwenden $apples--, da Sie zuerst die aktuelle Anzahl der Äpfel anzeigen und dann einen davon abziehen möchten.

Sie können Buchstaben auch in PHP erhöhen:

$i = "a";
while ($i < "c") {
    echo $i++;
}

Sobald zerreicht aaist, ist als nächstes und so weiter.

Beachten Sie, dass Zeichenvariablen inkrementiert, aber nicht dekrementiert werden können und daher nur einfache ASCII-Zeichen (az und AZ) unterstützt werden.

Stapelüberlaufpfosten:

• Inkrementieren verstehen

Bitweiser Operator

Was ist ein bisschen? Ein Bit ist eine Darstellung von 1 oder 0. Grundsätzlich AUS (0) und EIN (1)

Was ist ein Byte? Ein Byte besteht aus 8 Bits und der höchste Wert eines Bytes ist 255, was bedeuten würde, dass jedes Bit gesetzt ist. Wir werden untersuchen, warum der Maximalwert eines Bytes 255 beträgt.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

Diese Darstellung von 1 Byte

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 Byte)

Einige Beispiele zum besseren Verständnis

Der Operator "AND": &

$a =  9;
$b = 10;
echo $a & $b;

Dies würde die Nummer 8 ausgeben. Warum? Schauen wir uns unser Tabellenbeispiel an.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

Sie können also aus der Tabelle ersehen, dass das einzige Bit, das sie gemeinsam nutzen, das 8-Bit ist.

Zweites Beispiel

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

Die zwei gemeinsam genutzten Bits sind 32 und 4, die zusammen 36 ergeben.

Der Operator "Oder": |

$a =  9;
$b = 10;
echo $a | $b;

Dies würde die Nummer 11 ausgeben. Warum?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

Sie werden feststellen, dass in den Spalten 8, 2 und 1 3 Bits gesetzt sind. Addiere diese: 8 + 2 + 1 = 11.

<=> Raumschiffbetreiber

Hinzugefügt in PHP 7

Das Raumschiff Betreiber <=> ist der neueste Vergleichsoperator hinzugefügt in PHP 7.em Es ist ein nicht-assoziativer Binäroperators der gleichen Priorität wie Gleichheitsoperator ( ==, !=, ===, !==). Dieser Operator ermöglicht einen einfacheren Drei-Wege-Vergleich zwischen linken und rechten Operanden.

Der Operator führt zu einem ganzzahligen Ausdruck von:

• 0 wenn beide Operanden gleich sind
• Weniger als 0wenn der linke Operand kleiner als der rechte Operand ist
• Größer als 0wenn der linke Operand größer als der rechte Operand ist

z.B

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

Eine gute praktische Anwendung der Verwendung dieses Operators wären Rückrufe vom Vergleichstyp, von denen erwartet wird, dass sie eine Ganzzahl von Null, Negativ oder Positiv zurückgeben, basierend auf einem Drei-Wege-Vergleich zwischen zwei Werten. Die an übergebene Vergleichsfunktion usortist ein solches Beispiel.

Vor PHP 7 würden Sie schreiben ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

Seit PHP 7 kann man schreiben ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});

_ Alias ​​für gettext ()

Der Unterstrich '_' wie in _()ist ein Alias ​​für die gettext()Funktion.

Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
x or y     Or              True if any of x or y are true x=6 y=3
                           (x < 10 or y > 10) returns true 
x || y     Or              True if any of x or y are true x=6 y=3
                           (x < 3 || y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"

Magische Konstanten : Obwohl dies nicht nur Symbole sind, sondern ein wichtiger Teil dieser Token-Familie. Es gibt acht magische Konstanten, die sich je nach Verwendungsort ändern.

__LINE__: Die aktuelle Zeilennummer der Datei.

__FILE__: Der vollständige Pfad und Dateiname der Datei. Bei Verwendung in einem Include wird der Name der enthaltenen Datei zurückgegeben. Seit PHP 4.0.2 __FILE__enthält es immer einen absoluten Pfad mit aufgelösten Symlinks, während es in älteren Versionen unter bestimmten Umständen einen relativen Pfad enthielt.

__DIR__: Das Verzeichnis der Datei. Bei Verwendung in einem Include wird das Verzeichnis der enthaltenen Datei zurückgegeben. Dies entspricht dirname(__FILE__). Dieser Verzeichnisname hat keinen abschließenden Schrägstrich, es sei denn, es handelt sich um das Stammverzeichnis. (Hinzugefügt in PHP 5.3.0.)

__FUNCTION__: Der Funktionsname. (Hinzugefügt in PHP 4.3.0) Ab PHP 5 gibt diese Konstante den Funktionsnamen zurück, wie er deklariert wurde (Groß- und Kleinschreibung beachten). In PHP 4 wird der Wert immer in Kleinbuchstaben angegeben.

__CLASS__: Der Klassenname. (Hinzugefügt in PHP 4.3.0) Ab PHP 5 gibt diese Konstante den Klassennamen zurück, wie er deklariert wurde (Groß- und Kleinschreibung beachten). In PHP 4 wird der Wert immer in Kleinbuchstaben angegeben. Der Klassenname enthält den Namespace, in dem er deklariert wurde (z Foo\Bar. B. ). Beachten Sie, dass ab PHP 5.4 __CLASS__auch in Eigenschaften funktioniert. Bei Verwendung in einer Trait-Methode __CLASS__ist dies der Name der Klasse, in der das Trait verwendet wird.

__TRAIT__: Der Name des Merkmals. (Hinzugefügt in PHP 5.4.0) Ab PHP 5.4 gibt diese Konstante das deklarierte Merkmal zurück (Groß- und Kleinschreibung beachten). Der Merkmalname enthält den Namespace, in dem er deklariert wurde (z Foo\Bar. B. ).

__METHOD__: Der Name der Klassenmethode. (Hinzugefügt in PHP 5.0.0) Der Methodenname wird so zurückgegeben, wie er deklariert wurde (Groß- und Kleinschreibung beachten).

__NAMESPACE__: Der Name des aktuellen Namespace (Groß- und Kleinschreibung beachten). Diese Konstante wird in der Kompilierungszeit definiert (hinzugefügt in PHP 5.3.0).

Quelle

Typ Operatoren

instanceof wird verwendet, um zu bestimmen, ob eine PHP-Variable ein instanziiertes Objekt einer bestimmten Klasse ist.

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

Das obige Beispiel gibt Folgendes aus:

bool(true)
bool(false)

Grund: Das obige Beispiel $aist ein Objekt von mclass, verwenden Sie also nur eine mclassDateninstanz vonsclass

Beispiel mit Vererbung

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

Das obige Beispiel gibt Folgendes aus:

bool(true)
bool(true)

Beispiel mit Klon

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

Das obige Beispiel gibt Folgendes aus:

bool(true)
bool(true)

Ein Überblick über Operatoren in PHP :

Logische Operatoren:

• $ a && $ b: WAHR, wenn sowohl $ a als auch $ b WAHR sind.
• $ a || $ b: TRUE, wenn entweder $ a oder $ b TRUE ist.
• $ a xor $ b: TRUE, wenn entweder $ a oder $ b TRUE ist, aber nicht beide.
• ! $ a: WAHR, wenn $ a nicht WAHR ist.
• $ a und $ b: TRUE, wenn sowohl $ a als auch $ b TRUE sind.
• $ a oder $ b: WAHR, wenn entweder $ a oder $ b WAHR ist.

Vergleichsoperatoren:

• $ a == $ b: TRUE, wenn $ a nach dem Jonglieren gleich $ b ist.
• $ a === $ b: TRUE, wenn $ a gleich $ b ist und sie vom gleichen Typ sind.
• $ a! = $ b: TRUE, wenn $ a nach dem Jonglieren nicht gleich $ b ist.
• $ a <> $ b: TRUE, wenn $ a nach dem Jonglieren nicht gleich $ b ist.
• $ a! == $ b: TRUE, wenn $ a nicht gleich $ b ist oder sie nicht vom gleichen Typ sind.
• $ a <$ b : WAHR, wenn $ a streng kleiner als $ b ist.
• $ a> $ b : WAHR, wenn $ a streng größer als $ b ist.
• $ a <= $ b : TRUE, wenn $ a kleiner oder gleich $ b ist.
• $ a> = $ b : TRUE, wenn $ a größer oder gleich $ b ist.
• $ a <=> $ b : Eine Ganzzahl kleiner, gleich oder größer als Null, wenn $ a kleiner, gleich oder größer als $ b ist. Verfügbar ab PHP 7.
• $ a? $ b: $ c : wenn $ a return $ b sonst $ c zurückgibt ( ternärer Operator )
• $ a ?? $ c : Wie $ a? $ a: $ c ( Null-Koaleszenz-Operator - erfordert PHP> = 7)

Rechenzeichen:

• - $ a : Gegenüber von $ a.
• $ a + $ b : Summe von $ a und $ b.
• $ a - $ b : Differenz von $ a und $ b.
• $ a * $ b : Produkt von $ a und $ b.
• $ a / $ b : Quotient aus $ a und $ b.
• $ a% $ b : Rest von $ a geteilt durch $ b.
• $ a ** $ b : Ergebnis der Erhöhung von $ a auf die $ b'-te Potenz (eingeführt in PHP 5.6)

Inkrementieren / Dekrementieren von Operatoren:

• ++ $ a : Inkrementiert $ a um eins und gibt dann $ a zurück.
• $ a ++ : Gibt $ a zurück und erhöht dann $ a um eins.
• - $ a : Dekrementiert $ a um eins und gibt dann $ a zurück.
• $ a-- : Gibt $ a zurück und dekrementiert dann $ a um eins.

Bitweise Operatoren:

• $ a & $ b : Bits, die sowohl in $ a als auch in $ b gesetzt sind, werden gesetzt.
• $ a | $ b : Bits, die entweder in $ a oder $ b gesetzt sind, werden gesetzt.
• $ a ^ $ b : Bits, die in $ a oder $ b gesetzt sind, aber nicht beide, werden gesetzt.
• ~ $ a : Bits, die in $ a gesetzt sind, werden nicht gesetzt und umgekehrt.
• $ a << $ b : Verschieben Sie die Bits von $ a $ b Schritten nach links (jeder Schritt bedeutet "mit zwei multiplizieren").
• $ a >> $ b : Verschieben Sie die Bits von $ a $ b Schritten nach rechts (jeder Schritt bedeutet "durch zwei teilen").

String-Operatoren:

• $ a. $ b : Verkettung von $ a und $ b.

Array-Operatoren:

• $ a + $ b : Vereinigung von $ a und $ b.
• $ a == $ b : TRUE, wenn $ a und $ b dieselben Schlüssel / Wert-Paare haben.
• $ a === $ b : TRUE, wenn $ a und $ b dieselben Schlüssel / Wert-Paare in derselben Reihenfolge und vom selben Typ haben.
• $ a! = $ b : WAHR, wenn $ a nicht gleich $ b ist.
• $ a <> $ b : TRUE, wenn $ a nicht gleich $ b ist.
• $ a! == $ b : WAHR, wenn $ a nicht mit $ b identisch ist.

Zuweisungsoperatoren:

• $ a = $ b : Der Wert von $ b wird $ a zugewiesen
• $ a + = $ b : Wie $ a = $ a + $ b
• $ a - = $ b : Wie $ a = $ a - $ b
• $ a * = $ b : Wie $ a = $ a * $ b
• $ a / = $ b : Wie $ a = $ a / $ b
• $ a% = $ b : Wie $ a = $ a% $ b
• $ a ** = $ b : Wie $ a = $ a ** $ b
• $ a. = $ b : Wie $ a = $ a. $ b
• $ a & = $ b : Wie $ a = $ a & $ b
• $ a | = $ b : Wie $ a = $ a | $ b
• $ a ^ = $ b : Wie $ a = $ a ^ $ b
• $ a << = $ b : Wie $ a = $ a << $ b
• $ a >> = $ b : Wie $ a = $ a >> $ b

Hinweis

andOperator und orOperator haben eine niedrigere Priorität als Zuweisungsoperator =.

Dies bedeutet, dass dies $a = true and false;äquivalent zu ist ($a = true) and false.

In den meisten Fällen möchten Sie wahrscheinlich &&und verwenden ||, die sich in einer Weise verhalten, die aus Sprachen wie C, Java oder JavaScript bekannt ist.

Raumschiff-Operator<=> (hinzugefügt in PHP 7)

Beispiele für <=>Raumschiffbetreiber (PHP 7, Quelle: PHP-Handbuch):

Ganzzahlen, Gleitkommazahlen, Zeichenfolgen, Arrays und Objekte für den Drei-Wege-Vergleich von Variablen.

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
// Comparison is case-sensitive
echo "B" <=> "a"; // -1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1

{} Geschweifte Klammern

• Blöcke - geschweifte Klammern / keine geschweiften Klammern?
• Geschweifte Klammern in der Zeichenfolge in PHP
• PHP geschweifte Klammern in Array-Notation

Und ein paar Worte zum letzten Beitrag

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works

Null-Koaleszenz-Operator (??)

Dieser Operator wurde in PHP 7.0 für den allgemeinen Fall hinzugefügt, dass ein ternärer Operator in Verbindung mit verwendet werden muss isset(). Es gibt seinen ersten Operanden zurück, wenn er existiert und nicht NULL; Andernfalls wird der zweite Operand zurückgegeben.

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

PHP-Strings: PHP-Strings können auf vier Arten angegeben werden, nicht nur auf zwei Arten:

1) Zeichenfolgen in einfachen Anführungszeichen:

$string = 'This is my string'; // print This is my string

2) Doppelte Anführungszeichen:

$str = 'string';

$string = "This is my $str"; // print This is my string

3) Heredoc:

$string = <<<EOD
This is my string
EOD; // print This is my string

4) Nowdoc (seit PHP 5.3.0):

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string

FRAGE:

Was heißt =>das

ANTWORTEN:

=>Ist das Symbol, das wir Menschen verwenden, um "Key" => "Value"Paare in assoziativen Arrays zu trennen .

AUSARBEITEN:

Um dies zu verstehen, müssen wir wissen, was assoziative Arrays sind. Das erste, was auftaucht, wenn ein herkömmlicher Programmierer an ein Array ( in PHP ) denkt , ist etwas Ähnliches wie:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

Wenn wir das Array in einem späteren Teil des Codes aufrufen möchten, können wir Folgendes tun:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

So weit, ist es gut. Als Mensch fällt es uns jedoch möglicherweise schwer, uns daran zu erinnern, dass der Index [0]des Arrays der Wert des Jahres 2016 ist, der Index [1]des Arrays eine Begrüßung und der Index [2]des Arrays ein einfacher ganzzahliger Wert . Die Alternative wäre dann, ein sogenanntes assoziatives Array zu verwenden . Ein assoziatives Array weist einige Unterschiede zu einem sequentiellen Array auf ( wie es in den vorherigen Fällen der Fall war, da sie den in einer vorgegebenen Sequenz verwendeten Index erhöhen, indem sie für jeden folgenden Wert um 1 inkrementieren ).

Unterschiede ( zwischen einem sequentiellen und einem assoziativen Array ):

• Während der Deklaration eines assoziativen Arrays geben Sie nicht nur das valuean, was Sie in das Array einfügen möchten, sondern auch den Indexwert (genannt key), den Sie beim Aufrufen des Arrays in späteren Teilen des Arrays verwenden möchten Code. Die folgende Syntax wird während der Deklaration verwendet : "key" => "value".

• Bei Verwendung des assoziativen Arrays wird der keyWert dann in den Index des Arrays eingefügt, um das gewünschte Ergebnis abzurufen value.

Zum Beispiel:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

Um nun dieselbe Ausgabe wie zuvor zu erhalten, wird der keyWert im Arrays-Index verwendet:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

SCHLUSSPUNKT:

Aus dem obigen Beispiel ist ziemlich leicht ersichtlich, dass das =>Symbol verwendet wird, um die Beziehung eines assoziativen Arrays zwischen jedem der keyund valuePaare in einem Array während der Initiierung der Werte innerhalb des Arrays auszudrücken .

Frage :

Was bedeutet "&" hier in PHP?

PHP "&" Operator

Erleichtert das Leben, sobald wir uns daran gewöhnt haben. (Beispiel unten sorgfältig prüfen.)

& prüft normalerweise, ob Bits gesetzt sind, die sowohl in $ a als auch in $ b gesetzt sind.

Haben Sie überhaupt bemerkt, wie diese Anrufe funktionieren?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

Hinter allem steht also das Spiel des bitweisen Operators und der Bits.

Ein nützlicher Fall hierfür sind einfache Konfigurationen wie unten angegeben, sodass in einem einzelnen Ganzzahlfeld Tausende von Combos für Sie gespeichert werden können.

Die meisten Leute haben die Dokumente bereits gelesen, aber den realen Anwendungsfall dieser bitweisen Operatoren nicht überprüft.

Beispiel, das du lieben wirst

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird

== wird zur Überprüfung der Gleichheit ohne Berücksichtigung des variablen Datentyps verwendet

===wird für die Prüfung der Gleichstellung für verwendet sowohl den variablen Wert und Datentyp

Beispiel

$a = 5

1. if ($a == 5) - wird als wahr bewertet

2. if ($a == '5') - wird als wahr ausgewertet, da PHP beim Vergleichen dieser beiden Werte diesen Zeichenfolgenwert intern in eine Ganzzahl konvertiert und dann beide Werte vergleicht

3. if ($a === 5) - wird als wahr bewertet

4. if ($a === '5') - wird als falsch ausgewertet, da der Wert 5 ist, dieser Wert 5 jedoch keine Ganzzahl ist.

Null Coalesce Operator "??" (Hinzugefügt in PHP 7)

Nicht der eingängigste Name für einen Operator, aber PHP 7 bringt die ziemlich praktische Null-Koaleszenz mit sich, also dachte ich, ich würde ein Beispiel teilen.

In PHP 5 haben wir bereits einen ternären Operator, der einen Wert testet und dann das zweite Element zurückgibt, wenn dies true zurückgibt, und das dritte, wenn dies nicht der Fall ist:

echo $count ? $count : 10; // outputs 10

Es gibt auch eine Abkürzung für das, mit der Sie das zweite Element überspringen können, wenn es mit dem ersten identisch ist: echo $ count ?: 10; // gibt auch 10 aus

In PHP 7 bekommen wir zusätzlich die ?? Operator, der es uns ermöglicht, eine Reihe von Werten miteinander zu verketten, anstatt extreme Verwirrung anzuzeigen, wie ich normalerweise zwei Fragezeichen zusammen verwenden würde. Beim Lesen von links nach rechts ist der erste Wert, der existiert und nicht null ist, der Wert, der zurückgegeben wird.

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

Dieses Konstrukt ist nützlich, um einem oder mehreren Werten Vorrang einzuräumen, die möglicherweise aus Benutzereingaben oder vorhandenen Konfigurationen stammen, und um sicher auf einen bestimmten Standard zurückzugreifen, wenn diese Konfiguration fehlt. Es ist eine kleine Funktion, aber ich weiß, dass ich sie verwenden werde, sobald meine Anwendungen auf PHP 7 aktualisiert werden.

Nullable Rückgabetypdeklaration

PHP 7 bietet Unterstützung für Rückgabetypdeklarationen. Ähnlich wie bei Argumenttypdeklarationen geben Rückgabetypdeklarationen den Werttyp an, der von einer Funktion zurückgegeben wird. Für Rückgabetypdeklarationen stehen dieselben Typen zur Verfügung wie für Argumenttypdeklarationen.

Die strikte Eingabe wirkt sich auch auf Rückgabetypdeklarationen aus. Im schwachen Standardmodus werden zurückgegebene Werte auf den richtigen Typ gezwungen, wenn sie nicht bereits von diesem Typ sind. Im starken Modus muss der zurückgegebene Wert vom richtigen Typ sein, andernfalls wird ein TypeError ausgelöst.

Ab PHP 7.1.0 können Rückgabewerte als nullwert markiert werden, indem dem Typnamen ein Fragezeichen (?) Vorangestellt wird. Dies bedeutet, dass die Funktion entweder den angegebenen Typ oder NULL zurückgibt.

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

Quelle

Drei DOTS als Splat-Operator (...) (seit PHP 5.6)

PHP hat einen Operator "..." (drei Punkte), der als Splat-Operator bezeichnet wird. Es wird verwendet, um eine beliebige Anzahl von Parametern in einer Funktion zu übergeben, und diese Art von Funktion wird als Variadic Functions bezeichnet. Nehmen wir Beispiele für die Verwendung von "..." (drei Punkte).

Beispiel 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

echo calculateNumbers(10, 20, 30, 40, 50);

//Output 150
?>

Jedes Argument der Funktion berechneNummern () durchläuft $ params als Array, wenn "..." verwendet wird.

Es gibt viele verschiedene Möglichkeiten, den Operator "..." zu verwenden. Nachfolgend einige Beispiele:

Beispiel 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}

$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);

//Output 150
?>

Beispiel 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);

//Output 220
?>

Beispiel 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);

//Output 1650

?>

? -> NullSafe Operator

Im Moment ist es nur ein Vorschlag, den Sie hier finden können . Es wird zurückgegeben NullSafe Operator, nullwenn Sie versuchen, Funktionen aufzurufen oder Werte von null... zu erhalten. Beispiel

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object

NullSafe Operator "? ->" (möglicherweise) seit php8

Im Moment ist es nur ein Vorschlag. Den Link finden Sie hier . ?->Es ist das NullSafe Operator, es wird zurückgegeben, nullwenn Sie versuchen, Funktionen aufzurufen oder Werte von null...

Beispiele:

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>