Puis-je convertir une chaîne représentant une valeur booléenne (par exemple, "vrai", "faux") en un type intrinsèque en JavaScript?

J'ai un formulaire caché en HTML qui est mis à jour en fonction de la sélection d'un utilisateur dans une liste. Ce formulaire contient certains champs qui représentent des valeurs booléennes et sont remplis dynamiquement avec une valeur booléenne intrinsèque. Cependant, une fois que cette valeur est placée dans le champ de saisie masqué, elle devient une chaîne.

Le seul moyen que j'ai pu trouver pour déterminer la valeur booléenne du champ, une fois qu'il a été converti en chaîne, était de dépendre de la valeur littérale de sa représentation sous forme de chaîne.

var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';

Existe-t-il une meilleure façon d'accomplir cela?

Faire:

var isTrueSet = (myValue == 'true');

Vous pouvez le rendre plus strict en utilisant l'opérateur d'identité ( ===), qui n'effectue aucune conversion de type implicite lorsque les variables comparées ont des types différents, au lieu de l'opérateur d'égalité ( ==).

var isTrueSet = (myValue === 'true');

Ne pas:

Vous devriez probablement être prudent lorsque vous utilisez ces deux méthodes pour vos besoins spécifiques:

var myBool = Boolean("false");  // == true

var myBool = !!"false";  // == true

Toute chaîne qui n'est pas la chaîne vide sera évaluée trueen les utilisant. Bien que ce soient les méthodes les plus propres auxquelles je puisse penser en ce qui concerne la conversion booléenne, je pense que ce n'est pas ce que vous recherchez.

Attention

Cette réponse héritée très appréciée est techniquement correcte mais ne couvre qu'un scénario très spécifique, lorsque la valeur de votre chaîne est EXACTEMENT "true"ou "false".

Une chaîne json non valide passée dans ces fonctions ci-dessous lèvera une exception .

Réponse originale:

Que diriez-vous?

JSON.parse("True".toLowerCase());

ou avec jQuery

$.parseJSON("TRUE".toLowerCase());

stringToBoolean: function(string){
    switch(string.toLowerCase().trim()){
        case "true": case "yes": case "1": return true;
        case "false": case "no": case "0": case null: return false;
        default: return Boolean(string);
    }
}

Je pense que c'est beaucoup universel:

if (String(a) == "true") ...

Ça va:

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false

N'oubliez pas de faire correspondre la casse:

var isTrueSet = (myValue.toLowerCase() === 'true');

De plus, s'il s'agit d'une case à cocher d'élément de formulaire, vous pouvez également détecter si la case est cochée:

var isTrueSet = document.myForm.IS_TRUE.checked;

En supposant que s'il est coché, il est "défini" égal à vrai. Ceci est évalué comme vrai / faux.

Vous pouvez utiliser des expressions régulières:

/*
 * Converts a string to a bool.
 *
 * This conversion will:
 *
 *  - match 'true', 'on', or '1' as true.
 *  - ignore all white-space padding
 *  - ignore capitalization (case).
 *
 * '  tRue  ','ON', and '1   ' will all evaluate as true.
 *
 */
function strToBool(s)
{
    // will match one and only one of the string 'true','1', or 'on' rerardless
    // of capitalization and regardless off surrounding white-space.
    //
    regex=/^\s*(true|1|on)\s*$/i

    return regex.test(s);
}

Si vous aimez étendre la classe String, vous pouvez faire:

String.prototype.bool = function() {
    return strToBool(this);
};

alert("true".bool());

Pour ceux (voir les commentaires) qui souhaitent étendre l'objet String pour l'obtenir, mais s'inquiètent de l'énumération et craignent de se heurter à un autre code qui étend l'objet String:

Object.defineProperty(String.prototype, "com_example_bool", {
    get : function() {
        return (/^(true|1)$/i).test(this);
    }
});
alert("true".com_example_bool);

(Ne fonctionnera pas dans les anciens navigateurs bien sûr et Firefox affiche faux alors qu'Opera, Chrome, Safari et IE sont vrais. Bogue 720760 )

Wood-eye, soyez prudent. Après avoir vu les conséquences après avoir appliqué la première réponse avec plus de 500 votes positifs, je me sens obligé de publier quelque chose qui est réellement utile:

Commençons par le moyen le plus court mais le plus strict:

var str = "true";
var mybool = JSON.parse(str);

Et terminez d'une manière appropriée et plus tolérante:

var parseBool = function(str) 
{
    // console.log(typeof str);
    // strict: JSON.parse(str)

    if(str == null)
        return false;

    if (typeof str === 'boolean')
    {
        return (str === true);
    } 

    if(typeof str === 'string')
    {
        if(str == "")
            return false;

        str = str.replace(/^\s+|\s+$/g, '');
        if(str.toLowerCase() == 'true' || str.toLowerCase() == 'yes')
            return true;

        str = str.replace(/,/g, '.');
        str = str.replace(/^\s*\-\s*/g, '-');
    }

    // var isNum = string.match(/^[0-9]+$/) != null;
    // var isNum = /^\d+$/.test(str);
    if(!isNaN(str))
        return (parseFloat(str) != 0);

    return false;
}

Essai:

var array_1 = new Array(true, 1, "1",-1, "-1", " - 1", "true", "TrUe", "  true  ", "  TrUe", 1/0, "1.5", "1,5", 1.5, 5, -3, -0.1, 0.1, " - 0.1", Infinity, "Infinity", -Infinity, "-Infinity"," - Infinity", " yEs");

var array_2 = new Array(null, "", false, "false", "   false   ", " f alse", "FaLsE", 0, "00", "1/0", 0.0, "0.0", "0,0", "100a", "1 00", " 0 ", 0.0, "0.0", -0.0, "-0.0", " -1a ", "abc");


for(var i =0; i < array_1.length;++i){ console.log("array_1["+i+"] ("+array_1[i]+"): " + parseBool(array_1[i]));}

for(var i =0; i < array_2.length;++i){ console.log("array_2["+i+"] ("+array_2[i]+"): " + parseBool(array_2[i]));}

for(var i =0; i < array_1.length;++i){ console.log(parseBool(array_1[i]));}
for(var i =0; i < array_2.length;++i){ console.log(parseBool(array_2[i]));}

J'ai pensé que la réponse de @Steven était la meilleure et j'ai pris en charge beaucoup plus de cas que si la valeur entrante n'était qu'une chaîne. Je voulais l'étendre un peu et offrir ce qui suit:

function isTrue(value){
    if (typeof(value) === 'string'){
        value = value.trim().toLowerCase();
    }
    switch(value){
        case true:
        case "true":
        case 1:
        case "1":
        case "on":
        case "yes":
            return true;
        default: 
            return false;
    }
}

Il n'est pas nécessaire de couvrir tous les falsecas si vous connaissez déjà tous les truecas dont vous auriez à rendre compte. Vous pouvez passer n'importe quoi dans cette méthode qui pourrait passer pour une truevaleur (ou en ajouter d'autres, c'est assez simple), et tout le reste serait considéréfalse

Solution universelle avec analyse JSON:

function getBool(val) {
    return !!JSON.parse(String(val).toLowerCase());
}

getBool("1"); //true
getBool("0"); //false
getBool("true"); //true
getBool("false"); //false
getBool("TRUE"); //true
getBool("FALSE"); //false

MISE À JOUR (sans JSON):

function getBool(val){ 
    var num = +val;
    return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}

J'ai aussi créé du violon pour le tester http://jsfiddle.net/remunda/2GRhG/

Votre solution est très bien.

L'utilisation ===serait juste idiote dans ce cas, car le champ valuesera toujours a String.

var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) { 
    return !falsy.test(val) && !!val;
};

Ce rendement falsepour chaque valeur falsy et truepour chaque valeur de truthy sauf pour 'false', 'f', 'no', 'n'et '0'(insensible à la casse).

// False
Boolean.parse(false);
Boolean.parse('false');
Boolean.parse('False');
Boolean.parse('FALSE');
Boolean.parse('f');
Boolean.parse('F');
Boolean.parse('no');
Boolean.parse('No');
Boolean.parse('NO');
Boolean.parse('n');
Boolean.parse('N');
Boolean.parse('0');
Boolean.parse('');
Boolean.parse(0);
Boolean.parse(null);
Boolean.parse(undefined);
Boolean.parse(NaN);
Boolean.parse();

//True
Boolean.parse(true);
Boolean.parse('true');
Boolean.parse('True');
Boolean.parse('t');
Boolean.parse('yes');
Boolean.parse('YES');
Boolean.parse('y');
Boolean.parse('1');
Boolean.parse('foo');
Boolean.parse({});
Boolean.parse(1);
Boolean.parse(-1);
Boolean.parse(new Date());

L'objet booléen n'a pas de méthode 'parse'. Boolean('false')renvoie vrai, donc cela ne fonctionnera pas. !!'false'revient également true, de sorte que cela ne fonctionnera pas également.

Si vous souhaitez que chaîne 'true'renvoie un booléen trueet chaîne 'false'pour renvoyer un booléen false, la solution la plus simple consiste à utiliser eval(). eval('true')renvoie vrai et eval('false')renvoie faux. Gardez à l'esprit les implications en termes de performances lors de l'utilisation eval().

Cela a été tiré de la réponse acceptée, mais en réalité, il a un point très faible, et je suis choqué de voir comment il a obtenu ce nombre de votes positifs, le problème avec cela, c'est que vous devez considérer le cas de la chaîne car il est sensible à la casse

var isTrueSet = (myValue.toLowerCase() === 'true');

J'utilise ce qui suit:

function parseBool(b) {
    return !(/^(false|0)$/i).test(b) && !!b;
}

Cette fonction effectue la contrainte booléenne habituelle à l'exception des chaînes "false" (insensible à la casse) et "0".

Il y a beaucoup de réponses et il est difficile d'en choisir une. Dans mon cas, je priorise les performances lors du choix, donc je crée ce jsPerf qui, je l'espère, pourra apporter un peu de lumière ici.

Bref des résultats (le plus haut sera le mieux):

1. Déclaration conditionnelle : 2 826 922
2. Boîtier de commutateur sur objet Bool : 2 825 469
3. Casting en JSON : 1 867 774
4. !! conversions : 805 322
5. Prototype de chaîne : 713 637

Ils sont liés à la réponse correspondante où vous pouvez trouver plus d'informations (avantages et inconvénients) sur chacun d'eux; spécialement dans les commentaires.

Boolean.parse = function (str) {
  switch (str.toLowerCase ()) {
    case "true":
      return true;
    case "false":
      return false;
    default:
      throw new Error ("Boolean.parse: Cannot convert string to boolean.");
  }
};

L'expression que vous recherchez est simplement

/^true$/i.test(myValue)

un péché

var isTrueSet = /^true$/i.test(myValue);

Cela teste myValueune expression régulière, insensible à la casse et ne modifie pas le prototype.

Exemples:

/^true$/i.test("true"); // true
/^true$/i.test("TRUE"); // true
/^true$/i.test("tRuE"); // true
/^true$/i.test(" tRuE"); // false (notice the space at the beginning)
/^true$/i.test("untrue"); // false (some other solutions here will incorrectly return true
/^true$/i.test("false");// returns false
/^true$/i.test("xyz");  // returns false

Pour convertir à la fois une chaîne ("vrai", "faux") et un booléen en booléen

('' + flag) === "true"

Où flagpeut être

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"

Il y a déjà tellement de réponses disponibles. Mais ce qui suit peut être utile dans certains scénarios.

// One can specify all values against which you consider truthy
var TRUTHY_VALUES = [true, 'true', 1];

function getBoolean(a) {
    return TRUTHY_VALUES.some(function(t) {
        return t === a;
    });
}

Cela peut être utile lorsqu'un exemple avec des valeurs non booléennes.

getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true

pourquoi n'essayez-vous pas quelque chose comme ça

Boolean(JSON.parse((yourString.toString()).toLowerCase()));

Il retournera une erreur lorsqu'un autre texte est donné plutôt que vrai ou faux quel que soit le cas et il capturera également les nombres comme

// 0-> false
// any other number -> true

Cette fonction peut gérer les chaînes ainsi que les valeurs booléennes true / false.

function stringToBoolean(val){
    var a = {
        'true':true,
        'false':false
    };
    return a[val];
}

Démonstration ci-dessous:

function stringToBoolean(val) {
  var a = {
    'true': true,
    'false': false
  };
  return a[val];
}

console.log(stringToBoolean("true"));

console.log(typeof(stringToBoolean("true")));

console.log(stringToBoolean("false"));

console.log(typeof(stringToBoolean("false")));

console.log(stringToBoolean(true));

console.log(typeof(stringToBoolean(true)));

console.log(stringToBoolean(false));

console.log(typeof(stringToBoolean(false)));

console.log("=============================================");
// what if value was undefined? 
console.log("undefined result:  " + stringToBoolean(undefined));
console.log("type of undefined result:  " + typeof(stringToBoolean(undefined)));
console.log("=============================================");
// what if value was an unrelated string?
console.log("unrelated string result:  " + stringToBoolean("hello world"));
console.log("type of unrelated string result:  " + typeof(stringToBoolean(undefined)));

J'utilise celui-ci

String.prototype.maybeBool = function(){

    if ( ["yes", "true", "1", "on"].indexOf( this.toLowerCase() ) !== -1 ) return true;
    if ( ["no", "false", "0", "off"].indexOf( this.toLowerCase() ) !== -1 ) return false;

    return this;

}

"on".maybeBool(); //returns true;
"off".maybeBool(); //returns false;
"I like js".maybeBool(); //returns "I like js"

De loin, le moyen le plus simple (en supposant que votre chaîne soit «vraie» ou «fausse») est:

var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false

Utilisez toujours l'opérateur === au lieu de l'opérateur == pour ces types de conversions!

Comme l'a dit @ Shadow2531, vous ne pouvez pas simplement le convertir directement. Je suggérerais également que vous considériez les entrées de chaîne en plus de "vrai" et "faux" qui sont "véridiques" et "falsey" si votre code va être réutilisé / utilisé par d'autres. Voici ce que j'utilise:

function parseBoolean(string) {
  switch (String(string).toLowerCase()) {
    case "true":
    case "1":
    case "yes":
    case "y":
      return true;
    case "false":
    case "0":
    case "no":
    case "n":
      return false;
    default:
      //you could throw an error, but 'undefined' seems a more logical reply
      return undefined;
  }
}

Vous devez séparer (dans votre réflexion) la valeur de vos sélections et la représentation de cette valeur.

Choisissez un point dans la logique JavaScript où ils doivent passer des sentinelles de chaîne au type natif et faites une comparaison là-bas, de préférence où cela n'est fait qu'une seule fois pour chaque valeur à convertir. N'oubliez pas de répondre à ce qui doit se produire si la chaîne sentinelle n'est pas celle que le script connaît (c.-à-d. Est-ce que vous par défaut est vrai ou faux?)

En d'autres termes, oui, vous devez dépendre de la valeur de la chaîne. :-)

Mon point de vue sur cette question est qu'elle vise à satisfaire trois objectifs:

• Renvoie true / false pour les valeurs truey et falsey, mais renvoie également true / false pour les valeurs de chaîne multiples qui seraient véridiques ou falsey s'il s'agissait de booléens au lieu de chaînes.
• Deuxièmement, fournissez une interface résiliente afin que des valeurs autres que celles spécifiées n'échouent pas, mais renvoient plutôt une valeur par défaut
• Troisièmement, faites tout cela avec le moins de code possible.

Le problème avec l'utilisation de JSON est qu'il échoue en provoquant une erreur Javascript. Cette solution n'est pas résiliente (bien qu'elle satisfasse 1 et 3):

JSON.parse("FALSE") // fails

Cette solution n'est pas assez concise:

if(value === "TRUE" || value === "yes" || ...) { return true; }

Je travaille sur la résolution de ce problème exact pour Typecast.js . Et la meilleure solution à ces trois objectifs est celle-ci:

return /^true$/i.test(v);

Il fonctionne dans de nombreux cas, n'échoue pas lorsque des valeurs comme {} sont transmises et est très concis. De plus, il retourne false comme valeur par défaut plutôt que non défini ou lançant une erreur, ce qui est plus utile dans le développement Javascript de type lâche. Bravo aux autres réponses qui l'ont suggéré!

Je suis un peu en retard, mais j'ai un petit extrait pour ce faire, il maintient essentiellement tous JScripts truthey / Falsey / sale ness mais comprend "false"comme une valeur acceptible pour faux.

Je préfère cette méthode à celles mentionnées car elle ne repose pas sur un tiers pour analyser le code (ie: eval / JSON.parse), ce qui est exagéré dans mon esprit, il est assez court pour ne pas nécessiter de fonction utilitaire et maintient autres conventions Truthey / Falsey.

var value = "false";
var result = (value == "false") != Boolean(value);

// value = "true"  => result = true
// value = "false" => result = false
// value = true    => result = true
// value = false   => result = false
// value = null    => result = false
// value = []      => result = true
// etc..

une autre solution. jsFiddle

var toBoolean = function(value) {
    var strValue = String(value).toLowerCase();
    strValue = ((!isNaN(strValue) && strValue !== '0') &&
        strValue !== '' &&
        strValue !== 'null' &&
        strValue !== 'undefined') ? '1' : strValue;
    return strValue === 'true' || strValue === '1' ? true : false
};

cas de test exécutés dans le nœud

> toBoolean(true)
true
> toBoolean(false)
false
> toBoolean(undefined)
false
> toBoolean(null)
false
> toBoolean('true')
true
> toBoolean('True')
true
> toBoolean('False')
false
> toBoolean('false')
false
> toBoolean('0')
false
> toBoolean('1')
true
> toBoolean('100')
true
> 

Dieu sacré, certaines de ces réponses sont tout simplement sauvages. J'adore JS et son nombre infini de façons d'écorcher un bool.

Ma préférence, que j'ai été choquée de ne pas voir déjà, est:

testVar = testVar.toString().match(/^(true|[1-9][0-9]*|[0-9]*[1-9]+|yes)$/i) ? true : false;

Bon mot

Nous avons juste besoin de prendre en compte la "fausse" chaîne puisque toute autre chaîne (y compris "vraie") l'est déjà true.

function b(v){ return v==="false" ? false : !!v; }

Tester

b(true)    //true
b('true')  //true
b(false)   //false
b('false') //false

Une version plus exaustive

function bool(v){ return v==="false" || v==="null" || v==="NaN" || v==="undefined" || v==="0" ? false : !!v; }

Tester

bool(true)        //true
bool("true")      //true
bool(1)           //true
bool("1")         //true
bool("hello")     //true

bool(false)       //false
bool("false")     //false
bool(0)           //false
bool("0")         //false
bool(null)        //false
bool("null")      //false
bool(NaN)         //false
bool("NaN")       //false
bool(undefined)   //false
bool("undefined") //false
bool("")          //false

bool([])          //true
bool({})          //true
bool(alert)       //true
bool(window)      //true