Perché gli operatori logici (&& e ||) non restituiscono sempre un risultato booleano?

Perché questi operatori logici restituiscono un object e non un booleano?

var _ = (obj.fn && obj.fn() ) || obj._ || ( obj._ = {} ); var _ = obj && obj._; 

Voglio capire perché restituisce il risultato di obj.fn() (se è definito) O obj._ ma non il risultato booleano.

 var _ = ((obj.fn && obj.fn() ) || obj._ || ( obj._ == {/* something */}))? true: false 

restituirà booleano.

AGGIORNARE

Si noti che questo è basato sul mio test. Non devo essere pienamente invocato.

È un’espressione che non assegna un valore true o false . Piuttosto assegna il valore calcolato.

Diamo un’occhiata a questa espressione.

Un’espressione di esempio:

 var a = 1 || 2; // a = 1 // it's because a will take the value (which is not null) from left var a = 0 || 2; // so for this a=2; //its because the closest is 2 (which is not null) var a = 0 || 2 || 1; //here also a = 2; 

La tua espressione:

 var _ = (obj.fn && obj.fn() ) || obj._ || ( obj._ = {} ); // _ = closest of the expression which is not null // in your case it must be (obj.fn && obj.fn()) // so you are gettig this 

Un’altra espressione:

 var a = 1 && 2; // a = 2 var a = 1 && 2 && 3; // a = 3 //for && operator it will take the fartest value // as long as every expression is true var a = 0 && 2 && 3; // a = 0 

Un’altra espressione:

 var _ = obj && obj._; // _ = obj._ 

In JavaScript, entrambi || e && sono operatori logici di cortocircuito che restituiscono il primo “valore logico” completamente determinato quando vengono valutati da sinistra a destra.

Nell’espressione X || Y X || Y , X viene prima valutato e interpretato come valore booleano. Se questo valore booleano è “true”, viene restituito. E Y non è valutato. (Poiché non importa se Y è vero o Y è falso, X || Y è stato completamente determinato.) Questa è la parte di cortocircuito.

Se questo valore booleano è “false”, allora non sappiamo ancora se X || Y X || Y è vero o falso finché valutiamo Y e lo interpretiamo anche come valore booleano. Quindi Y viene restituito.

E && fa lo stesso, tranne che smette di valutare se il primo argomento è falso.

La prima parte difficile è che quando un’espressione viene valutata come “vera”, viene restituita l’espressione stessa. Che conta come “vero” nelle espressioni logiche, ma puoi anche usarlo. Questo è il motivo per cui stai visualizzando i valori effettivi restituiti.

La seconda parte difficile è che quando un’espressione viene valutata come “false”, in JS 1.0 e 1.1 il sistema restituisce un valore booleano di “false”; mentre in JS 1.2 in poi restituisce il valore reale dell’espressione.

In JS false , 0 , -0 , "" , null , undefined , NaN e document.all contano tutti come falso .

Qui sto ovviamente citando i valori logici per la discussione. Ovviamente, la stringa letterale "false" non è uguale al valore false , ed è quindi vera.

Nei termini più semplici:

|| l’operatore restituisce il primo valore di verità e, se nessuno è sincero, restituisce l’ultimo valore (che è un valore di falsità).

L’operatore && restituisce il primo valore di falsy e, se nessuno è falso, restituisce l’ultimo valore (che è un valore di verità).

È davvero così semplice. Sperimenta nella tua console per vedere di persona.

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

Penso che tu abbia una domanda di metodologia JavaScript di base qui. Ora, JavaScript è un linguaggio poco tipizzato in quanto tale il modo e il modo in cui tratta le operazioni logiche differiscono da altri linguaggi standard come Java e C ++. JavaScript utilizza un concetto noto come “tipo di coercizione” per determinare il valore di un’operazione logica e restituisce sempre il valore del primo tipo “true”. per esempio, dai un’occhiata al codice qui sotto:

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

Questo perché “myshit” è un’entity framework non definita apriori che sarà sempre valutata come falsa quando testata e come tale, JavaScript salta questo e verifica l’ quadro successiva per un valore “vero”. Poiché l’object documento è noto a JavaScript, restituisce un valore true e JavaScript restituisce questo object.

Se si desidera restituire un valore booleano, è necessario passare l’istruzione della condizione logica a una funzione come questa:

 var condition1 = myshit || 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' 

Possiamo fare riferimento alla specifica (11.11) di JS qui di:

Semantica

La produzione LogicalANDExpression: LogicalANDExpression && BitwiseORExpression viene valutata come segue:

  1. Valuta LogicalANDExpression.

2.Call GetValue (Risultato (1)).

3.Call ToBoolean (Result (2)).

4.Se il risultato (3) è falso, restituire Risultato (2).

5. Valutare BitwiseORExpression.

6. Call GetValue (Risultato (5)).

7. Ripristina risultato (6).

guarda qui per le specifiche

Nella maggior parte dei linguaggi di programmazione, && e || gli operatori restituiscono booleano. In JavaScript è diverso .


Operatore O:

Restituisce il valore del primo operando che si verifica come vero (se presente), altrimenti restituisce il valore dell’ultimo operando (anche se viene convalidato come falso) .

Esempio 1:

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

Esempio 2:

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

Operatore AND:

Restituisce il valore dell’ultimo operando che si applica come vero (se tutte le condizioni sono valide come true), altrimenti restituisce il valore del primo operando che viene convalidato come falso .

Esempio 1:

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

Esempio 2:

 var a = 2 && '' && 3 && null; ^ ^ ^ ^ tftf ^ entire condition is false, so return first operand that validates as false, so, a = '' 

Conclusione:

Se vuoi che JavaScript funzioni nello stesso modo di altri linguaggi di programmazione, usa Boolean() funzione Boolean() , in questo modo:

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

Prima di tutto, deve essere vero per tornare, quindi se stai verificando la veridicità, allora non fa differenza

In secondo luogo, ti consente di svolgere compiti sulla falsariga di:

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

Confrontare:

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

con:

 var prop=obj.value||0; 

Restituire un’espressione di verità – piuttosto che solo vero o falso – di solito rende il tuo codice più breve e comunque leggibile. Questo è molto comune per ||, non tanto per &&.

Potresti usare !! prima della condizione per ottenere il risultato booleano.

 !!(X && Y) // returns true if both X and Y are not null or undefined