PHP
operatori

introduzione

Osservazioni

Operatori di stringhe (. E. =)

Ci sono solo due operatori di stringhe:

• Concatenazione di due stringhe (punto):

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

• Assegnazione concatenata (punto =):

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

Assegnazione di base (=)

$a = "some string";

risulta in $a che ha il valore di some string .

Il risultato di un'espressione di assegnazione è il valore assegnato. Si noti che un singolo segno di uguale = NON è per il confronto!

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

fa quanto segue:

1. La riga 1 assegna da 3 a $a .
2. La riga 2 assegna da 5 a $a . Questa espressione produce anche il valore 5 .
3. La riga 2 assegna quindi il risultato dell'espressione tra parentesi ( 5 ) a $b .

Quindi: sia $a che $b ora hanno valore 5 .

Assegnazione combinata (+ = ecc.)

Gli operatori di assegnazione combinati sono una scorciatoia per un'operazione su alcune variabili e successivamente assegnano questo nuovo valore a quella variabile.

Aritmetica:

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

Elaborazione di più array insieme

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

Concatenazione combinata e assegnazione di una stringa:

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

Operatori di assegnazione bit a bit binari combinati:

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

Modifica della precedenza dell'operatore (con parentesi)

L'ordine in cui vengono valutati gli operatori è determinato dalla precedenza degli operatori (vedere anche la sezione Note).

Nel

$a = 2 * 3 + 4;

$a ottiene un valore di 10 perché 2 * 3 viene valutato per primo (la moltiplicazione ha una precedenza più alta rispetto all'addizione) producendo un risultato secondario di 6 + 4 , che equivale a 10.

La precedenza può essere modificata usando parentesi: in

$a = 2 * (3 + 4);

$a ottiene un valore di 14 perché (3 + 4) viene valutato per primo.

Associazione

Associazione sinistra

Se la prece- denza di due operatori è uguale, l'associatività determina il raggruppamento (vedere anche la sezione Osservazioni):

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

* e % hanno uguale precedenza e associatività a sinistra . Perché la moltiplicazione avviene prima (a sinistra), è raggruppata.

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

Ora, l'operatore modulo si verifica prima (a sinistra) ed è quindi raggruppato.

Giusta associazione

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

Sia $a che $b ora hanno valore 2 perché $b += 1 è raggruppato e quindi il risultato ( $b è 2 ) è assegnato a $a .

Operatori di confronto

Uguaglianza

Per il test di uguaglianza di base, viene utilizzato l'operatore uguale == . Per controlli più completi, utilizzare l'operatore identico === .

L'operatore identico funziona allo stesso modo dell'operatore uguale, richiedendo che i suoi operandi abbiano lo stesso valore, ma richiede anche che abbiano lo stesso tipo di dati.

Ad esempio, nell'esempio seguente verrà visualizzato 'aeb sono uguali', ma non 'aeb sono identici'.

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

Quando si utilizza l'operatore uguale, le stringhe numeriche vengono convertite in numeri interi.

Confronto di oggetti

=== confronta due oggetti controllando se sono esattamente la stessa istanza . Ciò significa che il new stdClass() === new stdClass() risolve in falso, anche se sono creati nello stesso modo (e hanno gli stessi identici valori).

== confronta due oggetti controllando in modo ricorsivo se sono uguali ( equazioni profonde ). Ciò significa, per $a == $b , se $a e $b sono:

1. della stessa classe
2. avere le stesse proprietà impostate, incluse le proprietà dinamiche
3. per ogni proprietà $property set di $property , $a->property == $b->property è vera (quindi controllato ricorsivamente).

Altri operatori di uso comune

Loro includono:

1. Maggiore di ( > )
2. Meno di ( < )
3. Maggiore o uguale a ( >= )
4. Minore di o uguale a ( <= )
5. Non uguale a ( != )
6. Non identicamente uguale a ( !== )

1. Superiore a: $a > $b , ritorna true se $a 'valore di s è maggiore di $b , altrimenti restituisce false.

Esempio :

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

2. Minore di: $a < $b , restituisce true se $a valore di s' è più piccola che di $b , altrimenti restituisce false.

Esempio :

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

3. Maggiore di o uguale a: $a >= $b , ritorna true se $a valore di s' è o superiore di $b o uguale a $b , altrimenti restituisce false .

Esempio :

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

4. Minore o uguale a: $a <= $b , ritorna true se $a 'valore di s è uno dei più piccolo di $b o uguale a $b , altrimenti restituisce false .

Esempio :

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

5/6. Non uguale / identico a: per ripetere l'esempio precedente sull'uguaglianza, nell'esempio seguente verrà visualizzato 'aeb non sono identici', ma non 'aeb non sono uguali'.

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

Operatore di astronave (<=>)

PHP 7 introduce un nuovo tipo di operatore, che può essere utilizzato per confrontare le espressioni. Questo operatore restituirà -1, 0 o 1 se la prima espressione è minore di, uguale a o maggiore della seconda espressione.

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

Gli oggetti non sono confrontabili e così facendo si otterranno comportamenti non definiti.

Questo operatore è particolarmente utile quando si scrive una funzione di confronto definita dall'utente utilizzando usort , uasort o uksort . Data una serie di oggetti da ordinare in base alla loro proprietà weight , ad esempio, una funzione anonima può utilizzare <=> per restituire il valore atteso dalle funzioni di ordinamento.

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

In PHP 5 questo avrebbe richiesto un'espressione piuttosto più elaborata.

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

Null Coalescing Operator (??)

Null coalescing è un nuovo operatore introdotto in PHP 7. Questo operatore restituisce il suo primo operando se è impostato e non NULL . Altrimenti restituirà il suo secondo operando.

Il seguente esempio:

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

è equivalente a entrambi:

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

e:

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

Questo operatore può anche essere incatenato (con semantica associativa a destra):

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

che è equivalente a:

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

Nota:
Quando si utilizza l'operatore di coalescenza sulla concatenazione di stringhe, non dimenticare di usare parentesi ()

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

Questo produrrà solo John , e se il suo $ firstName è null e $ lastName è Doe , emetterà Unknown Doe . Per generare John Doe , dobbiamo usare parentesi come questa.

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

Questo produrrà solo John Doe invece di John .

instanceof (tipo operatore)

Per verificare se alcuni oggetti sono di una certa classe, l'operatore instanceof (binario) può essere utilizzato da PHP versione 5.

Il primo parametro (a sinistra) è l'oggetto da testare. Se questa variabile non è un oggetto, instanceof restituisce sempre false . Se viene utilizzata un'espressione costante, viene generato un errore.

Il secondo parametro (a destra) è la classe con cui confrontare. La classe può essere fornita come nome di classe stesso, una variabile stringa contenente il nome della classe (non una costante di stringa!) O un oggetto di quella classe.

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 può anche essere usato per verificare se un oggetto è di una classe che estende un'altra classe o implementa una qualche interfaccia:

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;

Per verificare se un oggetto non è di qualche classe, è possibile utilizzare l'operatore not ( ! ):

class MyClass {
}

class OtherClass {
}

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

Nota che le parentesi intorno a $o instanceof MyClass non sono necessarie perché instanceof ha una precedenza più alta di ! , sebbene possa rendere il codice più leggibile con parentesi.

Avvertenze

Se una classe non esiste, le funzioni di autoload registrate vengono chiamate per provare a definire la classe (questo è un argomento al di fuori dell'ambito di questa parte della documentazione!). Nelle versioni di PHP precedenti alla 5.1.0, l'operatore instanceof avrebbe attivato anche queste chiamate, definendo quindi la classe (e se la classe non poteva essere definita, si sarebbe verificato un errore fatale). Per evitare ciò, usa una stringa:

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

A partire dalla versione 5.1.0 di PHP, i caricatori automatici registrati non vengono più chiamati in queste situazioni.

Versioni precedenti di PHP (prima di 5.0)

Nelle versioni precedenti di PHP (precedenti alla 5.0), la funzione is_a può essere utilizzata per determinare se un oggetto è di una classe. Questa funzione è stata dichiarata obsoleta in PHP versione 5 e undeprecated in PHP versione 5.3.0.

Operatore ternario (? :)

L'operatore ternario può essere pensato come un'istruzione in linea if . Consiste di tre parti. L' operator e due risultati. La sintassi è la seguente:

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

Se l' operator viene valutato come true , verrà restituito il valore nel primo blocco ( <true value> ), altrimenti verrà restituito il valore nel secondo blocco ( <false value> ). Dato che stiamo impostando $value sul risultato del nostro operatore ternario, esso memorizzerà il valore restituito.

Esempio:

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

$action conterrà la stringa 'default' se empty($_POST['action']) restituisce true. Altrimenti conterrebbe il valore di $_POST['action'] .

L'espressione (expr1) ? (expr2) : (expr3) restituisce expr2 se expr1 restituisce true , e expr3 se expr1 restituisce false .

È possibile escludere la parte centrale dell'operatore ternario. Espressione expr1 ?: expr3 rendimenti expr1 se expr1 è TRUE, e expr3 altrimenti. ?: è spesso indicato come operatore Elvis .

Questo si comporta come l' operatore Null Coalescing ?? , tranne che ?? richiede che l'operando di sinistra sia esattamente null mentre ?: prova a risolvere l'operando di sinistra in un booleano e controlla se si risolve in booleano false .

Esempio:

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

In questo esempio, setWidth accetta un parametro width, o default 0, per modificare il valore della larghezza della sessione. Se $width è 0 (se $width non è fornito), che si risolve in boolean false, viene utilizzato invece il valore di getDefaultWidth() . La funzione getDefaultWidth() non verrà chiamata se $width non si risolve in booleano false.

Fare riferimento a Tipi per ulteriori informazioni sulla conversione di variabili in booleana.

Incrementare (++) e decrementare gli operatori (-)

Le variabili possono essere incrementate o decrementate di 1 con ++ o -- , rispettivamente. Possono precedere o succedere variabili e variare leggermente semanticamente, come mostrato di seguito.

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

Ulteriori informazioni sugli operatori di incremento e decremento sono disponibili nella documentazione ufficiale .

Operatore di esecuzione (``)

L'operatore di esecuzione PHP è costituito da backtick (``) e viene utilizzato per eseguire comandi di shell. L'output del comando verrà restituito e, pertanto, può essere memorizzato in una variabile.

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

Si noti che l'operatore execute e shell_exec() daranno lo stesso risultato.

Operatori logici (&& / AND e || / OR)

In PHP, ci sono due versioni degli operatori logici AND e OR.

Nota che && e || gli operer hanno una precedenza maggiore di and e or . Vedi la tabella qui sotto:

Per questo motivo è più sicuro usare && e || invece di and e or .

Operatori bit a bit

Prefisso operatori bit a bit

Gli operatori bit a bit sono come operatori logici ma eseguiti per bit anziché per valore booleano.

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

Operatori bitmask-bitmask

AND bit a bit & : un bit è impostato solo se si trova in entrambi gli operandi

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

Bitwise OR | : un bit è impostato se è impostato su uno o su entrambi gli operandi

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

Bit XOR ^ : un bit viene impostato se è impostato in un operando e non impostato in un altro operando, cioè solo se quel bit si trova in uno stato diverso nei due operandi

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

Esempi di utilizzo di maschere di bit

Questi operatori possono essere utilizzati per manipolare le maschere di bit. Per esempio:

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

Qui, il | l'operatore è usato per combinare le due maschere di bit. Sebbene + abbia lo stesso effetto, | sottolinea che stai combinando le maschere di bit, non aggiungendo due normali valori scalari.

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

Questo esempio (supponendo che l' $option contenga sempre solo un bit) utilizza:

• l'operatore ^ per alternare comodamente le maschere di bit.
• il | operatore per impostare un po 'trascurando il suo stato originale o altri bit
• l'operatore ~ per convertire un numero intero con un solo bit impostato in un numero intero con un solo bit non impostato
• l'operatore & per disinserire un bit, usando queste proprietà di & :
  • Dal momento che &= con un bit impostato non farà nulla ( (1 & 1) === 1 , (0 & 1) === 0 ), facendo &= con un intero con un solo bit non impostato, disattiverà solo quel bit , non influenzando altri bit.
  • &= con un bit non impostato disattiverà quel bit ( (1 & 0) === 0 , (0 & 0) === 0 )
• Usando l'operatore & con un'altra maschera di bit si filtrano tutti gli altri bit non impostati in quella maschera di bit.
  • Se l'output ha qualche bit impostato, significa che ognuna delle opzioni è abilitata.
  • Se l'output ha tutti i bit della serie di maschere di bit, significa che tutte le opzioni nella maschera di bit sono abilitate.

Tenete a mente che questi operatori di confronto: ( < > <= >= == === != !== <> <=> ) hanno precedenza maggiore rispetto questi operatori maschera di bit-maschera di bit: ( | ^ & ). Poiché i risultati bit a bit vengono spesso confrontati utilizzando questi operatori di confronto, questo è un errore comune da tenere presente.

Operatori che cambiano bit

Spostamento a sinistra bit a bit << : sposta tutti i bit a sinistra (più significativi) del numero di passi specificato e scarta i bit che superano la dimensione int

<< $x equivale a disabilitare i più alti $x bit e moltiplicare per $x th di potenza di 2

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

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

Spostamento a destra bit a bit >> : eliminare lo spostamento più basso e spostare i bit rimanenti a destra (meno significativo)

>> $x equivale a dividere per $x th di potenza di 2 e scartare la parte non intera

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

Esempi di utilizzo del cambio di bit:

Divisione veloce per 16 (prestazione migliore di /= 16 )

$x >>= 4;

Nei sistemi a 32 bit, questo elimina tutti i bit nel numero intero, impostando il valore su 0. Sui sistemi a 64 bit, questo elimina i 32 bit più significativi e mantiene il minimo

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

32 bit significativi, equivalenti a $x & 0xFFFFFFFF

Nota: in questo esempio viene utilizzato printf("%'06b") . Emette il valore in 6 cifre binarie.

Operatori di oggetti e classi

È possibile accedere ai membri di oggetti o classi utilizzando l'operatore oggetto ( -> ) e l'operatore di classe ( :: .

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)

Si noti che dopo l'operatore dell'oggetto, $ non deve essere scritto ( $object->a invece di $object->$a ). Per l'operatore di classe, questo non è il caso e il $ è necessario. Per una costante definita nella classe, $ non viene mai utilizzato.

Si noti inoltre che var_dump(MyClass::d()); è consentito solo se la funzione d() non fa riferimento l'oggetto:

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

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

Ciò causa un errore "Fatal PHP": Errore non rilevato: utilizzo di $ this quando non nel contesto dell'oggetto "

Questi operatori hanno lasciato l' associatività, che può essere usata per "concatenare":

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)

Questi operatori hanno la precedenza più alta (non sono nemmeno menzionati nel manuale), ancora più alto di quello clone . Così:

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)

Il valore di $o1 viene aggiunto prima che l'oggetto sia clonato!

Nota che l'uso delle parentesi per influenzare la precedenza non funzionava nella versione 5 di PHP e precedenti (lo fa 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