PHP
Operatoren

Einführung

Bemerkungen

String-Operatoren (. Und. =)

Es gibt nur zwei Zeichenfolgenoperatoren:

• Verkettung zweier Strings (Punkt):

  $a = "a";
  $b = "b";
  $c = $a . $b; // $c => "ab"
  

• Verkettung der Zuweisung (Punkt =):

  $a = "a";
  $a .= "b"; // $a => "ab"
  

Grundaufgabe (=)

$a = "some string";

führt dazu, dass $a den Wert some string .

Das Ergebnis eines Zuweisungsausdrucks ist der zugewiesene Wert. Beachten Sie, dass ein einzelnes Gleichheitszeichen = NICHT zum Vergleich ist!

$a = 3;
$b = ($a = 5);

macht folgendes:

1. Zeile 1 weist 3 bis $a .
2. Zeile 2 weist 5 $a . Dieser Ausdruck ergibt ebenfalls den Wert 5 .
3. Zeile 2 weist dann das Ergebnis des Ausdrucks in Klammern ( 5 ) $b .

Also: Sowohl $a als auch $b jetzt den Wert 5 .

Kombinierte Zuordnung (+ = etc)

Die kombinierten Zuweisungsoperatoren sind eine Abkürzung für eine Operation mit einer Variablen und weisen diesen neuen Wert anschließend dieser Variablen zu.

Arithmetik:

$a = 1;   // basic assignment
$a += 2; // read as '$a = $a + 2'; $a now is (1 + 2) => 3
$a -= 1; // $a now is (3 - 1) => 2
$a *= 2; // $a now is (2 * 2) => 4
$a /= 2; // $a now is (16 / 2) => 8
$a %= 5; // $a now is (8 % 5) => 3 (modulus or remainder)

// array +
$arrOne = array(1);
$arrTwo = array(2);
$arrOne += $arrTwo;

Mehrere Arrays gemeinsam bearbeiten

$a **= 2; // $a now is (4 ** 2) => 16 (4 raised to the power of 2)

Kombinierte Verkettung und Zuweisung eines Strings:

$a = "a";
$a .= "b"; // $a => "ab"

Kombinierte binäre bitweise Zuweisungsoperatoren:

$a = 0b00101010;  // $a now is 42
$a &= 0b00001111; // $a now is (00101010 & 00001111) => 00001010 (bitwise and)
$a |= 0b00100010; // $a now is (00001010 | 00100010) => 00101010 (bitwise or)
$a ^= 0b10000010; // $a now is (00101010 ^ 10000010) => 10101000 (bitwise xor)
$a >>= 3;         // $a now is (10101000 >> 3) => 00010101 (shift right by 3)
$a <<= 1;         // $a now is (00010101 << 1) => 00101010 (shift left by 1)

Ändern der Operatorrangfolge (mit Klammern)

Die Reihenfolge, in der Operatoren ausgewertet werden, wird von der Operatorrangfolge bestimmt (siehe auch Abschnitt "Bemerkungen").

Im

$a = 2 * 3 + 4;

$a erhält einen Wert von 10, da zuerst 2 * 3 ausgewertet wird (Multiplikation hat Vorrang vor Addition), was ein Unterergebnis von 6 + 4 ergibt, was 10 entspricht.

Der Vorrang kann mit Klammern geändert werden: in

$a = 2 * (3 + 4);

$a erhält den Wert 14, da zuerst (3 + 4) ausgewertet wird.

Verband

Linke Vereinigung

Wenn der Vorrang zweier Operatoren gleich ist, bestimmt die Assoziativität die Gruppierung (siehe auch den Abschnitt "Bemerkungen"):

$a = 5 * 3 % 2; // $a now is (5 * 3) % 2 => (15 % 2) => 1

* und % haben gleiche Priorität und linke Assoziativität. Da die Multiplikation zuerst auftritt (links), wird sie gruppiert.

$a = 5 % 3 * 2; // $a now is (5 % 3) * 2 => (2 * 2) => 4

Nun tritt der Modulus-Operator zuerst (links) auf und ist somit gruppiert.

Richtige Vereinigung

$a = 1;
$b = 1;
$a = $b += 1;

Sowohl $a als auch $b jetzt den Wert 2 da $b += 1 gruppiert ist und das Ergebnis ( $b ist 2 ) $a zugewiesen wird.

Vergleichsoperatoren

Gleichberechtigung

Für grundlegende Gleichheitstests wird der Gleichheitsoperator == verwendet. Für umfassendere Überprüfungen verwenden Sie den identischen Operator === .

Der identische Operator funktioniert genauso wie der Equal-Operator. Er verlangt, dass seine Operanden denselben Wert haben, aber auch, dass sie denselben Datentyp haben.

Im Beispiel unten wird beispielsweise "a und b sind gleich" angezeigt, nicht jedoch "a und b sind identisch".

$a = 4;
$b = '4';
if ($a == $b) {
    echo 'a and b are equal'; // this will be printed
}
if ($a === $b) {
    echo 'a and b are identical'; // this won't be printed
}

Bei Verwendung des Gleichheitsoperators werden numerische Zeichenfolgen in Ganzzahlen umgewandelt.

Vergleich von Objekten

=== vergleicht zwei Objekte, indem geprüft wird, ob sie genau dieselbe Instanz sind . Das bedeutet, dass new stdClass() === new stdClass() zu false aufgelöst wird, auch wenn sie auf dieselbe Weise erstellt werden (und dieselben Werte haben).

== vergleicht zwei Objekte, indem sie rekursiv überprüft, ob sie gleich sind ( Deep Equals ). Das heißt für $a == $b , wenn $a und $b sind:

1. derselben Klasse
2. haben die gleichen Eigenschaften, einschließlich dynamischer Eigenschaften
3. Für jede Eigenschaft $property set ist $a->property == $b->property true (daher rekursiv geprüft).

Andere häufig verwendete Operatoren

Sie beinhalten:

1. Größer als ( > )
2. Kleiner als ( < )
3. Größer als oder gleich ( >= )
4. Weniger als oder gleich ( <= )
5. Nicht gleich ( != )
6. Nicht identisch mit ( !== )

1. Größer als: $a > $b , gibt true , wenn $a ‚s - Wert größer als von $b , sonst false zurück.

Beispiel :

var_dump(5 > 2); // prints bool(true)
var_dump(2 > 7); // prints bool(false)

2. Lesser als: $a < $b , gibt true , wenn $a ‚s - Wert kleinen , dass von $b , sonst false zurück.

Beispiel :

var_dump(5 < 2); // prints bool(false)
var_dump(1 < 10); // prints bool(true)

3. Größer - als - oder - gleich: $a >= $b , gibt true , wenn $a ‚s - Wert entweder größer als von $b oder gleich $b , sonst kehrt false .

Beispiel :

var_dump(2 >= 2); // prints bool(true)
var_dump(6 >= 1); // prints bool(true)
var_dump(1 >= 7); // prints bool(false)

4. Kleiner als oder gleich: $a <= $b , gibt true , wenn $a ‚s - Wert ist entweder kleiner als von $b oder gleich $b , sonst kehrt false .

Beispiel :

var_dump(5 <= 5); // prints bool(true)
var_dump(5 <= 8); // prints bool(true)
var_dump(9 <= 1); // prints bool(false)

5/6. Nicht gleich / identisch mit: Um das vorherige Beispiel zur Gleichheit erneut aufzuwärmen, wird im folgenden Beispiel 'a und b sind nicht identisch' angezeigt, nicht jedoch 'a und b sind nicht gleich'.

$a = 4;
$b = '4';
if ($a != $b) {
    echo 'a and b are not equal'; // this won't be printed
}
if ($a !== $b) {
    echo 'a and b are not identical'; // this will be printed
}

Raumschiffbetreiber (<=>)

PHP 7 führt eine neue Art von Operator ein, mit dem Ausdrücke verglichen werden können. Dieser Operator gibt -1, 0 oder 1 zurück, wenn der erste Ausdruck kleiner als, gleich oder größer als der zweite Ausdruck ist.

// Integers
print (1 <=> 1); // 0
print (1 <=> 2); // -1
print (2 <=> 1); // 1

// Floats
print (1.5 <=> 1.5); // 0
print (1.5 <=> 2.5); // -1
print (2.5 <=> 1.5); // 1
 
// Strings
print ("a" <=> "a"); // 0
print ("a" <=> "b"); // -1
print ("b" <=> "a"); // 1

Objekte sind nicht vergleichbar, und dies führt zu undefiniertem Verhalten.

Dieser Operator ist besonders nützlich, wenn Sie eine benutzerdefinierte Vergleichsfunktion mit usort , uasort oder uksort . Wenn ein Array von Objekten nach ihrer weight Eigenschaft sortiert wird, kann eine anonyme Funktion beispielsweise <=> , um den von den Sortierfunktionen erwarteten Wert zurückzugeben.

usort($list, function($a, $b) { return $a->weight <=> $b->weight; });

In PHP 5 hätte dies einen etwas aufwendigeren Ausdruck erfordert.

usort($list, function($a, $b) {
    return $a->weight < $b->weight ? -1 : ($a->weight == $b->weight ? 0 : 1);
});

Null-Koaleszenz-Operator (??)

Null-Koaleszenz ist ein neuer Operator, der in PHP 7 eingeführt wurde. Dieser Operator gibt den ersten Operanden zurück, wenn er gesetzt ist und nicht NULL . Andernfalls wird der zweite Operand zurückgegeben.

Das folgende Beispiel:

$name = $_POST['name'] ?? 'nobody';

ist gleichbedeutend mit beiden:

if (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

und:

$name = isset($_POST['name']) ? $_POST['name'] : 'nobody'; 

Dieser Operator kann auch verkettet werden (mit rechtsassoziativer Semantik):

$name = $_GET['name'] ?? $_POST['name'] ?? 'nobody';

Welches ist ein Äquivalent zu:

if (isset($_GET['name'])) {
    $name = $_GET['name'];
} elseif (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

Hinweis:
Bei der Verwendung des Koaleszenzoperators für die Verkettung von Zeichenfolgen sollten Sie die Verwendung von Klammern () nicht vergessen.

$firstName = "John";
$lastName = "Doe";
echo $firstName ?? "Unknown" . " " . $lastName ?? "";

Dies gibt nur John , und wenn $ firstName null ist und $ lastName Doe , wird Unknown Doe ausgegeben. Um John Doe auszugeben, müssen wir solche Klammern verwenden.

$firstName = "John";
$lastName = "Doe";
echo ($firstName ?? "Unknown") . " " . ($lastName ?? "");

Dadurch wird John Doe anstelle von John ausgegeben.

Instanz von (Typoperator)

Um zu überprüfen, ob ein Objekt einer bestimmten Klasse angehört, kann die (binäre) instanceof Operators ab PHP Version 5 verwendet werden.

Der erste (linke) Parameter ist das zu testende Objekt. Wenn diese Variable kein Objekt ist, gibt instanceof immer false . Wenn ein konstanter Ausdruck verwendet wird, wird ein Fehler ausgegeben.

Der zweite (rechte) Parameter ist die zu vergleichende Klasse. Die Klasse kann als Klassenname selbst bereitgestellt werden, eine Stringvariable, die den Klassennamen enthält (keine Stringkonstante!) Oder ein Objekt dieser Klasse.

class MyClass {
}

$o1 = new MyClass();
$o2 = new MyClass();
$name = 'MyClass';

// in the cases below, $a gets boolean value true
$a = $o1 instanceof MyClass;
$a = $o1 instanceof $name;
$a = $o1 instanceof $o2;

// counter examples:
$b = 'b';
$a = $o1 instanceof 'MyClass'; // parse error: constant not allowed
$a = false instanceof MyClass; // fatal error: constant not allowed
$a = $b instanceof MyClass;    // false ($b is not an object)

instanceof kann auch verwendet werden, um zu prüfen, ob ein Objekt einer Klasse angehört, die eine andere Klasse erweitert oder eine Schnittstelle implementiert:

interface MyInterface {
}

class MySuperClass implements MyInterface {
}

class MySubClass extends MySuperClass {
}

$o = new MySubClass();

// in the cases below, $a gets boolean value true    
$a = $o instanceof MySubClass;
$a = $o instanceof MySuperClass;
$a = $o instanceof MyInterface;

Um zu prüfen, ob ein Objekt keiner Klasse angehört, kann der Operator not ( ! ) Verwendet werden:

class MyClass {
}

class OtherClass {
}

$o = new MyClass();
$a = !$o instanceof OtherClass; // true

Beachten Sie, dass Klammern um $o instanceof MyClass nicht erforderlich sind, da instanceof höhere Priorität hat als ! , obwohl es den Code mit Klammern besser lesbar machen kann.

Vorsichtsmaßnahmen

Wenn keine Klasse vorhanden ist, werden die registrierten Autoload-Funktionen aufgerufen, um zu versuchen, die Klasse zu definieren (dies ist ein Thema, das außerhalb des Geltungsbereichs dieses Teils der Dokumentation liegt!). In PHP-Versionen vor 5.1.0 würde der Operator instanceof auch diese Aufrufe auslösen und somit die Klasse definieren (und wenn die Klasse nicht definiert werden könnte, würde ein schwerwiegender Fehler auftreten). Um dies zu vermeiden, verwenden Sie eine Zeichenfolge:

// only PHP versions before 5.1.0!
class MyClass {
}

$o = new MyClass();
$a = $o instanceof OtherClass; // OtherClass is not defined!
// if OtherClass can be defined in a registered autoloader, it is actually
// loaded and $a gets boolean value false ($o is not a OtherClass)
// if OtherClass can not be defined in a registered autoloader, a fatal
// error occurs.

$name = 'YetAnotherClass';
$a = $o instanceof $name; // YetAnotherClass is not defined!
// $a simply gets boolean value false, YetAnotherClass remains undefined.

Ab PHP Version 5.1.0 werden die registrierten Autoloader in diesen Situationen nicht mehr aufgerufen.

Ältere PHP-Versionen (vor 5.0)

In älteren PHP-Versionen (vor 5.0) kann mit der Funktion is_a festgestellt werden, ob ein Objekt von einer Klasse ist. Diese Funktion wurde in PHP Version 5 nicht mehr unterstützt und in PHP Version 5.3.0 nicht erkannt.

Ternärer Betreiber (? :)

Der ternäre Operator kann als Inline- if Anweisung verstanden werden. Es besteht aus drei Teilen. Der operator und zwei Ergebnisse. Die Syntax lautet wie folgt:

$value = <operator> ? <true value> : <false value>

Wenn der operator als true bewertet wird, wird der Wert im ersten Block zurückgegeben ( <true value> ). Andernfalls wird der Wert im zweiten Block zurückgegeben ( <false value> ). Da wir $value auf das Ergebnis unseres ternären Operators setzen, wird der zurückgegebene Wert gespeichert.

Beispiel:

$action = empty($_POST['action']) ? 'default' : $_POST['action'];

$action würde die Zeichenfolge 'default' enthalten 'default' wenn empty($_POST['action']) true" ist. Andernfalls würde es den Wert von $_POST['action'] .

Der Ausdruck (expr1) ? (expr2) : (expr3) Ausdruck1 (expr1) ? (expr2) : (expr3) wertet expr2 wenn expr1 als true ausgewertet wird, und expr3 wenn expr1 als false ausgewertet wird.

Es ist möglich, den mittleren Teil des ternären Operators wegzulassen. Ausdruck expr1 ?: expr3 gibt expr1 wenn expr1 als TRUE ausgewertet wird, andernfalls expr3 . ?: wird oft als Elvis- Operator bezeichnet.

Dies verhält sich wie der Null Coalescing Operator ?? , außer dem ?? erfordert, dass der linke Operand genau null während ?: versucht, den linken Operanden in einen Boolean-Wert aufzulösen, und prüfen, ob er in Boolean- false .

Beispiel:

function setWidth(int $width = 0){
    $_SESSION["width"] = $width ?: getDefaultWidth();
}

In diesem Beispiel akzeptiert setWidth einen width-Parameter oder einen Standardwert von 0, um den width-Sitzungswert zu ändern. Wenn $width 0 ist (wenn $width nicht angegeben ist), wodurch boolean false getDefaultWidth() wird, wird stattdessen der Wert von getDefaultWidth() verwendet. Die Funktion getDefaultWidth() wird nicht aufgerufen, wenn $width nicht in boolean false aufgelöst wurde.

Weitere Informationen zur Konvertierung von Variablen in Boolean finden Sie unter Types .

Inkrementieren (++) und Dekrementieren von Operatoren (-)

Variablen können mit ++ bzw. -- um 1 erhöht oder dekrementiert werden. Sie können Variablen vorangehen oder folgen und semantisch geringfügig variieren, wie unten gezeigt.

$i = 1;
echo $i; // Prints 1

// Pre-increment operator increments $i by one, then returns $i
echo ++$i; // Prints 2

// Pre-decrement operator decrements $i by one, then returns $i
echo --$i; // Prints 1

// Post-increment operator returns $i, then increments $i by one
echo $i++; // Prints 1 (but $i value is now 2)

// Post-decrement operator returns $i, then decrements $i by one
echo $i--; // Prints 2 (but $i value is now 1)

Weitere Informationen zum Inkrementieren und Dekrementieren von Operatoren finden Sie in der offiziellen Dokumentation .

Ausführungsoperator (``)

Der PHP-Ausführungsoperator besteht aus Backticks (``) und wird zum Ausführen von Shell-Befehlen verwendet. Die Ausgabe des Befehls wird zurückgegeben und kann daher in einer Variablen gespeichert werden.

// List files
$output = `ls`;
echo "<pre>$output</pre>";

Beachten Sie, dass der Ausführungsoperator und shell_exec() dasselbe Ergebnis liefern.

Logische Operatoren (&& / AND und || / OR)

In PHP gibt es zwei Versionen von logischen UND- und ODER-Operatoren.

Beachten Sie, dass && und || Operatoren haben höhere Priorität als and und or . Siehe Tabelle unten:

Aus diesem Grund ist es sicherer, && und || anstelle von and und or .

Bitweise Operatoren

Bitweise Operatoren voranstellen

Bitweise Operatoren sind wie logische Operatoren, werden jedoch pro Bit und nicht als boolescher Wert ausgeführt.

// bitwise NOT ~: sets all unset bits and unsets all set bits
printf("%'06b", ~0b110110); // 001001

Bitmasken-Bitmaskenoperatoren

Bitweises AND & : Ein Bit wird nur gesetzt, wenn es in beiden Operanden gesetzt ist

printf("%'06b", 0b110101 & 0b011001); // 010001

Bitweises ODER | : Ein Bit ist gesetzt, wenn es in einem oder beiden Operanden gesetzt ist

printf("%'06b", 0b110101 | 0b011001); // 111101

Bitweises XOR ^ : Ein Bit wird gesetzt, wenn es in einem Operanden und nicht in einem anderen Operanden gesetzt ist, dh nur, wenn sich dieses Bit in den beiden Operanden in einem anderen Zustand befindet

printf("%'06b", 0b110101 ^ 0b011001); // 101100

Beispielanwendungen von Bitmasken

Mit diesen Operatoren können Bitmasken bearbeitet werden. Zum Beispiel:

file_put_contents("file.log", LOCK_EX | FILE_APPEND);

Hier ist der | Operator wird verwendet, um die beiden Bitmasken zu kombinieren. Obwohl + die gleiche Wirkung hat, ist | hebt hervor, dass Sie Bitmasken kombinieren und nicht zwei normale Skalar-Ganzzahlen hinzufügen.

class Foo{
    const OPTION_A = 1;
    const OPTION_B = 2;
    const OPTION_C = 4;
    const OPTION_A = 8;

    private $options = self::OPTION_A | self::OPTION_C;

    public function toggleOption(int $option){
        $this->options ^= $option;
    }

    public function enable(int $option){
        $this->options |= $option; // enable $option regardless of its original state
    }

    public function disable(int $option){
        $this->options &= ~$option; // disable $option regardless of its original state,
                                    // without affecting other bits
    }

    /** returns whether at least one of the options is enabled */
    public function isOneEnabled(int $options) : bool{
        return $this->options & $option !== 0;
        // Use !== rather than >, because 
        // if $options is about a high bit, we may be handling a negative integer
    }

    /** returns whether all of the options are enabled */
    public function areAllEnabled(int $options) : bool{
        return ($this->options & $options) === $options;
        // note the parentheses; beware the operator precedence
    }
}

Dieses Beispiel (vorausgesetzt, die $option immer nur ein Bit) verwendet:

• Der Operator ^ , um Bitmasken bequem umzuschalten.
• die | um ein Bit zu setzen, wobei der ursprüngliche Zustand oder andere Bits vernachlässigt werden
• Der Operator ~ zum Konvertieren einer Ganzzahl mit nur einem gesetzten Bit in eine Ganzzahl mit nur einem nicht gesetzten Bit
• den & -Operator ein wenig mit den folgenden Eigenschaften von & :
  • Da &= mit einem gesetzten Bit nichts (1 & 1) === 1 ( (1 & 1) === 1 , (0 & 1) === 0 ), wird das (0 & 1) === 0 &= mit einer Ganzzahl mit nur einem nicht gesetzten Bit nur dieses Bit (0 & 1) === 0 , keine Auswirkungen auf andere Bits.
  • &= mit einem nicht gesetzten Bit setzt dieses Bit zurück ( (1 & 0) === 0 , (0 & 0) === 0 )
• Wenn Sie den Operator & mit einer anderen Bitmaske verwenden, werden alle anderen Bits weggefiltert, die nicht in dieser Bitmaske enthalten sind.
  • Wenn für die Ausgabe Bits gesetzt sind, bedeutet dies, dass eine der Optionen aktiviert ist.
  • Wenn für die Ausgabe alle Bits der Bitmaske gesetzt sind, bedeutet dies, dass alle Optionen in der Bitmaske aktiviert sind.

Denken Sie daran , dass diese Vergleichsoperatoren ( < > <= >= == === != !== <> <=> ) haben eine höhere Priorität als diese bitmask-Bitmaske Operatoren: ( | ^ & ). Da bitweise Ergebnisse häufig mit diesen Vergleichsoperatoren verglichen werden, ist dies eine häufige Gefahr.

Bitverschiebungsoperatoren

Bitweise Linksverschiebung << : Verschieben Sie alle Bits um die angegebene Anzahl von Schritten nach links (höherwertig) und verwerfen Sie die Bits, die die int-Größe überschreiten

<< $x ist äquivalent zum Aufheben der Einstellung der höchsten $x Bits und zum Multiplizieren mit der $x ten Potenz von 2

printf("%'08b", 0b00001011<< 2); // 00101100

assert(PHP_INT_SIZE === 4); // a 32-bit system
printf("%x, %x", 0x5FFFFFFF << 2, 0x1FFFFFFF << 4); // 7FFFFFFC, FFFFFFFF

Bitweise Verschiebung nach rechts >> : verwerfe die niedrigste Verschiebung und verschiebe die restlichen Bits nach rechts (weniger bedeutsam)

>> $x entspricht der Division durch die $x te Potenz von 2 und den nicht ganzzahligen Teil zu verwerfen

printf("%x", 0xFFFFFFFF >> 3); // 1FFFFFFF

Anwendungsbeispiele für Bitverschiebung:

Schnelle Division durch 16 (bessere Leistung als /= 16 )

$x >>= 4;

Bei 32-Bit-Systemen werden alle Bits in der Ganzzahl verworfen, und der Wert wird auf 0 gesetzt. Bei 64-Bit-Systemen werden die höchstwertigen 32 Bit aufgehoben und die niedrigsten beibehalten

$x = $x << 32 >> 32;

signifikante 32 Bits, entsprechend $x & 0xFFFFFFFF

Hinweis: In diesem Beispiel wird printf("%'06b") verwendet. Es gibt den Wert in 6 binären Ziffern aus.

Objekt- und Klassenoperatoren

Auf Mitglieder von Objekten oder Klassen kann mit dem Objektoperator ( -> ) und dem Klassenoperator ( :: zugegriffen werden.

class MyClass {
    public $a = 1;
    public static $b = 2;
    const C = 3;
    public function d() { return 4; }
    public static function e() { return 5; }
}

$object = new MyClass();
var_dump($object->a);   // int(1)
var_dump($object::$b);  // int(2)
var_dump($object::C);   // int(3)
var_dump(MyClass::$b);  // int(2)
var_dump(MyClass::C);   // int(3)
var_dump($object->d()); // int(4)
var_dump($object::d()); // int(4)
var_dump(MyClass::e()); // int(5)
$classname = "MyClass";
var_dump($classname::e()); // also works! int(5)

Beachten Sie, dass nach dem $object->a das $ nicht geschrieben werden sollte ( $object->a statt $object->$a ). Für den Klassenoperator ist dies nicht der Fall und das $ ist erforderlich. Für eine in der Klasse definierte Konstante wird das $ niemals verwendet.

Beachten Sie auch, dass var_dump(MyClass::d()); ist nur erlaubt, wenn die Funktion d() nicht auf das Objekt verweist:

class MyClass {
    private $a = 1;
    public function d() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump(MyClass::d());   // Error!

Dies führt zu einem schwerwiegenden PHP-Fehler: Nicht abgerufener Fehler: Verwendung von $ this, wenn es sich nicht im Objektkontext befindet

Diese Operatoren haben Assoziativität hinterlassen , die für die Verkettung verwendet werden kann:

class MyClass {
    private $a = 1;
    
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    
    public function get() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump($object->add(4)->get());  // int(5)

Diese Operatoren haben die höchste Priorität (sie werden im Handbuch nicht einmal erwähnt), sogar höher als der clone . Somit:

class MyClass {
    private $a = 0;
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    public function get() {
        return $this->a;
    }
}

$o1 = new MyClass();
$o2 = clone $o1->add(2);
var_dump($o1->get()); // int(2)
var_dump($o2->get()); // int(2)

Der Wert von $o1 wird hinzugefügt, bevor das Objekt geklont wird!

Beachten Sie, dass die Verwendung von Klammern zur Beeinflussung der Priorität in PHP Version 5 und älter nicht funktioniert hat (in PHP 7):

// using the class MyClass from the previous code
$o1 = new MyClass();
$o2 = (clone $o1)->add(2);  // Error in PHP 5 and before, fine in PHP 7
var_dump($o1->get()); // int(0) in PHP 7
var_dump($o2->get()); // int(2) in PHP 7