operators &$ - Referenz-Was bedeutet dieses Symbol in PHP?



call by (15)

Was ist das?

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

Warum ist das?

Früher war es schwierig, Fragen zu Operatoren und anderen Syntax-Tokens zu finden.¹
Die Hauptidee ist, Links zu bestehenden Fragen zu zu haben, so dass wir leichter auf sie verweisen können, anstatt Inhalte aus dem PHP Manual zu kopieren.

¹ Hinweis: Seit Januar 2013 unterstützt Sonderzeichen . Umgeben Sie die Suchbegriffe einfach in Anführungszeichen, zB [php] "==" vs "==="

Was soll ich hier machen?

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

Die Liste

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

Bitweise Operatoren oder References

=& References

&= Bitweise Operatoren

&& Logische Operatoren

% Arithmetische Operatoren

!! Logische Operatoren

@ Fehlersteuerungsoperatoren

?: Ternärer Operator

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

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

:: Scope Resolution 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)

  • Operator für Raumschiff (Dreiwegevergleich)

| Bitweise Operatoren

|| Logische Operatoren

~ Bitweise Operatoren

+ Arithmetische Operatoren , Array-Operatoren

+= und -= Zuweisungsoperatoren

++ und -- Operatoren inkrementieren / dekrementieren

.= Zuweisungsoperatoren

. String-Operatoren

, Funktionsargumente

, Variablendeklarationen

$$ Variable Variablen

` Ausführungsoperator

<?= Kurze offene Tags

[] Arrays (kurze Syntax seit PHP 5.4)

<? Tags öffnen und schließen

... Argument Auspacken (seit PHP 5.6)

** Exponentiation (seit PHP 5.6)

# Einzeiliger Shell-Kommentar


Answers

{} Geschweifte Klammern

Und noch 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

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

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

Ganzzahlen, Floats, Strings, Arrays und Objekte für den dreifachen 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

<=> Raumschiffbetreiber

In PHP 7 hinzugefügt

Der Spaceship-Operator <=> ist der letzte in PHP 7 hinzugefügte Vergleichsoperator. Er ist ein === binärer Operator mit der gleichen Priorität wie Gleichheitsoperatoren ( == === != , === !== ). Dieser Operator ermöglicht einen einfacheren dreifachen Vergleich zwischen linken und rechten Operanden.

Der Operator führt zu einem 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 ist als der rechte

z.B

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

Eine gute praktische Anwendung für die Verwendung dieses Operators wäre in Callbacks des Vergleichstyps, von denen erwartet wird, dass sie eine Null, eine negative oder eine positive ganze Zahl basierend auf einem Dreiwegevergleich zwischen zwei Werten zurückgeben. Die an usort übergebene usort ist 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;
});

Eine Übersicht der Operatoren in PHP :

Logische Operatoren:

  • $ a && $ b: TRUE, wenn sowohl $ a als auch $ b TRUE 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: TRUE, wenn $ a nicht TRUE ist.
  • $ a und $ b: TRUE, wenn sowohl $ a als auch $ b TRUE sind.
  • $ a oder $ b: TRUE, wenn entweder $ a oder $ b TRUE ist.

Vergleichsoperatoren:

  • $ a == $ b: TRUE, wenn $ a nach dem Typ-Jonglieren gleich $ b ist.
  • $ a === $ b: TRUE, wenn $ a $ b entspricht und sie vom selben Typ sind.
  • $ a! = $ b: TRUE, wenn $ a nach dem Jonglieren nicht gleich $ b ist.
  • $ a <> $ b: TRUE, wenn $ a nach dem Jonglieren mit Typ nicht gleich $ b ist.
  • $ a! == $ b: TRUE, wenn $ a nicht $ b entspricht oder nicht vom selben Typ ist.
  • $ a <$ b : TRUE, wenn $ a strikt weniger als $ b ist.
  • $ a> $ b : TRUE, wenn $ a strikt 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 ganze Zahl kleiner, 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 andernfalls $ c zurückgibt ( ternärer Operator )
  • $ a ?? $ c : Wie $ a? $ a: $ c ( Nullkoaleszenzoperator - erfordert PHP> = 7)

Rechenzeichen:

  • - $ a : Gegenteil von $ a.
  • $ a + $ b : Summe von $ a und $ b.
  • $ a - $ b : Unterschied zwischen $ a und $ b.
  • $ a * $ b : Produkt aus $ 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)

Operatoren inkrementieren / dekrementieren:

  • ++ $ a : Inkrementiert $ a um eins und gibt dann $ a zurück.
  • $ a ++ : Gibt $ a zurück und erhöht dann $ a um eins.
  • - $ a : Verringert $ a um eins und gibt dann $ a zurück.
  • $ a-- : Gibt $ a zurück und dekrementiert $ a dann 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, jedoch nicht beide.
  • ~ $ 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 "durch zwei teilen")

String-Operatoren:

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

Array-Operatoren:

  • $ a + $ b : Union 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 gleichen Typ haben.
  • $ a! = $ b : TRUE, wenn $ a nicht $ b entspricht.
  • $ a <> $ b : TRUE, wenn $ a nicht $ b entspricht.
  • $ a! == $ b : TRUE, 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 : Gleich wie $ a = $ a / $ b
  • $ a% = $ b : Wie $ a = $ a% $ b
  • $ a ** = $ b : Wie $ a = $ a ** $ b
  • $ a. = $ b : Gleich wie $ a = $ a. $ b
  • $ a & = $ b : Gleich wie $ a = $ a & $ b
  • $ a | = $ b : Entspricht $ a = $ a | $ b
  • $ a ^ = $ b : Entspricht $ a = $ a ^ $ b
  • $ a << = $ b : Wie $ a = $ a << $ b
  • $ a >> = $ b : Wie $ a = $ a >> $ b

Hinweis

Operator und Operator haben eine niedrigere Priorität als Zuweisungsoperator = .

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

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


Zauberkonstanten : Obwohl dies nicht nur Symbole sind, sondern ein wichtiger Bestandteil dieser Markenfamilie. Es gibt acht magische Konstanten, die sich je nach Einsatzort ä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 eingeschlossenen Datei zurückgegeben. Seit PHP 4.0.2 enthält __FILE__ immer einen absoluten Pfad mit aufgelösten Symlinks, während er 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 ist gleichbedeutend mit dirname(__FILE__) . Dieser Verzeichnisname hat keinen abschließenden Schrägstrich, sofern es sich nicht um das Stammverzeichnis handelt. (In PHP 5.3.0 hinzugefügt.)

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

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

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

__METHOD__ : Der Name der Klassenmethode. (Hinzugefügt in PHP 5.0.0) Der Methodenname wird bei der Deklaration zurückgegeben (Groß- und Kleinschreibung wird berücksichtigt).

__NAMESPACE__ : Der Name des aktuellen Namespaces (Groß- und Kleinschreibung wird __NAMESPACE__ ). Diese Konstante wird in der Kompilierzeit definiert (Hinzugefügt in PHP 5.3.0).

Source


Bitweiser Operator

Was ist ein bisschen Ein Bit ist eine Darstellung von 1 oder 0. Grundsätzlich ist 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 sehen, 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)

Einige Beispiele zum besseren Verständnis

Der Operator "AND": &

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

Dies würde die Zahl 8 ausgeben. Warum? Nun, schauen wir uns unser Beispiel 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 der Tabelle entnehmen, 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 gemeinsamen Bits sind 32 und 4, die zusammen 36 ergeben.

Der Operator "Oder": |

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

Dies würde die Zahl 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 wir 3 Bits in den Spalten 8, 2 und 1 gesetzt haben. Addiere diese auf: 8 + 2 + 1 = 11.


Null-Coalesce-Operator "??" (In PHP 7 hinzugefügt)

Nicht der eingängigste Name für einen Operator, aber PHP 7 bringt das eher praktische Null-Zusammenführen mit, deshalb 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 true zurückgegeben wird, und das dritte, wenn nicht:

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

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

In PHP 7 bekommen wir zusätzlich die ?? Ein Operator, der nicht extreme Verwirrung anzeigt, wie ich normalerweise zwei Fragezeichen verwenden würde, stattdessen können wir eine Reihe von Werten miteinander verketten. Beim Lesen von links nach rechts ist der erste Wert, der vorhanden ist 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, die möglicherweise von Benutzereingaben oder einer vorhandenen Konfiguration stammen, Priorität zu geben und sicher auf einen bestimmten Standard zurückzugreifen, wenn diese Konfiguration fehlt. Es ist eine Art kleines Feature, aber ich weiß, dass ich es verwenden werde, sobald meine Anwendungen auf PHP 7 aktualisiert werden.


Null Coalesce Operator php

Der Nullkoaleszenzoperator (??) wurde zu PHP7 hinzugefügt, wenn ein Ternär in Verbindung mit isset () verwendet werden muss. Es gibt den ersten Operanden zurück, wenn er existiert, und ist nicht NULL, ansonsten den zweiten Operanden, wie im folgenden Beispiel:

$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; 

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

===wird für die Prüfung Gleichheit verwendet sowohl den variablen Wert * und ** Datentyp

Beispiel

$a = 5

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

  2. if ($a == '5') - wird als wahr ausgewertet, da der Wert beider php intern den String-Wert in eine Ganzzahl konvertiert und beide Werte miteinander vergleicht

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

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


Typoperatoren

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: oben Beispiel $a ist ein Objekt der mclass Verwenden mclass daher nur Daten der sclass mclass die keine Instanz der 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 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)

Operatoren inkrementieren / dekrementieren

++ Inkrement-Operator

-- Operator dekrementieren

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 die Variable vor die Variable gestellt wird, wird zuerst die Inkrementierungs- / Dekrementierungsoperation für die Variable ausgeführt und das Ergebnis zurückgegeben. Wenn hinter die Variable gestellt wird, 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 wird ++$i verwendet, da es schneller ist. $i++ hätte die gleichen Ergebnisse.

Pre-Inkrement ist etwas schneller, da es die Variable wirklich inkrementiert und anschließend das Ergebnis zurückgibt. Post-Inkrement erstellt eine spezielle Variable, kopiert dort den Wert der ersten Variablen und ersetzt erst nach Verwendung der ersten Variablen ihren Wert durch die Sekunde.

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

Sie können Buchstaben in PHP auch inkrementieren:

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

Sobald z erreicht ist, ist aa nächste und so weiter.

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

Stapelüberlaufpfosten:


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

1) Einzelnes Zitat:

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

2) Doppelte Anführungsstrings:

$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 bedeutet "&" hier in PHP?

PHP "&" Operator

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

& normalerweise überprüft Bits, die in $ a und $ b gesetzt sind.

Hast du überhaupt gemerkt, 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);

Also hinter allem oben ist Spiel von bitweisem Operator und Bits.

Ein nützlicher Fall ist die einfache Konfiguration wie unten, so dass ein einzelnes ganzzahliges Feld Tausende von Combos für Sie speichern kann.

Die meisten Leute haben die Dokumente bereits gelesen, haben sich aber nicht auf den realen Anwendungsfall dieser bitweisen Operatoren verlassen.

Beispiel, das Sie lieben werden

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

Nullkoaleszenzoperator (??)

Dieser Operator wurde in PHP 7.0 für den häufigen Fall der Verwendung eines ternären Operators in Verbindung mit isset() . Es gibt den 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';
?>

Konvertierungsoperatoren (auch als benutzerdefinierte Conversions bezeichnet)

In C ++ können Sie Konvertierungsoperatoren erstellen, Operatoren, mit denen der Compiler zwischen Ihren Typen und anderen definierten Typen konvertieren kann. Es gibt zwei Arten von Konvertierungsoperatoren, implizite und explizite.

Implizite Konvertierungsoperatoren (C ++ 98 / C ++ 03 und C ++ 11)

Ein impliziter Konvertierungsoperator ermöglicht es dem Compiler, den Wert eines benutzerdefinierten Typs (wie die Konvertierung zwischen int und long ) implizit in einen anderen Typ zu konvertieren.

Das Folgende ist eine einfache Klasse mit einem impliziten Konvertierungsoperator:

class my_string {
public:
  operator const char*() const {return data_;} // This is the conversion operator
private:
  const char* data_;
};

Implizite Konvertierungsoperatoren, wie Konstruktoren mit einem Argument, sind benutzerdefinierte Konvertierungen. Compiler gewähren eine benutzerdefinierte Konvertierung, wenn versucht wird, einen Aufruf einer überladenen Funktion abzugleichen.

void f(const char*);

my_string str;
f(str); // same as f( str.operator const char*() )

Dies scheint zunächst sehr hilfreich zu sein, aber das Problem dabei ist, dass die implizite Konvertierung sogar einsetzt, wenn es nicht erwartet wird. Im folgenden Code wird void f(const char*) aufgerufen, weil my_string() kein lvalue , also stimmt der erste nicht überein:

void f(my_string&);
void f(const char*);

f(my_string());

Anfänger bekommen das leicht falsch und selbst erfahrene C ++ Programmierer sind manchmal überrascht, weil der Compiler eine Überladung auswählt, die sie nicht vermutet haben. Diese Probleme können durch explizite Konvertierungsoperatoren gemildert werden.

Explizite Konvertierungsoperatoren (C ++ 11)

Anders als implizite Konvertierungsoperatoren treten explizite Konvertierungsoperatoren niemals ein, wenn Sie dies nicht erwarten. Das Folgende ist eine einfache Klasse mit einem expliziten Konvertierungsoperator:

class my_string {
public:
  explicit operator const char*() const {return data_;}
private:
  const char* data_;
};

Beachten Sie das explicit . Wenn Sie nun versuchen, den unerwarteten Code von den impliziten Konvertierungsoperatoren auszuführen, erhalten Sie einen Compilerfehler:

prog.cpp: In function ‘int main()’:
prog.cpp:15:18: error: no matching function for call to ‘f(my_string)’
prog.cpp:15:18: note: candidates are:
prog.cpp:11:10: note: void f(my_string&)
prog.cpp:11:10: note:   no known conversion for argument 1 from ‘my_string’ to ‘my_string&’
prog.cpp:12:10: note: void f(const char*)
prog.cpp:12:10: note:   no known conversion for argument 1 from ‘my_string’ to ‘const char*’

Um den expliziten Cast-Operator aufzurufen, müssen Sie static_cast , einen C-Style-Cast oder einen Konstruktorstil-Cast (dh T(value) ) verwenden.

Es gibt jedoch eine Ausnahme: Der Compiler darf implizit in bool konvertieren. Außerdem darf der Compiler keine weitere implizite Konvertierung durchführen, nachdem er in bool konvertiert wurde (ein Compiler darf 2 implizite Konvertierungen gleichzeitig bool , aber maximal 1 benutzerdefinierte Konvertierung).

Da der Compiler keine "Vergangenheit" bool , entfernen explizite Konvertierungsoperatoren jetzt die Notwendigkeit für das Safe Bool-Idiom . Zum Beispiel haben intelligente Zeiger vor C ++ 11 das Safe Bool-Idiom verwendet, um Konvertierungen in ganzzahlige Typen zu verhindern. In C ++ 11 verwenden die Smartpointer stattdessen einen expliziten Operator, da der Compiler nicht implizit in einen Integraltyp konvertiert werden darf, nachdem er einen Typ explizit in bool konvertiert hat.

Weiter zu Überladen new und delete .





php operators symbols php-5.3