Frage Referenz - Was bedeutet dieses Symbol in PHP?


Was ist das?

Dies ist eine Sammlung von Fragen, die sich ab und zu über Syntax in PHP stellen. Dies ist auch ein Community-Wiki, so dass jeder eingeladen wird, sich an der Pflege dieser Liste zu beteiligen.

Warum ist das?

Es war schwierig, Fragen zu Operatoren und anderen Syntax-Token zu stellen
Die Hauptidee besteht darin, Links zu bestehenden Fragen zu Stack Overflow zu haben, so dass es für uns einfacher ist, sie zu referenzieren, als Inhalte aus dem PHP-Handbuch zu kopieren.

¹ Hinweis: Seit Januar 2013 Stack Overflow unterstützt Sonderzeichen. Umschließen Sie die Suchbegriffe einfach mit Anführungszeichen, z. [php] "==" vs "==="

Was soll ich hier machen?

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

Die Liste

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


&  Bitweise Operatoren oder Verweise


=&  Verweise


&=  Bitweise Operatoren


&&  Logische Operatoren


%  Rechenzeichen


!!  Logische Operatoren


@  Fehlerkontrolloperatoren


?:  Ternärer Operator


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


:  Alternative Syntax für Kontrollstrukturen, Ternärer Operator


::  Umfang Auflösung Operator


\  Namespaces


->  Klassen und Objekte


=>  Arrays


^  Bitweise Operatoren


>>  Bitweise Operatoren


<<  Bitweise Operatoren


<<<  Heredoc oder Nowdoc


=  Zuweisungsoperatoren


==  Vergleichsoperatoren


===  Vergleichsoperatoren


!==  Vergleichsoperatoren


!=  Vergleichsoperatoren


<>  Vergleichsoperatoren


<=>  Vergleichsoperatoren (seit PHP 7.0)


|  Bitweise Operatoren


||  Logische Operatoren


~  Bitweise Operatoren


+  Rechenzeichen, Array-Operatoren


+= und -=  Zuweisungsoperatoren


++ und --  Inkrementieren / Dekrementieren von Operatoren


.=  Zuweisungsoperatoren


.  Stringoperatoren


,  Funktionsargumente

,  Variablendeklarationen


$$  Variable Variablen


`  Ausführungsoperator


<?=  Kurze offene Tags


[]  Arrays (kurze Syntax seit PHP 5.4)


<?  Öffnen und Schließen von Tags


...  Argument entpacken (seit PHP 5.6)


**  Potenzierung (seit PHP 5.6)


#  Einzeilen-Shell-Stil-Kommentar



3785


Ursprung


Antworten:


Inkrementieren / Dekrementieren von Operatoren

++ Operator inkrementieren

-- 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 sie vor die Variable gesetzt wird, wird die Inkrement / Dekrement-Operation für die Variable durchgeführt zuerst dann wird das Ergebnis zurückgegeben. Wenn hinter der Variable steht, ist die Variable zuerst zurückgegeben, dann ist die Inkrement / Dekrement-Operation abgeschlossen.

Beispielsweise:

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

Live-Beispiel

In dem obigen Fall ++$i wird verwendet, da es schneller ist. $i++ hätte die gleichen Ergebnisse.

Pre-Increment ist ein bisschen schneller, weil es die Variable inkrementiert und danach das Ergebnis zurückgibt. Post-Inkrement erzeugt eine spezielle Variable, kopiert dort den Wert der ersten Variablen und ersetzt erst nach der ersten Variable ihren Wert durch die zweite.

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

Sie können Buchstaben auch in PHP inkrementieren:

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

Einmal z ist erreicht aa ist der nächste und so weiter.

Beachten Sie, dass Zeichenvariablen zwar inkrementiert, aber nicht dekrementiert werden können und sogar nur einfache ASCII-Zeichen (a-z und A-Z) unterstützt werden.


Stack-Überlauf-Posts:


947



Bitweiser Operator

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

Was ist ein Byte? Ein Byte besteht aus 8 Bits und der höchste Wert eines Bytes ist 255, was bedeutet, dass jedes Bit gesetzt ist. Wir werden uns ansehen, warum der maximale Wert eines Bytes 255 ist.

-------------------------------------------
|      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)

Ein paar Beispiele zum besseren Verständnis

Der Operator "AND": &

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

Dies würde die Zahl 8 ausgeben. Warum? Sehen wir uns mal 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|
------------------------------------------- 

So können Sie von der Tabelle sehen, dass das einzige Bit, das sie zusammen teilen, 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 geteilten 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 bemerken, dass wir 3 Bits in den Spalten 8, 2 und 1 gesetzt haben. Fügen Sie diese hinzu: 8 + 2 + 1 = 11.


359



_  Alias ​​für gettext () 

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


224



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
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"

209



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

__LINE__: Die aktuelle Zeilennummer der Datei.

__FILE__: Der vollständige Pfad und Dateiname der Datei. Wenn es in einem Include verwendet wird, wird der Name der enthaltenen Datei zurückgegeben. Seit PHP 4.0.2, __FILE__ enthält 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. Wenn es in einem Include verwendet wird, wird das Verzeichnis der enthaltenen Datei zurückgegeben. Dies entspricht dirname(__FILE__). Dieser Verzeichnisname hat keinen nachgestellten Schrägstrich, es sei denn, es handelt sich um das Stammverzeichnis. (Hinzugefügt in PHP 5.3.0.)

__FUNCTION__: Der Funktionsname. (In PHP 4.3.0 hinzugefügt) Ab PHP 5 gibt diese Konstante den Funktionsnamen zurück, wie er deklariert wurde (Groß- / Kleinschreibung beachten). In PHP 4 ist der Wert immer kleiner.

__CLASS__: Der Klassenname. (In PHP 4.3.0 hinzugefügt) Ab PHP 5 gibt diese Konstante den Klassennamen zurück, wie er deklariert wurde (Groß- / Kleinschreibung beachten). In PHP 4 ist der Wert immer kleiner. Der Klassenname enthält den Namensraum, in dem er deklariert wurde (z. Foo\Bar). Beachten Sie, dass ab PHP 5.4 __CLASS__ funktioniert auch in Merkmalen. Wenn sie in einer Merkmalsmethode verwendet werden, __CLASS__ ist der Name der Klasse, in der das Merkmal verwendet wird.

__TRAIT__: Der Name des Merkmals. (In PHP 5.4.0 hinzugefügt) Ab PHP 5.4 gibt diese Konstante das Merkmal zurück, wie es deklariert wurde (Groß- / Kleinschreibung beachten). Der Merkmalname enthält den Namensraum, in dem er deklariert wurde (z. Foo\Bar).

__METHOD__: Der Name der Klassenmethode. (In PHP 5.0.0 hinzugefügt) Der Methodenname wird zurückgegeben, wie er deklariert wurde (Groß- / Kleinschreibung beachten).

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

Quelle


194



<=> Raumschiffbetreiber

Hinzugefügt in PHP 7

Das Raumschiffbetreiber  <=> ist der neueste Vergleichsoperator in PHP 7. Es ist ein nicht assoziativ binärer Operator mit der gleichen Priorität wie Gleichheitsoperatoren (==, !=, ===, !==). Dieser Operator ermöglicht einen einfacheren Dreiwegevergleich zwischen linken und rechten Operanden.

Der Operator ergibt einen ganzzahligen Ausdruck von:

  • 0 wenn beide Operanden gleich sind
  • Weniger als 0 wenn der linke Operand kleiner als der rechte Operand ist
  • Größer als 0 wenn 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äre in Callbacks vom Vergleichstyp, von denen erwartet wird, dass sie eine Null-, eine negative oder eine positive Ganzzahl basierend auf einem Dreiwegevergleich zwischen zwei Werten zurückgeben. Die Vergleichsfunktion wurde an übergeben usort ist ein solches Beispiel.

Vor PHP 7 würdest du 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 kannst du schreiben ...

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

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

188



Geben Sie Operatoren ein

instanceof wird verwendet, um festzustellen, 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 wird ausgeben:

bool(true)
bool(false)

Grund: Oberes Beispiel $a ist ein Objekt der mclass also benutze nur ein mclass Daten nicht Instanz von mit dem sclass

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 wird ausgeben:

bool(true)
bool(true)

Beispiel mit Klonen

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

Das obige Beispiel wird ausgeben:

bool(true)
bool(true)

120



Ein Überblick über Operatoren in PHP:


Logische Operatoren:

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

Vergleichsoperatoren:

  • $ a == $ b: TRUE, wenn $ a nach dem Jonglieren mit dem Typ $ b übereinstimmt.
  • $ a === $ b: WAHR, wenn $ a gleich $ b ist und sie vom selben Typ sind.
  • $ a! = $ b: TRUE, wenn $ a nach dem Typ-Jonglieren ungleich $ b ist.
  • $ a <> $ b: TRUE, wenn $ a nach dem Typ-Jonglieren ungleich $ b ist.
  • $ a! == $ b: WAHR, wenn $ a ungleich $ b ist oder nicht vom selben Typ ist.
  • $ a <$ b : WAHR, wenn $ a streng kleiner als $ b ist.
  • $ a> $ b : WAHR, wenn $ a strikt größer als $ b ist.
  • $ a <= $ b : WAHR, wenn $ a kleiner oder gleich $ b ist.
  • $ a> = $ b : WAHR, wenn $ a größer oder gleich $ b ist.
  • $ a <=> $ b : Eine ganze Zahl kleiner als, gleich oder größer als null, wenn $ a jeweils kleiner als, gleich oder größer als $ b ist. Verfügbar ab PHP 7.
  • $ a? $ b: $ c : Wenn $ a return $ b sonst gibt $ c zurück (ternärer Betreiber)
  • $ a ?? $ c : Wie $ a? $ a: $ c (null Koaleszenzoperator - benötigt 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 von $ a und $ b.
  • $ a% $ b : Rest von $ a geteilt durch $ b.
  • $ a ** $ b : Ergebnis der Erhöhung von $ a zu $ ​​b'th power (eingeführt in PHP 5.6)

Inkrementieren / Dekrementieren von Operatoren:

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

Bitweise Operatoren:

  • $ a & $ b : Bits, die in $ a und $ 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, sind gesetzt.
  • ~ $ a : Bits, die in $ a gesetzt sind, werden nicht gesetzt und umgekehrt.
  • $ a << $ b : Verschiebe die Bits von $ a $ b Schritten nach links (jeder Schritt bedeutet "multiplizieren mit zwei")
  • $ a >> $ b : Verschiebe die Bits von $ a $ b Schritten nach rechts (jeder Schritt bedeutet "dividiere durch zwei")

Stringoperatoren:

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

Array-Operatoren:

  • $ a + $ b: Union von $ a und $ b.
  • $ a == $ b : TRUE, wenn $ a und $ b die gleichen Schlüssel / Wert-Paare haben.
  • $ a === $ b : TRUE, wenn $ a und $ b dieselben Schlüssel / Wert-Paare in der gleichen Reihenfolge und vom gleichen Typ haben.
  • $ a! = $ b : TRUE, 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

and Betreiber und or Der Operator hat eine niedrigere Priorität als der Zuweisungsoperator =.

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

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


96



Raumschiffbetreiber <=> (Hinzugefügt in PHP 7)

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

Integer, Floats, Strings, 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

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

72



{} Geschweifte Klammern

Und ein paar Worte zum letzten Post

$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

55