JavaScript：解析字符串布尔值？ [复制]

Question

JavaScript 有 parseInt() 和 parseFloat()，但据我所知，在全局范围内没有 parseBool 或 parseBoolean 方法。

我需要一个方法，该方法接受具有“true”或“false”等值的字符串并返回 JavaScript Boolean。

这是我的实现：

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

这是一个好功能吗？请给我您的反馈。

谢谢！

Answer 1

我倾向于用三元 if 做一个单行。

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

编辑：更快的方法是简单地避免使用逻辑语句，而只使用表达式本身：

var bool_value = value == 'true';

这是因为value == 'true' 是根据value 变量是否是'true' 的字符串来评估的。如果是，则整个表达式变为true，如果不是，则变为false，然后在评估后将该结果分配给bool_value。

Answer 2

您可以为此使用 JSON.parse：

JSON.parse("true"); //returns boolean true

Answer 3

这取决于您希望该功能如何工作。

如果您只想测试字符串中的单词“true”，并将任何不包含它的字符串（或非字符串）定义为 false，那么最简单的方法可能是：

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

如果您希望确保整个字符串都是 true，您可以这样做：

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

Answer 4

您可以尝试以下方法：

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;
}

如果是有效值，则返回等效的 bool 值，否则返回 null。

Answer 5

您可以使用 JSON.parse 或 jQuery.parseJSON 并使用以下方法查看它是否返回 true：

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

Answer 6

我个人认为这不好，您的函数将无效值“隐藏”为 false 并且 - 根据您的用例 - 不会为 "1" 返回 true。

另一个问题可能是它对任何不是字符串的东西都会产生呕吐声。

我会使用这样的东西：

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
}

并根据用例扩展它以区分 "0" 和 "1"。

（也许有一种方法可以只与"true" 比较一次，但我现在想不出什么。）

Answer 7

您可以添加此代码：

function parseBool(str) {

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

}

像这样工作：

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

Answer 8

为什么不保持简单？

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

    return (parseInt(str) > 0);
}

Answer 9

小心木眼。 看了这么多代码，觉得有义务发一下：

让我们从最短但非常严格的方式开始：

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

并以一种适当的、更宽容的方式结束：

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;
}

测试：

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

Answer 10

最后但并非最不重要的是，一种使用默认值的简单有效的方法：

ES5

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

ES6 ，更短的一个衬里

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

JSON.parse 可以高效地解析布尔值

Answer 11

我喜欢 RoToRa 提供的解决方案（尝试解析给定的值，如果它有任何布尔含义，否则 - 不要）。尽管如此，我还是想提供一些小的修改，让它或多或少像 C# 中的 Boolean.TryParse 那样工作，它支持 out 参数。在 JavaScript 中可以通过以下方式实现：

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.' }
    }
}

用法：

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

Answer 12

stringjs 有一个 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

Answer 13

我无耻地将Apache Common's toBoolean 转换为 JavaScript：

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

代码：

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.

Answer 14

足以使用 eval javascript 函数将字符串转换为布尔值

eval('true')  
eval('false')