Operații în PHP

În PHP putem folosi diferiți operatori: aritmetici, logici etc. Să examinăm fiecare tip de operații.

Operații aritmetice

• + (operație de adunare) De exemplu, $a + 5
• - (operație de scădere) De exemplu, $a - 5
• * (operație de înmulțire) De exemplu, $a * 5
• / (operație de împărțire) De exemplu, $a / 5
• % (obținerea restului de la împărțire)

De exemplu:

$a = 12;
echo $a % 5; // egal 2

• ** (ridicare la putere) De exemplu, $a ** 2

Exemple de operații:

$a = 8 + 2; // 10, adunare
$a = 8 - 2; // 6, scădere
$a = 8 * 2; // 16, înmulțire
$a = 8 / 2; // 4, împărțire
$a = 8 % 2; // 0, împărțire pe modulo
$a = 8 ** 2; // 64, ridicare la putere

Increment și decrement

Trebuie menționat separat operațiile de increment și decrement, care sunt, de asemenea, operații aritmetice, dar sunt efectuate pe un singur operand.

Increment - operația ++ mărește numărul cu unul. De exemplu, ++$a

Există două tipuri de increment: increment prefixat (++$a) și postfixat ($a++). Este important să înțelegem diferența dintre aceste operații. Să analizăm mai întâi incrementul prefixat:

$a = 12;
$b = ++$a; // $b egal 13
echo "a = $a   b = $b";

Rezultatul lucrării:

a = 13 b = 13

Aici mai întâi valoarea variabilei $a se mărește cu unul, apoi valoarea sa este atribuită variabilei $b.

Acum să vedem ce se întâmplă în cazul incrementului postfixat:

$a = 12;
$b = $a++; // $b egal 12
echo "a = $a   b = $b";

Rezultatul lucrării:

a = 13 b = 12

Aici mai întâi valoarea variabilei $a este atribuită variabilei $b, iar apoi valoarea variabilei $a este mărită.

Decrement - operația -- reprezintă scăderea valorii cu unul. De asemenea, există două tipuri: decrement prefixat și postfixat, și funcționează similar. De exemplu, decrementul prefixat:

$a = 12;
$b = --$a; // $b egal 11
echo "a = $a   b = $b";

Rezultatul lucrării:

a = 11 b = 11

Mai întâi valoarea variabilei $a scade cu unul, iar apoi valoarea sa este atribuită variabilei $b.

Decrementul postfixat:

$a = 12;
$b = $a--; // $b egal 12
echo "a = $a   b = $b";

Rezultatul lucrării:

a = 11 b = 12

Aici mai întâi valoarea variabilei $a este atribuită variabilei $b și numai după aceasta scade cu unul.

Concatenarea șirurilor

Pentru concatenarea șirurilor se folosește operatorul "punct". De exemplu, să unim câteva șiruri:

$a="Salut, ";
$b=" lume";
echo $a . " " . $b . "!";   // Salut lume!

Dacă variabilele nu reprezintă șiruri, ci alte tipuri, de exemplu, numere, valorile lor se convertesc în șiruri și apoi se realizează operația de concatenare a șirurilor.

Operații de comparare

Operațiile de comparare sunt de obicei folosite în construcții condiționate, când trebuie să comparăm două valori și, în funcție de rezultatul comparației, să executăm anumite acțiuni. Există următoarele operații de comparare.

• == Operatorul de egalitate compară două valori și, dacă sunt egale, returnează true, altfel returnează false: $a == 5
• === Operatorul de identitate compară două valori și, dacă sunt egale, returnează true, altfel returnează false: $a === 5
• != Compară două valori și, dacă nu sunt egale, returnează true, altfel returnează false: $a != 5
• !== Compară două valori și, dacă nu sunt egale, returnează true, altfel returnează false: $a !== 5
• > Compară două valori și, dacă prima este mai mare decât a doua, returnează true, altfel returnează false: $a > 5
• < Compară două valori și, dacă prima este mai mică decât a doua, returnează true, altfel returnează false: $a < 5
• >= Compară două valori și, dacă prima este mai mare sau egală cu a doua, returnează true, altfel returnează false: $a >= 5
• <= Compară două valori și, dacă prima este mai mică sau egală cu a doua, returnează true, altfel returnează false: $a <= 5

Operatorul de egalitate și identitate

Ambii operatori compară două expresii și returnează true dacă expresiile sunt egale. Dar între ele există diferențe. Dacă în operația de egalitate participă două valori de tipuri diferite, acestea sunt convertite la unul - cel pe care interpretatorul îl consideră optim. De exemplu:

$a = (2 == "2");    // true (valorile sunt egale)
$b = (2 === "2");   // false (valorile reprezintă tipuri diferite)

Șirul "2" în esență reprezintă aceeași valoare ca și numărul 2, operatorul de comparare va returna true. Cu toate acestea, ele reprezintă tipuri diferite, astfel operatorul de identitate va returna false.

Similar funcționează operatorii de inegalitate != și !==.

$a = (2 != "2");    // false, deoarece valorile sunt egale
$b = (2 !== "2");   // true, deoarece valorile reprezintă tipuri diferite

Operatorul <=>

Trebuie menționat separat operatorul <=>. El compară două valori și returnează

• 0, dacă ambele valori sunt egale
• 1, dacă valoarea din stânga este mai mare decât valoarea din dreapta
• -1, dacă valoarea din stânga este mai mică decât valoarea din dreapta

Aplicare:

$a = 2 <=> 2;     // 0    (echivalent cu 2 == 2)
$b = 3 <=> 2;     // 1    (echivalent cu 3 > 2)
$c = 1 <=> 2;     // -1   (echivalent cu 1 < 2)
echo "a=$a   b=$b   c=$c";  // a=0  b=1  c=-1

Operații logice

Operațiile logice sunt de obicei folosite pentru a combina rezultatele a două operații de comparare. De exemplu, trebuie să executăm o anumită acțiune dacă sunt adevărate mai multe condiții. Există următoarele operații logice:

• && - Returnează true, dacă ambele operații de comparare returnează true, altfel returnează false: $a && $b
• and - Similar operației &&: $a and $b
• || - Returnează true, dacă cel puțin una dintre operațiile de comparare returnează true, altfel returnează false: $a || $b
• or - Similar operației ||: $a or $b
• ! - Returnează true, dacă operația de comparare returnează false: !$a
• xor - Returnează true, dacă doar una dintre valori este egală cu true. Dacă ambele sunt egale cu true sau niciuna dintre ele nu este egală cu true, returnează false: $a xor $b

Exemple de operații logice:

$a = (true && false);   // false
// similar
$a = (true and false);  // false

$b = (true || false); // true
// similar următoarei operații
$b = (true or false); // true

$c = !true;           // false

Separat, exemple cu operația xor:

$a = (true xor true);   // false
$b = (false xor true);  // true
$c = (false xor false); // false

Operații pe biți.

Operațiile pe biți sunt efectuate pe anumite biți ai unui număr. Numerele sunt considerate în reprezentare binară, de exemplu, 2 în reprezentare binară este 010, iar numărul 7 este -111.

• & (înmulțire logică)

Înmulțirea se efectuează pe biți și dacă ambii operanzi au valori ale biților egale cu 1, operația returnează 1, altfel returnează 0. De exemplu:

$a = 4; //100
$b = 5; //101
echo $a & $b; // egal 4 - 100

Aici numărul 4 în sistem binar este egal cu 100, iar numărul 5 este egal cu 101. Înmulțind pe biți numerele obținem (1*1, 0*0, 0*1) = 100, adică numărul 4 în format zecimal.

• | (adunare logică)

Similar cu înmulțirea logică, operația se efectuează pe biți, dar acum returnează 1 dacă cel puțin un bit din cei doi operanzi este 1. De exemplu:

$a = 4; //100
$b = 5; //101
echo $a | $b; // egal 5 - 101

Adunând pe biți numerele obținem (1+1, 0+0, 0+1) = 101, adică numărul 5 în format zecimal.

• ^ (operația XOR)

Returnează 1 dacă ambii operanzi au valori diferite ale biților corespunzători. Dar dacă ambii operanzi au valori egale ale biților corespunzători, returnează 0. De exemplu:

$a = 5 ^ 4; // 101^100=001 - în sistemul zecimal 1
$b = 7 ^ 4; // 111^100=011 - în sistemul zecimal 3

Efectuăm operația pe biți 5 ^ 4 (în sistem binar este echivalent cu 101^100): (1^1, 0^0, 0^1) = 001. În cazul 1^1, valorile biților sunt egale, astfel returnează 0. În al doilea caz - 0^0 valorile sunt de asemenea egale, astfel returnează tot 0. În al treilea caz - 0^1 valorile sunt diferite, astfel returnează 1. În final obținem 001 sau numărul 1 în sistemul zecimal.

• ~ (negație logică)

Inversează toți biții: dacă valoarea unui bit este 1, devine 0 și invers.

$a = 4;     //00000100  
$b = ~$a;   //11111011  -5
echo $b;    // egal -5

• <<

x<<y - deplasează numărul x la stânga cu y biți. De exemplu, 4<<1 deplasează numărul 4 (care în reprezentare binară este 100) cu un bit la stânga, rezultând 1000 sau numărul 8 în reprezentare zecimală

• >>

x>>y - deplasează numărul x la dreapta cu y biți. De exemplu, 16>>1 deplasează numărul 16 (care în reprezentare binară este 10000) cu un bit la dreapta, rezultând 1000 sau numărul 8 în reprezentare zecimală

Operații de atribuire

• =

Atribuie unei variabile o valoare specifică: $a = 5

• +=

Adunare cu atribuirea rezultatului. De exemplu:

$a=12;
$a += 5;
echo $a; // egal 17

• -=

Scădere cu atribuirea rezultatului. De exemplu:

$a=12;
$a -= 5;
echo $a; // egal 7

• *=

Înmulțire cu atribuirea rezultatului:

$a=12;
$a *= 5;
echo $a; // egal 60
/=

Împărțire cu atribuirea rezultatului:

$a=12;
$a /= 5;
echo $a; // egal 2.4

• .=

Concatenare de șiruri cu atribuirea rezultatului. Se aplică la două șiruri. Dacă variabilele stochează alte tipuri, de exemplu, numere, valorile lor se convertesc în șiruri și apoi se realizează operația:

$a=12;
$a .= 5;
echo $a; // egal 125
// identic
$b="12";
$b .="5"; // egal 125

• %=

Obținerea restului de la împărțire cu atribuirea rezultatului:

$a=12;
$a %= 5;
echo $a; // egal 2

• **=

Obținerea rezultatului ridicării la putere:

$a=8;
$a **= 2;
echo $a; // egal 64 (8 la puterea 2)

• &=

Obținerea rezultatului operației de înmulțire logică:

$a=5; $a &= 4; // 101&100=100 - 4

• |=

Obținerea rezultatului operației de adunare logică:

$a=5; $a |= 4; // 101|100=101 - 5

• ^=

Obținerea rezultatului operației XOR:

$a=5; $a ^= 4; // 101^100=001 - 1

• <<=

Obținerea rezultatului operației de deplasare la stânga:

$a=8; $a <<= 1; // 1000 << 1 = 10000 - 16

• >>=

Obținerea rezultatului operației de deplasare la dreapta:

$a=8; $a >>= 1; // 1000 >> 1 = 100 - 4

Prioritatea operațiilor

Dacă o expresie conține mai multe operații diferite, atunci la executarea expresiei se ia în considerare prioritatea operațiilor. Mai întâi se execută operațiile cu prioritate mai mare și la final cele cu prioritate mai mică.

Prioritatea operațiilor poate fi descrisă prin următorul tabel:

Cu cât operatorul este mai sus în acest tabel, cu atât are prioritate mai mare. De exemplu:

$a = 10 + 5 * 2;    // 20

Operația de înmulțire are prioritate mai mare decât adunarea. De aceea mai întâi se execută subexpresia 5 * 2

Parantezele cresc prioritatea operației folosite în expresie.

$a = (10 + 5) * 2;  // 30

În acest caz, mai întâi se execută subexpresia 10 + 5 și abia apoi înmulțirea.