Expresii condiționale

Expresiile condiționale lucrează cu condiții - expresii care returnează o valoare de tip Boolean - true (adevărat) sau false (fals). Există două tipuri de operații condiționale: operații de comparație și operații logice.

Operații de comparație

Operatorii de comparație compară două valori și returnează valoarea true sau false:

• ==

Operatorul de egalitate compară două valori și, dacă sunt egale, returnează true, altfel returnează false: x == 5

• ===

Operatorul de identitate compară și valorile și tipurile lor, și, dacă sunt egale, returnează true, altfel returnează false: x === 5

• !=

Compară două valori și, dacă nu sunt egale, returnează true, altfel returnează false: x != 5

• !==

Compară două valori și tipurile lor, și, dacă nu sunt egale, returnează true, altfel returnează false: x !== 5

• >

Compară două valori și, dacă prima este mai mare decât a doua, returnează true, altfel returnează false: x > 5

• <

Compară două valori și, dacă prima este mai mică decât a doua, returnează true, altfel returnează false: x < 5

• >=

Compară două valori și, dacă prima este mai mare sau egală cu a doua, returnează true, altfel returnează false: x >= 5

• <=

Compară două valori și, dacă prima este mai mică sau egală cu a doua, returnează true, altfel returnează false: x <= 5

Toți operatorii sunt destul de simpli, poate cu excepția operatorului de egalitate și a operatorului de identitate. Ambii compară două valori, însă operatorul de identitate ia în considerare și tipul de valoare. De exemplu:

const income = 100;
const strIncome = "100";
const result = income == strIncome;
console.log(result); //true

Constanta result va fi aici egală cu true, deoarece atât income, cât și strIncome reprezintă efectiv numărul 100.

Cu toate acestea, operatorul de identitate va returna în acest caz false, deoarece datele au tipuri diferite:

const income = 100;
const strIncome = "100";
const result = income === strIncome;
console.log(result); // false

Operatorii de inegalitate != și !== funcționează similar.

Operațiile logice

Operațiile logice sunt, de obicei, aplicate valorilor de tip Boolean - true și false. Rezultatul operațiilor logice este, de asemenea, în mod obișnuit, o valoare de tip Boolean - true sau false. Adesea, acest tip de operații este utilizat pentru verificarea condițiilor. În JavaScript există următoarele operații logice:

Operația &&

Operația && returnează true dacă ambii operanzi returnează true, altfel returnează false:

console.log(true && true);  // true
console.log(true && false); // false
console.log(false && false); // false

Adesea, acest tip de operații este utilizat atunci când trebuie să se verifice adevărul a două condiții, ambele condiții trebuind să fie adevărate:

const money = 1000;
const age = 21;
// verificăm dacă age este mai mare de 18 și money este mai mare de 100
const access1 = age > 18 && money > 100;
console.log(access1); // true

// verificăm dacă age este mai mare de 18 și money este mai mare de 1000
const access2 = age > 18 && money > 1000;
console.log(access2);

În acest caz, constanta access1 va fi adevărată dacă atât age este mai mare de 18, cât și money este mai mare de 100. Cu alte cuvinte, dacă persoana are mai mult de 18 ani și are mai mult de 100 de unități monetare, atunci îi oferim acces. Aici ambele condiții sunt adevărate, așa că și access1 este adevărată.

Însă constanta access2 va fi adevărată doar dacă atât age este mai mare de 18, cât și money este mai mare de 1000. Aici, a doua condiție nu este îndeplinită, este falsă, așa că access2 este falsă.

Operația ||

Operația || returnează true dacă cel puțin unul dintre operațiile este true, altfel returnează false:

console.log(true || true);  // true
console.log(true || false); // true
console.log(false || false); // false

Această operație este adesea folosită pentru a verifica două condiții, când este suficient ca doar una dintre condiții să fie adevărată, de exemplu:

const money = 1000;
const age = 21;
// verificăm dacă age este mai mare de 18 sau money este mai mare de 1000
const access1 = age > 18 || money > 1000;
console.log(access1); // true

// verificăm dacă age este mai mare de 22 sau money este mai mare de 1000
const access2 = age > 22 || money > 1000;
console.log(access2);   // true

În acest caz, constanta access1 va fi adevărată dacă fie age este mai mare de 18, fie money este mai mare de 1000. Cu alte cuvinte, dacă persoana fie are mai mult de 18 ani, fie are mai mult de 1000 de unități monetare, atunci îi oferim acces. Este suficientă îndeplinirea a cel puțin unei condiții. Aici prima condiție este adevărată, astfel că și access1 este adevărată.

Dar constanta access2 va fi adevărată numai dacă atât age este mai mare de 22, cât și money este mai mare de 1000. Aici nici prima, nici a doua condiție nu sunt îndeplinite, sunt false, așa că access2 este falsă.

Negarea logică

Operația ! returnează true dacă operandul este fals și returnează false dacă operandul este adevărat.

console.log(!true);         // false
console.log(!false);         // true

const isAlive = true;
const isDead = !isAlive;
console.log(isDead);         // false

Оperаțiile logice cu valori arbitrare

Mai sus se menționa că operațiile logice, de obicei, iau ca operanzi valori de tip Boolean - true sau false, iar rezultatul acestor operații este, de obicei, o valoare de tip Boolean. Dar aceasta este situația obișnuită; în realitate, operanzii și rezultatele acestor operații pot fi valori arbitrare. Uneori, JavaScript poate converti automat anumite valori în tipul Boolean:

Și dacă unii dintre operanzi nu reprezintă o valoare Boolean, atunci în acest caz operațiile logice acționează conform unor anumite reguli.

Dacă cel puțin un operand al operației && nu este o valoare de tip Boolean, atunci se efectuează următoarele acțiuni:

• - dacă primul operand returnează false (de exemplu, numărul 0, șirul gol, null, undefined), atunci operația returnează primul operand.
• - în celelalte cazuri, se returnează al doilea operand.

let isAlive;        // undefined
let name = "Tom";
   
const result = isAlive && name;
console.log(result);  

În acest caz, primul operand al operației && - variabila isAlive este egală cu undefined (deoarece variabila nu este inițializată), iar în momentul conversiei la tipul Boolean, aceasta devine false, așa că operația va returna valoarea variabilei isAlive.

Iată câteva exemple suplimentare:

console.log(false && "Tom");  // false
console.log("Tom" && null);   // null
console.log(true && "Tom");   // Tom

Dacă unul sau ambii operanzi ai operației || nu sunt valori de tip Boolean, atunci operația efectuează următoarele acțiuni:

• Dacă primul operand este evaluat ca true (adică nu este egal cu 0, șirul gol, null sau undefined), atunci se returnează primul operand.
• În toate celelalte cazuri, se returnează al doilea operand.

Exemple:

console.log(false || "Tom");  // Tom
console.log("Tom" || null);   // Tom
console.log(true || "Tom");   // true

Dacă operandul operației de negare ! nu este o valoare Boolean, atunci se efectuează următoarele acțiuni:

• Dacă operandul este un șir gol, atunci se returnează true; dacă șirul nu este gol, atunci se returnează false.
• Dacă operandul este numărul 0, atunci se returnează true; pentru toate celelalte numere, se returnează false.
• Dacă operandul este un obiect, se returnează false.
• Dacă operandul este una dintre valorile null, NaN sau undefined, atunci se returnează true.

Exemple:

let isAlive;        // undefined
console.log(!isAlive);   // true
console.log(!null);     // true
console.log(!0);        // true
console.log(!10);        // false
console.log(!"");        // true (String gol)
console.log(!"Tom");     // false

Structuri condiționale

Mai sus am discutat despre faptul că operațiile logice pot primi valori de tipuri arbitrare, nu doar Boolean. La prima vedere, aceasta poate părea fără sens. Cu toate acestea, astfel de structuri pot fi foarte utile atunci când trebuie să verificăm o condiție și, în funcție de verificare, să executăm o acțiune sau alta.

De exemplu:

const age = 22;
age <= 17 && console.log("Aveți mai puțin de 18 ani. Acces interzis.");
age > 17 && console.log("Aveți mai mult de 17 ani. Acces permis.");

Aici, în funcție de valoarea constantei age (care reprezintă o vârstă condiționată), afișăm pe consolă un șir de caractere diferit, permițând sau interzicând accesul în funcție de vârstă. Amintiți-vă că operatorul && returnează al doilea operand dacă primul este adevărat. Mai întâi se execută prima operație &&.

age <= 17 && console.log("Aveți mai puțin de 18 ani. Acces interzis.");

Aici se verifică mai întâi primul operand - expresia age <= 17. Dacă aceasta este adevărată (adică dacă age este mai mic sau egal cu 17), atunci se execută metoda console.log(). Cu toate acestea, deoarece condiția din primul operand NU este adevărată (deoarece age este mai mare de 17), nu se va executa al doilea operand și operația va returna false.

A doua operație && funcționează similar, cu excepția faptului că verifică dacă expresia age > 17 este adevărată (adică age trebuie să fie mai mare de 17).

age > 17 && console.log("Aveți mai mult de 17 ani. Acces permis.");

În acest caz, condiția din primul operand este adevărată, așadar se va executa al doilea operand. În final, șirul de caractere va fi afișat pe consola browserului.

Aveți mai mult de 17 ani. Acces permis

Similar, pentru construirea construcțiilor condiționale se poate utiliza și operația ||, dar aceasta returnează al doilea operand dacă primul operand este evaluat ca fiind fals. Cu alte cuvinte, operația && returnează al doilea operand dacă condiția primului operand este adevărată, iar || returnează al doilea operand dacă condiția este falsă. Am putea rescrie exemplul anterior folosind operația || în felul următor:

const age = 12;
age <= 17 || console.log("Aveți mai mult de 17 ani. Acces permis.");
age > 17 || console.log("Aveți mai puțin de 18 ani. Acces interzis.");

Operatori de atribuire

JavaScript are, de asemenea, o serie de operații care combină operațiuni logice cu atribuirea:

• &&=

Este echivalent cu a = a && b:

let x = true;
let y = false;
y &&= x;
console.log(y); // false

let c = false;
let d = true;
c &&= d;
console.log(c); // false

let a = true;
let b = true;
a &&= b;
console.log(a); // true

let e = false;
let f = false;
e &&= f;
console.log(e); // false

• ||=

Este echivalent cu a = a || b:

let x = true;
let y = false;
y ||= x;
console.log(y); // true

let a = true;
let b = true;
a ||= b;
console.log(a); // true

let c = false;
let d = true;
c ||= d;
console.log(c); // true

let e = false;
let f = false;
e ||= f;
console.log(e); // false