Bisakah saya mengonversi string yang mewakili nilai boolean (misalnya, 'benar', 'salah') menjadi tipe intrinsik dalam JavaScript?

Saya memiliki formulir tersembunyi dalam HTML yang diperbarui berdasarkan pilihan pengguna dalam daftar. Formulir ini berisi beberapa bidang yang mewakili nilai boolean dan secara dinamis diisi dengan nilai boolean intrinsik. Namun, begitu nilai ini ditempatkan ke bidang input tersembunyi, ia menjadi string.

Satu-satunya cara saya dapat menemukan untuk menentukan nilai boolean bidang, setelah dikonversi menjadi string, adalah bergantung pada nilai literal dari representasi stringnya.

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

Apakah ada cara yang lebih baik untuk mencapai ini?

Melakukan:

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

Anda bisa membuatnya lebih ketat dengan menggunakan operator identitas ( ===), yang tidak membuat konversi tipe implisit ketika variabel yang dibandingkan memiliki tipe yang berbeda, alih-alih operator persamaan ( ==).

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

Jangan:

Anda mungkin harus berhati-hati dalam menggunakan kedua metode ini untuk kebutuhan spesifik Anda:

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

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

Setiap string yang bukan string kosong akan dievaluasi truedengan menggunakannya. Meskipun mereka adalah metode terbersih yang dapat saya pikirkan terkait konversi boolean, saya pikir mereka bukan yang Anda cari.

Peringatan

Jawaban warisan yang sangat mutakhir ini secara teknis benar tetapi hanya mencakup skenario yang sangat spesifik, ketika nilai string Anda TEPAT "true"atau "false".

String json yang tidak valid diteruskan ke fungsi-fungsi di bawah ini AKAN melemparkan pengecualian .

Jawaban asli:

Bagaimana tentang?

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

atau dengan 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);
    }
}

Saya pikir ini sangat universal:

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

Begini:

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

Ingat untuk mencocokkan case:

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

Selain itu, jika kotak centang elemen elemen, Anda juga dapat mendeteksi jika kotak centang dicentang:

var isTrueSet = document.myForm.IS_TRUE.checked;

Dengan asumsi bahwa jika dicentang, itu "diset" sama dengan true. Ini dievaluasi sebagai benar / salah.

Anda dapat menggunakan ekspresi reguler:

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

Jika Anda suka memperluas kelas String yang dapat Anda lakukan:

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

alert("true".bool());

Bagi mereka (lihat komentar) yang ingin memperluas objek String untuk mendapatkan ini tetapi khawatir tentang enumerability dan khawatir tentang bentrok dengan kode lain yang memperluas objek String:

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

(Tidak akan bekerja di browser yang lebih lama tentu saja dan Firefox menunjukkan false sementara Opera, Chrome, Safari dan IE menunjukkan true. Bug 720760 )

Wood-eye berhati-hatilah. Setelah melihat konsekuensi setelah menerapkan jawaban teratas dengan 500+ upvotes, saya merasa berkewajiban untuk memposting sesuatu yang sebenarnya berguna:

Mari kita mulai dengan cara terpendek, tetapi sangat ketat:

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

Dan akhiri dengan cara yang tepat dan lebih toleran:

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

Pengujian:

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

Saya pikir jawaban @Steven adalah yang terbaik, dan menangani lebih banyak kasus daripada jika nilai yang masuk hanya string. Saya ingin sedikit memperluas dan menawarkan yang berikut:

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

Tidak perlu menutup semua falsekasus jika Anda sudah tahu semua truekasus yang harus Anda pertanggungjawabkan. Anda dapat meneruskan apa pun ke dalam metode ini yang dapat memberikan truenilai (atau menambahkan yang lain, itu cukup mudah), dan segala hal lainnya akan dipertimbangkanfalse

Solusi universal dengan parse 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

PEMBARUAN (tanpa JSON):

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

Saya juga membuat biola untuk mengujinya http://jsfiddle.net/remunda/2GRhG/

Solusi Anda baik-baik saja.

Menggunakan ===hanya akan konyol dalam hal ini, karena bidang itu valueakan selalu menjadi String.

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

Ini kembali falseuntuk setiap nilai falsy dan trueuntuk setiap nilai truthy kecuali untuk 'false', 'f', 'no', 'n', dan '0'(case-sensitive).

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

Objek Boolean tidak memiliki metode 'parse'. Boolean('false')mengembalikan true, sehingga itu tidak akan berfungsi. !!'false'juga kembali true, sehingga itu tidak akan berfungsi juga.

Jika Anda ingin string 'true'mengembalikan boolean truedan string 'false'untuk mengembalikan boolean false, maka solusi paling sederhana adalah menggunakan eval(). eval('true')mengembalikan benar dan eval('false')mengembalikan salah. Ingatlah implikasi kinerja saat menggunakan eval()meskipun.

Ini telah diambil dari jawaban yang diterima, tetapi benar-benar memiliki titik yang sangat lemah, dan saya terkejut bagaimana hal itu mendapatkan jumlah upvote, masalah dengan itu bahwa Anda harus mempertimbangkan case dari string karena ini case-sensitive

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

Saya menggunakan yang berikut ini:

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

Fungsi ini melakukan pemaksaan Boolean seperti biasa dengan pengecualian string "false" (case-sensitive) dan "0".

Ada banyak jawaban dan sulit untuk memilihnya. Dalam kasus saya, saya memprioritaskan kinerja ketika memilih, jadi saya membuat jsPerf ini yang saya harap dapat memberikan sedikit cahaya di sini.

Ringkasan hasil (semakin tinggi semakin baik):

1. Pernyataan bersyarat : 2.826.922
2. Beralih kasus pada objek Bool : 2.825.469
3. Casting ke JSON : 1,867.774
4. !! konversi : 805.322
5. Prototipe String : 713.637

Mereka terkait dengan jawaban terkait di mana Anda dapat menemukan lebih banyak informasi (pro dan kontra) tentang masing-masing; khususnya di komentar.

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

Ekspresi yang Anda cari adalah sederhana

/^true$/i.test(myValue)

seperti dalam

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

Ini menguji myValueekspresi reguler, tidak peka huruf besar-kecil, dan tidak memodifikasi prototipe.

Contoh:

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

Untuk mengkonversi kedua string ("true", "false") dan boolean ke boolean

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

Di mana flagbisa

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

Sudah ada begitu banyak jawaban yang tersedia. Tetapi mengikuti dapat bermanfaat dalam beberapa skenario.

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

Ini bisa bermanfaat di mana satu contoh dengan nilai-nilai non-boolean.

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

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

kenapa kamu tidak mencoba yang seperti ini

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

Ini akan mengembalikan kesalahan ketika beberapa teks lain diberikan daripada benar atau salah terlepas dari kasusnya dan itu akan menangkap angka juga

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

Fungsi ini dapat menangani string serta Boolean benar / salah.

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

Demonstrasi di bawah ini:

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

Saya menggunakan yang ini

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"

Cara termudah (dengan anggapan string Anda 'benar' atau 'salah') adalah:

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

Selalu gunakan operator === daripada operator == untuk jenis konversi ini!

Seperti yang dikatakan @ Shadow2531, Anda tidak bisa langsung mengubahnya. Saya juga menyarankan agar Anda mempertimbangkan input string selain "benar" dan "salah" yang 'benar' dan 'palsu' jika kode Anda akan digunakan kembali / digunakan oleh orang lain. Inilah yang saya gunakan:

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

Anda perlu memisahkan (dalam pemikiran Anda) nilai dari pilihan Anda dan representasi dari nilai itu.

Pilih satu titik dalam logika JavaScript di mana mereka perlu bertransisi dari sentinel string ke tipe asli dan melakukan perbandingan di sana, lebih disukai jika hanya dilakukan sekali untuk setiap nilai yang perlu dikonversi. Ingatlah untuk membahas apa yang perlu terjadi jika string sentinel tidak diketahui oleh skrip (yaitu apakah Anda default ke true atau false?)

Dengan kata lain, ya, Anda harus bergantung pada nilai string. :-)

Menurut saya, pertanyaan ini bertujuan untuk memenuhi tiga tujuan:

• Mengembalikan nilai true / false untuk nilai-nilai true dan falsey, tetapi juga mengembalikan true / false untuk beberapa nilai string yang akan bernilai true atau falsey jika mereka adalah Boolean alih-alih string.
• Kedua, menyediakan antarmuka tangguh sehingga nilai-nilai selain yang ditentukan tidak akan gagal, melainkan mengembalikan nilai default
• Ketiga, lakukan semua ini dengan kode sesedikit mungkin.

Masalah dengan menggunakan JSON adalah gagal dengan menyebabkan kesalahan Javascript. Solusi ini tidak tangguh (meskipun memenuhi 1 dan 3):

JSON.parse("FALSE") // fails

Solusi ini tidak cukup ringkas:

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

Saya sedang bekerja untuk memecahkan masalah ini untuk Typecast.js . Dan solusi terbaik untuk ketiga tujuan ini adalah yang satu ini:

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

Ini berfungsi untuk banyak kasus, tidak gagal ketika nilai seperti {} dilewatkan, dan sangat ringkas. Juga mengembalikan false sebagai nilai default daripada undefined atau melempar Error, yang lebih berguna dalam pengembangan Javascript yang diketik secara longgar. Bravo ke jawaban lain yang menyarankan itu!

Saya sedikit terlambat, tapi saya punya sedikit cuplikan untuk melakukan ini, pada dasarnya mempertahankan semua JSrkrip truthey / falsey / kotor -ness tetapi termasuk"false" sebagai nilai yang dapat diterima untuk false.

Saya lebih suka metode ini daripada yang disebutkan karena tidak bergantung pada pihak ke-3 untuk menguraikan kode (yaitu: eval / JSON.parse), yang berlebihan dalam pikiran saya, cukup pendek untuk tidak memerlukan fungsi utilitas dan memelihara konvensi truthey / falsey lainnya.

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

solusi lain. 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
};

test case dijalankan dalam node

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

Dewa suci beberapa jawaban ini benar-benar liar. Saya suka JS dan sejumlah cara tak terbatas untuk menguliti bool.

Preferensi saya, yang saya kaget karena belum melihatnya, adalah:

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

Satu Liner

Kita hanya perlu menjelaskan string "false" karena string lain (termasuk "true") sudah ada true.

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

Uji

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

Versi yang lebih exaustive

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

Uji

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