En javascript, ¿una cadena vacía siempre es falsa como booleana?

en javascript,

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

var bse ajustará a false.

¿Es este un comportamiento definido en el que se puede confiar?

Si. Javascript es un dialecto de ECMAScript, y la especificación del lenguaje ECMAScript define claramente este comportamiento:

ToBoolean

El resultado es falso si el argumento es la cadena vacía (su longitud es cero); de lo contrario el resultado es verdadero

Cita tomada de http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

Si. Todo false, 0, cadenas vacías ''y "", NaN, undefined, y nullsiempre se evalúan como false; todo lo demás es true.

Y en su ejemplo, b es falsedespués de la evaluación. (Creo que escribiste por error true)

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

var bse establecerá en true.

¿Es este un comportamiento definido en el que se puede confiar?

Como la explicación anterior, sí , ese es el comportamiento definido de una cadena vacía en un condicional (una ifexpresión, ||, &&, ? :, ...). (El estándar dice que se debe aplicar la operación interna ToBoolean ).

La evaluación es diferente cuando se utiliza la cadena vacía en una comparación (ver Verdad, Igualdad y JavaScript ), aunque los resultados son en su mayoría los mismos :

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

Explicación: Esencialmente, cuando los operandos de ==tienen diferentes tipos, JavaScript se esfuerza por convertirlos a Números, de acuerdo con su valor , ( usando operaciones que las llamadas estándar ToNumber y ToPrimitive ), y luego se aplica internamente ===. Pero cuando se usa ===directamente, los tipos no se convierten, por lo que siempre se compara una cadena con un booleano false.

En términos generales, la prueba de condicionales de JavaScript ( ToBoolean ) para un valor definido, no nulo, no cero, no vacío, no falso (una cadena vacía está ... vacía, los números -0 o +0 son ... cero, NaN no es un número definido, pero un Objeto vacío aparentemente no está realmente vacío), o como me gusta pensar, los condicionales prueban una cosa (verdadera) , mientras ==compara los valores aparentes, cuidadosamente convertidos ( ToPrimitive , ToNumber ) de sus operandos, y ===busca la similitud exacta .

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?

Hay más ejemplos en Verdad, Igualdad y JavaScript en los que esta distinción realmente importa, por ejemplo, '0'es truecondicional (longitud distinta de cero, o es una cosa ), pero falseen una ==comparación (el valor es cero). '1'de nuevo, es trueen ambos casos (es una cosa y tiene un valor distinto de cero).

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 bse ajustará a true. Esto se debe a que una cadena vacía cuenta como un valor 'falsey' en JavaScript al igual que otros valores.

Mire http://www.sitepoint.com/javascript-truthy-falsy/ para ver los valores falsos

Ejemplos de expresiones que se pueden convertir a falso son aquellas que se evalúan como nulas, 0, la cadena vacía ("") o indefinida. (ver referencia de MDN )