【问题标题】：How can I convert a string to boolean in JavaScript?如何在 JavaScript 中将字符串转换为布尔值？
【发布时间】：2010-09-20 19:23:49
【问题描述】：

我可以在 JavaScript 中将表示布尔值（例如，'true'、'false'）的字符串转换为固有类型吗？

我有一个 HTML 中的隐藏表单，它会根据用户在列表中的选择进行更新。此表单包含一些表示布尔值的字段，并使用固有的布尔值动态填充。但是，一旦将此值放入隐藏的输入字段中，它就会变成一个字符串。

一旦将字段转换为字符串，我能找到确定该字段的布尔值的唯一方法是依赖于其字符串表示的文字值。

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

有没有更好的方法来做到这一点？

【问题讨论】：

“有没有更好的方法来完成这个？” - 当然还有更糟糕的方法：D string=(string==String(string?true:false))?(string?true:false):(!string?true:fa‌lse);
轻松处理字符串和布尔值：function parseBool(val) { return val === true || val === "true" }
@Mark function checkBool(x) { if(x) {return true;} else {return false;} }
@Sebi：你忘记记录了：if (checkBool(x) != false) { ... } else { ... }
!!(parseInt(value) || value === "true")

标签： javascript boolean-expression boolean-operations string-conversion

【解决方案1】：

做：

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

使用标识运算符 (===)，当比较变量具有不同类型时，它不会进行任何隐式类型转换。

不要：

您可能应该谨慎使用这两种方法以满足您的特定需求：

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

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

任何不是空字符串的字符串都将通过使用它们来评估为true。尽管它们是我能想到的关于布尔转换的最简洁的方法，但我认为它们不是您想要的。

【讨论】：

myValue === 'true'; 完全等同于myValue == 'true';。在这里使用=== 而不是== 没有任何好处。
我关注 Crockford's advice 并在有意义的时候使用 === 和 !==，这几乎总是如此。
@guinaps 大多数 javascript 严格约定一概适用于所有 javascript 使用，只会导致复杂的代码和缺乏对 javascript 的原理、理论或用法的理解。
=== 应该被使用，因为它也在检查正确的类型。此外，它比==具有更好的比较性能。

【解决方案2】：

记住要匹配大小写：

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

另外，如果是表单元素复选框，还可以检测复选框是否被选中：

var isTrueSet = document.myForm.IS_TRUE.checked;

假设如果选中，则“设置”等于true。这评估为真/假。

【讨论】：

如果 myValue 为 null 或 undefined 或字符串以外的任何类型，这将失败。

【解决方案3】：

你的解决方案很好。

在这种情况下使用=== 会很愚蠢，因为该字段的value 将始终是String。

【讨论】：

为什么您认为使用=== 会很愚蠢？就性能而言，如果两种类型都是字符串，那将是完全相同的。无论如何，我宁愿使用===，因为我总是避免使用== 和!=。理由：stackoverflow.com/questions/359494/…
因为value 将永远是string，== 和=== 都不是傻瓜。两者都是这项工作的正确工具。它们仅在类型不相等时有所不同。在这种情况下，=== 只返回 false 而== 在比较之前执行复杂的类型强制算法。

【解决方案4】：

您需要（在您的想法中）将您的选择的价值和该价值的表示分开。

在 JavaScript 逻辑中选择一个点，他们需要从字符串标记转换为原生类型并在那里进行比较，最好是对每个需要转换的值只进行一次比较。如果字符串 sentinel 不是脚本知道的字符串，请记住解决需要发生的事情（即，您默认为 true 还是 false？）

换句话说，是的，你需要依赖字符串的值。 :-)

【讨论】：

【解决方案5】：

如果有其他代码将布尔值转换为字符串，您需要确切了解该代码如何存储真/假值。要么，要么您需要有权访问反转该转换的函数。

有无数种方法可以在字符串中表示布尔值（“true”、“Y”、“1”等）。所以你不应该依赖一些通用的字符串到布尔转换器，比如 Boolean(myValue)。您需要使用一个例程来反转原始的布尔到字符串的转换，不管是什么。

如果您知道它将真布尔值转换为“真”字符串，那么您的示例代码就可以了。除了你应该使用 === 而不是 ==，所以没有自动类型转换。

【讨论】：

【解决方案6】：

你可以使用正则表达式：

/*
 * 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);
}

如果你喜欢扩展 String 类，你可以这样做：

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

alert("true".bool());

对于那些想要扩展 String 对象来获得它但担心可枚举性并担心与扩展 String 对象的其他代码冲突的人（参见 cmets）：

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

（当然不能在旧浏览器中运行，Firefox 显示为 false 而 Opera、Chrome、Safari 和 IE 显示为 true。Bug 720760）

【讨论】：

如果您担心它会干扰其他代码，您可以随时为函数添加前缀。如果某些代码仍然中断，则该代码太脆弱，应该修复。如果您添加的函数使对象太重而导致其他代码的性能问题，那么显然您不想这样做。但是，我认为扩展内置对象通常不是一个坏主意。如果是这样，它们也不会公开扩展。
@DTrejo @Szymon 我不同意。这正是重载原型的目的。如果您担心它会破坏依赖 for..in 的（糟糕的）代码，那么有一些方法可以从枚举中隐藏属性。见Object.defineProperty。

【解决方案7】：

我认为这是非常普遍的：

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

是这样的：

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

【讨论】：

当你能接收到一个大写或布尔值的字符串时，那么String(a).toLowerCase() === 'true'

【解决方案8】：

if (String(a) == "true"){
  //true block
} else {
  //false block
}

【讨论】：

【解决方案9】：

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

【讨论】：

其实可以简化。 1) 无需测试"true"、"yes" 和"1"。 2) toLowerCase 不返回 null。 3) Boolean(string) 与这里的string!=="" 相同。 => switch(string.toLowerCase()) {case "false": case "no": case "0": case "": return false; default: return true;}
注意，这将默认为true - 例如：stringToBoolean('banana') // true

【解决方案10】：

做一个：

var myBool = eval (yourString);

例子：

alert (eval ("true") == true); // TRUE
alert (eval ("true") == false); // FALSE
alert (eval ("1") == true); // TRUE
alert (eval ("1") == false); // FALSE
alert (eval ("false") == true); // FALSE;
alert (eval ("false") == false); // TRUE
alert (eval ("0") == true); // FALSE
alert (eval ("0") == false); // TRUE
alert (eval ("") == undefined); // TRUE
alert (eval () == undefined); // TRUE

这个方法很自然地处理空字符串和未定义的字符串，就像你声明一个变量而不给它赋值一样。

【讨论】：

-1：请不要提倡使用 eval （可能除了聪明的黑客和必要性）。
这是对 eval 的非常糟糕和不安全的使用。它甚至不聪明。 -1

【解决方案11】：

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.");
  }
};

【讨论】：

你可以使用 true.toString() 而不是 "true" 来更干净:-)
不要更改全局变量，尽量保持您的更改隔离，也许创建一个新的function parseBoolean 代替

【解决方案12】：

以下就足够了

String.prototype.boolean = function() {
    return "true" == this; 
};

"true".boolean() // returns true "false".boolean() // returns false

【讨论】：

修改原型是个很糟糕的主意
@SzymonWygnański：我不同意。除了 for--in 循环和浏览器对相同功能的本机支持之外，我没有看到任何其他原因。 Reg for-inloop：我想不出在字符串中确实需要 for-in 循环的情况。注册原生支持：我们绝对可以添加一个 proto 道具，直到原生浏览器支持，如果我们不构建类似原型或 jquery 等的框架...更多关于 @Kangax(Perfect kills) 的信息在这里。 webcache.googleusercontent.com/…
考虑：我们可以走得更远："true".checkbox() 将转换为复选框，或者 "true".application() 将转换为 app:D 不仅 for-in 循环失败，而且这里的风格是错误的。在大型应用程序中，您会在哪里查找此“布尔/复选框/应用程序”定义的代码？想象一下每个图书馆都会这样想的世界。定义一个类或函数不是更好吗： checkbox("true") - 它更简洁，字母数量几乎相同。在将其定义为标准（如 Object.create 等）之前，您永远不会知道 IF 浏览器会支持您的自定义函数。

【解决方案13】：

布尔对象没有“解析”方法。 Boolean('false') 返回 true，所以这不起作用。 !!'false' 也返回 true，所以这也行不通。

如果您希望字符串'true' 返回布尔值true 和字符串'false' 返回布尔值false，那么最简单的解决方案是使用eval()。 eval('true') 返回真，eval('false') 返回假。但请记住使用 eval() 时对性能的影响。

【讨论】：

要了解 eval 的“错误”（或正确） - 查看 javascriptweblog.wordpress.com/2010/04/19/how-evil-is-eval 之类的文章或在 stackoverflow 上搜索“Javascript eval 恶意软件”
我同意var isTrueSet = (myValue === 'true'); 是最佳答案。
我喜欢它简洁。但是对于eval('TRUE') 的基本情况，它非常失败；再次证明，eval() 是邪恶的。
@Area 51 侦探小说，以同样的方式，来自下面答案的JSON.parse('TRUE') 也非常失败。在 JavaScript（或任何语言，就此而言）强制一个错误条件是很容易的。考虑到这一点，您应该首先规范化字符串，例如，var myValue = document.myForm.IS_TRUE.value.toLowerCase(); var isTrueSet = (myValue==='true' || myValue==='false') ? eval(myValue) : false;
@10basetom：非常正确。你应该在答案中包含.toLowerCase() 是我的观点。我不想强迫任何事情。大写的TRUE 是一个足够常见的值，可以被许多 UI 小部件返回。

【解决方案14】：

最简单的方法（假设你的字符串是“真”或“假”）是：

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

始终在这些类型的转换中使用 === 运算符而不是 == 运算符！

【讨论】：

你在说什么转换？ :-)
在 javascript 中比较字符串时，在不使用转换时使用 == 或 === 运算符没有区别。在这里，您正在与字符串进行比较，因此没有类型转换。见stackoverflow.com/questions/359494/…

【解决方案15】：

function returnBoolean(str){

    str=str.toString().toLowerCase();

    if(str=='true' || str=='1' || str=='yes' || str=='y' || str=='on' || str=='+'){
        return(true);
    }
    else if(str=='false' || str=='0' || str=='no' || str=='n' || str=='off' || str=='-'){
        return(false);
    }else{
        return(undefined);
    }
}

【讨论】：

【解决方案16】：

警告

这个高度赞成的旧答案在技术上是正确的，但只涵盖了一个非常具体的场景，当您的字符串值完全是 "true" 或 "false" 时。

传递给下面这些函数的无效 json 字符串将引发异常。

原答案：

怎么样？

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

或使用 jQuery

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

【讨论】：

这个问题是许多潜在的值会产生一个解析错误，从而停止 JS 执行。所以运行 JSON.parse("FALSE") 会炸毁 Javascript。我认为，问题的重点不是简单地解决这些确切的情况，而是要适应其他情况。
只要说JSON.parse("TRUE".toLowerCase()) 就可以正确解析了。
@BishopZ ：停止 JS 执行可能是遵循最佳模式编码风格的理想功能：en.wikipedia.org/wiki/Fail-fast

【解决方案17】：

我发现使用 '1' 和空值 '' 作为布尔值比 'true' 或 'false' 字符串值更可预测...特别是对于 html 表单，因为 Dom 元素中的未初始化/空值将始终评估为 false，而其中的 any 值评估为 true。

例如：

<input type='button' onclick='this.value = tog(this.value);' />

<script type="text/javascript">

    function tog(off) {
        if(off) {
            alert('true, toggle to false');
            return '';
        } else {
            alert('false, toggle to true');
            return '1';
        }
    }   
</script>

似乎是一条更容易的道路，到目前为止它一直非常一致/容易......也许有人可以确定一种方法来打破这个？

【讨论】：

【解决方案18】：

就像@Shadow2531 所说，你不能直接转换它。如果您的代码将被其他人重用/使用，我还建议您考虑除“true”和“false”之外的字符串输入，它们是“真”和“假”。这是我使用的：

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

【讨论】：

【解决方案19】：

@guinaps> 任何不是空字符串的字符串都将通过使用它们评估为真。

使用 String.match() 方法怎么样

var str="true";
var boolStr=Boolean(str.match(/^true$/i));

仅此一项不会得到 1/0 或是/否，但它会捕获 TRUE/true，而且，对于碰巧将“true”作为子字符串的任何字符串，它将返回 false。

编辑

下面是处理真/假、1/0、是/否（不区分大小写）的函数

function stringToBool(str) {
    var bool;
    if (str.match(/^(true|1|yes)$/i) !== null) {
        bool = true;
    } else if (str.match(/^(false|0|no)*$/i) !== null) {
        bool = false;
    } else {
        bool = null;
        if (console) console.log('"' + str + '" is not a boolean value');
    }
    return bool;
}

stringToBool('1'); // true
stringToBool('No'); // false
stringToBool('falsey'); // null ("falsey" is not a boolean value.)
stringToBool(''); // false

【讨论】：

如所写（2018 年 12 月 19 日 16:00 Z），/^(false|0|no)*$/i 将匹配一个空字符串（这可能是意图），但也匹配任何数字 false、0、或no，例如"0falseno0nofalse0" 也将评估为false，但应该评估为null 并输出一条控制台消息，表明它不是布尔值。

【解决方案20】：

Boolean.parse() 确实存在于某些浏览器实现中。它绝对不是通用的，所以如果这是你需要的东西，你不应该使用这种方法。但在 Chrome 中，例如（我使用的是 v21）它工作得很好，正如人们所期望的那样。

【讨论】：

Boolean("false") => true

【解决方案21】：

我一直在使用这个 sn-p 来转换数字和布尔值：

var result = !isNaN(value) ? parseFloat(value) : /^\s*(true|false)\s*$/i.exec(value) ? RegExp.$1.toLowerCase() === "true" : value;

【讨论】：

【解决方案22】：

您正在寻找的表达式就是

/^true$/i.test(myValue)

如

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

这会针对正则表达式测试myValue，不区分大小写，并且不会修改原型。

例子：

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

【讨论】：

【解决方案23】：

我对这个问题的看法是，它旨在满足三个目标：

为真值和假值返回真/假，但也为多个字符串值返回真/假，如果它们是布尔值而不是字符串，则它们将是真或假。
其次，提供弹性接口，使指定以外的值不会失败，而是返回默认值
第三，用尽可能少的代码完成所有这些工作。

使用 JSON 的问题在于它会因导致 Javascript 错误而失败。这个解决方案没有弹性（尽管它满足 1 和 3）：

JSON.parse("FALSE") // fails

这个方案不够简洁：

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

我正在为Typecast.js 解决这个确切的问题。这三个目标的最佳解决方案是：

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

它适用于很多情况，在传入 {} 之类的值时不会失败，并且非常简洁。它还返回 false 作为默认值，而不是 undefined 或抛出错误，这在松散类型的 Javascript 开发中更有用。对建议它的其他答案表示赞许！

【讨论】：

只是回到你的目标，你的第三个也是最好的解决方案的唯一问题是它不符合目标#1 - 它只会返回值为'true'，但不是对于任何真实的输入。为了使其满足目标#1，它仅比解决方案#2稍微简洁，而且可读性差很多。
return /^(true|yes|1|t|y)$/i.test(str);

【解决方案24】：

在上面 Steven 的回答的基础上，我编写了这个函数作为字符串输入的通用解析器：

parse:
  function (value) {
    switch (value && value.toLowerCase()) {
      case null: return null;
      case "true": return true;
      case "false": return false;
      default: try { return parseFloat(value); } catch (e) { return value; }
    }
  }

【讨论】：

【解决方案25】：

您甚至不需要将字符串转换为布尔值。只需使用以下内容： var yourstring = yourstringValue == 1 ? true : false;

【讨论】：

【解决方案26】：

我编写了一个辅助函数来处理您的案例（以及更多案例）。随意更改它以满足您的特定需求

/**
 * @example
 * <code>
 * var pageRequestParams = {'enableFeatureX': 'true'};
 * toBool(pageRequestParams.enableFeatureX);  // returns true
 *
 * toBool(pageRequestParams.enableFeatureY, true, options.enableFeatureY)
 * </code>
 * @param {*}value
 * @param {Boolean}[mapEmptyStringToTrue=false]
 * @param {Boolean}[defaultVal=false] this is returned if value is undefined.
 *
 * @returns {Boolean}
 * @example
 * <code>
 * toBool({'enableFeatureX': ''        }.enableFeatureX);          // false
 * toBool({'enableFeatureX': ''        }.enableFeatureX, true);    // true
 * toBool({                            }.enableFeatureX, true);    // false
 * toBool({'enableFeatureX': 0         }.enableFeatureX);          // false
 * toBool({'enableFeatureX': '0'       }.enableFeatureX);          // false
 * toBool({'enableFeatureX': '0 '      }.enableFeatureX);          // false
 * toBool({'enableFeatureX': 'false'   }.enableFeatureX);          // false
 * toBool({'enableFeatureX': 'falsE '  }.enableFeatureX);          // false
 * toBool({'enableFeatureX': 'no'      }.enableFeatureX);          // false
 *
 * toBool({'enableFeatureX': 1         }.enableFeatureX);          // true
 * toBool({'enableFeatureX': '-2'      }.enableFeatureX);          // true
 * toBool({'enableFeatureX': 'true'    }.enableFeatureX);          // true
 * toBool({'enableFeatureX': 'false_'  }.enableFeatureX);          // true
 * toBool({'enableFeatureX': 'john doe'}.enableFeatureX);          // true
 * </code>
 *
 */
var toBool = function (value, mapEmptyStringToTrue, defaultVal) {
    if (value === undefined) {return Boolean(defaultVal); }
    mapEmptyStringToTrue = mapEmptyStringToTrue !== undefined ? mapEmptyStringToTrue : false; // default to false
    var strFalseValues = ['0', 'false', 'no'].concat(!mapEmptyStringToTrue ? [''] : []);
    if (typeof value === 'string') {
        return (strFalseValues.indexOf(value.toLowerCase().trim()) === -1);
    }
    // value is likely null, boolean, or number
    return Boolean(value);
};

【讨论】：

【解决方案27】：

    MyLib.Convert.bool = function(param) {
         var res = String(param).toLowerCase();
         return !(!Boolean(res) || res === "false" || res === "0");
     };

【讨论】：

【解决方案28】：

这是我的 1 行提交：我需要评估一个字符串和输出，如果“真”则为真，如果“假”则为假，如果像“-12.35673”之类的则为数字。

val = 'false';

val = /^false$/i.test(val) ? false : ( /^true$/i.test(val) ? true : val*1 ? val*1 : val );

【讨论】：

【解决方案29】：

我使用以下：

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

此函数执行通常的布尔强制转换，字符串“false”（不区分大小写）和“0”除外。

【讨论】：

【解决方案30】：

我有点晚了，但我有一点 sn-p 来做这件事，它基本上维护了所有 JScripts 的真/假/脏-ness，但包括 "false" 作为可接受的值为 false。

我更喜欢这种方法而不是提到的方法，因为它不依赖第三方来解析代码（即：eval/JSON.parse），这在我看来是多余的，它足够短，不需要实用程序功能并维护其他真/假约定。

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

【讨论】：