我这样做，将处理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”它会（故意）抛出错误

布尔对象没有“parse”方法。布尔值（'false'）返回true，因此这不起作用。！！'false'也返回true，因此这也不起作用。

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

不过，在使用eval（）时，请记住性能和安全性的影响。

我很惊讶没有人建议我加入

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

您可以为true修改检查或包含更多条件（例如null、“”）。

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

似乎是一条更容易的路，到目前为止，这条路一直很稳定/容易。。。也许有人能找到打破这种局面的方法？

我一直使用的最简单的方法：

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

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

有助于加快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;
  };
}