Czy w javascript pusty ciąg jest zawsze fałszywy jako wartość logiczna?

w javascript,

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

var bzostanie ustawiony na false.

czy jest to określone zachowanie, na którym można polegać?

Tak. Javascript jest dialektem ECMAScript, a specyfikacja języka ECMAScript jasno definiuje to zachowanie:

ToBoolean

Wynik jest fałszywy, jeśli argument jest pustym ciągiem (jego długość wynosi zero); w przeciwnym razie wynik jest prawdziwy

Cytat pochodzi z http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

Tak. Wszystko false, 0, puste struny ''i "", NaN, undefined, i nullsą zawsze oceniane jako false; wszystko inne jest true.

W twoim przykładzie b jest falsepo ocenie. (Myślę, że omyłkowo napisałeś true)

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

var bzostanie ustawiony na true.

czy jest to określone zachowanie, na którym można polegać?

Jak odpowiedział wyżej, tak , że jest zdefiniowane zachowanie pusty ciąg w ramach warunkowego (e ifwypowiedzi, ||, &&, ? :, ...). ( Norma mówi, że należy zastosować wewnętrzną operację ToBoolean ).

Ocena jest inna, gdy w porównaniu używany jest pusty ciąg (patrz Prawda, Równość i JavaScript ), nawet jeśli wyniki są w większości takie same :

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

Objaśnienie: Zasadniczo, gdy operandy z ==mają różne typy, JavaScript usilnie próbuje przekształcić je w Numbers, zgodnie z ich wartością ( używając operacji, które standard wywołuje ToNumber i ToPrimitive ), a następnie stosuje się to wewnętrznie ===. Ale gdy używasz ===bezpośrednio, typy nie są konwertowane, więc zawsze porównuje się ciąg znaków z wartością logiczną false.

Z grubsza rzecz biorąc, warunkowe JavaScript ( ToBoolean ) testują zdefiniowaną, niezerową, niezerową, niepustą, inną niż fałsz wartość (pusty łańcuch jest ... pusty, liczby -0 lub +0 to ... zero, NaN nie jest zdefiniowaną liczbą, ale pusty Obiekt najwyraźniej nie jest naprawdę pusty) lub, jak lubię myśleć, warunkowe testuje (prawdziwą) rzecz , ==porównując pozorne, starannie przekonwertowane wartości ( ToPrimitive , ToNumber ) jej operandy i ===szuka dokładnej identyczności .

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?

W Prawda, Równość i JavaScript jest więcej przykładów, w których to rozróżnienie naprawdę ma znaczenie, np. '0'Jest truewarunkowe (niezerowa długość lub, jest rzeczą ), ale falsew ==porównaniu ( wartość wynosi zero). '1'znowu jest truew obu przypadkach (jest rzeczą i ma wartość niezerową).

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 bzostanie ustawiony na true. Dzieje się tak, ponieważ pusty ciąg liczy się jako wartość „falsey” w JavaScript, podobnie jak niektóre inne wartości.

Sprawdź http://www.sitepoint.com/javascript-truthy-falsy/ pod kątem fałszywych wartości

Przykładami wyrażeń, które można przekonwertować na fałsz, są wyrażenia, których wynikiem jest null, 0, pusty ciąg („”) lub nieokreślony. (patrz Dokumentacja MDN )