ฉันสามารถแปลงสตริงที่แสดงค่าบูลีน (เช่น 'true', 'false') เป็นประเภทที่แท้จริงใน JavaScript ได้หรือไม่

ฉันมีรูปแบบที่ซ่อนอยู่ใน HTML ที่มีการปรับปรุงตามการเลือกของผู้ใช้ภายในรายการ แบบฟอร์มนี้มีบางฟิลด์ที่เป็นตัวแทนของค่าบูลีนและมีประชากรแบบไดนามิกด้วยค่าบูลีนที่แท้จริง อย่างไรก็ตามเมื่อค่านี้ถูกวางลงในช่องใส่ที่ซ่อนอยู่มันจะกลายเป็นสตริง

วิธีเดียวที่ฉันสามารถค้นหาเพื่อกำหนดค่าบูลีนของฟิลด์เมื่อมันถูกแปลงเป็นสตริงจะขึ้นอยู่กับค่าตัวอักษรของการเป็นตัวแทนสตริง

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

มีวิธีที่ดีกว่าในการบรรลุเป้าหมายนี้หรือไม่?

ทำ:

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

คุณสามารถทำให้มันเข้มงวดขึ้นโดยใช้ตัวดำเนินการเอกลักษณ์ ( ===) ซึ่งไม่ได้ทำการแปลงประเภทโดยนัยเมื่อตัวแปรที่เปรียบเทียบมีประเภทต่าง ๆ แทนที่จะเป็นตัวดำเนินการความเท่าเทียมกัน ( ==)

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

ไม่ได้:

คุณควรระมัดระวังเกี่ยวกับการใช้สองวิธีนี้สำหรับความต้องการเฉพาะของคุณ:

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

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

สตริงใด ๆ ที่ไม่ใช่สตริงว่างจะประเมินค่าtrueโดยใช้สตริงเหล่านั้น แม้ว่าพวกเขาจะเป็นวิธีที่สะอาดที่สุดที่ฉันสามารถนึกถึงเกี่ยวกับการแปลงแบบบูลีน แต่ฉันคิดว่าพวกเขาไม่ใช่สิ่งที่คุณต้องการ

คำเตือน

คำตอบนี้มรดก upvoted สูงเป็นเทคนิคที่ถูกต้อง แต่เพียงครอบคลุมสถานการณ์ที่เฉพาะเจาะจงมากเมื่อค่าสตริงของคุณอยู่ตรงหรือ"true""false"

สตริง JSON ไม่ถูกต้องผ่านเข้าสู่ฟังก์ชั่นเหล่านี้ด้านล่างจะโยนข้อยกเว้น

คำตอบเดิม:

เกี่ยวกับ?

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

หรือกับ 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);
    }
}

ฉันคิดว่ามันเป็นสากลมาก:

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

มันจะไป:

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

จำไว้ว่าให้ตรงกับกรณี:

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

นอกจากนี้หากเป็นช่องทำเครื่องหมายองค์ประกอบแบบฟอร์มคุณสามารถตรวจสอบได้ว่ามีการทำเครื่องหมายที่ช่องทำเครื่องหมายหรือไม่:

var isTrueSet = document.myForm.IS_TRUE.checked;

สมมติว่าหากมีการตรวจสอบก็จะ "ตั้ง" เท่ากับจริง สิ่งนี้ประเมินว่าเป็นจริง / เท็จ

คุณสามารถใช้นิพจน์ทั่วไป:

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

(จะไม่ทำงานในเบราว์เซอร์รุ่นเก่ากว่าและ Firefox จะแสดงเท็จขณะที่ Opera, Chrome, Safari และ IE แสดงผลจริงข้อผิดพลาด 720760 )

ไม้ตาระวัง หลังจากเห็นผลที่ตามมาหลังจากใช้คำตอบสูงสุดกับ 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]));}

ฉันคิดว่าคำตอบของ @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

โซลูชันสากลที่มีการแยกวิเคราะห์ 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/

ทางออกของคุณดี

ใช้===เพียงแค่จะโง่ในกรณีนี้เป็นของสนามจะเป็นvalueString

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

ผลตอบแทนนี้falseสำหรับทุกๆค่า falsy และtrueสำหรับทุกๆค่า truthy ยกเว้น'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());

วัตถุบูลีนไม่มีวิธีการ 'แยกวิเคราะห์' Boolean('false')ผลตอบแทนจริงเพื่อที่จะไม่ทำงาน !!'false'ผลตอบแทนtrueก็จะได้ผลเช่นกัน

หากคุณต้องการสตริง'true'ที่จะกลับมาบูลtrueและสตริง'false'กลับบูลแล้วทางออกที่ง่ายที่สุดคือการใช้งานfalse ผลตอบแทนจริงและผลตอบแทนที่เป็นเท็จ โปรดทราบถึงความหมายของประสิทธิภาพเมื่อใช้แม้ว่าeval()eval('true')eval('false')eval()

สิ่งนี้ถูกนำมาจากคำตอบที่ยอมรับ แต่จริงๆแล้วมันมีจุดอ่อนมากและฉันก็ตกใจว่ามันมีจำนวน upvotes มากเท่าไหร่ปัญหาที่คุณต้องพิจารณาถึงกรณีของสตริงเพราะมันเป็นตัวพิมพ์เล็กหรือใหญ่

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

ฉันใช้สิ่งต่อไปนี้:

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

ฟังก์ชั่นนี้ดำเนินการบังคับบูลีนปกติด้วยข้อยกเว้นของสตริง "เท็จ" (กรณีตาย) และ "0"

มีคำตอบมากมายและเป็นการยากที่จะเลือก ในกรณีของฉันฉันจัดลำดับความสำคัญการแสดงเมื่อเลือกดังนั้นฉันจึงสร้างjsPerf นี้ที่ฉันหวังว่าจะสามารถเปิดไฟได้ที่นี่

สรุปผลลัพธ์ (ยิ่งสูงยิ่งดี):

1. คำสั่งแบบมีเงื่อนไข : 2,826,922
2. สลับตัวเรือนบนวัตถุบูล: 2,825,469
3. กำลังส่งไปยัง JSON : 1,867,774
4. !! การแปลง : 805,322
5. ต้นแบบของสายอักขระ : 713,637

พวกเขาเชื่อมโยงกับคำตอบที่เกี่ยวข้องที่คุณสามารถค้นหาข้อมูลเพิ่มเติม (ข้อดีและข้อเสีย) เกี่ยวกับแต่ละคน; โดยเฉพาะในความคิดเห็น

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

การแสดงออกที่คุณกำลังมองหาก็คือ

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

ในการแปลงทั้งสตริง ("จริง", "เท็จ") และบูลีนเป็นบูลีน

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

ไหนflagสามารถ

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

มีคำตอบมากมายอยู่แล้ว แต่การติดตามมีประโยชน์ในบางสถานการณ์

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

ทำไมคุณไม่ลองอะไรแบบนี้

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

มันจะกลับข้อผิดพลาดเมื่อข้อความอื่น ๆ ที่ได้รับมากกว่าจริงหรือเท็จโดยไม่คำนึงถึงกรณีและมันจะจับตัวเลขเช่นกัน

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

ฟังก์ชั่นนี้สามารถจัดการกับสตริงเช่นเดียวกับบูลีนจริง / เท็จ

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

การสาธิตด้านล่าง:

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

ฉันใช้อันนี้

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"

กำหนดวิธีที่ง่ายที่สุด (สมมติว่าสตริงของคุณจะเป็น 'จริง' หรือ 'เท็จ') คือ:

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

มักใช้ประกอบ === แทนของผู้ประกอบการ == สำหรับประเภทนี้ของการแปลง!

เช่น @ Shadow2531 กล่าวว่าคุณไม่สามารถแปลงเป็นโดยตรงได้ ฉันขอแนะนำให้คุณพิจารณาอินพุตสตริงนอกเหนือจาก "ความจริง" และ "เท็จ" ที่เป็น 'ความจริง' และ 'เท็จ' หากรหัสของคุณจะถูกนำไปใช้ซ้ำ / ใช้โดยผู้อื่น นี่คือสิ่งที่ฉันใช้:

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

คุณต้องแยกค่าของการเลือกของคุณและการแทนค่านั้น

เลือกจุดในตรรกะ JavaScript ที่พวกเขาต้องการเปลี่ยนจากสตริงรักษาการณ์ไปเป็นชนิดเนทีฟและทำการเปรียบเทียบที่นั่นโดยเฉพาะอย่างยิ่งที่จะทำเพียงครั้งเดียวสำหรับแต่ละค่าที่ต้องถูกแปลง โปรดจำไว้ว่าต้องจัดการสิ่งที่ต้องเกิดขึ้นหากสตริง Sentinel ไม่ใช่สคริปต์ที่รู้ (เช่นคุณกำหนดค่าเริ่มต้นเป็นจริงหรือเท็จ)

กล่าวอีกนัยหนึ่งใช่คุณต้องขึ้นอยู่กับค่าของสตริง :-)

คำถามของฉันเกี่ยวกับเรื่องนี้ก็คือมันมีจุดมุ่งหมายเพื่อให้บรรลุวัตถุประสงค์สามประการ:

• ส่งคืนค่า 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);

ใช้งานได้หลายกรณีไม่ล้มเหลวเมื่อค่าเช่น {} ผ่านไปและมีความรัดกุมมาก นอกจากนี้มันจะคืนค่าเท็จเป็นค่าเริ่มต้นแทนที่จะไม่ได้กำหนดหรือส่งข้อผิดพลาดซึ่งมีประโยชน์มากขึ้นในการพัฒนา Javascript แบบหลวม ๆ ไชโยกับคำตอบอื่น ๆ ที่แนะนำ!

ฉันมาสายนิดหน่อย แต่ฉันมีตัวอย่างเล็ก ๆ น้อย ๆ ที่จะทำสิ่งนี้มันเป็นสิ่งสำคัญที่จะรักษา JScripts factey / falsey / สกปรก -ทั้งหมด แต่รวมถึง"false"เป็นค่าที่ยอมรับได้สำหรับเท็จ

ฉันชอบวิธีนี้มากกว่าที่กล่าวไว้เพราะไม่ต้องพึ่งพาบุคคลที่สามในการวิเคราะห์รหัส (เช่น: eval / JSON.parse) ซึ่งเกินความคิดในใจของฉันมันสั้นพอที่จะไม่ต้องการฟังก์ชั่นยูทิลิตี้และรักษา อนุสัญญาความจริง / ความเท็จอื่น ๆ

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

ทางออกอื่น 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
> 

เทพเจ้าศักดิ์สิทธิ์บางคำตอบเหล่านี้เป็นเพียงป่า ฉันรัก JS และวิธีมากมายในการสกินบูล

การตั้งค่าของฉันซึ่งฉันตกใจที่ไม่เห็นแล้วคือ:

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

หนึ่งในสายการบิน

เราก็ต้องบัญชีสำหรับสตริง "false" ตั้งแต่สตริงอื่น ๆ (รวมทั้ง "ความจริง") 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