我可以将表示布尔值的字符串（例如，'true'、'false'）转换为 JavaScript 中的内在类型吗？
我在 HTML 中有一个隐藏的表单，它会根据用户在列表中的选择进行更新。此表单包含一些表示布尔值的字段，并使用固有的布尔值动态填充。但是，一旦将此值放入隐藏的输入字段中，它就会变成一个字符串。
一旦将字段转换为字符串，我能找到确定字段布尔值的唯一方法是依赖于其字符串表示的文字值。
var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';
有没有更好的方法来实现这一点？
var isTrueSet = (myValue === 'true');
使用恒等运算符 ( ===)，当比较变量具有不同类型时，它不会进行任何隐式类型转换。
您可能应该谨慎使用这两种方法来满足您的特定需求：
var myBool = Boolean("false"); // == true
var myBool = !!"false"; // == true
任何不是空字符串的字符串都将true通过使用它们来评估。尽管它们是我能想到的关于布尔转换的最简洁的方法，但我认为它们不是您想要的。
这个高度赞成的遗留答案在技术上是正确的，但只涵盖了一个非常具体的场景，当您的字符串值为 EXACTLY"true"或"false".
传递给下面这些函数的无效 json 字符串将引发异常。
原答案：
怎么样？
JSON.parse("True".toLowerCase());
或使用 jQuery
$.parseJSON("TRUE".toLowerCase());
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);
}
}
我认为这是非常普遍的：
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
记住要匹配大小写：
var isTrueSet = (myValue.toLowerCase() === 'true');
此外，如果它是一个表单元素复选框，您还可以检测该复选框是否被选中：
var isTrueSet = document.myForm.IS_TRUE.checked;
假设如果它被选中，它被“设置”等于真。这评估为真/假。
您可以使用正则表达式：
/*
* 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。错误 720760）
木眼要小心。在应用获得 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]));}
这是我最近遇到的最简单的布尔转换方法。想加上它。
JSON.parse('true');
let trueResponse = JSON.parse('true');
let falseResponse = JSON.parse('false');
console.log(trueResponse);
console.log(falseResponse);我认为@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;
}
}
false如果您已经知道您必须考虑的所有案例，则不必涵盖所有案例true。您可以将任何可以传递true值的内容传递给此方法（或添加其他值，这非常简单），其他所有内容都将被考虑false
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,'');
}
我还创建了小提琴来测试它http://jsfiddle.net/remunda/2GRhG/
你的解决方案很好。
在这种情况下使用===会很愚蠢，因为该字段value将始终是String.
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());
布尔对象没有“解析”方法。Boolean('false')返回true，所以这不起作用。!!'false'也返回true，所以这也行不通。
如果您希望字符串'true'返回布尔值true和字符串'false'返回布尔值false，那么最简单的解决方案是使用eval(). eval('true')返回真并eval('false')返回假。请记住使用时的性能影响eval()。
有很多答案，很难选择一个。就我而言，我在选择时会优先考虑性能，所以我创建了这个 jsPerf，希望可以在这里有所启发。
结果简介（越高越好）：
它们链接到相关答案，您可以在其中找到有关每个答案的更多信息（优点和缺点）；特别是在评论中。
这是从接受的答案中得出的，但实际上它有一个非常薄弱的地方，我很震惊它是如何获得赞成票的，它的问题是你必须考虑字符串的大小写，因为这是区分大小写的
var isTrueSet = (myValue.toLowerCase() === 'true');
我使用以下内容：
function parseBool(b) {
return !(/^(false|0)$/i).test(b) && !!b;
}
除了字符串“false”（不区分大小写）和“0”之外，此函数执行通常的布尔强制转换。
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$/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
已经有很多答案可用了。但在某些情况下，以下可能很有用。
// 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
使用逻辑 NOT两次[ !! ]获取转换后的字符串
只需粘贴此表达式...
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
将 string("true", "false") 和 boolean 都转换为 boolean
('' + flag) === "true"
哪里flag可以
var flag = true
var flag = "true"
var flag = false
var flag = "false"
你可以使用JSON.parse如下：
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if(result==true)
alert('this is true');
else
alert('this is false');在这种情况下.toLowerCase很重要
此函数可以处理字符串以及布尔值 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)));我正在使用这个
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"
你为什么不试试这样的东西
Boolean(JSON.parse((yourString.toString()).toLowerCase()));
无论情况如何，当给出其他文本而不是真或假时，它将返回错误，并且它还将捕获数字作为
// 0-> false
// any other number -> true
您需要（在您的想法中）将您的选择的价值和该价值的表示分开。
在 JavaScript 逻辑中选择一个点，他们需要从字符串标记转换为原生类型并在那里进行比较，最好是对每个需要转换的值只进行一次比较。如果字符串 sentinel 不是脚本知道的字符串，请记住解决需要发生的情况（即，您默认为 true 还是 false？）
换句话说，是的，您需要依赖字符串的值。:-)
我们只需要考虑“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
我很惊讶没有includes被建议
let bool = "false"
bool = !["false", "0", 0].includes(bool)
您可以修改检查是否为 true 或包含更多条件（例如null, ''）。
放下最简单的方法（假设您的字符串将是“真”或“假”）是：
var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false
对于这些类型的转换，请始终使用 === 运算符而不是 == 运算符！
就像@Shadow2531 说的，你不能直接转换它。如果您的代码将被其他人重用/使用，我还建议您考虑除 "true" 和 "false" 之外的字符串输入，它们是 'truthy' 和 'falsey'。这就是我使用的：
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;
}
}
我有点晚了，但我有一个小片段可以做到这一点，它基本上维护了所有 JScripts 的真/假/脏-ness ，但包括"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..
另一种解决方案。 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
>
天哪，其中一些答案很疯狂。我喜欢 JS 和它无数种剥皮布尔值的方法。
我很震惊地没有看到我的偏好是：
testVar = testVar.toString().match(/^(true|[1-9][0-9]*|[0-9]*[1-9]+|yes)$/i) ? true : false;
我对这个问题的看法是，它旨在满足三个目标：
使用 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 开发中更有用。对建议它的其他答案表示赞许！
我写了一个函数来匹配 PHP 的 filter_var ，它很好地做到了这一点。提供要点：https ://gist.github.com/CMCDragonkai/7389368
/**
* 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;
};
我一直使用的最简单的方法：
let value = 'true';
let output = value === 'true';
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;
}
这里有很多花哨的答案。真的很惊讶没有人发布这个解决方案：
var booleanVal = toCast > '';
在大多数情况下，这解析为 true，而不是 bool false、数字零和空字符串（显然）。您可以在事后轻松查找其他虚假字符串值，例如：
var booleanVal = toCast > '' && toCast != 'false' && toCast != '0';
String(true).toLowerCase() == 'true'; // true
String("true").toLowerCase() == 'true'; // true
String("True").toLowerCase() == 'true'; // true
String("TRUE").toLowerCase() == 'true'; // true
String(false).toLowerCase() == 'true'; // false
如果您不确定输入，则上述内容适用于布尔值以及任何字符串。
如果您确定测试主题始终是一个字符串，那么明确检查它是否等于是true您最好的选择。
您可能需要考虑包含一些额外的代码，以防主题实际上是布尔值。
var isTrueSet =
myValue === true ||
myValue != null &&
myValue.toString().toLowerCase() === 'true';
如果代码得到改进/重构以使用实际的布尔值而不是字符串，这可以在将来为您节省一些工作。
最简单的方法是
a = 'True';
a = !!a && ['1', 'true', 1, true].indexOf(a.toLowerCase()) > -1;
我发现对布尔值使用 '1' 和空值 '' 比使用 'true' 或 'false' 字符串值更可预测......特别是对于 html 表单，因为 Dom 元素中的未初始化/空值将始终评估为假，而其中的任何值都为真。
例如：
<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>
似乎是一条更容易的道路，到目前为止它一直非常一致/容易......也许有人可以确定一种方法来打破这个？
@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
我这样做，它将处理 1=TRUE=yes=YES=true, 0=FALSE=no=NO=false：
BOOL=false
if (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; // false
var test2 = null; // false
var test3 = 'undefined'; // false
var test4 = 'true'; // true
var test5 = 'false'; // false
var test6 = true; // true
var test7 = false; // false
var test8 = 1; // true
var test9 = 0; // false
var test10 = '1'; // true
var test11 = '0'; // false
小提琴：http: //jsfiddle.net/av5xcj6s/
在 nodejs 中使用node-boolify是可能的
布尔转换结果
Boolify(true); //true
Boolify('true'); //true
Boolify('TRUE'); //null
Boolify(1); //true
Boolify(2); //null
Boolify(false); //false
Boolify('false'); //false
Boolify('FALSE'); //null
Boolify(0); //false
Boolify(null); //null
Boolify(undefined); //null
Boolify(); //null
Boolify(''); //null
/// Convert something to boolean
function 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) --> false
toBoolean(true) --> true
toBoolean("false") --> false
toBoolean("true") --> true
toBoolean("TRue") --> true
toBoolean("1") --> true
toBoolean("0") --> false
toBoolean(1) --> true
toBoolean(0) --> false
toBoolean(123.456) --> true
toBoolean(0.0) --> false
toBoolean("") --> false
toBoolean(null) --> false
toBoolean() --> false
如果有一些其他代码将布尔值转换为字符串，您需要确切地知道该代码如何存储真/假值。要么，要么您需要访问一个反转该转换的函数。
有无数种方法可以在字符串中表示布尔值（“true”、“Y”、“1”等）。所以你不应该依赖一些通用的字符串到布尔转换器，比如 Boolean(myValue)。无论是什么，您都需要使用一个反转原始布尔到字符串转换的例程。
如果您知道它将真正的布尔值转换为“真正的”字符串，那么您的示例代码就可以了。除了你应该使用 === 而不是 ==，所以没有自动类型转换。
if (String(a) == "true"){
//true block
} else {
//false block
}
我写了一个辅助函数来处理你的案例（以及更多）。随意更改它以满足您的特定需求
/**
* @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);
};
这是我的 1 班轮提交：我需要评估一个字符串和输出，如果为“真”则为真，如果为“假”则为假，如果为“-12.35673”之类的则为数字。
val = 'false';
val = /^false$/i.test(val) ? false : ( /^true$/i.test(val) ? true : val*1 ? val*1 : val );
简单的解决方案我已经使用了一段时间
function asBoolean(value) {
return (''+value) === 'true';
}
// asBoolean(true) ==> true
// asBoolean(false) ==> false
// asBoolean('true') ==> true
// asBoolean('false') ==> false
有助于加快 Javascript 代码执行的功能之一是Short-Circuit Evaluation：
由于逻辑表达式是从左到右评估的，因此使用以下规则测试它们是否存在可能的“短路”评估：
- false && (anything) 短路评估为 false。
- 真 || (anything) 短路评估为真。
因此，如果您想测试一个字符串值是否处于true测试false状态JSON.parse并保持性能强劲，您可以使用||运算符将慢速代码排除在执行之外，以防测试值是布尔类型。
test === true || ['true','yes','1'].indexOf(test.toString().toLowerCase()) > -1
由于该Array.prototype.indexOf()方法是第 5 版中ECMA-262标准的一部分，您可能需要一个polyfill来支持旧浏览器。
// Production steps of ECMA-262, Edition 5, 15.4.4.14
// Reference: http://es5.github.io/#x15.4.4.14
if (!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 < len
while (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;
};
}
function isTrue(val) {
try {
return !!JSON.parse(val);
} catch (e) {
return false;
}
}
我使用这种简单的方法（使用“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 0
return false if value is string '0'
return false if value is string 'false'
return false if value is boolean false
return true if value is number 1
return true if value is string '1'
return true if value is string 'true'
return true if value is boolean true
这是一个简单的函数，可以解决问题，
function convertStringToBool(str){
return ((str === "True") || (str === "true")) ? true:false;
}
这将给出以下结果
convertStringToBool("false") //returns false
convertStringToBool("true") // returns true
convertStringToBool("False") // returns false
convertStringToBool("True") // returns true
当我从 URL/Form 或其他来源获得价值时，我正在使用这个。
这是非常通用的一行代码。
也许不是最好的性能，如果您需要运行它数百万次，请告诉我，我们可以检查如何优化它，否则非常好并且可定制。
boolResult = !(['false', '0', '', 'undefined'].indexOf(String(myVar).toLowerCase().trim()) + 1);
结果：
myVar = true; // true
myVar = 'true'; // true
myVar = 'TRUE'; // true
myVar = '1'; // true
myVar = 'any other value not related to false'; // true
myVar = false; // false
myVar = 'false'; // false
myVar = 'FALSE'; // false
myVar = '0'; // false
对于 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;
}
试试这个解决方案（它就像一个魅力！）：
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;
};
};
许多现有的答案使用与此语义相似的方法，但我认为值得一提的是，以下“一个衬里”通常就足够了。例如，除了 OP 的情况（表单中的字符串）之外，人们经常希望从NodeJSprocess.env中读取环境变量（据我所知，其值始终是字符串）以启用或禁用某些行为，以及这些通常具有形式。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));
}
对此的（开玩笑）单元测试可能如下所示：
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);
});
}
}
});
如果 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();
我一直在使用这个片段来转换数字和布尔值：
var result = !isNaN(value) ? parseFloat(value) : /^\s*(true|false)\s*$/i.exec(value) ? RegExp.$1.toLowerCase() === "true" : value;
基于上面 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; }
}
}
MyLib.Convert.bool = function(param) {
var res = String(param).toLowerCase();
return !(!Boolean(res) || res === "false" || res === "0");
};
许多现有的答案都是相似的，但大多数都忽略了给定参数也可能是一个对象的事实。
这是我刚刚整理的东西：
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');
}
}
};
写这个的更短的方法可能是var isTrueSet = (myValue === "true") ? true : false;假设只有“真”是真的，其他值是假的。
为了评估布尔值和类似布尔值的字符串，我使用了这个简单的公式：
var trueOrStringTrue = (trueOrStringTrue === true) || (trueOrStringTrue === 'true');
很明显，它会为 true 和 'true' 返回 true。其他一切都返回假。
请注意，也许将来代码会更改并返回布尔值而不是此时的一个字符串。
解决方案是：
//Currently
var isTrue = 'true';
//In the future (Other developer change the code)
var isTrue = true;
//The solution to both cases
(isTrue).toString() == 'true'
警告： 切勿将此方法用于不受信任的输入，例如 URL 参数。
您可以使用该eval()功能。直接将您的字符串传递给eval()函数。
console.log(eval('true'), typeof eval('true'))
console.log(eval('false'), typeof eval('false'))const boolTrue = JSON.parse("true")
const boolFalse = JSON.parse("false")
console.log(boolTrue) // true
console.log(boolFalse) // false将字符串布尔值（如“true”）转换为实际的布尔值只是包装到JSON.parse()
示例：JSON.parse("true")
Boolean(value) 的简写是 !!value，这是因为 ! 将值转换为与当前值相反的值，然后 ! 再次将其反转回原始形式。
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);
}
}
Boolean.parse()在某些浏览器实现中确实存在。它绝对不是通用的，所以如果这是你需要的东西，那么你不应该使用这种方法。但在 Chrome 中，例如（我使用的是 v21）它工作得很好，正如人们所期望的那样。
您甚至不需要将字符串转换为布尔值。只需使用以下内容：
var yourstring = yourstringValue == 1 ? true : false;
从字符串或数字中获取布尔值这是一个很好的解决方案：
var boolValue = Boolean(Number('0'));
var boolValue = Boolean(Number('1'));
第一个将返回false，第二个将返回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 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;
}
在 HTML 中，属性的值最终会变成字符串。为了在不希望的情况下减轻这种情况，您可以使用一个函数有条件地将它们解析为它们在 JavaScript 或任何其他感兴趣的编程语言中表示的值。
以下是从字符串类型恢复布尔类型的解释，但它也可以进一步扩展到其他数据类型，如数字、数组或对象。
除此之外 JSON.parse 有一个revive 参数，它是一个函数。它也可以用来实现相同的目的。
让我们称一个看起来像boolean的字符串"true" 是一个boolean 字符串，同样我们也可以称一个像数字的字符串 "1" 是一个数字字符串。然后我们可以确定一个字符串是否为布尔字符串：
const isBooleanString = (string) => ['true', 'false'].some(item => item === string);
之后，我们需要通过方法将布尔字符串解析为 JSON JSON.parse：
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);
const result: Boolean = strValue === "true" ? true : false
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'));你甚至不需要使用变量，如果你知道“真”总是小写，你可以使用它来返回真或假：
(eval(yourBooleanString == 'true'))
我认为它可以用一个使用箭头功能在 1 班轮中完成
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最强的方法如下，因为它也处理未定义的情况：
({'true': true, 'false': false})[myValue];
({'true': true, 'false': false})[undefined] // => undefined
({'true': true, 'false': false})['true'] // => true
({'true': true, 'false': false})['false] // => 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": // Locale
case "t":
case "e": // Locale
case "1":
case "on":
case "yes":
case 1:
return true;
case false:
case "false":
case "hayır": // Locale
case "f":
case "h": // Locale
case "0":
case "off":
case "no":
case 0:
return false;
default:
return null;
}
}
以下就足够了
String.prototype.boolean = function() {
return "true" == this;
};
"true".boolean() // returns true "false".boolean() // returns false
您可以使用从字符串Function返回值或Boolean"true""false"
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"``toBoolean' 函数为 null、undefined、''、'false' 返回 false。它为任何其他字符串返回 true：
const toBoolean = (bool) => {
if (bool === 'false') bool = false
return !!bool
}
toBoolean('false') // returns false
const string = "false"
const string2 = "true"
const test = (val) => (val === "true" || val === "True")
console.log(test(string))
console.log(test(string2))false如果您需要布尔值和true字符串值，则简单的一行操作：
storeBooleanHere = stringVariable=="true"?true:false;
将字符串转换为布尔值的最简单方法如下：
Boolean(<stringVariable>)
完美且非常简单：
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);
}// 尝试这两种方式将字符串转换为布尔值
const checkBoolean = Boolean("false");
const checkBoolean1 = !!"false";
console.log({checkBoolean, checkBoolean1});
我建议您创建一个类似于图像中第三个选项的函数并将其作为导出放置在辅助类中，并在需要时重用此函数。
只需做一个：
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
此方法自然地处理空字符串和未定义字符串，就好像您声明一个变量而不给它赋值一样。