it-swarm.com.de

Referenz - Was bedeutet dieses Symbol in PHP?

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 mitzuwirken.

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 Stack Overflow zu haben, damit wir sie leichter referenzieren können, anstatt Inhalte aus dem PHP Handbuch zu überschreiben.

Hinweis: Seit Januar 2013 unterstützt Stack Overflow Sonderzeichen . Umgeben 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 unten die entsprechende Syntax. Die verlinkten Seiten zum PHP-Handbuch zusammen mit den verlinkten Fragen werden Ihre Frage dann wahrscheinlich beantworten. In diesem Fall werden Sie aufgefordert, die Antwort zu unterstützen. Diese Liste ist kein Ersatz für die Hilfe anderer.

Die Liste

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


_&_ Bitweise Operatoren oder Referenzen


_=&_ Referenzen


_&=_ Bitweise Operatoren


_&&_ Logische Operatoren


_%_ arithmetische Operatoren


_!!_ Logische Operatoren


_@_ Fehlersteuerungsoperatoren


_?:_ Ternärer Operator


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


_?string_ _?int?array?bool?float_ Nullable return type declare (since PHP 7.1)


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


_|_ Bitweise Operatoren


_||_ Logische Operatoren


_~_ Bitweise Operatoren


_+_ Arithmetische Operatoren , Array-Operatoren


_+=_ und _-=_ Zuweisungsoperatoren


_++_ und _--_ Inkrementieren/Dekrementieren von Operatoren


_.=_ Zuweisungsoperatoren


_._ String-Operatoren


_,_ Funktionsargumente

_,_ Variablendeklarationen


_$$_ Variable Variablen


_`_ Ausführungsoperator


_<?=_ Short Open Tags


_[]_ Arrays (kurze Syntax seit PHP 5.4)


_<?_ Tags öffnen und schließen


_..._ Argument entpacken (seit PHP 5.6)


_**_ Exponentiation (seit PHP 5.6)


_#_ Einzeiliger Kommentar im Shell-Stil


_:?_ Nullable return types


4233
Gordon

Inkrementieren/Dekrementieren von Operatoren

++ Inkrementoperator

-- 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 die Variable gestellt, wird die Inkrementierungs-/Dekrementierungsoperation zuerst mit der Variablen durchgeführt , dann wird das Ergebnis zurückgegeben. Wird die Variable nach der Variablen eingefügt, wird sie zuerst zurückgegeben , und die Inkrementierungs-/Dekrementierungsoperation wird 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.

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 Wert der ersten Variablen wird kopiert und erst nachdem die erste Variable verwendet wurde, wird ihr Wert durch den Wert der zweiten Variablen ersetzt.

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

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

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

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

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


Stapelüberlaufpfosten:

1090
Peter Ajtai

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 bedeutet, dass jedes Bit gesetzt ist. Wir werden uns ansehen, warum der Maximalwert 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 "AND" -Operator: &

$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 haben, das 8-Bit ist.

Zweites Beispiel

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

Die beiden gemeinsam genutzten Bits sind 32 und 4, die zusammen 36 zurückgeben.

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 wir 3 Bits in den Spalten 8, 2 und 1 gesetzt haben. Addieren Sie diese: 8 + 2 + 1 = 11.

414
Ankur Saxena

_Alias ​​für gettext ()

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

260
Habeeb Perwad
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"
253
Ankur Saxena

<=> Raumschiff-Operator

Hinzugefügt in PHP 7

Der Raumschiffoperator<=> ist der letzte Vergleichsoperator, der in PHP 7 hinzugefügt wurde. Es ist ein nicht assoziativer binärer Operator mit der gleichen Priorität wie Gleichheitsoperatoren (==, !=, ===, !==). Dieser Operator ermöglicht einen einfacheren Drei-Wege-Vergleich zwischen linken und rechten Operanden.

Der Operator ergibt einen ganzzahligen Ausdruck von:

  • 0 wenn beide Operanden gleich sind
  • Kleiner 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 für die Verwendung dieses Operators wären Rückrufe vom Vergleichstyp, von denen erwartet wird, dass sie eine Null, eine negative oder eine positive Ganzzahl basierend auf einem Drei-Wege-Vergleich zwischen zwei Werten zurückgeben. Die Vergleichsfunktion, die an usort übergeben wird, ist ein solches Beispiel.

Vor PHP 7 würden Sie schreiben ...

$arr = array(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 können Sie schreiben ...

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

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

Magische Konstanten : Obwohl dies nicht nur Symbole sind, sondern ein wichtiger Teil dieser Token-Familie. Es gibt acht magische Konstanten, die sich je nach Verwendungszweck ä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 enthält __FILE__ immer einen absoluten Pfad mit aufgelösten Symlinks, während er in älteren Versionen unter 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 ist 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 so zurück, wie er deklariert wurde (Groß- und Kleinschreibung beachten). In PHP 4 wird sein Wert immer in Kleinbuchstaben geschrieben.

__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 beachten). In PHP 4 wird sein Wert immer in Kleinbuchstaben geschrieben. Der Klassenname enthält den Namespace, in dem er deklariert wurde (z. B. Foo\Bar). Beachten Sie, dass ab PHP 5.4 __CLASS__ auch in Merkmalen funktioniert. Bei Verwendung in einer Merkmalmethode ist __CLASS__ der Name der Klasse, in der das Merkmal verwendet wird.

__TRAIT__: Der Name der Eigenschaft. (Hinzugefügt in PHP 5.4.0) Ab PHP 5.4 gibt diese Konstante das Merkmal zurück, wie es deklariert wurde (Groß- und Kleinschreibung beachten). 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 so zurückgegeben, wie er deklariert wurde (Groß- und Kleinschreibung beachten).

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

Quelle

221
Sumoanand

Geben Sie Operatoren ein

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 genanntes Beispiel $a ist ein Objekt von mclass. Verwenden Sie daher nur eine mclass -Dateninstanz von mit 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)
139
Maulik patel

Eine Übersicht über 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 xoder $ 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 gleich $ b ist und sie vom gleichen Typ sind.
  • $ a! = $ b: TRUE, wenn $ a nach dem Typ 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 : TRUE, wenn $ a genau kleiner als $ b ist.
  • $ a> $ b : TRUE, 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 ganze Zahl kleiner, gleich oder größer als Null, wenn $ a kleiner, gleich oder ist größer als $ b. Verfügbar ab PHP 7.
  • $ a? $ b: $ c : Wenn $ a $ b zurückgibt, wird $ c ( ternärer Operator zurückgegeben. )
  • $ a ?? $ c : Wie $ a? $ a: $ c ( null Koaleszenzoperator - benötigt PHP> = 7)

arithmetische Operatoren:

  • - $ a : Gegenteil 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 $ a dann um eins.
  • - $ a : Verringert $ a um eins und gibt dann $ a zurück.
  • $ a - : Gibt $ a zurück und dekrementiert $ a um eins.

Bitweise Operatoren:

  • $ a & $ b : Bits, die sowohl in $ a als auch in $ b gesetzt sind, werden gesetzt.
  • $ a | $ b : Bits, die 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 : Verschiebt die Bits von $ a $ b-Schritten nach links (jeder Schritt bedeutet "mit zwei multiplizieren")
  • $ a >> $ b : Verschiebt die Bits von $ a $ b-Schritten nach rechts (jeder Schritt bedeutet "durch zwei teilen")

Zeichenkettenoperatoren:

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

Array-Operatoren:

  • $ a + $ b : Vereinigung 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 die gleichen 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 : 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 : 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

Der Operator and und der Operator or haben eine niedrigere Priorität als der Zuweisungsoperator _=_.

Dies bedeutet, dass _$a = true and false;_ _($a = true) and false_ entspricht.

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

124
John Slegers

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

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

Ganzzahlen, 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
// 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
96
rajangupta

{} Geschweifte Klammern

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
65
mnv

Nullkoaleszenzoperator (??)

Dieser Operator wurde in PHP 7.0 für den allgemeinen Fall hinzugefügt, dass ein ternärer Operator in Verbindung mit isset() verwendet werden muss. Es gibt seinen ersten Operanden zurück, wenn er existiert und nicht NULL ist. 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';
?>
60
VIPIN A ROY

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

1) Einfache Anführungszeichen:

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

2) Double Quote Strings:

$str = 'string';

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

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

FRAGE:

Was bedeutet =>?


ANTWORT:

=> Ist das Symbol, mit dem wir Menschen uns entschieden haben, "Key" => "Value" Paare in assoziativen Arrays zu trennen.

AUSARBEITEND:

Um dies zu verstehen, müssen wir wissen, was Assoziative Arrays sind. Das erste, was auftaucht, wenn ein herkömmlicher Programmierer an ein Array denkt (in PHP), ist ungefähr wie folgt:

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

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

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

Als ob wir das Array in einem späteren Teil des Codes aufrufen wollten, könnten 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 ist ein - Grüße und der Index [2] des Arrays ist ein einfaches ganzzahliger Wert. Die Alternative wäre dann, ein sogenanntes assoziatives Array zu verwenden. Ein assoziatives Array weist einige Unterschiede zu einem sequentielles Array ( auf, wie es in den vorherigen Fällen der Fall war, da sie den in einer vorgegebenen Reihenfolge verwendeten Index durch Inkrementieren um 1 inkrementieren für jeden folgenden Wert ).

Unterschiede ( zwischen einem sequentiellen und einem assoziativen Array ):

  • Während der Deklaration eines assoziativen Arrays geben Sie nicht nur das value an, was Sie in das Array einfügen möchten, sondern auch den gewünschten Indexwert (genannt key) Verwenden Sie diese Option, wenn Sie das Array in späteren Teilen des Codes aufrufen. Die folgende Syntax wird während der Deklaration verwendet: "key" => "value".

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

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 die gleiche Ausgabe wie zuvor zu erhalten, wird der Wert key im Array-Index verwendet:

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

ENDPUNKT:

Aus dem obigen Beispiel ist also ziemlich leicht ersichtlich, dass das Symbol => verwendet wird, um die Beziehung eines assoziativen Arrays zwischen jedem der Paare key und value in einem Array auszudrücken. WÄHREND die Einleitung der Werte innerhalb des Arrays.

42
Webeng

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.

hast du ü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 all dem steckt also ein Spiel mit bitweisen Operatoren und 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 Dokumentation bereits gelesen, haben sich jedoch nicht auf den realen Anwendungsfall dieser bitweisen Operatoren verlassen.

Beispiel Das wirst du lieben

<?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
31
dev.meghraj

== wird zur Überprüfung der Gleichheit verwendet ohne unter Berücksichtigung der Variablen Datentyp

=== wird zur Überprüfung der Gleichheit für beide die Variable Wert * und ** Datentyp verwendet

Beispiel

$a = 5

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

  2. if ($a == '5') - wird mit true ausgewertet, da beim Vergleichen dieser beiden Werte PHP diesen String-Wert intern in eine Ganzzahl umwandelt und dann beide Werte vergleicht

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

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

25
Parth Nayak

Null Coalesce Operator php

Der Null-Koaleszenz-Operator (??) wurde zu PHP7 hinzugefügt, um den allgemeinen Fall zu berücksichtigen, dass ein Ternär in Verbindung mit isset () verwendet werden muss. Es gibt seinen ersten Operanden zurück, wenn er existiert, und ist nicht NULL, andernfalls gibt es seinen zweiten Operanden zurück, wie im folgenden Beispiel:

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

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-Vereinigung 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 wahr ist, und das dritte, wenn dies nicht der Fall ist:

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 identisch ist: echo $ count?: 10; // gibt auch 10 aus

In PHP 7 bekommen wir zusätzlich die ?? Operator, der es uns ermöglicht, eine Folge von Werten zu verketten, anstatt auf extreme Verwirrung hinzuweisen, wie ich normalerweise zwei Fragezeichen zusammen verwende. Wenn Sie von links nach rechts lesen, 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 Priorität einzuräumen, die möglicherweise von Benutzereingaben oder einer vorhandenen Konfiguration stammen, und um sicher auf einen bestimmten Standard zurückzugreifen, wenn diese Konfiguration fehlt. Es ist ein kleines Feature, von dem ich weiß, dass ich es verwenden werde, sobald meine Anwendungen auf PHP 7 aktualisiert werden.

22
Yogi Ghorecha

Nullable Rückgabetypdeklaration

PHP 7 fügt Unterstützung für Rückgabetypdeklarationen hinzu. Ä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.

Strikte Typisierung wirkt sich auch auf Rückgabetypdeklarationen aus. Im schwachen Standardmodus werden zurückgegebene Werte auf den richtigen Typ erzwungen, wenn sie nicht bereits diesen Typ haben. 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 nullwertfähig 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

8
John Conde