Operatore '&&' in Javascript vs in Java

Question

Attualmente sto leggendo JavaScript da JavaScript: la Guida definitiva. A pagina 76, c'è questa dichiarazione scritta,

o && o.x // => 1: o is truthy, so return value of o.x 

Essendo un programmatore Java voglio chiedere, perché è tornando 1 invece di 'true' In Java questo non era il caso, ma in ogni caso so che JavaScript è diverso ma il meccanismo AND logico è lo stesso ovunque. (In C restituisce 1 come vero.)

Mi chiedo, perché ha senso per questo comportamento?
C'è un modo, posso garantire di restituire solo i valori veri o falsi?

Answer 1

Come per la Spec per Binary Logical Operators

Il valore prodotto da un & & o || l'operatore non è necessariamente di tipo booleano. Il valore prodotto sarà sempre il valore di una delle due espressioni di operando di .

Questa è una funzionalità utilizzata in javascript molto, un caso di uso comune è assegnare un valore predefinito a una variabile se non è definita. Come assumere vi aspettate un opzioni oggetto come un parametro, ma non è obbligatorio in modo che l'utente non può passare che

function x(options){ 
    options = options || {}; 
    //now your can access optionx.a without fearing whether options is undefined 
} 

Si può fare qualcosa di simile !!(o && o.x) per ottenere sempre un vero/falso

Answer 2

È possibile utilizzare Boolean(o && o.x); per ottenere true o false

Answer 3

se abbiamo:

expr1 && expr2 

& & Returns 'expr1' se può essere convertito in false; in caso contrario, restituisce 'expr2'. Pertanto, se utilizzato con valori booleani, & & restituisce true se entrambi gli operandi sono veri; in caso contrario, restituisce false.

Quindi, se abbiamo:

Var xyz = a && b; // dove è indefinito (false) e b è 123, allora sarà allocare indefinito.

In caso di istruzioni if, questi valori vengono specificamente convertiti in booleano.

, consultare il seguente link: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators"

Answer 4

E 'restituire il valore del l'operando di destra. Se il valore di o.x era true, restituirebbe true. Se il valore di o.x era 'banana', restituirebbe 'banana'.

var o = {x:true}; 
 
console.log(o && o.x);

Answer 5

Tecnicamente && operatore attuate per restituire il primo operando, se il suo valore non è pari a zero, e restituisce il secondo operando tuttavia in molte lingue tra cui Java, C/C++, Javascript, Perl ... Mentre la maggior parte delle lingue accetta qualsiasi tipo di operandi, Java ti obbliga a usare gli operandi booleani in modo che restituisca sempre true o false. Per forzare un risultato booleano in Javascript uso:

Boolean(a && b) 

Answer 6

Questo comportamento è chiamato coercizione. La coercizione è l'azione di forzare un oggetto a comportarsi come un altro tipo e gli operatori logici possono produrre coercizione quando tenta di accedere al valore dell'oggetto da valutare.

È importante ricordare tavolo per truthy e falsy valori, perché a causa di coercizione, diversi risultati possono essere ottenuti.

• false produce false
• 0 produce false
• “” produce false
• NaN produce false
• null produce false
• undefined produce 0.123.

Tutto il resto produce true, incluso il testo "0" e "false", funzioni, array e oggetti vuoti.

Date le condizioni per gli operatori logici, esiste cortocircuito valutazione in JavaScript, per esempio:

0 && 1; //-> 0, falsy value 
!(0 && 1); //-> true, falsy value negated 
!!(0 && 1); //-> false, boolean falsy value 

void 0 && alert("1") //-> undefined (void produces undefined) 
[] && Math.ceil(9.1) //-> 10, truthy value 
{} && someFunc() //-> the result of someFunc() 

0 || null; //-> null, falsy value 
null || "0"; //-> "0", truthy value 
"" || void 1; //-> undefined, falsy value 
!!(+"5px" || {}); //-> true, boolean truthy value 

coercizione è utile quando è necessario convalidare i valori predefiniti, al fine di evitare errori, ad esempio

function divide (a, b) { 
    a = +a; //-> coerced to number 
    b = +b; //-> coerced to number 
    if (!a) return 0; //-> NaN or zero 
    return b && a/b; //-> b must be a number different from zero 
} 

divide(); //-> 0 
divide(5); //-> NaN, no error thrown! 
divide(5, "a"); //-> NaN, no error thrown! 
divide(5, 0); //-> 0, division by zero prevented! 
divide(49, 6); //-> 8.1666 

Se si desidera impedire il ritorno NaN, basta aggiungere un altro coercizione nella dichiarazione di ritorno:

return (b && a/b) || 0; 

È possibile controllare gli altri casi di coercizione: JavaScript Coercion

---

Felice codifica!