Logica este baza oricărui program, așa că veți dori să stăpâniți operatorii logici pentru a vă structura codul în mod eficient.

Operatorii logici vă permit să efectuați operații logice pe valori booleene. Vă permit să combinați, să anulați sau să comparați valori booleene și să luați decizii logice în codul dvs. pe baza rezultatului.

Explorați diferiții operatori logici pe care îi acceptă JavaScript, inclusiv operatorul de coalescere ES6 Nullish.

Operatorul logic și (&&).

Operatorul AND (&&) este un operator logic care revine Adevărat dacă ambii operanzi evaluează la Adevărat și fals in caz contrar.

Iată sintaxa operatorului AND:

a && b

Iată un exemplu de operator AND în uz:

const a = 5;
const b = 10;
const c = 15;
const rezultat_1 = (a < b) && (b < c);
consolă.log (rezultat_1); // Adevărat
const rezultat_2 = (a > b) && (b < c);
consolă.log (rezultat_2); // fals

În acest exemplu, rezultat_1 evaluează să Adevărat deoarece cei doi operanzi din expresie evaluează la Adevărat. In orice caz, rezultat_2 evaluează să fals deoarece primul operand (a > b) se intoarce fals.

instagram viewer

Dacă ambii operanzi nu sunt booleeni, JavaScript va încerca să le convertească în valori booleene înainte de a evalua expresia. Pentru a le converti în boolean, JavaScript evaluează mai întâi dacă valorile sunt adevărate sau false.

JavaScript consideră orice valoare care nu este în mod explicit falsă, o valoare adevărată. Când sunt convertite, ei se evaluează la un boolean Adevărat.

Cu toate acestea, anumite valori și tipuri de date în JavaScript sunt false, așa că atunci când JavaScript le convertește, evaluează la un boolean fals.

Valorile false din JavaScript sunt:

  • fals
  • nul
  • nedefinit
  • NaN (Nu este un număr)
  • 0
  • BigInt (0n)
  • Șir gol ("" sau '' sau ``)
  • nedefinit

Când utilizați operatorul AND pentru a evalua valori non-booleene, expresia returnează imediat valoarea primului operand dacă operandul este fals fără a evalua al doilea. Acest comportament este cunoscut sub numele de scurtcircuitare și îl puteți folosi pentru a scrie declarații condiționale în JavaScript.

Totuși, dacă primul operand este adevărat, expresia continuă să evalueze al doilea operand. Dacă al doilea operand este adevărat, îl returnează.

De exemplu:

const a = 5;
const b = 'Buna ziua';
const c = nul;
const rezultat_1 = a && b;
consolă.log (rezultat_1); // "Buna ziua"
const rezultat_2 = c && b;
consolă.log (rezultat_2); // nul

În acest exemplu, rezultat_1 evaluează „Bună ziua”, deoarece ambii operanzi din expresie sunt adevărați. In orice caz, rezultat_2 scurtcircuite și retururi nul fără evaluarea celui de-al doilea operand.

Rețineți că dacă există mai mulți operanzi, operatorul AND va continua să îi evalueze până când va întâlni o valoare falsă. Dacă nu întâlnește o valoare falsă, returnează ultima valoare adevărată pe care o întâlnește.

Operatorul logic SAU (||).

Operatorul SAU (||) este un operator logic care returnează Adevărat dacă și numai dacă unul sau mai mulți operanzi ai săi este Adevărat. Doar se întoarce fals când ambii operanzi sunt fals.

Iată sintaxa operatorului SAU:

a || b

Iată un exemplu de operator OR utilizat:

const a = 5;
const b = 10;
const c = 15;
const rezultat_1 = (a < b) || (b < c);
consolă.log (rezultat_1); // Adevărat


const rezultat_2 = (a > b) || (b < c);
consolă.log (rezultat_2); // Adevărat
const rezultat_3 = (a > b) || (b > c);
consolă.log (rezultat_3); // fals

În exemplul de mai sus, rezultat_1 evaluează să Adevărat deoarece ambii operanzi din expresie evaluează la Adevărat. rezultat_2 evaluează să Adevărat deoarece al doilea operand evaluează la Adevărat. rezultat_3 evaluează să fals deoarece cei doi operanzi din expresie evaluează la fals.

Când utilizați operatorul OR în contexte non-booleene, JavaScript încearcă să convertească în valori booleene înainte de a evalua expresia.

Când expresia este evaluată, dacă primul operand este adevărat, operatorul scurtcircuitează și îl returnează. Totuși, dacă este fals, se evaluează următorul operand până când întâlnește un operand adevărat. Dacă nu există operanzi adevărați în expresie, aceasta returnează ultima valoare falsă pe care o întâlnește.

De exemplu:

const a = 5;
const b = 'Buna ziua';
const c = nul;
const rezultat_1 = a || b;
consolă.log (rezultat_1); // 5


const rezultat_2 = c || b;
consolă.log (rezultat_2); // "Buna ziua"
const rezultat_3 = c || " ";
consolă.log (rezultat_3); // " "

În exemplul de mai sus, rezultat_1 scurtcircuite și retururi 5 pentru că este o valoare adevărată. rezultat_2 returnează „Bună ziua”, deoarece este prima valoare de adevăr pe care o întâlnește în expresie. rezultat_3 returnează un șir gol deoarece este ultima valoare falsă din expresie.

Operatorul logic NOT (!).

Operatorul logic NOT (!) este un operator unar care returnează valoarea booleană opusă a operandului său.

Iată sintaxa operatorului NOT:

!X

Unde X este o valoare booleană sau adevărată sau falsă.

Iată un exemplu de operator NOT utilizat:

const a = 5;
const b = '';
const c = Adevărat;
const rezultat_1 = !a;
consolă.log (rezultat_1); // fals


const rezultat_2 = !b;
consolă.log (rezultat_2); // Adevărat
const rezultat_3 = !c;
consolă.log (rezultat_3); // fals

În exemplul de mai sus, operatorul NOT returnează valoarea inversă a operanzilor booleeni. Când utilizați operatorul NOT în contexte non-booleene (rezultat_1 & rezultat_2), convertește valorile de adevăr în valoarea inversă a Adevărat și convertește valorile false în valoarea inversă a fals.

Operatorul Nullish Coalescing (??).

Operatorul de coalescere nul este un operator logic care evaluează doi operanzi și returnează primul operand dacă nu este nul sau nedefinit. În caz contrar, returnează al doilea operand.

La o privire, operatorul de coalescere nul ar putea părea identic cu operatorul logic SAU (||), dar nu este cazul. Diferența cheie este că operatorul SAU returnează operandul din partea dreaptă dacă operandul din stânga este „orice” valoare falsă, nu numai nul sau nedefinit.

Oferă o modalitate concisă de a alege o valoare implicită atunci când întâlniți nul sau nedefinit valorile.

Iată sintaxa pentru operatorul de coalescere nul:

X?? y

Iată un exemplu de operator de coalescere nul în uz:

const nume = nul;
const defaultName = „John Doe”;
const rezultat_1 = nume?? defaultName;
consolă.log (rezultat_1); // „John Doe”


const varsta = 0;
const defaultAge = 25;
const rezultat_2 = varsta?? defaultAge;
consolă.log (rezultat_2); // 0

În exemplul de mai sus, rezultat_1 returnează „John Doe” deoarece primul operand avea valoarea de nul. rezultat_2 se intoarce 0 pentru că, deși este o valoare falsă, nu este nici una nul nici nedefinit.

Utilizarea operatorilor logici în codul dvs

Operatorii logici sunt utilizați în mod obișnuit pentru a scrie instrucțiuni condiționale, pentru a atribui valori implicite sau pentru a comuta valorile booleene în funcție de condiții.

Folosind acești operatori logici, puteți scrie un cod mai concis și mai expresiv, care tratează diferite scenarii bazate pe veridicitatea sau falsitatea valorilor.