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

如果你已经知道所有你需要解释的真实案例，那么就不必涵盖所有的虚假案例。您可以向该方法传递任何可以传递真值的值（或添加其他值，这很简单），其他所有值都将被视为假

const boolTrue=JSON.parse（“true”）const boolFalse=JSON.parse（“false”）console.log（boolTrue）//trueconsole.log（boolFalse）//false

要将字符串布尔值（如“true”）转换为实际布尔值，只需包装为JSON.parse（）示例：JSON.parse（“true”）

我有点晚了，但我有一个小片段要做，它本质上维护了所有JScripts truthey/falsey/dirty ness，但包含“false”作为false的可接受值。

与上述方法相比，我更喜欢这种方法，因为它不依赖第三方来解析代码（即：eval/JSON.parse），这在我看来是过度的，它足够短，不需要实用函数，并维护其他truthey/falsy约定。

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

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

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

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

有助于加快Javascript中代码执行的一个特性是短路评估：

当逻辑表达式从左到右求值时，使用以下规则对其进行可能的“短路”求值测试：false&（任何东西）短路评估为false。true||（任何东西）被短路评估为真。

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

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