web-dev-qa-db-fra.com

JavaScript: analyse d'une valeur booléenne de chaîne?

JavaScript a parseInt() et parseFloat(), mais il n'y a pas de méthode parseBool ou parseBoolean dans la portée globale, à ma connaissance.

J'ai besoin d'une méthode qui prend des chaînes avec des valeurs telles que "true" ou "false" et renvoie un code JavaScript Boolean.

Voici ma mise en œuvre:

function parseBool(value) {
    return (typeof value === "undefined") ? 
           false : 
           // trim using jQuery.trim()'s source 
           value.replace(/^\s+|\s+$/g, "").toLowerCase() === "true";
}

Est-ce une bonne fonction? S'il vous plaît donnez-moi vos commentaires.

Merci!

javascripttrim
65
AgileMeansDoAsLittleAsPossible

Je serais enclin à faire un one liner avec un si ternaire.

var bool_value = value == "true" ? true : false

Edit: Il serait encore plus rapide d'éviter simplement d'utiliser une instruction logique et d'utiliser simplement l'expression elle-même:

var bool_value = value == 'true';

Cela fonctionne parce que value == 'true' est évalué selon que la variable value est une chaîne de 'true'. Si tel est le cas, cette expression entière devient true et si ce n'est pas le cas, elle devient false, alors le résultat est attribué à bool_value après évaluation.

74
RGB

Vous pouvez utiliser JSON.parse pour cela:

JSON.parse("true"); //returns boolean true
33
F.Alves

Cela dépend de la manière dont vous souhaitez que la fonction fonctionne.

Si tout ce que vous voulez faire, c'est tester le mot 'true' dans la chaîne et définir toute chaîne (ou non) qui ne l'a pas comme étant fausse, le moyen le plus simple est probablement le suivant:

function parseBoolean(str) {
  return /true/i.test(str);
}

Si vous souhaitez vous assurer que la chaîne entière est le mot true, procédez comme suit:

function parseBoolean(str) {
  return /^true$/i.test(str);
}
14
Martin Jespersen

Vous pouvez essayer ce qui suit:

function parseBool(val)
{
    if ((typeof val === 'string' && (val.toLowerCase() === 'true' || val.toLowerCase() === 'yes')) || val === 1)
        return true;
    else if ((typeof val === 'string' && (val.toLowerCase() === 'false' || val.toLowerCase() === 'no')) || val === 0)
        return false;

    return null;
}

Si c'est une valeur valide, il retourne la valeur bool équivalente, sinon il retourne null.

10
Paul Fleming

Vous pouvez ajouter ce code:

function parseBool(str) {

  if (str.length == null) {
    return str == 1 ? true : false;
  } else {
    return str == "true" ? true : false;
  }

}

Fonctionne comme ceci:

parseBool(1) //true
parseBool(0) //false
parseBool("true") //true
parseBool("false") //false
3
CodeGems

Vous pouvez utiliser JSON.parse ou jQuery.parseJSON et voir s'il renvoie true en utilisant quelque chose comme ceci:

function test (input) {
    try {
        return !!$.parseJSON(input.toLowerCase());
    } catch (e) { }
}
3
rsp

Personnellement, je pense que ce n’est pas bon que votre fonction "cache" des valeurs non valides sous la forme false et - en fonction de vos cas d'utilisation - ne renvoie pas true pour "1".

Un autre problème pourrait être que cela se produit sur tout ce qui n'est pas une chaîne.

Je voudrais utiliser quelque chose comme ça:

function parseBool(value) {
  if (typeof value === "string") {
     value = value.replace(/^\s+|\s+$/g, "").toLowerCase();
     if (value === "true" || value === "false")
       return value === "true";
  }
  return; // returns undefined
}

Et en fonction des cas d'utilisation, étendez-le pour distinguer "0" et "1".

(Peut-être y a-t-il un moyen de comparer une seule fois contre "true", mais je ne pouvais pas penser à quelque chose en ce moment.)

3
RoToRa

Pourquoi ne pas garder les choses simples?

var parseBool = function(str) {
    if (typeof str === 'string' && str.toLowerCase() == 'true')
            return true;

    return (parseInt(str) > 0);
}
2
MiniGod

Oeil de bois soyez prudent. Après avoir regardé tout ce code, je me sens obligé de poster:

Commençons par le chemin le plus court, mais très strict:

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

Et terminez avec une manière plus tolérante:

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

    if(str == null)
        return false;

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

        return false;
    } 

    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]));}
2
Stefan Steiger

J'ai converti sans vergogne toBoolean d'Apache Common en JavaScript:

JSFiddle: https://jsfiddle.net/m2efvxLm/1/

Code:

function toBoolean(str) {
  if (str == "true") {
    return true;
  }
  if (!str) {
    return false;
  }
  switch (str.length) {
    case 1: {
      var ch0 = str.charAt(0);
      if (ch0 == 'y' || ch0 == 'Y' ||
          ch0 == 't' || ch0 == 'T' ||
          ch0 == '1') {
        return true;
      }
      if (ch0 == 'n' || ch0 == 'N' ||
          ch0 == 'f' || ch0 == 'F' ||
          ch0 == '0') {
        return false;
      }
      break;
    }
    case 2: {
      var ch0 = str.charAt(0);
      var ch1 = str.charAt(1);
      if ((ch0 == 'o' || ch0 == 'O') &&
          (ch1 == 'n' || ch1 == 'N') ) {
        return true;
      }
      if ((ch0 == 'n' || ch0 == 'N') &&
          (ch1 == 'o' || ch1 == 'O') ) {
        return false;
      }
      break;
    }
    case 3: {
      var ch0 = str.charAt(0);
      var ch1 = str.charAt(1);
      var ch2 = str.charAt(2);
      if ((ch0 == 'y' || ch0 == 'Y') &&
          (ch1 == 'e' || ch1 == 'E') &&
          (ch2 == 's' || ch2 == 'S') ) {
        return true;
      }
      if ((ch0 == 'o' || ch0 == 'O') &&
          (ch1 == 'f' || ch1 == 'F') &&
          (ch2 == 'f' || ch2 == 'F') ) {
        return false;
      }
      break;
    }
    case 4: {
      var ch0 = str.charAt(0);
      var ch1 = str.charAt(1);
      var ch2 = str.charAt(2);
      var ch3 = str.charAt(3);
      if ((ch0 == 't' || ch0 == 'T') &&
          (ch1 == 'r' || ch1 == 'R') &&
          (ch2 == 'u' || ch2 == 'U') &&
          (ch3 == 'e' || ch3 == 'E') ) {
        return true;
      }
      break;
    }
    case 5: {
      var ch0 = str.charAt(0);
      var ch1 = str.charAt(1);
      var ch2 = str.charAt(2);
      var ch3 = str.charAt(3);
      var ch4 = str.charAt(4);
      if ((ch0 == 'f' || ch0 == 'F') &&
          (ch1 == 'a' || ch1 == 'A') &&
          (ch2 == 'l' || ch2 == 'L') &&
          (ch3 == 's' || ch3 == 'S') &&
          (ch4 == 'e' || ch4 == 'E') ) {
        return false;
      }
      break;
    }
    default:
      break;
  }

  return false;
}
console.log(toBoolean("yEs")); // true
console.log(toBoolean("yES")); // true
console.log(toBoolean("no")); // false
console.log(toBoolean("NO")); // false
console.log(toBoolean("on")); // true
console.log(toBoolean("oFf")); // false
Inspect this element, and view the console output.
0
Xaero Degreaz

stringjs a une méthode toBoolean ():

http://stringjs.com/#methods/toboolean-tobool

S('true').toBoolean() //true
S('false').toBoolean() //false
S('hello').toBoolean() //false
S(true).toBoolean() //true
S('on').toBoolean() //true
S('yes').toBoolean() //true
S('TRUE').toBoolean() //true
S('TrUe').toBoolean() //true
S('YES').toBoolean() //true
S('ON').toBoolean() //true
S('').toBoolean() //false
S(undefined).toBoolean() //false
S('undefined').toBoolean() //false
S(null).toBoolean() //false
S(false).toBoolean() //false
S({}).toBoolean() //false
S(1).toBoolean() //true
S(-1).toBoolean() //false
S(0).toBoolean() //false
0
prule

J'aime la solution fournie par RoToRa (essayez d'analyser une valeur donnée, si elle a une signification booléenne, sinon, ne le faites pas). Néanmoins, j'aimerais apporter de petites modifications pour qu'il fonctionne plus ou moins comme Boolean.TryParse en C #, qui prend en charge out params. En JavaScript, il peut être implémenté de la manière suivante:

var BoolHelpers = {
    tryParse: function (value) {
        if (typeof value == 'boolean' || value instanceof Boolean)
            return value;
        if (typeof value == 'string' || value instanceof String) {
            value = value.trim().toLowerCase();
            if (value === 'true' || value === 'false')
                return value === 'true';
        }
        return { error: true, msg: 'Parsing error. Given value has no boolean meaning.' }
    }
}

L'usage:

var result = BoolHelpers.tryParse("false");
if (result.error) alert(result.msg);
0
jwaliszko

last but not least, un moyen simple et efficace de le faire avec une valeur par défaut:

ES5

function parseBool(value, defaultValue) {
    return (value == 'true' || value == 'false' || value === true || value === false) && JSON.parse(value) || defaultValue;
}

ES6, une ligne plus courte

const parseBool = (value, defaultValue) => ['true', 'false', true, false].includes(value) && JSON.parse(value) || defaultValue

JSON.parse est efficace pour analyser les booléens

0
Sebastien H.