PHP
operatörer

Introduktion

Anmärkningar

Strängoperatörer (. Och. =)

Det finns bara två strängoperatörer:

• Sammankoppling av två strängar (punkt):

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

• Sammanställningsuppgift (punkt =):

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

Grundläggande tilldelning (=)

$a = "some string";

resulterar i $a med värdet some string .

Resultatet av ett tilldelningsuttryck är värdet som tilldelas. Observera att ett enda lika tecken = INTE är för jämförelse!

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

gör följande:

1. Rad 1 tilldelar 3 till $a .
2. Rad 2 tilldelar 5 till $a . Detta uttryck ger också värde 5 .
3. Rad 2 tilldelar sedan resultatet av uttrycket i parentes ( 5 ) till $b .

Således: både $a och $b nu värde 5 .

Kombinerad tilldelning (+ = etc)

De kombinerade tilldelningsoperatörerna är en genväg för en operation på någon variabel och tilldelar därefter detta nya värde till den variabeln.

Aritmetisk:

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

Bearbetar flera matriser tillsammans

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

Kombinerad sammanlänkning och tilldelning av en sträng:

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

Kombinerade binära tilldelningsoperatörer:

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

Ändra operatörens prioritet (med parenteser)

Ordningen i vilken operatörerna utvärderas bestäms av operatörens prioritet (se även avsnittet Kommentarer).

I

$a = 2 * 3 + 4;

$a får ett värde av 10 eftersom 2 * 3 utvärderas först (multiplikation har högre företräde än tillägg) vilket ger ett delresultat av 6 + 4 , vilket motsvarar 10.

Företräde kan ändras med parenteser: in

$a = 2 * (3 + 4);

$a får ett värde av 14 eftersom (3 + 4) utvärderas först.

Förening

Vänsterförening

Om två operatörers företräde är lika bestämmer associativiteten grupperingen (se även avsnittet Anmärkningar):

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

* och % har samma prioritet och vänsterassociativitet . Eftersom multiplikationen sker först (vänster) grupperas den.

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

Nu inträffar moduloperatören först (vänster) och är således grupperad.

Rätt förening

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

Både $a och $b nu värde 2 eftersom $b += 1 är grupperade och resultatet ( $b är 2 ) tilldelas $a .

Jämförelseoperatörer

Jämlikhet

För grundläggande jämställdhetstest används den lika operatören == . För mer omfattande kontroller, använd samma operatör === .

Den identiska operatören fungerar på samma sätt som den lika operatören, vilket kräver att dess operander har samma värde, men kräver också att de har samma datatyp.

Exempelvis visar exemplet nedan 'a och b är lika', men inte 'a och b är identiska'.

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

När du använder den lika operatören kastas numeriska strängar till heltal.

Jämförelse av objekt

=== jämför två objekt genom att kontrollera om de är exakt samma instans . Detta innebär att new stdClass() === new stdClass() löser sig till falskt, även om de skapas på samma sätt (och har exakt samma värden).

== jämför två objekt genom rekursivt att kontrollera om de är lika ( djupa lika ). Det betyder, för $a == $b , om $a och $b är:

1. av samma klass
2. har samma egenskaper, inklusive dynamiska egenskaper
3. för varje fastighet $property är $a->property == $b->property sann (därför rekursivt kontrollerad).

Andra vanliga operatörer

De inkluderar:

1. Större än ( > )
2. Mindre än ( < )
3. Större än eller lika med ( >= )
4. Mindre än eller lika med ( <= )
5. Inte lika med ( != )
6. Inte identiskt lika med ( !== )

1. Större än : $a > $b , returnerar true om $a 's värde är större än på $b , annars returnerar falskt.

Exempel :

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

2. Mindre än : $a < $b , returnerar true om $a 's värde är mindre än $b , annars returnerar falskt.

Exempel :

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

3. Större än eller lika med : $a >= $b , returnerar true om $a värdet antingen är större än $b eller lika med $b , annars returnerar false .

Exempel :

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

4. Mindre än eller lika med : $a <= $b , returnerar true om $a 's värde är antingen mindre än $b eller lika med $b , annars returnerar false .

Exempel :

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

5/6. Inte lika / identisk med: För att skaka om det tidigare exemplet på jämlikhet kommer exemplet nedan att visa "a och b är inte identiska", men inte "a och b är inte lika".

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

Rymdskeppsoperatör (<=>)

PHP 7 introducerar en ny typ av operatör som kan användas för att jämföra uttryck. Denna operatör returnerar -1, 0 eller 1 om det första uttrycket är mindre än, lika med eller större än det andra uttrycket.

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

Objekt är inte jämförbara, och så kommer detta att leda till odefinierat beteende.

Den här operatören är särskilt användbar när du skriver en användardefinierad jämförelsefunktion med usort , uasort eller uksort . Med tanke på en mängd objekt som ska sorteras efter deras weight , till exempel, kan en anonym funktion använda <=> att returnera värdet som förväntas av sorteringsfunktionerna.

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

I PHP 5 skulle detta kräva ett ganska mer detaljerat uttryck.

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

Null Coalescing Operator (??)

Null coalescing är en ny operatör som introduceras i PHP 7. Denna operatör returnerar sin första operand om den är inställd och inte NULL . Annars kommer den att returnera sin andra operand.

Följande exempel:

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

motsvarar båda:

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

och:

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

Denna operatör kan också kedjas (med högerassocierande semantik):

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

vilket motsvarar:

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

Notera:
Glöm inte att använda parenteser när du använder coalescing-operatör på strängkoncatenation ()

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

Detta kommer endast att mata ut John , och om dess $ firstName är noll och $ lastName är Doe kommer det att mata ut Unknown Doe . För att mata ut John Doe måste vi använda parenteser som detta.

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

Detta kommer att mata ut John Doe istället för John .

instans av (typoperatör)

För att kontrollera om något objekt tillhör en viss klass, instanceof operatörens (binära) instanceof användas sedan PHP version 5.

Den första (vänster) parametern är objektet som ska testas. Om denna variabel inte är ett objekt, returnerar instanceof alltid false . Om ett konstant uttryck används kastas ett fel.

Den andra (höger) parametern är klassen att jämföra med. Klassen kan tillhandahållas som själva klassnamnet, en strängvariabel som innehåller klassnamnet (inte en strängkonstant!) Eller ett objekt i den klassen.

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 också användas för att kontrollera om ett objekt tillhör någon klass som utökar en annan klass eller implementerar ett gränssnitt:

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;

För att kontrollera om ett objekt inte tillhör någon klass kan inte operatören ( ! ) Användas:

class MyClass {
}

class OtherClass {
}

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

Observera att parenteser runt $o instanceof MyClass inte behövs eftersom instanceof har högre prioritet än ! , även om det kan göra koden bättre läsbar med parenteser.

förbehåll

Om det inte finns en klass, kallas de registrerade autoloadfunktionerna för att försöka definiera klassen (detta är ett ämne utanför ramen för denna del av dokumentationen!). I PHP-versioner före 5.1.0 skulle operatörens instanceof också utlösa dessa samtal och definiera faktiskt klassen (och om klassen inte kunde definieras skulle ett dödligt fel uppstå). Använd en sträng för att undvika detta:

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

Från PHP version 5.1.0 kallas de registrerade autoloadrarna inte längre i dessa situationer.

Äldre versioner av PHP (före 5.0)

I äldre versioner av PHP (före 5.0) is_a funktionen is_a användas för att bestämma om ett objekt tillhör någon klass. Den här funktionen avskrivs i PHP version 5 och utskrivs inte i PHP version 5.3.0.

Ternary Operator (? :)

Den ternära operatören kan betraktas som en inline if uttalande. Den består av tre delar. operator och två resultat. Syntaxen är som följer:

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

Om operator utvärderas som true , kommer värdet i det första blocket att returneras ( <true value> ), annars kommer värdet i det andra blocket att returneras ( <false value> ). Eftersom vi sätter $value till resultatet från vår ternära operatör kommer det att lagra det returnerade värdet.

Exempel:

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

$action skulle innehålla strängen 'default' om empty($_POST['action']) utvärderas till true. Annars skulle det innehålla värdet på $_POST['action'] .

Uttrycket (expr1) ? (expr2) : (expr3) utvärderar till expr2 om expr1 utvärderar till true och expr3 om expr1 utvärderar till false .

Det är möjligt att lämna den mellersta delen av den ternära operatören. Uttryck expr1 ?: expr3 returnerar expr1 om expr1 utvärderar till SANT och expr3 annars. ?: kallas ofta Elvis- operatör.

Detta uppför sig som operatören Null Coalescing ?? , utom det ?? kräver att den vänstra operanden är exakt null medan ?: försöker lösa den vänstra operanden till en booleska och kontrollera om den löser sig att boolsk false .

Exempel:

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

I det här exemplet accepterar setWidth en setWidth , eller standard 0, för att ändra breddssessionens värde. Om $width är 0 (om $width inte tillhandahålls), vilket kommer att lösa till boolean falskt, används värdet på getDefaultWidth() istället. getDefaultWidth() kommer inte att anropas om $width inte löstes till boolesk falsk.

Se Typer för mer information om konvertering av variabler till booleska.

Incrementing (++) and Decrementing Operators (-)

Variabler kan ökas eller minskas med 1 med ++ respektive -- . De kan antingen föregå eller lyckas variabler och variera något semantiskt, som visas nedan.

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

Mer information om inkrementering och dekrementering av operatörer finns i den officiella dokumentationen .

Exekveringsoperatör (``)

PHP-exekveringsoperatören består av backticks (``) och används för att köra skalkommandon. Utgången från kommandot returneras och kan därför lagras i en variabel.

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

Observera att den exekverande operatören och shell_exec() ger samma resultat.

Logiska operatörer (&& / AND och || / OR)

I PHP finns det två versioner av logiska AND- och OR-operatörer.

Observera att && och || operatörer har högre prioritet än and och or . Se tabell nedan:

På grund av detta är det säkrare att använda && och || istället för and och or .

Bitvisa operatörer

Prefix bitvis operatörer

Bitvisa operatörer är som logiska operatörer men körs per bit snarare än per booleskt värde.

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

Bitmask-bitmaskoperatörer

Bitvis OCH & : en bit ställs endast in om den är inställd i båda operanderna

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

Bitvis ELLER | : En bit är inställd om den är inställd i endera eller båda operanderna

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

Bitvis XOR ^ : en bit är inställd om den är inställd i en operand och inte inställd i en annan operand, dvs. bara om den biten är i olika tillstånd i de två operandema

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

Exempel på användning av bitmasker

Dessa operatörer kan användas för att manipulera bitmasks. Till exempel:

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

Här, | operator används för att kombinera de två bitmaskerna. Även om + har samma effekt, | betonar att du kombinerar bitmasker och inte lägger till två normala skalheltal.

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

Detta exempel (förutsatt att $option alltid alltid innehåller en bit) använder:

• ^ -operatören för att enkelt växla bitmasks.
• den | operatören att ställa in lite försummar dess ursprungliga tillstånd eller andra bitar
• ~ -operatören för att konvertera ett heltal med endast en bituppsättning till ett heltal med endast en bit inte inställd
• & operatören för att återställa lite, med hjälp av dessa egenskaper för & :
  • Eftersom &= med en inställd bit inte kommer att göra någonting ( (1 & 1) === 1 , (0 & 1) === 0 ), gör &= med ett heltal med bara en bit inte inställt kommer bara att återställa den biten , påverkar inte andra bitar.
  • &= med en ouppsatt bit kommer att återställa den biten ( (1 & 0) === 0 , (0 & 0) === 0 )
• Om du använder & operatören med en annan bitmask filtreras bort alla andra bitar som inte är inställda i den bitmasken.
  • Om utgången har några bitar inställd betyder det att något av alternativen är aktiverade.
  • Om utgången har alla bitar i bitmaskuppsättningen, betyder det att alla alternativ i bitmasken är aktiverade.

Tänk på att dessa jämförelseoperatorer ( < > <= >= == === != !== <> <=> ) har högre prioritet än dessa bitmask-bitmask operatörer: ( | ^ & ). Eftersom bitvisa resultat jämförs ofta med hjälp av dessa jämförelser är detta en vanlig fallgrop att vara medveten om.

Bitskiftande operatörer

Bitvis vänsterskift << : flytta alla bitar till vänster (mer betydelsefulla) med det angivna antalet steg och släng bitarna som överstiger int-storleken

<< $x motsvarar att ställa in de högsta $x bitarna och multiplicera med $x effekten på 2

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

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

Bitvis högerväxling >> : kasta den lägsta växlingen och flytta återstående bitar åt höger (mindre betydande)

>> $x motsvarar att dela med $x e kraften på 2 och kassera den icke-heltaliga delen

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

Exempel på användning av bitskiftning:

Snabb division med 16 (bättre prestanda än /= 16 )

$x >>= 4;

På 32-bitars-system kasserar detta alla bitar i heltalet och ställer in värdet på 0. I 64-bitars-system återställer detta de mest betydande 32 bitarna och håller minst

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

betydande 32 bitar, motsvarande $x & 0xFFFFFFFF

Obs: I det här exemplet används printf("%'06b") . Det matar ut värdet i 6 binära siffror.

Objekt och klassoperatörer

Medlemmar av objekt eller klasser kan nås med hjälp av objektoperatören ( -> ) och klassoperatören (: :: .

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)

Observera att efter objektoperatören ska $ inte skrivas ( $object->a istället för $object->$a ). För klassoperatören är detta inte fallet och $ är nödvändig. För en konstant definierad i klassen används aldrig $ .

Observera också att var_dump(MyClass::d()); är endast tillåtet om funktionen d() inte refererar till objektet:

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

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

Detta orsakar ett "PHP Fatal-fel: Okänt fel: Att använda $ detta när det inte är i objektsammanhang"

Dessa operatörer har lämnat associativitet, som kan användas för "kedja":

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)

Dessa operatörer har högsta prioritet (de nämns inte ens i manualen), ännu högre clone . Således:

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)

Värdet på $o1 läggs till innan objektet klonas!

Observera att användning av parenteser för att påverka företräde inte fungerade i PHP version 5 och äldre (det gör i 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