Dlaczego operatory logiczne (&&i ||) zawsze nie zwracają wyniku logicznego?

W JavaScript zarówno ||, jak i && są operatorami zwarć logicznych, które zwracają pierwszą w pełni określoną "wartość logiczną", gdy są obliczane od lewej do prawej.

W wyrażeniu X || Y, X jest najpierw obliczana i interpretowana jako wartość logiczna. Jeżeli wartością logiczną jest "true", wtedy jest zwracana. I {[4] } nie jest oceniana. (Ponieważ nie ma znaczenia, czy Y jest prawdą, czy Y jest fałszem, X || Y zostało w pełni ustalone.) To jest część zwarciowa.

Jeśli ta wartość logiczna jest "false", wtedy nadal nie wiemy, czy X || Y jest prawdziwa czy fałszywa, dopóki nie ocenimy Y i nie zinterpretujemy jej jako wartości logicznej. Więc Y zostanie zwrócona.

I && robi to samo, z wyjątkiem tego, że przestaje oceniać, czy pierwszy argument jest fałszywy.

Pierwszą trudną częścią jest to, że gdy wyrażenie jest obliczane jako "true", to samo wyrażenie jest zwracane. Który w wyrażeniach logicznych liczy się jako "prawda", ale można go również używać. Więc to dlatego jesteś wyświetlanie zwracanych rzeczywistych wartości.

Druga trudna część polega na tym, że gdy wyrażenie jest oceniane jako "false", to w JS 1.0 i 1.1 system zwróci wartość logiczną "false"; podczas gdy w JS 1.2 zwraca rzeczywistą wartość wyrażenia.

W JS false, 0, -0, "", null, undefined, NaN i document.all wszystkie liczą się jako fałszywe .

Tutaj oczywiście cytuję wartości logiczne dla dobra dyskusji. Oczywiście ciąg dosłowny "false" Nie jest tym samym co wartość false i dlatego jest prawdziwa.

W najprostszych słowach:

Operator || zwraca pierwszą prawdziwą wartość, a jeśli żadna nie jest prawdziwa, zwraca ostatnią wartość (która jest fałszywą wartością).

Operator && zwraca pierwszą wartość falsy, a jeśli żadna nie jest falsy, zwraca ostatnią wartość (która jest wartością prawdziwą).

"" && "Dog"    // ""
"Cat" && "Dog" // "Dog"
"" || "Dog"    // "Dog"
"Cat" || "Dog" // "Cat"

W większości języków programowania operatory && i || zwracają wartość logiczną. w JavaScript jest inaczej .

Lub Operator:

Zwraca wartość pierwszego operandu , który waliduje jako true( jeśli istnieje), w przeciwnym razie zwraca wartość ostatniego operandu (nawet jeśli waliduje jako false).

Przykład 1:

var a = 0 || 1 || 2 || 3;
        ^    ^    ^    ^
        f    t    t    t
             ^
             first operand that validates as true
             so, a = 1

Przykład 2:

var a = 0 || false || null || '';
        ^    ^        ^       ^
        f    f        f       f
                              ^
                              no operand validates as true,
                              so, a = ''

I Operator:

powraca wartość ostatniego parametru , który sprawdza się jako true (jeśli wszystkie warunki sprawdzają się jako true), w przeciwnym razie zwraca wartość pierwszego parametru, który sprawdza się jako false.

Przykład 1:

var a = 1 && 2 && 3 && 4;
        ^    ^    ^    ^
        t    t    t    t
                       ^
                       last operand that validates as true
                       so, a = 4

Przykład 2:

var a = 2 && '' && 3 && null;
        ^    ^     ^    ^
        t    f     t    f
             ^
             return first operand that validates as false,
             so, a = ''

Wniosek:

Jeśli chcesz, aby JavaScript działał tak samo jak inne języki programowania, użyj funkcji Boolean(), jak ta:

var a = Boolean(1 || 2 || 3);// a = true

Operatory zwarciowe należy traktować jako warunkowe , a nie operatory logiczne.

x || y w przybliżeniu odpowiada:

if ( x ) { return x; } else { return y; }  

I x && y w przybliżeniu odpowiada:

if ( x ) { return y; } else { return x; }  

Biorąc to pod uwagę, wynik jest całkowicie zrozumiały.

Z dokumentacja MDN :

operatory logiczne są zwykle używane z wartościami logicznymi. Gdy są, zwracają wartość logiczną. jednak operatory && i || w rzeczywistości zwraca wartość jednego z podanych operandów, więc jeśli te operatory są używane z wartościami Nieboolowymi, zwrócą one wartość nieboolową.

I oto tabela {[17] } z zwracanymi wartościami wszystkich operatorów logicznych.

Myślę, że masz tutaj podstawowe pytanie dotyczące metodologii JavaScript.

Teraz JavaScript jest językiem luźno wpisanym. Jako taki, sposób i sposób, w jaki traktuje operacje logiczne różni się od innych standardowych języków, takich jak Java i C++. JavaScript używa koncepcji znanej jako "type coercion" do określenia wartości operacji logicznej i zawsze zwraca wartość pierwszego typu true. Na przykład spójrz na poniższy kod:

var x = mystuff || document;
// after execution of the line above, x = document

To dlatego, że mystuff jest a priori undefined encja, która zawsze będzie oceniana na false podczas testowania i jako taka, JavaScript pomija tę wartość i testuje następną encję na wartość true. Ponieważ obiekt document jest znany JavaScript, zwraca on wartość true, a JavaScript zwraca ten obiekt.

Jeśli chcesz, aby wartość logiczna została zwrócona, musisz przekazać instrukcję logical condition do takiej funkcji:

var condition1 = mystuff || document;

function returnBool(cond){
  if(typeof(cond) != 'boolean'){ //the condition type will return 'object' in this case
     return new Boolean(cond).valueOf();
  }else{ return; }
}    
// Then we test...
var condition2 = returnBool(condition1);
window.console.log(typeof(condition2)); // outputs 'boolean' 

Możemy odnieść się do spec (11.11) JS tutaj z:

Semantyka

Produkcja LogicalANDExpression: LogicalANDExpression & & BitwiseORExpression jest oceniana w następujący sposób:

1. Oceń LogicalANDExpression.

2.Wywołanie GetValue(Result (1)).

3.Wywołanie ToBoolean(Result(2)).

4.Jeśli Result (3) jest false, zwraca Result(2).

5.Oceń Ekspresję BitwiseORExpression.

6.Wywołanie GetValue(Result (5)).

7.Return { Wynik(6).

Zobacz tutaj dla spec

Po pierwsze, to musi być prawdziwe, aby powrócić, więc jeśli testujesz na prawdziwość, to nie ma różnicy

Po drugie, pozwala na wykonywanie zadań w następujący sposób:

function bar(foo) {
    foo = foo || "default value";

Porównaj:

var prop;
if (obj.value) {prop=obj.value;}
else prop=0;

Z:

var prop=obj.value||0;

Zwracanie prawdziwych wyrażeń - a nie tylko prawdziwych lub fałszywych-zwykle sprawia, że kod jest krótszy i nadal czytelny. Jest to bardzo powszechne dla|/, nie tyle dla&&.