JavaScript中字符串转布尔值的方法

技术背景

在JavaScript开发中，我们常常会遇到需要将字符串转换为布尔值的场景，例如处理表单提交的数据、解析配置文件等。然而，JavaScript并没有直接提供内置的字符串转布尔值的方法，因此需要开发者自己实现。

实现步骤

1. 使用严格相等运算符

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

使用严格相等运算符 ===，当比较的变量类型不同时，不会进行任何隐式类型转换。如果字符串是 "true"，则 isTrueSet 会被设置为布尔值 true；如果是字符串 "false" 或未设置，则为 false。

2. 忽略大小写的转换

var isTrueSet = /^true$/i.test(myValue);
// 或者
var isTrueSet = (myValue?.toLowerCase?.() === 'true');
// 或者
var isTrueSet = (String(myValue).toLowerCase() === 'true');

3. 使用JSON.parse方法

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

但要注意，传入无效的JSON字符串会抛出异常。

4. 自定义函数转换

function parseBool(str, strict) {
    if (str == null) {
        if (strict)
            throw new Error("Parameter 'str' is null or undefined.");
        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, '-');
    }
    if(!isNaN(str))
        return (parseFloat(str) != 0);
    return false;
}

5. 使用正则表达式

function strToBool(s) {
    regex=/^\s*(true|1|on)\s*$/i;
    return regex.test(s);
}

6. 扩展字符串原型

String.prototype.bool = function() {
    return strToBool(this);
};

7. 使用逻辑非运算符

const stringToBoolean = (string) => string === 'false' ? false : !!string;

核心代码

以下是一个综合的示例代码，包含了多种转换方法：

// 严格相等运算符
var myValue = 'true';
var isTrueSet = (myValue === 'true');
console.log(isTrueSet);

// 忽略大小写
var isTrueSetCaseInsensitive = /^true$/i.test(myValue);
console.log(isTrueSetCaseInsensitive);

// JSON.parse
try {
    var boolFromJSON = JSON.parse('true');
    console.log(boolFromJSON);
} catch (error) {
    console.error(error);
}

// 自定义函数
var array_1 = [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 = [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"];

function parseBool(str, strict) {
    if (str == null) {
        if (strict)
            throw new Error("Parameter 'str' is null or undefined.");
        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, '-');
    }
    if(!isNaN(str))
        return (parseFloat(str) != 0);
    return false;
}

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

// 正则表达式
function strToBool(s) {
    regex=/^\s*(true|1|on)\s*$/i;
    return regex.test(s);
}
console.log(strToBool("true"));

// 扩展字符串原型
String.prototype.bool = function() {
    return strToBool(this);
};
console.log("true".bool());

// 逻辑非运算符
const stringToBoolean = (string) => string === 'false' ? false : !!string;
console.log(stringToBoolean('true'));

最佳实践

• 性能优先：如果对性能要求较高，可以选择使用条件语句或 switch 语句，它们的性能相对较好。
• 兼容性：如果需要兼容旧版本浏览器，避免使用 Object.defineProperty 扩展字符串原型的方法。
• 安全性：避免使用 eval() 方法，因为它存在性能和安全问题。

常见问题

1. 使用 Boolean() 或 !! 转换字符串

var myBool = Boolean("false"); // 结果为 true
var myBool = !! "false"; // 结果为 true

任何非空字符串使用这两种方法都会被转换为 true，不符合我们将 "true" 和 "false" 字符串转换为布尔值的需求。

2. JSON.parse 传入无效字符串

try {
    var bool = JSON.parse('abc'); // 抛出异常
} catch (error) {
    console.error(error);
}

传入无效的JSON字符串会抛出异常，使用时需要进行异常处理。

3. 大小写问题

在比较字符串时，如果不考虑大小写，需要先将字符串转换为小写或使用正则表达式进行不区分大小写的匹配。