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

in javascript,

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

var bsarà impostato su false.

è un comportamento definito su cui si può fare affidamento?

Sì. Javascript è un dialetto di ECMAScript e la 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 è vero

Citazione tratta da http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

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

E nel tuo esempio, b è falsedopo la valutazione. (Penso che tu abbia scritto per errore true)

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

var bsarà impostato su true.

è un comportamento definito su cui si può fare affidamento?

Come precedentemente risolta, sì , cioè il comportamento definito di una stringa vuota in un condizionale (a ifespressione, ||, &&, ? :, ...). (Lo standard afferma che è necessario applicare l'operazione ToBoolean interna .)

La valutazione è diversa quando la stringa vuota viene utilizzata in un confronto (vedi Verità, Uguaglianza e JavaScript ), anche se i risultati sono sostanzialmente 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: Sostanzialmente, quando gli operandi ==hanno tipi diversi, JavaScript si sforza di convertirli in numeri, in base al loro valore ( utilizzando le operazioni standard chiama ToNumber e ToPrimitive ) e quindi si applica internamente ===. Ma quando si utilizza ===direttamente, i tipi non vengono convertiti, quindi confrontare sempre una stringa con un valore booleano è sempre false.

In parole povere, test condizionali JavaScript ( ToBoolean ) per un valore definito, non nullo, non zero, non vuoto, non falso (una stringa vuota è ... vuota, i numeri -0 o +0 sono ... zero, NaN non è un numero definito, ma un oggetto vuoto apparentemente non è realmente vuoto), o come mi piace pensare, i condizionali testano una cosa (vera) , mentre ==confronta i valori apparenti, accuratamente convertiti ( ToPrimitive , ToNumber ) di i suoi operandi e ===cerca la stessa 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?

Ci sono altri esempi in Verità, Uguaglianza e JavaScript in cui questa distinzione conta davvero, ad es. '0'È truein una condizione (lunghezza diversa da zero, o è una cosa ), ma falsein un ==confronto (il valore è zero). '1'di nuovo, è truein 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

var bsarà impostato su true. Questo perché una stringa vuota conta come valore 'falsey' in JavaScript così come altri valori.

Si prega di consultare http://www.sitepoint.com/javascript-truthy-falsy/ per i valori falsi

Esempi di espressioni che possono essere convertite in false sono quelle che valutano null, 0, la stringa vuota ("") o non definita. (vedi riferimento MDN )