logo

Logické operátory

V JavaScriptu jsou čtyři logické operátory:|| (NEBO), && (AND), ! (NE), ?? (Nulové srůstání). Zde pokryjeme první tři, ?? operátor je v dalším článku.

Přestože se nazývají „logické“, lze je použít na hodnoty jakéhokoli typu, nejen na booleovské. Jejich výsledek může být také libovolného typu.

Podívejme se na podrobnosti.

|| (NEBO)

Operátor „OR“ je reprezentován dvěma svislými čarami:

result = a || b;

V klasickém programování je logický OR určen pouze k manipulaci s booleovskými hodnotami. Pokud je některý z jeho argumentů true , vrátí true , jinak vrátí false .

V JavaScriptu je operátor o něco složitější a výkonnější. Nejprve se však podívejme, co se stane s booleovskými hodnotami.

Existují čtyři možné logické kombinace:

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

Jak vidíme, výsledek je vždy true kromě případu, kdy jsou oba operandy false .

Pokud operand není booleovský, je pro vyhodnocení převeden na booleovský.

Například číslo 1 je považováno za true , číslo 0 jako false :

if (1 || 0) { // works just like if( true || false )
 alert( 'truthy!' );
}

Většinou NEBO || se používá v if příkaz k testování, zda nějaké z daných podmínek je true .

Například:

let hour = 9;

if (hour < 10 || hour > 18) {
 alert( 'The office is closed.' );
}

Můžeme splnit více podmínek:

let hour = 12;
let isWeekend = true;

if (hour < 10 || hour > 18 || isWeekend) {
 alert( 'The office is closed.' ); // it is the weekend
}

NEBO "||" najde první pravdivou hodnotu

Výše popsaná logika je poněkud klasická. Nyní si představíme „extra“ funkce JavaScriptu.

Rozšířený algoritmus funguje následovně.

Zadáno více hodnot NEBO:

result = value1 || value2 || value3;

NEBO || operátor provede následující:

  • Vyhodnocuje operandy zleva doprava.
  • Pro každý operand jej převede na booleovský. Pokud je výsledek true , zastaví a vrátí původní hodnotu tohoto operandu.
  • Pokud byly vyhodnoceny všechny operandy (tj. všechny byly false ), vrátí poslední operand.

Hodnota je vrácena ve své původní podobě, bez převodu.

Jinými slovy, řetězec OR || vrátí první pravdivou hodnotu nebo poslední, pokud není nalezena žádná pravdivá hodnota.

Například:

alert( 1 || 0 ); // 1 (1 is truthy)

alert( null || 1 ); // 1 (1 is the first truthy value)
alert( null || 0 || 1 ); // 1 (the first truthy value)

alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)

To vede k zajímavému použití ve srovnání s „čistým, klasickým, pouze booleovským OR“.

  1. Získání první pravdivé hodnoty ze seznamu proměnných nebo výrazů.

    Například máme firstName , lastName a nickName proměnné, všechny volitelné (tj. mohou být nedefinované nebo mají falešné hodnoty).

    Použijme OR || vyberte ten, který má data a zobrazí je (nebo "Anonymous" pokud není nic nastaveno):

    let firstName = "";
let lastName = "";
let nickName = "SuperCoder";

alert( firstName || lastName || nickName || "Anonymous"); // SuperCoder

    Pokud byly všechny proměnné nepravdivé, "Anonymous" by se objevil.

  2. Vyhodnocení zkratu.

    Další funkce OR || operátorem je takzvané „zkratové“ vyhodnocení.

    To znamená, že || zpracovává své argumenty, dokud není dosaženo první pravdivé hodnoty, a poté je hodnota okamžitě vrácena, aniž by se dotkla druhého argumentu.

    Důležitost této funkce je zřejmá, pokud operand není jen hodnota, ale výraz s vedlejším efektem, jako je přiřazení proměnné nebo volání funkce.

    V níže uvedeném příkladu se vytiskne pouze druhá zpráva:

    true || alert("not printed");
false || alert("printed");

    Na prvním řádku je OR || operátor zastaví vyhodnocování okamžitě po zobrazení true , tedy alert není spuštěn.

    Někdy lidé používají tuto funkci k provádění příkazů pouze v případě, že podmínka v levé části je chybná.

&&(A)

Operátor AND je reprezentován dvěma ampersandy && :

result = a && b;

V klasickém programování AND vrací true pokud jsou oba operandy pravdivé a false jinak:

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

Příklad s if :

let hour = 12;
let minute = 30;

if (hour == 12 && minute == 30) {
 alert( 'The time is 12:30' );
}

Stejně jako u OR je povolena jakákoli hodnota jako operand AND:

if (1 && 0) { // evaluated as true && false
 alert( "won't work, because the result is falsy" );
}

A „&&“ najde první chybnou hodnotu

Zadáno několik hodnot AND’ed:

result = value1 && value2 && value3;

AND && operátor provede následující:

  • Vyhodnocuje operandy zleva doprava.
  • Pro každý operand jej převede na booleovský. Pokud je výsledek false , zastaví a vrátí původní hodnotu tohoto operandu.
  • Pokud byly vyhodnoceny všechny operandy (tj. všechny byly pravdivé), vrátí poslední operand.

Jinými slovy AND vrátí první nesprávnou hodnotu nebo poslední hodnotu, pokud žádná nebyla nalezena.

Výše uvedená pravidla jsou podobná jako OR. Rozdíl je v tom, že AND vrací první nepravdu hodnotu, zatímco OR vrátí první pravdu jeden.

Příklady:

// if the first operand is truthy,
// AND returns the second operand:
alert( 1 && 0 ); // 0
alert( 1 && 5 ); // 5

// if the first operand is falsy,
// AND returns it. The second operand is ignored
alert( null && 5 ); // null
alert( 0 && "no matter what" ); // 0

Můžeme také předat několik hodnot za sebou. Podívejte se, jak je vrácen první falešný:

alert( 1 && 2 && null && 3 ); // null

Když jsou všechny hodnoty pravdivé, vrátí se poslední hodnota:

alert( 1 && 2 && 3 ); // 3, the last one
Priorita AND && je vyšší než NEBO ||

Priorita AND && operátor je vyšší než OR || .

Tedy kód a && b || c && d je v podstatě stejný, jako kdyby && výrazy byly v závorkách:(a && b) || (c && d) .

Nenahrazujte if s || nebo &&

Někdy lidé používají AND && operátor jako "kratší způsob zápisu if ".

."

Například:

let x = 1;

(x > 0) && alert( 'Greater than zero!' );

Akce v pravé části && se provede pouze tehdy, pokud ho hodnocení dosáhne. Tedy pouze pokud (x > 0) je pravda.

Takže v podstatě máme analog pro:

let x = 1;

if (x > 0) alert( 'Greater than zero!' );

I když, varianta s && se zobrazí kratší, if je zřetelnější a má tendenci být o něco čitelnější. Proto doporučujeme použít každý konstrukt pro jeho účel:použijte if pokud chceme if a použijte && pokud chceme AND.

! (NE)

Booleovský operátor NOT je reprezentován vykřičníkem ! .

Syntaxe je velmi jednoduchá:

result = !value;

Operátor přijme jeden argument a provede následující:

  1. Převede operand na booleovský typ:true/false .
  2. Vrátí převrácenou hodnotu.

Například:

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

Dvojité NOT !! se někdy používá pro převod hodnoty na booleovský typ:

alert( !!"non-empty string" ); // true
alert( !!null ); // false

To znamená, že první NOT převede hodnotu na booleovskou a vrátí inverzní hodnotu a druhý NOT ji znovu převrátí. Nakonec máme prostý převod hodnoty na booleovskou hodnotu.

Existuje trochu podrobnější způsob, jak udělat totéž – vestavěný Boolean funkce:

alert( Boolean("non-empty string") ); // true
alert( Boolean(null) ); // false

Priorita NOT ! je nejvyšší ze všech logických operátorů, takže se vždy provede jako první, před && nebo || .