En javascript, une chaîne vide est-elle toujours fausse en tant que booléen?

en javascript,

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

var bsera défini sur false.

est-ce un comportement défini sur lequel on peut se fier?

Oui. Javascript est un dialecte d'ECMAScript, et la spécification du langage ECMAScript définit clairement ce comportement:

ToBoolean

Le résultat est faux si l'argument est la chaîne vide (sa longueur est égale à zéro); sinon le résultat est vrai

Citation tirée de http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

Oui. Tous false, 0, des chaînes vides ''et "", NaN, undefinedet nullsont toujours évalués comme false; tout le reste est true.

Et dans votre exemple, b est falseaprès évaluation. (Je pense que tu as écrit par erreur true)

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

var bsera défini sur true.

est-ce un comportement défini sur lequel on peut se fier?

Comme ci - dessus répondu, oui , c'est le comportement défini d'une chaîne vide dans une condition (une ifexpression, ||, &&, ? :, ...). (La norme dit que l' opération ToBoolean interne doit être appliquée.)

L'évaluation est différente lorsque la chaîne vide est utilisée dans une comparaison (voir Vérité, Égalité et JavaScript ), même si les résultats sont pour la plupart les mêmes :

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

Explication: Essentiellement, lorsque les opérandes de ==ont des types différents, JavaScript s'efforce de les convertir en nombres, en fonction de leur valeur , (à l' aide d' opérations que le standard appelle ToNumber et ToPrimitive ), puis il s'applique en interne ===. Mais lorsque vous utilisez ===directement, les types ne sont pas convertis, donc comparer une chaîne à un booléen l'est toujours false.

En gros, les conditions JavaScript ( ToBoolean ) testent une valeur définie, non nulle, non nulle, non vide, non fausse (une chaîne vide est ... vide, les nombres -0 ou +0 sont ... zéro, NaN n'est pas un nombre défini, mais un objet vide n'est apparemment pas vraiment vide), ou comme j'aime à le penser, les conditions testent une chose (vraie) , tandis que ==compare les valeurs apparentes et soigneusement converties ( ToPrimitive , ToNumber ) de ses opérandes, et ===recherche la similitude exacte .

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?

Il y a d' autres exemples dans la vérité, l' égalité et JavaScript où cette distinction est vraiment important, par exemple , '0'est truedans une condition (longueur non nulle, ou, il est une chose ), mais falsedans une ==comparaison (la valeur est égale à zéro). '1'encore une fois, c'est truedans les deux cas (c'est une chose et a une valeur non nulle).

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 bsera défini sur true. En effet, une chaîne vide compte comme une valeur «falsey» dans JavaScript, tout comme certaines autres valeurs.

Veuillez consulter http://www.sitepoint.com/javascript-truthy-falsy/ pour des valeurs fausses

Des exemples d'expressions qui peuvent être converties en false sont celles qui évaluent à null, 0, la chaîne vide ("") ou indéfinie. (voir référence MDN )