做：

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

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

如果字符串为“true”，这将设置isTrueSet为booleantrue，如果字符串为“false”或根本未设置，则设置booleanfalse。

不要：

您可能应该为您的特定需求使用这两种方法要小心：

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

任何不是空字符串的字符串都将通过使用它们评估为true。虽然它们是我能想到的关于布尔转换的最干净的方法，但我认为它们不是你要找的。

记得要匹配case：

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

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

var isTrueSet = document.myForm.IS_TRUE.checked;

假设如果选中它，则“设置”等于true。这计算为true/false。

你的解决方案很好。

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

你需要分离（在你的思想中）你选择的价值和该价值的表示。

在JavaScript逻辑中选择一个需要从字符串哨兵转换为本机类型的点，并在那里进行比较，最好是对每个需要转换的值只完成一次。记住要解决如果字符串哨兵不是脚本知道的（即你默认为true还是false？）

换句话说，是的，你需要依赖于字符串的值。：-）

如果有其他代码将布尔值转换为字符串，您需要确切地知道该代码如何存储真/假值。要么这样，要么您需要访问一个反转该转换的函数。

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

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

您可以使用正则表达式：

/** 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对象的其他代码发生冲突的人（请参阅注释）：

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。

我认为这是非常普遍的：

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

它说：

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

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

const stringToBoolean = (stringValue) => {switch(stringValue?.toLowerCase()?.trim()){case "true":case "yes":case "1":return true;
case "false":case "no":case "0":case null:case undefined:return false;
default:return JSON.parse(stringValue);}}

只要做一个：

var myBool = eval (yourString);

示例：

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

此方法自然地处理空字符串和未定义字符串，就像您声明变量而不为其分配值一样。

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

以下内容就足够了

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

Boolean对象没有'parse'方法。Boolean('false')返回true，因此不起作用。!!'false'也返回true，因此也不起作用。

如果您希望字符串'true'返回布尔值true，字符串'false'返回布尔值false，那么最简单的解决方案是使用eval()。eval('true')返回true，eval('false')返回false。

请记住使用#0时的性能和安全影响.

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

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

<强>总是对于这些类型的转换，使用===运算符而不是==运算符！

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

警告

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

一个无效的json字符串传入下面的这些函数将抛出异常。

原答复：

怎么样？

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

或使用jQuery

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

我发现使用'1'和一个空值来表示布尔值比'true'或'false'字符串值更容易预测……特别是对于html形式，因为Dom元素中的未初始化/空值将始终评估为false，而它们中的任何值评估为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>

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

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

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

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

如何使用String.match（）方法

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

仅此一项不会获得1/0或yes/no，但它会捕获TRUE/true，并且它会为任何碰巧具有“true”作为子字符串的字符串返回false。

编辑

下面是一个处理true/false、1/0、yes/no（不区分大小写）的函数

​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'); // truestringToBool('No'); // falsestringToBool('falsey'); // null ("falsey" is not a boolean value.)stringToBool(''); // false

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

我一直在使用这个代码段来转换数字和布尔值：

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

你要找的表达方式就是

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

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

• 对于truthy和false sey值返回true/false，但对于多个字符串值返回true/false，如果它们是布尔值而不是字符串，则它们将是truthy或false sey。
• 其次，提供一个弹性接口，以便指定值以外的值不会失败，而是返回默认值
• 第三，用尽可能少的代码完成这一切。

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

JSON.parse("FALSE") // fails

这个方案不够简洁：

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

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

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

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

基于上面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; }}}

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

我写了一个帮助函数来处理你的情况（以及更多）。随意根据您的特定需求修改它

/*** @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 falsevar strFalseValues = ['0', 'false', 'no'].concat(!mapEmptyStringToTrue ? [''] : []);if (typeof value === 'string') {return (strFalseValues.indexOf(value.toLowerCase().trim()) === -1);}// value is likely null, boolean, or numberreturn Boolean(value);};

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

这是我的1行提交：我需要评估一个字符串和输出，true如果'true'，false如果'false'和一个数字，如果像'-12.35673'。

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

我使用以下内容：

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

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

我有点晚了，但我有一个小片段来做这件事，它基本上维护了所有JScricript trushe/false sey/肮脏-ness，但包括"false"作为false的可接受值。

我更喜欢这种方法，因为它不依赖于第三方来解析代码（即：ava/JSON.parse），这在我看来是多余的，它足够短，不需要实用函数，并维护其他true/false sey约定。

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

function parseBool(value) {if (typeof value === "boolean") return value;
if (typeof value === "number") {return value === 1 ? true : value === 0 ? false : undefined;}
if (typeof value != "string") return undefined;
return value.toLowerCase() === 'true' ? true : false;}

我写了一个函数来匹配PHP的filter_var它做得很好。

/*** Parses mixed type values into booleans. This is the same function as filter_var in PHP using boolean validation* @param  {Mixed}        value* @param  {Boolean}      nullOnFailure = false* @return {Boolean|Null}*/var parseBooleanStyle = function(value, nullOnFailure = false){switch(value){case true:case 'true':case 1:case '1':case 'on':case 'yes':value = true;break;case false:case 'false':case 0:case '0':case 'off':case 'no':value = false;break;default:if(nullOnFailure){value = null;}else{value = false;}break;}return value;};

使用JSON解析的通用解决方案：

function getBool(val) {return !!JSON.parse(String(val).toLowerCase());}
getBool("1"); //truegetBool("0"); //falsegetBool("true"); //truegetBool("false"); //falsegetBool("TRUE"); //truegetBool("FALSE"); //false

更新（没有JSON）：

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

我还创建了小提琴来测试它http://jsfiddle.net/remunda/2GRhG/

许多现有的答案是相似的，但大多数忽略了给定参数也可以是对象的事实。

这是我刚刚写的东西：

Utils.parseBoolean = function(val){if (typeof val === 'string' || val instanceof String){return /true/i.test(val);} else if (typeof val === 'boolean' || val instanceof Boolean){return new Boolean(val).valueOf();} else if (typeof val === 'number' || val instanceof Number){return new Number(val).valueOf() !== 0;}return false;};

…和单元测试

Utils.Tests = function(){window.console.log('running unit tests');
var booleanTests = [['true', true],['false', false],['True', true],['False', false],[, false],[true, true],[false, false],['gibberish', false],[0, false],[1, true]];
for (var i = 0; i < booleanTests.length; i++){var lhs = Utils.parseBoolean(booleanTests[i][0]);var rhs = booleanTests[i][1];var result = lhs === rhs;
if (result){console.log('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tpass');} else {console.log('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tfail');}}};

我认为@Steven的答案是最好的，并且比传入值只是一个字符串时处理了更多的情况。我想对它进行一点扩展并提供以下内容：

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

如果你已经知道你必须考虑的所有true情况，就没有必要涵盖所有false情况。你可以将任何可以传递为true值的东西传递到此方法中（或添加其他值，非常简单），其他一切都将被视为false

木眼要小心。在看到应用500+赞成票的顶部答案后的后果后，我觉得有义务发布一些实际上有用的东西：

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

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

并以适当的，更宽容的方式结束：

var parseBool = function(str, strict){// console.log(typeof str);// strict: JSON.parse(str)    
if (str == null){if (strict)throw new Error("Parameter 'str' is null or undefined.");
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;}

测试：

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

更短的写法，可以是var isTrueSet = (myValue === "true") ? true : false;假设只有“true”为true，其他值为false。

简单的解决方案我已经使用了一段时间

function asBoolean(value) {
return (''+value) === 'true';
}

// asBoolean(true) ==> true// asBoolean(false) ==> false// asBoolean('true') ==> true// asBoolean('false') ==> false

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

这对于每个false sy值返回false，对于每个truthy值返回true，除了'false'、'f'、'no'、'n'和'0'（不区分大小写）。

// FalseBoolean.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();
//TrueBoolean.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());

我这样做，这将处理1=TRUE=yes=YES=true，0=FALSE=no=NO=false：

BOOL=falseif (STRING)BOOL=JSON.parse(STRING.toLowerCase().replace('no','false').replace('yes','true'));

将STRING替换为字符串变量的名称。

如果它不为空，则为一个数值或以下字符串之一："true"，"true"，"false"，"FALSE"，"yes"，"yes"，"no"，"NO"它会抛出一个错误（故意）。

我使用自己的方法，其中包括检查对象是否首先存在以及更直观地转换为布尔值：

function str2bool(strvalue){return (strvalue && typeof strvalue == 'string') ? (strvalue.toLowerCase() == 'true' || strvalue == '1') : (strvalue == true);}

结果如下：

var test; // falsevar test2 = null; // falsevar test3 = 'undefined'; // falsevar test4 = 'true'; // truevar test5 = 'false'; // falsevar test6 = true; // truevar test7 = false; // falsevar test8 = 1; // truevar test9 = 0; // falsevar test10 = '1'; // truevar test11 = '0'; // false

小提琴：http://jsfiddle.net/av5xcj6s/

我要用这个

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"

答案有很多，很难选择一个。在我的情况下，我在选择时优先考虑性能，所以我创建了这个jsPerf，我希望可以在这里提供一些线索。

结果简介（越高越好）：

1. 条件语句:2,826,922
2. 在Bool对象上切换大小写:2,825,469
3. 转换为JSON:1,867,774
4. ！！转换:805,322
5. 字符串原型:713,637

它们与相关答案相关联，您可以在其中找到有关每个答案的更多信息（优点和缺点）；特别是在评论中。

为了评估boolean和boolean之类的字符串，我使用了这个简单的公式：

var trueOrStringTrue = (trueOrStringTrue === true) || (trueOrStringTrue === 'true');

显然，对于true和'true'，它都将返回true。其他所有内容都返回false。

将字符串（“true”、“false”）和布尔值转换为布尔值

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

flag可以在哪里

 var flag = truevar flag = "true"var flag = falsevar flag = "false"

完美且非常简单：

var boolean = "false";boolean = (boolean === "true");
//boolean = JSON.parse(boolean); //or this way..

测试它：

var boolean = "false";boolean = (boolean === "true");
//boolean = JSON.parse(boolean); //or this way..
if(boolean == true){alert("boolean = "+boolean);}else{alert("boolean = "+boolean);}

另一种解决方案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};

测试用例在节点中运行

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

在一行代码中将字符串转换为布尔值的最快安全方法

有助于加快Javascript中代码执行的功能之一是短路评估：

由于逻辑表达式从左到右求值，因此使用以下规则对它们进行测试以进行可能的“短路”求值：

• false&&（任何东西）被短路评估为false。
• true||（任何东西）被短路评估为true。

因此，如果您想在JSON.parse测试方式中测试字符串值为true offalse并保持性能强劲，您可以使用||运算符来排除执行缓慢的代码，以防测试值为布尔类型。

test === true || ['true','yes','1'].indexOf(test.toString().toLowerCase()) > -1

由于Array.prototype.indexOf()方法是第5版中ECMA-262标准的一部分，您可能需要聚填充来支持旧浏览器。

// Production steps of ECMA-262, Edition 5, 15.4.4.14// Reference: http://es5.github.io/#x15.4.4.14if (!Array.prototype.indexOf) {Array.prototype.indexOf = function(searchElement, fromIndex) {
var k;
// 1. Let O be the result of calling ToObject passing//    the this value as the argument.if (this == null) {throw new TypeError('"this" is null or not defined');}
var O = Object(this);
// 2. Let lenValue be the result of calling the Get//    internal method of O with the argument "length".// 3. Let len be ToUint32(lenValue).var len = O.length >>> 0;
// 4. If len is 0, return -1.if (len === 0) {return -1;}
// 5. If argument fromIndex was passed let n be//    ToInteger(fromIndex); else let n be 0.var n = +fromIndex || 0;
if (Math.abs(n) === Infinity) {n = 0;}
// 6. If n >= len, return -1.if (n >= len) {return -1;}
// 7. If n >= 0, then Let k be n.// 8. Else, n<0, Let k be len - abs(n).//    If k is less than 0, then let k be 0.k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
// 9. Repeat, while k < lenwhile (k < len) {// a. Let Pk be ToString(k).//   This is implicit for LHS operands of the in operator// b. Let kPresent be the result of calling the//    HasProperty internal method of O with argument Pk.//   This step can be combined with c// c. If kPresent is true, then//    i.  Let elementK be the result of calling the Get//        internal method of O with the argument ToString(k).//   ii.  Let same be the result of applying the//        Strict Equality Comparison Algorithm to//        searchElement and elementK.//  iii.  If same is true, return k.if (k in O && O[k] === searchElement) {return k;}k++;}return -1;};}

从字符串或数字中获取布尔值这里有一个很好的解决方案：

var boolValue = Boolean(Number('0'));
var boolValue = Boolean(Number('1'));

第一个将返回false，第二个将返回true。

function isTrue(val) {try {return !!JSON.parse(val);} catch {return false;}}

小心，也许将来代码会更改并返回布尔值，而不是现在的一个字符串。

解决办法是：

//Currentlyvar isTrue = 'true';//In the future (Other developer change the code)var isTrue = true;//The solution to both cases(isTrue).toString() == 'true'

这里有很多花哨的答案。真的很惊讶没有人发布这个解决方案：

var booleanVal = toCast > '';

这在大多数情况下解析为true，而不是bool false、数字零和空字符串（显然）。您可以在事实之后轻松查找其他false sey字符串值，例如：

var booleanVal = toCast > '' && toCast != 'false' && toCast != '0';

已经有很多答案了。但以下内容在某些情况下可能会很有用。

// One can specify all values against which you consider truthyvar TRUTHY_VALUES = [true, 'true', 1];
function getBoolean(a) {return TRUTHY_VALUES.some(function(t) {return t === a;});}

这对于具有非布尔值的示例很有用。

getBoolean('aa'); // falsegetBoolean(false); //falsegetBoolean('false'); //false
getBoolean('true'); // truegetBoolean(true); // truegetBoolean(1); // true

这是从接受的答案中提取的，但实际上它有一个非常薄弱的点，我很震惊它是如何获得赞成票的，它的问题是您必须考虑字符串的大小写，因为这是大小写敏感的

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

我使用这个简单的方法（使用“myVarToTest”）：

var trueValuesRange = ['1', 1, 'true', true];
myVarToTest = (trueValuesRange.indexOf(myVarToTest) >= 0);

轻松使用此库。

https://github.com/rohmanhm/force-boolean

你只需要写一行

const ForceBoolean = require('force-boolean')
const YOUR_VAR = 'false'console.log(ForceBoolean(YOUR_VAR)) // it's return boolean false

它也支持以下内容

 return false if value is number 0return false if value is string '0'return false if value is string 'false'return false if value is boolean falsereturn true if value is number 1return true if value is string '1'return true if value is string 'true'return true if value is boolean true

var trueVals = ["y", "t", "yes", "true", "gimme"];var isTrueSet = (trueVals.indexOf(myValue) > -1) ? true : false;

甚至只是

var trueVals = ["y", "t", "yes", "true", "gimme"];var isTrueSet = (trueVals.indexOf(myValue) > -1);

与一些Switch语句类似，但更紧凑。只有当字符串是trueVals字符串之一时，返回的值才会为真。其他一切都是假的。当然，您可能希望将输入字符串规范化为小写并修剪任何空格。

将字符串转换为布尔值

var vIn = "true";var vOut = vIn.toLowerCase()=="true"?1:0;

将字符串转换为数字

var vIn = 0;var vOut = parseInt(vIn,10/*base*/);

这是一个简单的函数，它可以做到这一点，

   function convertStringToBool(str){return ((str === "True") || (str === "true")) ? true:false;}

这将给出以下结果

convertStringToBool("false") //returns falseconvertStringToBool("true") // returns trueconvertStringToBool("False") // returns falseconvertStringToBool("True") // returns true

One Liner

我们只需要考虑“false”字符串，因为任何其他字符串（包括“true”）已经是true。

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

测试

b(true)    //trueb('true')  //trueb(false)   //falseb('false') //false

更刺激的版本

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

测试

bool(true)        //truebool("true")      //truebool(1)           //truebool("1")         //truebool("hello")     //true
bool(false)       //falsebool("false")     //falsebool(0)           //falsebool("0")         //falsebool(null)        //falsebool("null")      //falsebool(NaN)         //falsebool("NaN")       //falsebool(undefined)   //falsebool("undefined") //falsebool("")          //false
bool([])          //truebool({})          //truebool(alert)       //truebool(window)      //true

String(true).toLowerCase() == 'true'; // trueString("true").toLowerCase() == 'true'; // trueString("True").toLowerCase() == 'true'; // trueString("TRUE").toLowerCase() == 'true'; // true
String(false).toLowerCase() == 'true'; // false

如果您不确定输入，上述方法适用于布尔值以及任何字符串。

您可以使用Function从字符串"true"或"false"返回Boolean值

const TRUE_OR_FALSE = str => new Function(`return ${str}`)();
const [TRUE, FALSE] = ["true", "false"];
const [T, F] = [TRUE_OR_FALSE(TRUE), TRUE_OR_FALSE(FALSE)];
console.log(T, typeof T); // `true` `"boolean"`
console.log(F, typeof F); // `false` `"boolean"`

您可以使用JSON.parse如下：

var trueOrFalse='True';result =JSON.parse(trueOrFalse.toLowerCase());if(result==true)alert('this is true');elsealert('this is false');

在这种情况下.toLowerCase很重要

'toBoolean'函数对null返回false，未定义, '', 'false'。它对任何其他字符串返回true：

const toBoolean = (bool) => {if (bool === 'false') bool = falsereturn !!bool}
toBoolean('false') // returns false

当我从URL/Form或其他来源获取值时，我正在使用这个。

这是非常通用的一行代码。

也许不是最好的性能，如果你需要运行数百万次让我知道，我们可以检查如何优化它，否则是相当不错的和可定制的。

boolResult = !(['false', '0', '', 'undefined'].indexOf(String(myVar).toLowerCase().trim()) + 1);

结果：

myVar = true;  // truemyVar = 'true';  // truemyVar = 'TRUE';  // truemyVar = '1';  // truemyVar = 'any other value not related to false';  // true
myVar = false; // falsemyVar = 'false';  // falsemyVar = 'FALSE';  // falsemyVar = '0';  // false

神圣的上帝，这些答案中的一些只是野生的。我喜欢JS和它的无限多的方式来皮肤布尔。

我的偏好，我很震惊没有看到，是：

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

你为什么不试试这样的东西

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

当给出其他文本而不是true或false时，它将返回错误，无论情况如何，它都将捕获数字

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

此函数可以处理字符串以及布尔true/false。

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

下面演示：

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

在nodejs中使用node-boolify是可能的

布尔转换结果

Boolify(true); //trueBoolify('true'); //trueBoolify('TRUE'); //nullBoolify(1); //trueBoolify(2); //nullBoolify(false); //falseBoolify('false'); //falseBoolify('FALSE'); //nullBoolify(0); //falseBoolify(null); //nullBoolify(undefined); //nullBoolify(); //nullBoolify(''); //null

对于TypeScript，我们可以使用函数：

export function stringToBoolean(s: string, valueDefault: boolean = false): boolean {switch(s.toLowerCase()){case "true":case "1":case "on":case "yes":case "y":return true;
case "false":case "0":case "off":case "no":case "n":return false;}
return valueDefault;}

如果您确定测试主题始终是一个字符串，那么显式检查它是否等于true是您最好的选择。

您可能需要考虑包含额外的代码，以防主题实际上可能是布尔值。

var isTrueSet =myValue === true ||myValue != null &&myValue.toString().toLowerCase() === 'true';

如果代码得到改进/重构以使用实际的布尔值而不是字符串，这可以节省您将来的一些工作。

我经常使用的最简单的方法：

let value = 'true';let output = value === 'true';

我希望这是一个最全面的用例

function parseBoolean(token) {if (typeof token === 'string') {switch (token.toLowerCase()) {case 'on':case 'yes':case 'ok':case 'ja':case 'да':// case '':// case '':token = true;break;default:token = false;}}let ret = false;try {ret = Boolean(JSON.parse(token));} catch (e) {// do nothing or make a notification}return ret;}

试试这个解决方案（它就像一个魅力！）：

function convertStrToBool(str){switch(String(str).toLowerCase()){case 'undefined': case 'null': case 'nan': case 'false': case 'no': case 'f': case 'n': case '0': case 'off': case '':return false;break;default:return true;};};

在超文本标记语言中，属性的值最终会变成字符串。为了在不需要的情况下减轻这种情况，您可以使用一个函数将它们有条件地解析为它们在JavaScript或任何其他感兴趣的编程语言中表示的值。

以下是从字符串类型恢复布尔类型的解释，但它也可以进一步扩展为其他数据类型，如数字、数组或对象。

除此之外JSON.parse还有一个复活参数，它是一个函数。它也可以用来实现相同的功能。

让我们调用一个看起来像布尔、“true”、布尔字符串的字符串，同样我们可以调用一个像数字、“1”、数字串的字符串。然后我们可以确定一个字符串是否是布尔字符串：

const isBooleanString = (string) => ['true', 'false'].some(item => item === string);

之后，我们需要通过JSON.parse方法将布尔字符串解析为JSON：

JSON.parse(aBooleanString);

但是，任何不是布尔字符串、数字串或任何字符串化对象或数组（任何无效的JSON）的字符串都将导致JSON.parse方法抛出SyntaxError。

因此，您需要知道如何调用它，即如果它是布尔字符串。您可以通过编写一个函数来实现这一点，该函数使上述defiend布尔字符串检查并调用JSON.parse：

function parse(string){return isBooleanString(string) ? JSON.parse(string): string;}

可以进一步推广isBooleanString实用程序，通过进一步参数化它以接受接受的布尔字符串的可选数组，对布尔字符串的资格有更广泛的视角：

const isBooleanString = (string, spec = ['true', 'false', 'True', 'False']) => spec.some(item => item === string);

最简单的方法是

a = 'True';a = !!a && ['1', 'true', 1, true].indexOf(a.toLowerCase()) > -1;

const result: Boolean = strValue === "true" ? true : false

许多现有的答案使用的方法在语义上与此相似，但我认为值得一提的是，以下“一行”通常就足够了。例如，除了OP的情况（表单中的字符串）之外，人们经常想从nodejs中的#0中读取环境变量（据我所知，其值总是字符串）以启用或禁用某些行为，这些行为的形式SOME_ENV_VAR=1很常见。

const toBooleanSimple = (input) =>['t', 'y', '1'].some(truePrefix => truePrefix === input[0].toLowerCase());

一个稍微更健壮和更具表现力的实现可能如下所示：

/*** Converts strings to booleans in a manner that is less surprising* to the non-JS world (e.g. returns true for "1", "yes", "True", etc.* and false for "0", "No", "false", etc.)* @param input* @returns {boolean}*/function toBoolean(input) {if (typeof input !== 'string') {return Boolean(input);}const s = input.toLowerCase();return ['t', 'y', '1'].some(prefix => s.startsWith(prefix));}

对此的（jest）单元测试可能如下所示：

describe(`toBoolean`, function() {const groups = [{inputs: ['y', 'Yes', 'true', '1', true, 1],expectedOutput: true}, {inputs: ['n', 'No', 'false', '0', false, 0],expectedOutput: false}]for (let group of groups) {for (let input of group.inputs) {it(`should return ${group.expectedOutput} for ${JSON.stringify(input)}`, function() {expect(toBoolean(input)).toEqual(group.expectedOutput);});}}});

使用if语句：

function parseBool(str) {if (str.toLowerCase() == 'true') {var val = true;} else if (str.toLowerCase() == 'false') {var val = false;} else {//If it is not true of false it returns undefined.//var val = undefined;}return val;}console.log(parseBool(''), typeof parseBool(''));console.log(parseBool('TrUe'), typeof parseBool('TrUe'));console.log(parseBool('false'), typeof parseBool('false'));

警告：从来没有将此方法用于不受信任的输入，例如URL参数。

您可以使用eval()函数。直接将字符串传递给eval()函数。

console.log(eval('true'), typeof eval('true'))console.log(eval('false'), typeof eval('false'))

你甚至不需要使用变量，如果你知道'true'总是小写的，你可以使用它来返回true或false：

(eval(yourBooleanString == 'true'))

我认为它可以在一个使用箭头函数的衬里中完成

const convertStringToBoolean = (value) => value ? String(value).toLowerCase() === 'true' : false;

你们可以使用以下代码片段运行和测试各种情况

const convertStringToBoolean = (value) => value ? String(value).toLowerCase() === 'true' : false;
console.log(convertStringToBoolean("a"));console.log(convertStringToBoolean(null));console.log(convertStringToBoolean(undefined));console.log(convertStringToBoolean("undefined"));console.log(convertStringToBoolean(true));console.log(convertStringToBoolean(false));console.log(convertStringToBoolean(0));console.log(convertStringToBoolean(1)); // only case which will not work

将字符串转换为布尔值的最简单方法如下：

Boolean(<stringVariable>)

如果您需要字符串值中的Booleanfalse和true，请进行简单的一行操作：

storeBooleanHere = stringVariable=="true"?true:false;

• store Booleanhere-此变量将保存布尔值
• stringVariable-将布尔值存储为字符串的变量

我建议您创建一个类似于图像中第三个选项的函数，并将其作为导出放在助手类中，并在需要时重用此函数。

/// Convert something to booleanfunction toBoolean( o ) {if ( null !== o ) {let t = typeof o;if ( "undefined" !== typeof o ) {if ( "string" !== t ) return !!o;o = o.toLowerCase().trim();return "true" === o || "1" === o;}}return false;}
toBoolean(false) --> falsetoBoolean(true) --> truetoBoolean("false") --> falsetoBoolean("true") --> truetoBoolean("TRue") --> truetoBoolean("1") --> truetoBoolean("0") --> falsetoBoolean(1) --> truetoBoolean(0) --> falsetoBoolean(123.456) --> truetoBoolean(0.0) --> falsetoBoolean("") --> falsetoBoolean(null) --> falsetoBoolean() --> false

最强的方法如下，因为它也处理未定义的情况：

    ({'true': true, 'false': false})[myValue];

    ({'true': true, 'false': false})[undefined] // => undefined({'true': true, 'false': false})['true'] // => true({'true': true, 'false': false})['false] // => false

如果您确定输入仅在“true”和“false”中为什么不呢？

let x = 'true' ;//let x = 'false';let y = x === 'true' ? true : false;console.log(typeof(y), y);

function convertBoolean(value): boolean {if (typeof value == 'string') {value = value.toLowerCase();}switch (value) {case true:case "true":case "evet": // Localecase "t":case "e": // Localecase "1":case "on":case "yes":case 1:return true;case false:case "false":case "hayır": // Localecase "f":case "h": // Localecase "0":case "off":case "no":case 0:return false;default:return null;}}

最简单的解决方案🙌🏽

与es6+

使用逻辑不两次[！！]来转换字符串

只需粘贴此表达式…

const stringToBoolean = (string) => string === 'false' ? false : !!string

把你的绳子给它！

stringToBoolean('')                 // falsestringToBoolean('false')            // falsestringToBoolean('true')             // truestringToBoolean('hello my friend!') // true

const betterStringToBoolean = (string) =>string === 'false' || string === 'undefined' || string === 'null' || string === '0' ?false : !!string

您可以随意包含其他字符串以轻松扩展此表达式的使用…：

betterStringToBoolean('undefined')     // falsebetterStringToBoolean('null')          // falsebetterStringToBoolean('0')             // falsebetterStringToBoolean('false')         // falsebetterStringToBoolean('')              // falsebetterStringToBoolean('true')          // truebetterStringToBoolean('anything else') // true

//尝试以两种方式将字符串转换为布尔值

    const checkBoolean = Boolean("false");const checkBoolean1 = !!"false";    
console.log({checkBoolean, checkBoolean1});

es6+

const string = "false"const string2 = "true"
const test = (val) => (val === "true" || val === "True")console.log(test(string))console.log(test(string2))

const boolTrue = JSON.parse("true")const boolFalse = JSON.parse("false")

console.log(boolTrue) // trueconsole.log(boolFalse) // false

将字符串布尔值（如“true”）转换为实际布尔值只是包装为JSON.parse()示例：JSON.parse("true")

这是我最近遇到的最简单的布尔转换方法。考虑添加它。

JSON.parse('true');

let trueResponse = JSON.parse('true');
let falseResponse = JSON.parse('false');
console.log(trueResponse);console.log(falseResponse);

Boolean（value）的简写是！！value，这是因为！将值转换为与当前值相反的值，然后！再次将其反转回原始形式。

如果String对象上有一个函数为我们做到这一点，那就太好了，但我们可以轻松添加自己的原型来扩展String对象。

在使用之前将此代码添加到项目中的某个地方。

String.prototype.toBoolean = function() {return String(this.valueOf()).toLowerCase() === true.toString();};

试试这样做：

var myValue = "false"console.log("Bool is " + myValue.toBoolean())console.log("Bool is " + "False".toBoolean())console.log("Bool is " + "FALSE".toBoolean())console.log("Bool is " + "TRUE".toBoolean())console.log("Bool is " + "true".toBoolean())console.log("Bool is " + "True".toBoolean())

因此，原始问题的结果将是：

var myValue = document.myForm.IS_TRUE.value;var isTrueSet = myValue.toBoolean();

我很惊讶includes没有被推荐

let bool = "false"bool = !["false", "0", 0].includes(bool)

您可以修改检查是否真实或包含更多条件（例如null、''）。

我需要一个将任何变量类型转换为布尔值的代码。这是我想出的：

const toBoolean = (x) => {if (typeof x === 'object') {for (var i in x) return truereturn false}return (x !== null) && (x !== undefined) && !['false', '', '0', 'no', 'off'].includes(x.toString().toLowerCase())}

让我们测试它！

const toBoolean = (x) => {if (typeof x === 'object') {for (var i in x) return truereturn false}return (x !== null) && (x !== undefined) && !['false', '', '0', 'no', 'off'].includes(x.toString().toLowerCase())}  

// Let's test it!let falseValues = [false, 'False', 0, '', 'off', 'no', [], {}, null, undefined]let trueValues = [  true, 'true', 'True', 1, -1, 'Any thing', ['filled array'], {'object with any key': null}]  
falseValues.forEach((value, index) => console.log(`False value ${index} of type ${typeof value}: ${value} -> ${toBoolean(value)}`))trueValues.forEach((value, index) => console.log(`True value ${index} of type ${typeof value}: ${value} -> ${toBoolean(value)}`))

您可以从数组中删除“off”和“no”之类的单词，如果它们与您的大小写不匹配。

在打字脚本中，一个小函数，用于处理值是作为字符串、数字还是布尔值传递的，例如“true”、“false”、true、false、1还是0。

const getAsBoolean = (value: string | boolean | number) => {if (typeof value === 'string') {return value === 'true';} else if (typeof value === 'boolean' || typeof value === 'number') {return Boolean(value);} else {return undefined;}};