Operatory logiczne

Operatory logiczne s─ů zazwyczaj u┼╝ywane z warto┼Ťciami typu Boolean (logicznymi) ÔÇô w├│wczas zwracaj─ů r├│wnie┼╝ warto┼Ť─ç typu logicznego. Jednak┼╝e operatory && i || w istocie zwracaj─ů warto┼Ť─ç jednego z podanych operand├│w, wi─Öc je┼Ťli operatory te s─ů u┼╝ywane z warto┼Ťciami nie-boolowskimi, wtedy mog─ů r├│wnie┼╝ zwraca─ç nie-boolowskie warto┼Ťci.

Opis

Operatory logiczne s─ů opisane w poni┼╝szej tabeli:

Operator U┼╝ycie Opis
Logiczne AND (&&) expr1 && expr2 Zwraca expr1 je┼Ťli warto┼Ť─ç ta mo┼╝e by─ç przekonwertowana na false, w przeciwnym razie zwraca expr2. Zatem, u┼╝ywany z warto┼Ťciami typu logicznego, operator && zwraca true je┼Ťli obydwa operandy maj─ů warto┼Ť─ç true, w przeciwnym razie zwraca false.
Logiczne OR (||) expr1 || expr2 Zwraca expr1, je┼Ťli warto┼Ť─ç ta mo┼╝e by─ç przekonwertowana na true; w przeciwnym razie zwraca expr2. Tak wi─Öc, u┼╝ywany z warto┼Ťciami typu logicznego, operator || zwraca true kt├│rykolwiek z operand├│w r├│wny jest true.
Logiczne NOT (!) !expr Zwraca false je┼Ťli jego operand mo┼╝na przekonwertowa─ç na true; w przeciwnym razie zwraca true.

Je┼Ťli dana warto┼Ť─ç mo┼╝e by─ç przekonwertowana na true, w├│wczas jest to tzw. warto┼Ť─ç truthy. Je┼Ťli dana warto┼Ť─ç mo┼╝e by─ç przekonwertowana na false, jest to tzw. warto┼Ť─ç falsy.

Przyk┼éadami wyra┼╝e┼ä, kt├│re mog─ů by─ç przekonwertowane na false s─ů:

  • null;
  • NaN;
  • 0;
  • pusty ┼éa┼äcuch znak├│w (string) ÔÇô "" lub ''
  • undefined.

Mimo tego, ┼╝e operatory && i || mog─ů by─ç u┼╝ywane z warto┼Ťciami nie-boolowskimi, nadal mog─ů by─ç uznane za operatory boolowskie (logiczne), gdy┼╝ zwracane przez nie warto┼Ťci mog─ů by─ç zawsze przekonwertowane na warto┼Ťci logiczne.

Ewaluacja short-circuit

Poniewa┼╝ wyra┼╝enia logiczne s─ů przetwarzane od lewej do prawej, sprawdzana jest najkr├│tsza mo┼╝liwa ┼Ťcie┼╝ka, pozwalaj─ůca na zwr├│cenie wyniku ca┼éego wyra┼╝enia (tzw. short-circuit evaluation), zgodnie z nast─Öpuj─ůcymi zasadami:

  • false && (cokolwiek) zostanie przetworzone na false.
  • true || (cokolwiek) zostanie przetworzone na true.

Zasady logiki gwarantuj─ů, ┼╝e powy┼╝sze ewaluacje s─ů zawsze poprawne. Zauwa┼╝, ┼╝e cz─Ö┼Ťci wyra┼╝e┼ä oznaczone s┼éowem cokolwiek nie s─ů ewaluowane, wi─Öc nie pojawi─ů si─Ö ┼╝adne efekty uboczne. Zauwa┼╝ te┼╝, ┼╝e cz─Ö┼Ť─ç cokolwiek powy┼╝szych wyra┼╝e┼ä mo┼╝e by─ç dowolnym pojedynczym wyra┼╝eniem logicznym (co wskazano przez nawiasy).

Dla przyk┼éadu, poni┼╝sze dwie funkcje s─ů r├│wnowa┼╝ne.

function shortCircuitEvaluation() {
  // logiczne OR (||)
  doSomething() || doSomethingElse();

  // logiczne AND (&&)
  doSomething() && doSomethingElse();
}

function equivalentEvaluation() {

  // logiczne OR (||)
  var orFlag = doSomething();
  if (!orFlag) {
    doSomethingElse();
  }


  // logiczne AND (&&)
  var andFlag = doSomething();
  if (andFlag) {
    doSomethingElse();
  }
}

Poni┼╝sze wyra┼╝enia nie s─ů jednak r├│wnowa┼╝ne ze wzgl─Ödu na pierwsze┼ästwo operator├│w, co podkre┼Ťla, jak wa┼╝ne jest, by operator po prawej stronie by┼é pojedynczym wyra┼╝eniem (zgrupowanym w razie potrzeby przy pomocy nawias├│w).

false && true  || true      // zwraca true
false && (true || true)     // zwraca false

Logiczne AND (&&)

Poni┼╝ej pokazane s─ů przyk┼éady u┼╝ycia operatora && (logicznego AND).

a1 = true  && true       // t && t zwraca true
a2 = true  && false      // t && f zwraca false
a3 = false && true       // f && t zwraca false
a4 = false && (3 == 4)   // f && f zwraca false
a5 = 'Cat' && 'Dog'      // t && t zwraca "Dog"
a6 = false && 'Cat'      // f && t zwraca false
a7 = 'Cat' && false      // t && f zwraca false
a8 = ''    && false      // f && f zwraca ""
a9 = false && ''         // f && f zwraca false

Logiczne OR (||)

Poni┼╝ej pokazane s─ů przyk┼éady u┼╝ycia operatora || (logicznego OR).

o1 = true  || true       // t || t zwraca true
o2 = false || true       // f || t zwraca true
o3 = true  || false      // t || f zwraca true
o4 = false || (3 == 4)   // f || f zwraca false
o5 = 'Cat' || 'Dog'      // t || t zwraca "Cat"
o6 = false || 'Cat'      // f || t zwraca "Cat"
o7 = 'Cat' || false      // t || f zwraca "Cat"
o8 = ''    || false      // f || f zwraca false
o9 = false || ''         // f || f zwraca ""

Logiczne NOT (!)

Poni┼╝ej pokazane s─ů przyk┼éady u┼╝ycia operatora ! (logicznego NOT).

n1 = !true               // !t zwraca false
n2 = !false              // !f zwraca true
n3 = !'Cat'              // !t zwraca false

Podw├│jne NOT (!!)

Jest mo┼╝liwe u┼╝ycie kilku operator├│w NOT naraz, by wprost wymusi─ç konwersj─Ö dowolnej warto┼Ťci do odpowiedniej warto┼Ťci boolowskiej. Konwersja bazuje na ÔÇ×prawdziwo┼ŤciÔÇŁ lub ÔÇ×fa┼észywo┼ŤciÔÇŁ warto┼Ťci (zobacz truthy i falsy).

Taka sama konwersja mo┼╝e by─ç dokonana poprzez funkcj─Ö Boolean.

n1 = !!true                   // !!prawda zwraca true
n2 = !!{}                     // !!prawda returns true: ka┼╝dy obiekt jest "prawd─ů"...
n3 = !!(new Boolean(false))   // ...nawet obiekty booloweskie z false jako warto┼Ťci─ů .valueOf()!
n4 = !!false                  // !!fałsz zwraca false
n5 = !!""                     // !!fałsz zwraca false
n6 = !!Boolean(false)         // !!fałsz zwraca false

Zasady przekształcania wyrażeń

Przekształcanie AND na OR

Poni┼╝sza operacja na warto┼Ťciach logicznych:

bCondition1 && bCondition2

jest zawsze r├│wna:

!(!bCondition1 || !bCondition2)

Przekształcanie OR na AND

Poni┼╝sza operacja na warto┼Ťciach logicznych:

bCondition1 || bCondition2

jest zawsze r├│wna:

!(!bCondition1 && !bCondition2)

Przekształcanie NOT

Poni┼╝sza operacja na warto┼Ťciach logicznych:

!!bCondition

jest zawsze r├│wna:

bCondition

Usuwanie zagnieżdżonych wyrażeń z nawiasami

Jako ┼╝e wyra┼╝enia logiczne s─ů ewaluowane od lewej do prawej, jest zawsze mo┼╝liwe usuni─Öcie nawias├│w ze z┼éo┼╝onego wyra┼╝enia przy u┼╝yciu pewnych, przedstawionych dalej, regu┼é.

Usuwanie zagnie┼╝d┼╝onego AND

Nast─Öpuj─ůce wyra┼╝enie z┼éo┼╝one na warto┼Ťciach logicznych:

bCondition1 || (bCondition2 && bCondition3)

jest zawsze r├│wne:

bCondition1 || bCondition2 && bCondition3

Usuwanie zagnie┼╝d┼╝onego OR

Nast─Öpuj─ůce wyra┼╝enie z┼éo┼╝one na warto┼Ťciach logicznych:

bCondition1 && (bCondition2 || bCondition3)

jest zawsze r├│wne:

!(!bCondition1 || !bCondition2 && !bCondition3)

Specyfikacje

Specyfikacja Status Uwagi
ECMAScript 1st Edition (ECMA-262) Standard Definicja pocz─ůtkowa.
ECMAScript 5.1 (ECMA-262) Standard Zdefiniowane w kilku sekcjach specyfikacji: Logical NOT Operator, Binary Logical Operators
ECMAScript 2015 (6th Edition, ECMA-262) Standard Zdefiniowane w kilku sekcjach specyfikacji: Logical NOT Operator, Binary Logical Operators
ECMAScript (ECMA-262) Living Standard Zdefiniowane w kilku sekcjach specyfikacji: Logical NOT Operator, Binary Logical Operators

Zobacz te┼╝