如何在 JavaScript 中将字符串转换为布尔值？
Posted
技术标签:
【中文标题】如何在 JavaScript 中将字符串转换为布尔值？【英文标题】：How can I convert a string to boolean in JavaScript? 【发布时间】：2010-09-20 19:23:49 【问题描述】：我可以在 javascript 中将表示布尔值（例如，'true'、'false'）的字符串转换为固有类型吗？
我有一个 html 中的隐藏表单，它会根据用户在列表中的选择进行更新。此表单包含一些表示布尔值的字段，并使用固有的布尔值动态填充。但是，一旦将这个值放入隐藏的输入字段，它就会变成一个字符串。
一旦将字段转换为字符串，我能找到确定该字段的布尔值的唯一方法是依赖于其字符串表示的文字值。
var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';
有没有更好的方法来做到这一点？
【问题讨论】：
“有没有更好的方法来完成这个？” - 当然还有更糟糕的方法：Dstring=(string==String(string?true:false))?(string?true:false):(!string?true:false);
轻松处理字符串和布尔值：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")
【参考方案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】：
警告
这个高度赞成的旧答案在技术上是正确的，但只涵盖了一个非常具体的场景，当您的字符串值完全是 "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【参考方案3】：
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【参考方案4】：
我认为这是非常普遍的：
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'【参考方案5】：
记住要匹配大小写：
var isTrueSet = (myValue.toLowerCase() === 'true');
另外，如果是表单元素复选框，还可以检测复选框是否被选中：
var isTrueSet = document.myForm.IS_TRUE.checked;
假设如果选中，则“设置”等于true。这评估为真/假。
【讨论】：
如果 myValue 为 null 或 undefined 或字符串以外的任何类型，这将失败。【参考方案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】：
小心木眼。 在看到应用了 500 多个赞成票的最佳答案后的后果后，我觉得有义务发布一些真正有用的东西：
让我们从最短但非常严格的方式开始：
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')
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]));
【讨论】：
if(str == null) 返回 false；每次输入错误地初始化为 null 时都会返回随机错误。大多数时候，宽容并不是一个理想的特征：【参考方案8】：我认为@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
【讨论】：
【参考方案9】：这是我最近遇到的最简单的布尔转换方法。想添加它。
JSON.parse('true');
let trueResponse = JSON.parse('true');
let falseResponse = JSON.parse('false');
console.log(trueResponse);
console.log(falseResponse);【讨论】：
这行得通，但你必须小心不要将空字符串传递给它，否则它会弹出。 性感的解决方案，我喜欢它！【参考方案10】：使用 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
更新（不带 JSON）：
function getBool(val)
var num = +val;
return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
我还创建了 fiddle 来测试它http://jsfiddle.net/remunda/2GRhG/
【讨论】：
“无 JSON”版本有一些缺陷： val="0" ; console.log(!!(+val||String(val).toLowerCase().replace(!!0,'')) );产生真getBool(undefined) 将在使用原始 JSON 版本时崩溃，并且将为第二个版本返回 true。这是返回 false 的第三个版本： function getBool(val) var num; return val != null && (!isNaN(num = +val) ? !!num : !!String(val).toLowerCase().replace(!!0,'')); 【参考方案11】：
你的解决方案很好。
在这种情况下使用=== 会很愚蠢，因为该字段的value 将始终是String。
【讨论】：
为什么你认为使用=== 会很傻？就性能而言，如果两种类型都是字符串，那将是完全相同的。无论如何，我宁愿使用===，因为我总是避免使用== 和!=。理由：***.com/questions/359494/…
因为value 将永远是string 既不是== 也不是=== 是愚蠢的。两者都是这项工作的正确工具。它们仅在类型不相等时有所不同。在这种情况下，=== 只返回 false 而== 在比较之前执行复杂的类型强制算法。【参考方案12】：
var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val)
return !falsy.test(val) && !!val;
;
这会为每个假值返回 false，为每个真值返回 true，除了 'false'、'f'、'no'、'n' 和 '0'（不区分大小写）。
// 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());
【讨论】：
【参考方案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 之类的文章或在 *** 上搜索“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】：
有很多答案，很难选择一个。就我而言，我在选择时会优先考虑性能，所以我创建了this jsPerf，希望可以在这里有所启发。
结果简介（越高越好）：
-
Conditional statement: 2,826,922
Switch case on Bool object: 2,825,469
Casting to JSON: 1,867,774
!! conversions: 805,322
Prototype of String: 713,637
它们链接到相关答案，您可以在其中找到有关每个答案的更多信息（优点和缺点）；特别是在 cmets 中。
【讨论】：
“出现问题”时尝试查看 jsPerf 测试【参考方案15】：这是从接受的答案中提取的，但实际上它有一个非常薄弱的地方，我很震惊它是如何获得这么多赞成票的，它的问题是你必须考虑字符串的大小写，因为这是区分大小写
var isTrueSet = (myValue.toLowerCase() === 'true');
【讨论】：
更不用说如果myValue 等于null 或undefined，.toLowerCase 可能会抛出【参考方案16】：
我使用以下：
function parseBool(b)
return !(/^(false|0)$/i).test(b) && !!b;
此函数执行通常的布尔强制转换，字符串“false”（不区分大小写）和“0”除外。
【讨论】：
【参考方案17】：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 代替【参考方案18】：
您正在寻找的表达式就是
/^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
【讨论】：
【参考方案19】：已经有很多答案了。但在某些情况下，跟随可能很有用。
// 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;
);
这对于一个具有非布尔值的示例很有用。
getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false
getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true
【讨论】：
【参考方案20】：将字符串（“true”，“false”）和布尔值都转换为布尔值
('' + flag) === "true"
flag 可以在哪里
var flag = true
var flag = "true"
var flag = false
var flag = "false"
【讨论】：
【参考方案21】：你可以使用JSON.parse如下：
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if(result==true)
alert('this is true');
else
alert('this is false');在这种情况下.toLowerCase 很重要
【讨论】：
但不保证返回布尔值。【参考方案22】：最简单的解决方案??
使用 ES6+
两次使用逻辑非 [ !! ] 转换字符串
只需粘贴此表达式...
const stringToBoolean = (string) => string === 'false' ? false : !!string
并将你的字符串传递给它！
stringToBoolean('') // false
stringToBoolean('false') // false
stringToBoolean('true') // true
stringToBoolean('hello my friend!') // true
const betterStringToBoolean = (string) =>
string === 'false' || string === 'undefined' || string === 'null' || string === '0' ?
false : !!string
您可以随意包含其他字符串，以轻松扩展此表达式的使用...：
betterStringToBoolean('undefined') // false
betterStringToBoolean('null') // false
betterStringToBoolean('0') // false
betterStringToBoolean('false') // false
betterStringToBoolean('') // false
betterStringToBoolean('true') // true
betterStringToBoolean('anything else') // true
【讨论】：
'1' 怎么样？应该转换为true 还是false？我想应该是true，不是吗？但是使用您的答案，它将返回false
猜你做错了什么兄弟......我刚刚测试了代码，如果你输入' 1 '，返回总是true。不知道你是怎么得到的 false 但我认为你一定是在某种程度上搞砸了
对不起！我的错，我正在测试第一个功能。感谢您澄清这一点。【参考方案23】：
此函数可以处理字符串以及布尔值的真/假。
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)));【讨论】：
【参考方案24】：我在用这个
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"
【讨论】：
这很好，但仅适用于字符串类型。想象一下，这需要由可能是"true" 或true 的变量使用。如果来第二个，这将不起作用。是否可以创建一个document.prototype在任何我们想要的地方使用它？
这看起来很优雅。做得好！但是，我注意到在大型 JS 应用程序（也需要单元测试）中重载基本原型可能会导致一些意外行为（即，当你想用“for”遍历一个原型重载的数组时，你会得到一些您通常不会期望的属性）。你被警告了。 ;)
你的一个变种也接受布尔值 function StringOrElse2Bool(sob) if (typeof sob === "string") return ["no", "false", "0", "off "].indexOf(sob.toLowerCase()) !== -1？假：真； 其他 返回 !!sob 【参考方案25】：
你为什么不试试这样的东西
Boolean(JSON.parse((yourString.toString()).toLowerCase()));
当给出其他文本而不是真或假时，无论大小写如何，它都会返回一个错误，并且它也会将数字捕获为
// 0-> false
// any other number -> true
【讨论】：
【参考方案26】：您需要（在您的想法中）将您的选择的价值和该价值的表示分开。
在 JavaScript 逻辑中选择一个点，他们需要从字符串标记转换为原生类型并在那里进行比较，最好是对每个需要转换的值只进行一次比较。如果字符串 sentinel 不是脚本知道的字符串，请记住解决需要发生的事情（即，您默认为 true 还是 false？）
换句话说，是的，你需要依赖字符串的值。 :-)
【讨论】：
【参考方案27】：一个班轮
我们只需要考虑“false”字符串，因为任何其他字符串（包括“true”）已经是true。
function b(v) return v==="false" ? false : !!v;
测试
b(true) //true
b('true') //true
b(false) //false
b('false') //false
更详尽的版本
function bool(v) return v==="false" || v==="null" || v==="NaN" || v==="undefined" || v==="0" ? false : !!v;
测试
bool(true) //true
bool("true") //true
bool(1) //true
bool("1") //true
bool("hello") //true
bool(false) //false
bool("false") //false
bool(0) //false
bool("0") //false
bool(null) //false
bool("null") //false
bool(NaN) //false
bool("NaN") //false
bool(undefined) //false
bool("undefined") //false
bool("") //false
bool([]) //true
bool() //true
bool(alert) //true
bool(window) //true
【讨论】：
使用!!v而不是直接使用true有什么具体原因吗？【参考方案28】：
最简单的方法（假设你的字符串是“真”或“假”）是：
var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false
始终在这些类型的转换中使用 === 运算符而不是 == 运算符！
【讨论】：
你在说什么转换？ :-) 在 javascript 中比较字符串时，在不使用转换时使用 == 或 === 运算符没有区别。在这里，您正在与字符串进行比较，因此没有类型转换。见***.com/questions/359494/…【参考方案29】：就像@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;
【讨论】：
【参考方案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..
【讨论】：
以上是关于如何在 JavaScript 中将字符串转换为布尔值？的主要内容，如果未能解决你的问题，请参考以下文章