PHP
operators

Invoering

Opmerkingen

Stringoperators (. En. =)

Er zijn slechts twee stringoperators:

• Samenvoeging van twee tekenreeksen (punt):

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

• Aansluitende opdracht (punt =):

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

Basisopdracht (=)

$a = "some string";

resulteert in $a met als waarde some string .

Het resultaat van een toewijzingsuitdrukking is de waarde die wordt toegewezen. Merk op dat een enkel gelijkteken = NIET te vergelijken is!

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

doet het volgende:

1. Regel 1 wijst 3 aan $a .
2. Regel 2 wijst 5 aan $a . Deze uitdrukking levert ook waarde 5 .
3. Regel 2 wijst vervolgens het resultaat van de uitdrukking tussen haakjes ( 5 ) toe aan $b .

Dus: zowel $a als $b nu waarde 5 .

Gecombineerde opdracht (+ = etc)

De gecombineerde toewijzingsoperatoren zijn een snelkoppeling voor een bewerking op een variabele en vervolgens het toewijzen van deze nieuwe waarde aan die variabele.

Rekenkundig:

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

Meerdere arrays samen verwerken

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

Gecombineerde aaneenschakeling en toewijzing van een string:

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

Gecombineerde binaire bitsgewijze toewijzingsoperatoren:

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

Prioriteit van operator wijzigen (tussen haakjes)

De volgorde waarin operators worden geëvalueerd, wordt bepaald door de prioriteit van de operator (zie ook het gedeelte Opmerkingen).

In

$a = 2 * 3 + 4;

$a krijgt een waarde van 10 omdat 2 * 3 eerst wordt geëvalueerd (vermenigvuldiging heeft een hogere prioriteit dan optelling) wat een subresultaat oplevert van 6 + 4 , wat gelijk is aan 10.

De prioriteit kan worden gewijzigd met haakjes: in

$a = 2 * (3 + 4);

$a krijgt een waarde van 14 omdat (3 + 4) eerst wordt geëvalueerd.

Vereniging

Linkse vereniging

Als de prioriteit van twee operatoren gelijk is, bepaalt de associativiteit de groepering (zie ook het gedeelte Opmerkingen):

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

* en % hebben dezelfde prioriteit en links associativiteit. Omdat de vermenigvuldiging eerst (links) plaatsvindt, is deze gegroepeerd.

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

Nu treedt de modulus-operator eerst op (links) en is dus gegroepeerd.

Juiste vereniging

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

Zowel $a als $b nu waarde 2 omdat $b += 1 is gegroepeerd en het resultaat ( $b is 2 ) wordt toegewezen aan $a .

Vergelijkingsoperatoren

Gelijkheid

Voor elementaire gelijkheidstests wordt de gelijke operator == gebruikt. Voor uitgebreidere controles gebruikt u de identieke operator === .

De identieke operator werkt hetzelfde als de gelijke operator, vereist dat zijn operanden dezelfde waarde hebben, maar vereist ook dat ze hetzelfde gegevenstype hebben.

In het onderstaande voorbeeld wordt bijvoorbeeld 'a en b zijn gelijk' weergegeven, maar niet 'a en b zijn identiek'.

$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
}

Bij gebruik van de gelijke operator worden numerieke tekenreeksen naar gehele getallen geworpen.

Vergelijking van objecten

=== vergelijkt twee objecten door te controleren of ze exact dezelfde instantie zijn . Dit betekent dat new stdClass() === new stdClass() in false, zelfs als ze op dezelfde manier worden gemaakt (en exact dezelfde waarden hebben).

== vergelijkt twee objecten door recursief te controleren of ze gelijk zijn ( diep gelijk aan ). Dat betekent voor $a == $b , als $a en $b zijn:

1. van dezelfde klasse
2. hebben dezelfde eigenschappen ingesteld, inclusief dynamische eigenschappen
3. voor elke eigenschap $property is $a->property == $b->property waar (dus recursief gecontroleerd).

Andere veelgebruikte operatoren

Ze bevatten:

1. Groter dan ( > )
2. Kleiner dan ( < )
3. Groter dan of gelijk aan ( >= )
4. Kleiner dan of gelijk aan ( <= )
5. Niet gelijk aan ( != )
6. Niet identiek aan ( !== )

1. Groter dan: $a > $b , returns true indien $a value 's groter is dan van $b , anders false.

Voorbeeld :

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

2. Lesser Than: $a < $b , returns true indien $a value 's kleiner is dan van $b , anders false.

Voorbeeld :

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

3. Groter dan of gelijk aan: $a >= $b , returns true indien $a value 's is of groter is dan van $b of gelijk aan $b , anders keert false .

Voorbeeld :

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

4. Kleiner dan of gelijk aan: $a <= $b , returns true indien $a value 's is of kleiner is dan van $b of gelijk aan $b , anders keert false .

Voorbeeld :

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

5/6. Niet gelijk / identiek aan: om het eerdere voorbeeld over gelijkheid opnieuw te haken, toont het onderstaande voorbeeld 'a en b zijn niet identiek', maar niet 'a en b zijn niet gelijk'.

$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
}

Ruimteschipoperator (<=>)

PHP 7 introduceert een nieuw soort operator, die kan worden gebruikt om expressies te vergelijken. Deze operator retourneert -1, 0 of 1 als de eerste uitdrukking kleiner is dan, gelijk aan of groter dan de tweede uitdrukking.

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

Objecten zijn niet vergelijkbaar en dit leidt tot ongedefinieerd gedrag.

Deze operator is bijzonder nuttig bij het schrijven van een door de gebruiker gedefinieerde vergelijkingsfunctie gebruik usort , uasort of uksort . Gegeven een reeks objecten die moeten worden gesorteerd op basis van hun weight , kan een anonieme functie bijvoorbeeld <=> om de waarde te retourneren die wordt verwacht door de sorteerfuncties.

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

In PHP 5 zou dit een wat uitgebreidere uitdrukking vereisen.

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

Null Coalescing Operator (??)

Null coalescentie is een nieuwe operator geïntroduceerd in PHP 7. Deze operator retourneert zijn eerste operand als deze is ingesteld en niet NULL . Anders zal het zijn tweede operand teruggeven.

Het volgende voorbeeld:

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

is gelijk aan beide:

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

en:

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

Deze operator kan ook worden gekoppeld (met rechts-associatieve semantiek):

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

wat een equivalent is van:

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

Notitie:
Bij het gebruik van het samenvoegen operator op tekenreekssamenvoegingsoperator vergeet niet om haakjes ()

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

Dit zal alleen John , en als zijn $ firstName nul is en $ lastName Doe is, zal het Unknown Doe . Om John Doe , moeten we haakjes als deze gebruiken.

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

Hiermee wordt John Doe plaats van alleen John .

instanceof (type operator)

Om te controleren of een object van een bepaalde klasse is, kan de (binaire) instanceof operator worden gebruikt sinds PHP versie 5.

De eerste (linker) parameter is het te testen object. Als deze variabele geen object is, retourneert instanceof altijd false . Als een constante uitdrukking wordt gebruikt, wordt een fout gegenereerd.

De tweede (rechter) parameter is de klasse om mee te vergelijken. De klasse kan worden opgegeven als de klassenaam zelf, een tekenreeksvariabele die de klassenaam bevat (geen tekenreeksconstante!) Of een object van die 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 kan ook worden gebruikt om te controleren of een object van een bepaalde klasse is dat een andere klasse uitbreidt of een interface implementeert:

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;

Om te controleren of een object niet van een bepaalde klasse is, kan de operator not ( ! ) Worden gebruikt:

class MyClass {
}

class OtherClass {
}

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

Merk op dat haakjes rond $o instanceof MyClass niet nodig zijn omdat instanceof een hogere prioriteit heeft dan ! , Hoewel het de code beter leesbaar haakjes kunnen maken.

Voorbehoud

Als een klasse niet bestaat, worden de geregistreerde autoload-functies aangeroepen om de klasse te definiëren (dit is een onderwerp dat buiten het bereik van dit deel van de documentatie valt!). In PHP-versies vóór 5.1.0 activeerde de operator instanceof ook deze aanroepen, waardoor de klasse feitelijk werd gedefinieerd (en als de klasse niet kon worden gedefinieerd, zou er een fatale fout optreden). Gebruik een string om dit te voorkomen:

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

Vanaf PHP versie 5.1.0 worden in deze situaties de geregistreerde autoloaders niet meer aangeroepen.

Oudere versies van PHP (vóór 5.0)

In oudere versies van PHP (vóór 5.0) kan de functie is_a worden gebruikt om te bepalen of een object van een bepaalde klasse is. Deze functie is verouderd in PHP versie 5 en niet meer verouderd in PHP versie 5.3.0.

Ternary Operator (? :)

De ternaire operator kan worden gezien als een inline if statement. Het bestaat uit drie delen. De operator en twee resultaten. De syntaxis is als volgt:

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

Als de operator als true wordt geëvalueerd, wordt de waarde in het eerste blok geretourneerd ( <true value> ), anders wordt de waarde in het tweede blok geretourneerd ( <false value> ). Omdat we $value op het resultaat van onze ternaire operator, wordt de geretourneerde waarde opgeslagen.

Voorbeeld:

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

$action zou de string 'default' als empty($_POST['action']) resulteert in true. Anders zou het de waarde van $_POST['action'] .

De uitdrukking (expr1) ? (expr2) : (expr3) evalueert expr2 als expr1 evalueert naar true en expr3 als expr1 evalueert tot false .

Het is mogelijk om het middelste gedeelte van de ternaire operator weg te laten. Expression expr1 ?: expr3 returns expr1 als expr1 true, en expr3 anderszins. ?: wordt vaak de Elvis- operator genoemd.

Dit gedraagt zich als de operator Null Coalescing ?? , behalve dat ?? vereist dat de linkeroperand exact null terwijl ?: probeert de linkeroperand op te lossen in een boolean en te controleren of deze wordt opgelost in boolean false .

Voorbeeld:

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

In dit voorbeeld accepteert setWidth een parameter parameter of standaard 0 om de waarde van de breedte-sessie te wijzigen. Als $width 0 is (als $width niet is opgegeven), wat zal oplossen in boolean false, wordt in plaats daarvan de waarde van getDefaultWidth() gebruikt. De functie getDefaultWidth() wordt niet aangeroepen als $width niet is opgelost in boolean false.

Raadpleeg Typen voor meer informatie over de conversie van variabelen naar Boolean.

Verhogen (++) en verlagen van operatoren (-)

Variabelen kunnen met 1 worden verhoogd of verlaagd met respectievelijk ++ of -- . Ze kunnen voorafgaan aan of slagen voor variabelen en enigszins semantisch variëren, zoals hieronder wordt getoond.

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

Meer informatie over oplopende en afnemende operatoren is te vinden in de officiële documentatie .

Uitvoeringsoperator (``)

De PHP-uitvoeringsoperator bestaat uit backticks (``) en wordt gebruikt om shell-opdrachten uit te voeren. De uitvoer van de opdracht wordt geretourneerd en kan daarom worden opgeslagen in een variabele.

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

Merk op dat de operator execute en shell_exec() hetzelfde resultaat zullen geven.

Logische operatoren (&& / AND en || / OR)

In PHP zijn er twee versies van logische EN- en OF-operatoren.

Merk op dat de && en || operatoren hebben een hogere prioriteit dan and en or . Zie onderstaande tabel:

Hierdoor is het veiliger om && en || in plaats van and en or .

Bitwise Operators

Voorvoegsels voor bitsgewijze operatoren

Bitwise-operators zijn net als logische operators, maar worden per bit uitgevoerd in plaats van per booleaanse waarde.

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

Bitmasker-bitmaskeroperatoren

Bitwise AND & : een bit wordt alleen ingesteld als het in beide operanden is ingesteld

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

Bitgewijs OF | : een bit wordt ingesteld als het is ingesteld in een of beide operanden

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

Bitwise XOR ^ : een bit wordt ingesteld als het is ingesteld in de ene operand en niet in een andere operand, dat wil zeggen alleen als dat bit zich in een andere status bevindt in de twee operanden

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

Voorbeeldgebruik van bitmaskers

Deze operatoren kunnen worden gebruikt om bitmaskers te manipuleren. Bijvoorbeeld:

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

Hier, de | operator wordt gebruikt om de twee bitmaskers te combineren. Hoewel + hetzelfde effect heeft, | benadrukt dat u bitmaskers combineert en geen twee normale scalaire gehele getallen toevoegt.

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

Dit voorbeeld (ervan uitgaande dat de $option altijd maar één bit bevat) maakt gebruik van:

• de ^ operator om gemakkelijk bitmaskers te schakelen.
• de | operator om een bit in te stellen waarbij de oorspronkelijke staat of andere bits worden verwaarloosd
• de ~ operator om een geheel getal met slechts één bit te zetten in een geheel getal met slechts één bit niet ingesteld
• de operator & om een beetje uit te schakelen, met behulp van deze eigenschappen van & :
  • Omdat &= met een ingesteld bit niets doet ( (1 & 1) === 1 , (0 & 1) === 0 ), zal &= met een geheel getal met slechts één bit niet ingesteld dat bit alleen uitschakelen , heeft geen invloed op andere bits.
  • &= met een uitgeschakeld bit wordt dat bit uitgeschakeld ( (1 & 0) === 0 , (0 & 0) === 0 )
• Het gebruik van de operator & met een ander bitmasker filtert alle andere bits weg die niet in dat bitmasker zijn ingesteld.
  • Als voor de uitvoer bits zijn ingesteld, betekent dit dat een van de opties is ingeschakeld.
  • Als de uitvoer alle bits van het bitmasker heeft, betekent dit dat alle opties in het bitmasker zijn ingeschakeld.

Houd er rekening mee dat deze vergelijking operatoren: ( < > <= >= == === != !== <> <=> ) hebben een hogere prioriteit dan deze bitmask-bitmask operatoren: ( | ^ & ). Aangezien bitgewijze resultaten vaak worden vergeleken met behulp van deze vergelijkingsoperatoren, is dit een veel voorkomende valkuil om bewust van te zijn.

Bit-verschuivende operators

Bitwise Left Shift << : verplaats alle bits naar links (meer significant) met het gegeven aantal stappen en gooi de bits weg die de int-grootte overschrijden

<< $x komt overeen met het uitschakelen van de hoogste $x bits en vermenigvuldiging met de $x th macht van 2

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

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

Bitwise Right Shift >> : verwijder de laagste shift en schuif de resterende bits naar rechts (minder belangrijk)

>> $x is gelijk aan delen door de $x th macht van 2 en gooi het niet-gehele deel weg

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

Voorbeeldgebruik van bitverschuiving:

Snelle deling door 16 (betere prestaties dan /= 16 )

$x >>= 4;

Op 32-bits systemen verwijdert dit alle bits in het gehele getal, waarbij de waarde wordt ingesteld op 0. Op 64-bits systemen schakelt dit de meest significante 32 bits uit en behoudt de minste

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

significante 32 bits, equivalent aan $x & 0xFFFFFFFF

Opmerking: in dit voorbeeld wordt printf("%'06b") gebruikt. Het geeft de waarde weer in 6 binaire cijfers.

Object- en klasse-operators

Leden van objecten of klassen kunnen worden geopend met behulp van de objectoperator ( -> ) en de klasseoperator (: :: .

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)

Merk op dat na de objectoperator de $ niet moet worden geschreven ( $object->a plaats van $object->$a ). Voor de klasse-operator is dit niet het geval en de $ is noodzakelijk. Voor een constante die in de klasse is gedefinieerd, wordt de $ nooit gebruikt.

Merk ook op dat var_dump(MyClass::d()); is alleen toegestaan als de functie d() niet naar het object verwijst:

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

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

Dit veroorzaakt een 'PHP Fatal error: Uncaught Error: $ this using when not in object context'

Deze operators hebben associativiteit verlaten , die kan worden gebruikt voor 'chaining':

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)

Deze operatoren hebben de hoogste prioriteit (ze worden zelfs niet in de handleiding genoemd), zelfs hoger dan die clone . Dus:

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)

De waarde van $o1 wordt opgeteld voordat het object wordt gekloond!

Merk op dat het gebruik van haakjes om de prioriteit te beïnvloeden niet werkte in PHP versie 5 en ouder (wel 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