Logické operátory

V jazyku JavaScript sú tri logické operátory: || (OR),  && (AND), ! (NOT).

Hoci sa nazývajú „logické“, možno ich použiť na hodnoty akéhokoľvek typu, nielen boolean. Ich výsledok môže byť tiež akéhokoľvek typu.

|| (OR)

Operátor „OR“ je reprezentovaný dvoma symbolmi vertikálnej čiary:

result = a || b;

V klasickom programovaní je logický OR určený len na manipuláciu s booleovskými hodnotami. Ak je niektorý z jeho argumentov pravdivý, vráti hodnotu true, inak vráti hodnotu false.

V jazyku JavaScript je operátor trochu zložitejší a výkonnejší. Po prvé, pozrime sa, čo sa stane s booleovskými hodnotami.

Existujú štyri možné logické kombinácie:

alert( true || true );   // true
alert( false || true );  // true
alert( true || false );  // true
alert( false || false ); // false

Ako môžeme vidieť, výsledok je vždy pravdivý okrem prípadu, keď sú obidva operandy nepravdivé.

Ak operand nie je boolean, konvertuje sa na boolean pre vyhodnotenie.

Napríklad číslo 1 je považované za pravdivé, číslo 0 je nepravdivé:

if (1 || 0) { // funguje ako if( true || false )
  alert( 'true' );
}

Väčšinu času sa OR || používa v príkaze if na testovanie, či je niektorá z uvedených podmienok pravdivá.

Napríklad:

let hour = 9;

if (hour < 10 || hour > 18) {
  alert( 'Kancelária je zatvorená' );
}

Môžeme uviesť viac podmienok:

let hour = 12;
let isWeekend = true;

if (hour < 10 || hour > 18 || isWeekend) {
  alert( 'Kancelária je zatvorená' ); // je víkend
}

OR nájde prvý výraz s kladnou pravdivostnou hodnotou

Logický operátor OR dá na výsledok prvú hodnotu, ktorá má booleovský výraz vyhodnotený ako true. To znamená, že výraz:

result = value1 || value2 || value3;

vráti tú hodnotu, ktorá nie je typu false.

OR operátor robí nasledovné:

  • Vyhodnocuje operandy zľava doprava.
  • Pre každý operand ho konvertuje na boolean. Ak je výsledok true, zastaví a vráti pôvodnú hodnotu operandu.
  • Ak boli vyhodnotené všetky operandy (t.j. všetky boli nepravdivé), vráti posledný operand.

Hodnota sa vracia v pôvodnej forme bez konverzie.

Inými slovami, zreťazený OR „||“ vráti prvú pravdivú hodnotu alebo poslednú hodnotu, ak sa nenájde žiadna takáto hodnota.

Napríklad:

alert( 1 || 0 ); // 1 (1 je pravdivé)
alert( true || 'no matter what' ); // (true je pravdivý)

alert( null || 1 ); // 1 (1 je prvá pravdivá hodnota)
alert( null || 0 || 1 ); // 1 (prvá pravdivá hodnota)
alert( undefined || null || 0 ); // 0 (všetky nepravdivé, vráti poslednú hodnotu)

&& (AND)

Operátor AND je reprezentovaný dvoma ampersandmi &&:

result = a && b;

V klasickom programovaní AND vráti hodnotu true, ak sú oba operandy pravdivé a false v každom inom prípade:

alert( true && true );   // true
alert( false && true );  // false
alert( true && false );  // false
alert( false && false ); // false

Príklad s použitím podmienky:

let hour = 12;
let minute = 30;

if (hour == 12 && minute == 30) {
  alert( 'Čas je 12:30' );
}

Rovnako ako v prípade OR je ľubovoľná hodnota povolená ako operand AND:

if (1 && 0) { // vzhodnocované ako true && false
  alert( "nebude funkgovať, lebo podmienka je nepravdivá" );
}

AND nájde prvý výraz so zápornou pravdivostnou hodnotou

Nech máme niekoľko výrazov:

result = value1 && value2 && value3;

Operátor AND && vykonáva nasledovné:

  • Vyhodnocuje operandy zľava doprava.
  • Pre každý operand ho konvertuje na boolean. Ak je výsledok false, zastaví a vráti pôvodnú hodnotu operandu.
  • Ak boli vyhodnotené všetky operandy (t.j. všetky boli pravdivé), vráti posledný operand.

Inými slovami, AND vracia prvú nepravdivú hodnotu alebo poslednú hodnotu, ak neboli nájdené žiadne.

Vyššie uvedené pravidlá sú podobné OR. Rozdiel je v tom, že AND vracia prvú nepravdivú hodnotu, zatiaľ čo OR vracia prvú pravdivú hodnotu.

Príklady:

// ak je prvý operand pravdivý,
// AND vráti druhý operand:
alert( 1 && 0 ); // 0
alert( 1 && 5 ); // 5

// ak je prvý operand nepravdivý,
// AND ho vráti. Druhý operand je ignorovaný
alert( null && 5 ); // null
alert( 0 && "hocičo" ); // 0

! (NOT)

Booleovský operátor NOT je reprezentovaný výkričníkom !.

Syntax je veľmi jednoduchá:

result = !value;

Operátor akceptuje jeden argument a vykoná nasledovné:

  1. Konvertuje operand na boolean typ: true / false.
  2. Vracia inverznú hodnotu.

Napríklad:

alert( !true ); // false
alert( !0 ); // true