Tôi có thể chuyển đổi một chuỗi biểu thị một giá trị boolean (ví dụ: 'true', 'false') thành một loại nội tại trong JavaScript không?

Tôi có một biểu mẫu ẩn trong HTML được cập nhật dựa trên lựa chọn của người dùng trong danh sách. Biểu mẫu này chứa một số trường đại diện cho các giá trị boolean và được điền động với giá trị boolean nội tại. Tuy nhiên, một khi giá trị này được đặt vào trường đầu vào ẩn, nó sẽ trở thành một chuỗi.

Cách duy nhất tôi có thể tìm thấy để xác định giá trị boolean của trường, một khi nó được chuyển đổi thành một chuỗi, là phụ thuộc vào giá trị bằng chữ của biểu diễn chuỗi của nó.

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

Có cách nào tốt hơn để thực hiện điều này?

Làm:

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

Bạn có thể làm cho nó chặt chẽ hơn bằng cách sử dụng toán tử nhận dạng ( ===), không thực hiện bất kỳ chuyển đổi loại ngầm định nào khi các biến được so sánh có các loại khác nhau, thay vì toán tử đẳng thức ( ==).

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

Đừng:

Có lẽ bạn nên thận trọng khi sử dụng hai phương pháp này cho các nhu cầu cụ thể của mình:

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

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

Bất kỳ chuỗi nào không phải là chuỗi trống sẽ đánh giá truebằng cách sử dụng chúng. Mặc dù chúng là những phương pháp sạch nhất tôi có thể nghĩ đến liên quan đến chuyển đổi boolean, tôi nghĩ chúng không phải là thứ bạn đang tìm kiếm.

Cảnh báo

Câu trả lời kế thừa được đánh giá cao này là đúng về mặt kỹ thuật nhưng chỉ bao gồm một kịch bản rất cụ thể, khi giá trị chuỗi của bạn là CHÍNH XÁC "true"hoặc "false".

Một chuỗi json không hợp lệ được truyền vào các hàm này bên dưới SILL ném một ngoại lệ .

Câu trả lời gốc:

Làm thế nào về?

JSON.parse("True".toLowerCase());

hoặc với 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);
    }
}

Tôi nghĩ rằng điều này là phổ quát nhiều:

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

Nó đi:

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

Nhớ khớp trường hợp:

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

Ngoài ra, nếu đó là hộp kiểm phần tử biểu mẫu, bạn cũng có thể phát hiện nếu hộp kiểm được chọn:

var isTrueSet = document.myForm.IS_TRUE.checked;

Giả sử nếu nó được kiểm tra, nó được "đặt" bằng đúng. Điều này đánh giá là đúng / sai.

Bạn có thể sử dụng các biểu thức thông thường:

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

Nếu bạn muốn mở rộng lớp String, bạn có thể làm:

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

alert("true".bool());

Đối với những người (xem các bình luận) muốn mở rộng đối tượng Chuỗi để có được điều này nhưng lo lắng về tính vô số và lo lắng về việc xung đột với mã khác mở rộng đối tượng Chuỗi:

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

(Tất nhiên, không hoạt động trong các trình duyệt cũ hơn và Firefox hiển thị sai trong khi Opera, Chrome, Safari và IE hiển thị đúng. Bug 720760 )

Mắt gỗ hãy cẩn thận. Sau khi thấy hậu quả sau khi áp dụng câu trả lời hàng đầu với hơn 500 lượt upvote, tôi cảm thấy bắt buộc phải đăng một cái gì đó thực sự hữu ích:

Hãy bắt đầu với cách ngắn nhất nhưng rất nghiêm ngặt:

var str = "true";
var mybool = JSON.parse(str);

Và kết thúc bằng một cách đúng đắn, khoan dung hơn:

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

Kiểm tra:

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

Tôi nghĩ rằng câu trả lời của @Steven là câu trả lời hay nhất và quan tâm đến nhiều trường hợp hơn là nếu giá trị đến chỉ là một chuỗi. Tôi muốn mở rộng nó một chút và cung cấp như sau:

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

Không cần thiết phải bao gồm tất cả các falsetrường hợp nếu bạn đã biết tất cả các truetrường hợp bạn phải tính đến. Bạn có thể chuyển bất cứ thứ gì vào phương thức này có thể chuyển cho một truegiá trị (hoặc thêm các giá trị khác, nó khá đơn giản) và mọi thứ khác sẽ được xem xétfalse

Giải pháp phổ quát với phân tích cú pháp 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

CẬP NHẬT (không có JSON):

function getBool(val){ 
    var num = +val;
    return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}

Tôi cũng đã tạo fiddle để kiểm tra nó http://jsfiddle.net/remunda/2GRhG/

Giải pháp của bạn là tốt.

Sử dụng ===sẽ chỉ là ngớ ngẩn trong trường hợp này, vì trường valuesẽ luôn là một String.

var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) { 
    return !falsy.test(val) && !!val;
};

Đây lợi nhuận falsecho mỗi giá trị falsy và truecho mỗi giá trị truthy trừ 'false', 'f', 'no', 'n', và '0'(case-insensitive).

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

Đối tượng Boolean không có phương thức 'phân tích cú pháp'. Boolean('false')trả về đúng, do đó sẽ không hoạt động. !!'false'cũng trở lạitrue , do đó sẽ không làm việc.

Nếu bạn muốn chuỗi 'true'trả về boolean truevà chuỗi 'false'trả về boolean false, thì giải pháp đơn giản nhất là sử dụng eval(). eval('true')trả về true và eval('false')trả về false. Hãy ghi nhớ ý nghĩa hiệu suất khi sử dụng eval()mặc dù.

Điều này đã được lấy từ câu trả lời được chấp nhận, nhưng thực sự nó có một điểm rất yếu và tôi bị sốc khi nó có số lượng upvote như thế nào, vấn đề với nó là bạn phải xem xét trường hợp của chuỗi vì đây là trường hợp nhạy cảm

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

Tôi sử dụng như sau:

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

Hàm này thực hiện cưỡng chế Boolean thông thường ngoại trừ các chuỗi "false" (không phân biệt chữ hoa chữ thường) và "0".

Có rất nhiều câu trả lời và thật khó để chọn một câu trả lời. Trong trường hợp của tôi, tôi ưu tiên hiệu suất khi chọn, vì vậy tôi tạo jsPerf này mà tôi hy vọng có thể đưa ra ánh sáng ở đây.

Tóm tắt kết quả (càng cao càng tốt):

1. Tuyên bố có điều kiện : 2.826.922
2. Trường hợp chuyển đổi trên đối tượng Bool : 2,825,469
3. Truyền tới JSON : 1.867.774
4. !! chuyển đổi : 805.322
5. Nguyên mẫu của chuỗi : 713,637

Chúng được liên kết với câu trả lời liên quan nơi bạn có thể tìm thêm thông tin (ưu và nhược điểm) về mỗi câu hỏi; đặc biệt trong các ý kiến.

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

Biểu thức bạn đang tìm kiếm đơn giản là

/^true$/i.test(myValue)

như trong

var isTrueSet = /^true$/i.test(myValue);

Bài kiểm tra này myValue đối với một biểu thức chính quy, không phân biệt chữ hoa chữ thường và không sửa đổi nguyên mẫu.

Ví dụ:

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

Để chuyển đổi cả chuỗi ("true", "false") và boolean thành boolean

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

Nơi flagcó thể

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

Đã có rất nhiều câu trả lời có sẵn. Nhưng sau đây có thể hữu ích trong một số tình huống.

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

Điều này có thể hữu ích khi một ví dụ với các giá trị không phải là boolean.

getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true

tại sao bạn không thử một cái gì đó như thế này

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

Nó sẽ trả về lỗi khi một số văn bản khác được đưa ra thay vì đúng hoặc sai bất kể trường hợp nào và nó cũng sẽ nắm bắt các số như

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

Hàm này có thể xử lý chuỗi cũng như Boolean true / false.

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

Trình diễn dưới đây:

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

Tôi đang sử dụng cái này

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"

Cách dễ dàng nhất (giả sử chuỗi của bạn sẽ là 'true' hoặc 'false') là:

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

Luôn sử dụng toán tử === thay vì toán tử == cho các loại chuyển đổi này!

Giống như @ Shadow2531 đã nói, bạn không thể chuyển đổi trực tiếp. Tôi cũng đề nghị bạn xem xét các đầu vào chuỗi bên cạnh "true" và "false" là "true" và "falsey" nếu mã của bạn sẽ được người khác sử dụng / sử dụng lại. Đây là những gì tôi sử dụng:

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

Bạn cần tách riêng (theo suy nghĩ của bạn) giá trị của các lựa chọn của bạn và đại diện của giá trị đó.

Chọn một điểm trong logic JavaScript nơi chúng cần chuyển từ các chuỗi lệnh sang kiểu gốc và thực hiện so sánh ở đó, tốt nhất là nó chỉ được thực hiện một lần cho mỗi giá trị cần chuyển đổi. Hãy nhớ giải quyết những gì cần xảy ra nếu chuỗi sentinel không phải là một đoạn script biết (nghĩa là bạn mặc định là true hay false?)

Nói cách khác, có, bạn cần phụ thuộc vào giá trị của chuỗi. :-)

Tôi đưa ra câu hỏi này là nó nhằm mục đích thỏa mãn ba mục tiêu:

• Trả về true / false cho các giá trị trung thực và falsey, nhưng cũng trả về true / false cho nhiều giá trị chuỗi sẽ là true hoặc falsey nếu chúng là Booleans thay vì chuỗi.
• Thứ hai, cung cấp giao diện linh hoạt để các giá trị khác với các giá trị được chỉ định sẽ không bị lỗi mà thay vào đó trả về giá trị mặc định
• Thứ ba, làm tất cả điều này với càng ít mã càng tốt.

Vấn đề với việc sử dụng JSON là nó bị lỗi do gây ra lỗi Javascript. Giải pháp này không linh hoạt (mặc dù nó thỏa mãn 1 và 3):

JSON.parse("FALSE") // fails

Giải pháp này không đủ ngắn gọn:

if(value === "TRUE" || value === "yes" || ...) { return true; }

Tôi đang làm việc để giải quyết vấn đề chính xác này cho typecast.js . Và giải pháp tốt nhất cho cả ba mục tiêu là mục tiêu này:

return /^true$/i.test(v);

Nó hoạt động trong nhiều trường hợp, không thất bại khi các giá trị như {} được truyền vào và rất ngắn gọn. Ngoài ra, nó trả về false là giá trị mặc định thay vì không xác định hoặc ném Lỗi, hữu ích hơn trong phát triển Javascript được gõ lỏng lẻo. Bravo cho các câu trả lời khác mà đề nghị nó!

Tôi hơi muộn, nhưng tôi có một đoạn nhỏ để làm điều này, về cơ bản nó duy trì tất cả các bản mô tả sự thật / falsey / bẩn thỉu nhưng bao gồm "false"như một giá trị chấp nhận được cho sai.

Tôi thích phương thức này hơn các phương thức được đề cập bởi vì nó không dựa vào bên thứ 3 để phân tích mã (ví dụ: eval / JSON.parse), điều này quá mức trong tâm trí của tôi, nó đủ ngắn để không yêu cầu chức năng tiện ích và duy trì các quy ước chân lý / falsey khác.

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

giải pháp khác. 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
};

trường hợp thử nghiệm chạy trong nút

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

Thánh thần một số trong những câu trả lời chỉ là hoang dã. Tôi yêu JS và vô số cách để tạo ra một bool.

Sở thích của tôi, mà tôi đã bị sốc khi không thấy, là:

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

Lót

Chúng ta chỉ cần tính đến chuỗi "false" vì bất kỳ chuỗi nào khác (bao gồm cả "true") đã có sẵn true.

function b(v){ return v==="false" ? false : !!v; }

Kiểm tra

b(true)    //true
b('true')  //true
b(false)   //false
b('false') //false

Một phiên bản mạnh mẽ hơn

function bool(v){ return v==="false" || v==="null" || v==="NaN" || v==="undefined" || v==="0" ? false : !!v; }

Kiểm tra

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