Em javascript, uma string vazia sempre é falsa como um booleano?

em javascript,

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

var bserá definido como false.

este é um comportamento definido em que se pode confiar?

Sim. Javascript é um dialeto do ECMAScript, e a especificação da linguagem ECMAScript define claramente esse comportamento:

ToBoolean

O resultado é falso se o argumento for a String vazia (seu comprimento é zero); caso contrário, o resultado é verdadeiro

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

Sim. Todos false, 0, cadeias vazias ''e "", NaN, undefined, e nullsão sempre avaliadas como false; tudo o resto é true.

E no seu exemplo, b é falseapós a avaliação. (Eu acho que você escreveu por engano true)

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

var bserá definido como true.

este é um comportamento definido em que se pode confiar?

Como respondida acima, sim , que é o comportamento definido de uma cadeia vazia em uma condicional (uma ifexpressão, ||, &&, ? :, ...). (O padrão diz que a operação ToBoolean interna deve ser aplicada.)

A avaliação é diferente quando a cadeia vazia é usada em uma comparação (consulte Verdade, Igualdade e JavaScript ), mesmo que os resultados sejam basicamente os mesmos :

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

Explicação: Essencialmente, quando os operandos ==têm tipos diferentes, o JavaScript tenta convertê-los em números, de acordo com seu valor ( usando operações que o padrão chama de ToNumber e ToPrimitive ) e, em seguida, aplica-se internamente ===. Mas quando você usa ===diretamente, os tipos não são convertidos; portanto, comparar uma String com um Boolean é sempre false.

Grosso modo, as condicionais JavaScript ( ToBoolean ) testam um valor definido, não nulo, diferente de zero, não vazio e não falso (uma String vazia é ... vazia, os Números -0 ou +0 são ... zero, NaN não é um número definido, mas um objeto vazio aparentemente não é realmente vazia), ou como eu gosto de pensar, condicionais teste para um verdadeiro coisa () , enquanto que ==compara os aparentes, cuidadosamente convertido valores ( ToPrimitive , tonumber ) de seus operandos e ===procura a semelhança exata .

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?

Há mais exemplos em Verdade, Igualdade e JavaScript, onde essa distinção realmente importa, por exemplo, '0'é truecondicional (comprimento diferente de zero ou é uma coisa ), mas falseem ==comparação (o valor é zero). '1'novamente, é truenos dois casos (é uma coisa e tem um valor diferente de 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 bserá definido como true. Isso ocorre porque uma string vazia conta como um valor 'falsey' em JavaScript, assim como alguns outros valores.

Consulte http://www.sitepoint.com/javascript-truthy-falsy/ para obter valores falsos

Exemplos de expressões que podem ser convertidas em false são aquelas que avaliam como nulo, 0, a sequência vazia ("") ou indefinida. (Vejo Referência MDN )