执行：

Question

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

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

我可以找到确定字段的布尔值的唯一方法，一旦将其转换为字符串，就要依赖于字符串表示的字面值。

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

有没有更好的方法来实现这一目标？

Answer 1

执行：

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

您可以使用标识运算符（===）使其更严格，当比较变量具有不同类型而不是等于运算符（==）时，它不会进行任何隐式类型转换

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

不要：

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

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

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

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

Answer 2

警告

这个高度支持的遗留答案在技术上是正确的，但只涵盖了非常具体的情况，当您的字符串值完全"true"或"false"时（必须也是小写）。

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

原始回答：

怎么样？

JSON.parse("true");

或使用jQuery

$.parseJSON("true");

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

Answer 4

我认为这很普遍：

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

它是：

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

Answer 5

请记住匹配案例：

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

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

var isTrueSet = document.myForm.IS_TRUE.checked;

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

Answer 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对象的其他代码发生冲突：

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

（当然，在旧的浏览器中不起作用，而且当Opera，Chrome，Safari和IE显示为真时，Firefox显示为假。Bug 720760）

Answer 7

木眼要小心。在使用500多个upvotes应用最佳答案后看到后果后，我觉得有义务发布实际有用的内容：

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

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

Answer 8

使用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/

Answer 9

你的解决方案很好。

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

Answer 10

我认为@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

Answer 11

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());（不区分大小写）。

{{1}}

Answer 12

Boolean对象没有'parse'方法。 Boolean('false')返回true，因此无效。 !!'false'也会返回true，因此也无效。

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

Answer 13

答案很多，选择一个很难。在我的情况下，我在选择时优先考虑性能，所以我创建了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

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

Answer 14

我使用以下内容：

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

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

Answer 15

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

Answer 16

已经有很多答案可供选择。但是在某些情况下，以下内容可能很有用。

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

Answer 17

您正在寻找的表达式是

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

Answer 18

这是从已接受的答案中取得的，但实际上它有一个非常弱点，我很震惊它是如何得到那些赞成票，它的问题是你必须考虑字符串的情况，因为这是区分大小写

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

Answer 19

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

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

flag可以

的地方

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"

Answer 20

你为什么不尝试这样的事呢

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

当给出一些其他文本而不是真或假时，它将返回错误，无论情况如何，它也会将数字捕获为

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

Answer 21

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

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

始终使用===运算符代替==运算符进行这些类型的转换！

Answer 22

就像@ Shadow2531所说，你不能直接转换它。我还建议你考虑字符串输入除了＆＃34; true＆＃34;和＆＃34;假＆＃34;这是＆＃39; truthy＆＃39;并且＆＃39; falsey＆＃39;如果您的代码将被其他人重用/使用。这就是我使用的：

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

Answer 23

我正在使用这个

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"

Answer 24

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

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

以下演示：

＆＃13;

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

＆＃13;

Answer 25

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

Answer 26

最简单的解决方案??

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

Answer 27

我有点迟了，但是我有一个小片段可以做到这一点，它基本上维护了所有的JScripts truthey / falsey / 肮脏的 -ness但包含"false"作为可加入的虚假的价值。

我更喜欢这种方法，因为它不依赖第三方来解析代码（即：eval / JSON.parse），这在我看来太过分了，它足够短，不需要实用程序功能和维护其他truthey / falsey惯例。

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

Answer 28

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

对于truthy和falsey值返回true / false，但对于多个字符串值，如果它们是布尔值而不是字符串，则返回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或抛出Error，这在松散类型的Javascript开发中更有用。勇敢地回答其他建议的答案！

Answer 29

您需要（在您的思考中）分离您的选择的值和该值的表示。

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

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

Answer 30

圣洁的上帝这些答案中的一些只是狂野的。我喜欢JS及其无数种方法来涂抹布尔。

我不喜欢看到我的偏见是：

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

Answer 31

一个班轮

我们只需要考虑“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

Answer 32

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

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

Answer 33

最简单的方法是

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

Answer 34

我写了一个函数来匹配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;
};

Answer 35

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

Answer 36

我发现对布尔值使用'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>

看起来似乎是一条更轻松的道路，到目前为止它已经非常一致/容易......也许有人可以决定打破这种方式吗？

Answer 37

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

如何使用String.match（）方法

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

单独这将不会得到1/0或是/否，但是它将捕获TRUE / true，并且对于碰巧具有“true”作为子串的任何字符串，它将返回false。 / p>

修改

下面是一个处理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

Answer 38

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

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/

Answer 39

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

Answer 40

许多现有答案使用的语义与此相似，但我认为提及以下“一个班轮”通常就足够了。例如，除了OP的大小写（形式为字符串）之外，人们经常想从process.env中的NodeJS中读取环境变量（据我所知，其值始终是字符串）为了启用或禁用某些行为，通常这些行为的形式为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);
      });
    }      
  }
});

Answer 41

我这样做，它将处理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替换为字符串变量的名称。

如果它不是null，则是数值或其中一个字符串： “true”，“TRUE”，“false”，“FALSE”，“yes”，“YES”，“no”，“NO” 它会抛出错误（故意。）

Answer 42

你可以使用：

＆＃13;

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

＆＃13;

在这种情况下.toLowerCase很重要

Answer 43

这是我最近遇到的最简单的布尔转换方法。想加了。

JSON.parse('true');

let trueResponse = JSON.parse('true');

let falseResponse = JSON.parse('false');

console.log(trueResponse);
console.log(falseResponse);

Answer 44

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

Answer 45

如果您确定测试主题始终是字符串，那么最好检查它是否等于Screen2。

您可能需要考虑添加一些代码，以防主体实际上是布尔值。

true

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

Answer 46

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

Answer 47

这是一个简单的功能，可以解决这个问题，

   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

Answer 48

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

var trueValuesRange = ['1', 1, 'true', true];

myVarToTest = (trueValuesRange.indexOf(myVarToTest) >= 0);

Answer 49

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

var booleanVal = toCast > '';

除了bool false，数字0和空字符串（显然）之外，这在大多数情况下都会解析为true。您可以在事实之后轻松查找其他错误的字符串值，例如：

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

Answer 50

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

Answer 51

以下是我的1个班轮提交：我需要评估一个字符串和输出，如果＆＃39;是＆＃39;则为true，如果＆＃39; false＆＃39;则为false。还有一个数字，如果有＆＃39; -12.35673＆＃39;。

val = 'false';

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

Answer 52

我写了一个辅助函数来处理你的情况（还有一些）。随意根据您的特定需求进行更改

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

Answer 53

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

这是我刚刚掀起的事情：

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

Answer 54

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

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

Answer 55

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

Answer 56

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

Answer 57

我认为可以使用箭头功能在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

Answer 58

警告： 切勿将此方法用于不受信任的输入，例如URL参数。

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

eval()

Answer 59

使用`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'));

Answer 60

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

Answer 61

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

Answer 62

在HTML中，属性的值最终变为字符串。为了缓解这种情况，您可以使用函数有条件地将其解析为它们在JavaScript或其他任何感兴趣的编程语言中表示的值。

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

除此以外，JSON.parse还有一个revive parameter这是一个函数。也可以用来达到相同目的。

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

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

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

JSON.parse(aBooleanString);

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

因此，您需要知道如何称呼它，即它是否是布尔字符串。您可以通过编写一个函数来实现上面的 boolean string 检查并调用JSON.parse：

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

可以进一步推广isBooleanString实用程序，以通过进一步参数化接受可接受的 boolean < / em>字符串：

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

Answer 63

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

Answer 64

如果有一些其他代码将布尔值转换为字符串，则需要确切知道该代码如何存储true / false值。要么您或者您需要访问一个反转该转换的函数。

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

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

Answer 65

写一个更短的方法，可能是var isTrueSet = (myValue === "true") ? true : false;只假设＆＃34; true＆＃34;是真的，其他价值观都是假的。

Answer 66

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

function asBoolean(value) {

    return (''+value) === 'true'; 

}


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

Answer 67

当我从网址/表单或其他来源获取价值时，我正在使用这个。

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

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

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

Answer 68

某些浏览器实现中确实存在

Boolean.parse()。它绝对不是通用的，所以如果你需要的东西比你不应该使用这种方法。但是在Chrome中，例如（我正在使用v21）它可以正常运行，正如人们所期望的那样。

Answer 69

请注意，将来代码可能会更改并返回boolean而不是一个字符串。

解决方案是：

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

Answer 70

要像boolean一样评估类似布尔和布尔类的字符串，我使用了这个简单的公式：

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

很明显，对于true和'true'，它将返回true。其他一切都是假的。

Answer 71

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

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

当逻辑表达式从左到右进行评估时，它们会使用以下规则进行可能的“短路”评估测试：


false＆amp;＆amp; （任何）短路评估为假。

true || （任何）短路评估为真。

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

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

由于Array.prototype.indexOf()方法是第5版中 ECMA-262 标准的一部分，因此旧浏览器支持可能需要 polyfill 。< / p>

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

Answer 72

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

Answer 73

使用此库轻松一下。

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

Answer 74

`toBoolean'函数为null，undefined，''，'false'返回false。对于任何其他字符串，它返回true：

const toBoolean = (bool) => {
  if (bool === 'false') bool = false
  return !!bool
}

toBoolean('false') // returns false

Answer 75

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


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

将像 "true" 这样的字符串布尔值转换为实际的布尔值只是包装到 JSON.parse() 示例：JSON.parse("true")

Answer 76

ES6+

const string = "false"
const string2 = "true"

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

Answer 77

如果您确定输入的内容仅在 'true' 和 'false' 范围内为什么不：

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

Answer 78

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

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

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

Answer 79

以下就足够了

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

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

Answer 80

如果您需要从字符串值中获取布尔值false和true，则只需执行简单的一行操作即可：

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

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

Answer 81

您甚至不需要使用变量，如果您知道'true'始终是小写字母，则可以使用它返回true或false：

(eval(yourBooleanString == 'true'))

Answer 82

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字符串之一时才为true。其他一切都是假的。当然，您可能希望规范化输入字符串以使其小写并修剪任何空格。

Answer 83

将字符串转换为布尔值

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

将字符串转换为数字

{{1}}

Answer 84

我经常使用的最简单的方法是三元运算符：

let value = 'true';
let output = value === 'true' ? true : false;

Answer 85

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

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

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

首先返回false，然后返回true。

Answer 86

在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

Answer 87

您可以使用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"`

Answer 88

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

Boolean(<stringVariable>)

Answer 89

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

Answer 90

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

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

Answer 91

Boolean(Number(value));
var value = 1;  //true
var value = "1" //true
var value = 0;  //false
var value = "0" //false`

Answer 92

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

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

Answer 93

完美且非常简单：

var boolean = "false";
boolean = (boolean === "true");

//boolean = JSON.parse(boolean); //or this way..

测试它：

＆＃13;

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

＆＃13;

Answer 94

只做一个：

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

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

Answer 95

 var myBool = Boolean.parse("true");

或

var myBool = Boolean("true");

或

var myBool = !!"true";

不确定第一个是否特定于IE。

如何在JavaScript中将字符串转换为布尔值？

95 个答案:

执行：

不要：

警告

最简单的解决方案??

使用 ES6+

一个班轮

更为激进的版本

使用`if`语句：

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

ES6+

如何在JavaScript中将字符串转换为布尔值？

95 个答案:

执行：

不要：

警告

最简单的解决方案??

使用 ES6+

一个班轮

更为激进的版本

使用if语句：

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

ES6+

使用`if`语句：