In javascript, una stringa vuota è sempre falsa come booleano?

Question

in javascript,

var a = ''; 
var b = (a) ? false : true; // fixed! 

var b verrà impostato true.

è un comportamento definito su cui è possibile fare affidamento?

Answer 1

Sì. JavaScript è un dialetto di ECMAScript, e specifica del linguaggio ECMAScript definisce chiaramente questo comportamento:

ToBoolean

Il risultato è falso se l'argomento è la stringa vuota (la sua lunghezza è zero); altrimenti il ​​risultato vale

dato ricavato http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

Answer 2

Sì. Tutti false, 0, stringhe vuote '' e "", NaN, undefined e null vengono sempre valutati come false; tutto il resto è true.

E nel tuo esempio, b è false dopo la valutazione. (Penso che tu abbia erroneamente scritto true)

Answer 3

var b sarà impostato su false. Questo perché una stringa vuota conta come un valore "falso" in JavaScript come altri valori.

prega di guardare al http://www.sitepoint.com/javascript-truthy-falsy/ per i valori falsy

Answer 4

Esempi di espressioni che possono essere convertiti in falso sono quelli che valore NULL, 0, la stringa vuota (""), oppure non definito. (vedi MDN Reference)

Answer 5

var a = ''; 
 
var b = (a) ? false : true; // fixed! 
 
console.log(b);    // => true

var b verrà impostato true.

è un comportamento definito su cui è possibile fare affidamento?

come risposta sopra, sì, cioè il comportamento definito di una stringa vuota in un condizionale (a if espressione, ||, &&, ? :, ...). (standard says deve essere applicata l'operazione interna ToBoolean.)

La valutazione è diversa quando la stringa vuota viene utilizzato in un confronto (vedi Truth, Equality and JavaScript), anche se i risultati sono lo più gli stessi:

// conditional (note: evaluation to false prints false here!) 
 
console.log('' ? true : false); // zero length  => false 
 

 
// comparisons 
 
console.log('' == true);  // +0 === 1  => false 
 
console.log('' == false);  // +0 === +0  => true 
 
console.log('' === true);  // different types => false 
 
console.log('' === false);  // different types => false

Spiegazione : In sostanza, quando gli operandi di == hanno tipi diversi, JavaScript tenta di convertirli in numeri, in base al loro valore , (usingoperations lo standard chiama ToNumber e ToPrimitive), e quindi si applica internamente ===. Tuttavia, quando si utilizza direttamente ===, i tipi non vengono convertiti, pertanto il confronto di una stringa con un booleano è sempre false.

povere, JavaScript condizionali (ToBoolean) test per una definito, non nullo, diverso da zero, non vuoto, non falso valore (una stringa vuota è ... vuoto, la I numeri -0 o +0 sono ... zero, NaN non è un numero definito, ma un oggetto vuoto non è apparentemente vuoto), o come mi piace pensare, condizionali test per una cosa (vera), mentre == confronta i valori apparenti , convertiti con cura valori (ToPrimiti ve, ToNumber) dei suoi operandi e === cerca l'identicità .

if (X) {}  // is X a (true) thing? 
if (X == Y) {} // are the values of X and Y same-ish? 
if (X === Y) {} // are X and Y exactly the same? 

Non ci sono altri esempi in Truth, Equality and JavaScript in cui questa distinzione è importante, ad esempio, '0' è true in condizionale (lunghezza diversa da zero, o, è una cosa), ma false in un confronto == (il valoreè zero). '1' di nuovo, è true in entrambi i casi (è una cosa e ha un valore diverso da zero).

console.log('' ? true : false); // zero length  => false 
 
console.log('' == true);   // +0 === 1  => false 
 
console.log('0' ? true : false); // non-zero length => true 
 
console.log('0' == true);   // +0 === 1  => false 
 
console.log('1' ? true : false); // non-zero length => true 
 
console.log('1' == true);   // 1 === 1  => true