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"