Ist in Javascript eine leere Zeichenfolge als Boolescher Wert immer falsch?

in Javascript,

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

var bwird auf gesetzt false.

Ist dies ein definiertes Verhalten, auf das man sich verlassen kann?

Ja. Javascript ist ein Dialekt von ECMAScript, und die ECMAScript-Sprachspezifikation definiert dieses Verhalten klar:

ToBoolean

Das Ergebnis ist falsch, wenn das Argument der leere String ist (seine Länge ist Null). Andernfalls ist das Ergebnis wahr

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

Ja. Alle false, 0leere Saiten ''und "", NaN, undefinedund nullwerden immer ausgewertet , wie false; alles andere ist true.

Und in Ihrem Beispiel steht b falsenach der Auswertung. (Ich denke, Sie haben fälschlicherweise geschrieben true)

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

var bwird auf gesetzt true.

Ist dies ein definiertes Verhalten, auf das man sich verlassen kann?

Wie oben beantwortet, ja , das ist das definierte Verhalten eines leeren String in einem bedingten (ein ifAusdruck, ||, &&, ? :, ...). (Der Standard besagt, dass die interne ToBoolean- Operation angewendet werden muss.)

Die Auswertung ist unterschiedlich, wenn die leere Zeichenfolge in einem Vergleich verwendet wird (siehe Wahrheit, Gleichheit und JavaScript ), obwohl die Ergebnisse größtenteils gleich sind :

// 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

Erläuterung: Wenn die Operanden von ==unterschiedliche Typen haben, versucht JavaScript im Wesentlichen, sie entsprechend ihrem Wert in Zahlen zu konvertieren (unter Verwendung von Operationen, die die Standardaufrufe ToNumber und ToPrimitive verwenden ), und gilt dann intern ===. Bei ===direkter Verwendung werden die Typen jedoch nicht konvertiert, sodass der Vergleich eines Strings mit einem Booleschen Wert immer erfolgt false.

Grob gesagt testen JavaScript- Bedingungen ( ToBoolean ) auf einen definierten Wert, der nicht null, nicht null, nicht leer und nicht falsch ist (ein leerer String ist ... leer, die Zahlen -0 oder +0 sind ... Null, NaN ist nicht eine definierte Zahl, aber ein leeres Objekt ist offenbar nicht wirklich leer) oder als Ich mag denken, conditionals Test für eine (true) Sache , während ==vergleicht die scheinbaren, sorgfältig konvertierte Werte ( ToPrimitive , toNumber ) von seine Operanden und ===sucht nach exakter Gleichheit .

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?

Es gibt weitere Beispiele in Wahrheit, Gleichheit und JavaScript , wo diese Unterscheidung wirklich wichtig ist , zum Beispiel '0'ist truein einer bedingten (nicht-Null - Länge, oder es ist eine Sache ), aber falsein einem ==Vergleich (der Wert Null). '1'wieder ist truein beiden Fällen (es ist eine Sache und hat einen Wert ungleich Null).

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 bwird auf gesetzt true. Dies liegt daran, dass eine leere Zeichenfolge in JavaScript ebenso wie einige andere Werte als Falsey-Wert gilt.

Unter http://www.sitepoint.com/javascript-truthy-falsy/ finden Sie falsche Werte

Beispiele für Ausdrücke, die in false konvertiert werden können, sind solche, die als null, 0, die leere Zeichenfolge ("") oder undefiniert ausgewertet werden. (siehe MDN-Referenz )