operator - Referenz-Was bedeutet dieses Symbol in PHP?




php return reference (12)

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 Stack Overflow 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 Stack Overflow 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

https://code.i-harness.com


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.


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.


<=> 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;
});

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

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



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:


FRAGE:

Was bedeutet => ?

ANTWORTEN:

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

RABATTIERUNG:

Um dies zu verstehen, müssen wir wissen, was Assoziative Arrays sind. Das erste, was sich ergibt, wenn ein herkömmlicher Programmierer an ein Array ( in PHP ) denkt, wäre etwa so ähnlich:

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

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

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

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

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

So weit, ist es gut. Als Menschen können wir uns jedoch schwer merken, dass der Index [0] des Arrays der Wert des Jahres 2016 ist, der Index [1] des Arrays eine Begrüßung ist und der Index [2] des Arrays ein einfacher ist ganzzahliger Wert Die Alternative wäre dann, ein so genanntes assoziatives Array zu verwenden . Ein assoziatives Array weist einige Unterschiede zu einem sequentiellen Array auf ( dies ist der Fall, in dem die vorherigen Fälle vorlagen, da sie den verwendeten Index in einer vorbestimmten Reihenfolge inkrementieren, indem er für jeden folgenden Wert um 1 erhöht wird ).

Unterschiede ( zwischen einem sequentiellen und einem assoziativen Array ):

  • Bei der Deklaration eines assoziativen Arrays nehmen Sie nicht nur den value des gewünschten Arrays in das Array auf, sondern geben auch den Indexwert (als key ) an, den Sie beim Aufruf des Arrays in späteren Teilen verwenden möchten des Codes. Bei der Deklaration wird folgende Syntax verwendet: "key" => "value" .

  • Bei Verwendung des assoziativen Arrays wird der key dann im Index des Arrays platziert, um den gewünschten 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 dieselbe Ausgabe wie zuvor zu erhalten, wird der 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 es ziemlich einfach zu erkennen, dass das =>Symbol verwendet wird, um die Beziehung eines assoziativen Arrays zwischen jedem keyund den valuePaaren in einem Array auszudrücken, WÄHREND der Einleitung der Werte innerhalb des Arrays.


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'; 

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

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


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"




php-5.3