JavaScript'te bir string'i boolean'a nasıl dönüştürebilirim?

JavaScript'te bir boolean değeri temsil eden bir dizeyi (örneğin, 'true', 'false') temel bir tipe dönüştürebilir miyim?

HTML'de, bir kullanıcının bir liste içindeki seçimine göre güncellenen gizli bir formum var. Bu form, bazı alanları boolean değerleri temsil eden ve doğal bir boolean değeriyle dinamik olarak doldurulan alanlar içerir. Ancak, bu değer gizli giriş alanına yerleştirildiğinde string haline gelir.

Alan bir dizeye dönüştürüldükten sonra, alanın boole değerini belirlemenin bulabildiğim tek yolu, dizge temsilinin literal değerine dayanmak oldu.

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

Bunu başarmanın daha iyi bir yolu var mı?

Cevap #1

Yap :

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

Farklı türdeki değişkenler karşılaştırıldığında herhangi bir örtük tür dönüşümü yapmayan katı eşitlik operatörü (===) kullanın.

Bu, eğer dize "true" ise isTrueSet'i boolean true olarak ve eğer dize "false" ise veya hiç ayarlanmamışsa boolean false olarak ayarlayacaktır.

Büyük/küçük harf duyarsız yapmak için, deneyin:

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

Yapma:

Özel ihtiyaçlarınız için bu iki yöntemi kullanırken dikkatli olmalısınız.

var myBool = Boolean("false"); // evaluates to true
var myBool = !!"false"; // evaluates to true

Boş olmayan herhangi bir dize, onları kullanarak true olarak değerlendirilecektir. Boolean dönüşümüyle ilgili olarak aklıma gelen en temiz yöntemler olsalar da, sanırım aradığınız şey bunlar değil.

Cevap #2

Uyarı

Bu oldukça oy almış eski cevap teknik olarak doğru, ancak yalnızca string değeriniz TAM OLARAK "true" veya "false" olduğunda çok özel bir senaryoyu kapsar.

Aşağıdaki bu fonksiyonlara geçersiz bir JSON dizgesi iletildiğinde istisna fırlatılacaktır.

Orijinal cevap:

Ne dersin?

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

veya jQuery ile

$.parseJSON("TRUE".toLowerCase());

Cevap #3

const stringToBoolean = (stringValue) => {
    switch(stringValue?.toLowerCase()?.trim()){
        case "true": 
        case "yes": 
        case "1": 
          return true;

        case "false": 
        case "no": 
        case "0": 
        case null: 
        case undefined:
          return false;

        default: 
          return JSON.parse(stringValue);
    }
}

Cevap #4

Bence bu çok daha evrensel:

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

Şöyle gider:

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

Cevap #5

Büyük/küçük harfe dikkat etmeyi unutma:

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

Ayrıca, eğer bir form öğesi olan onay kutusuysa, onay kutusunun işaretli olup olmadığını da tespit edebilirsiniz:

var isTrueSet = document.myForm.IS_TRUE.checked;

Kontrol edilirse, bunun true (doğru) olarak "ayarlanmış" olduğunu varsayarsak. Bu doğru/yanlış olarak değerlendirilir.

Cevap #6

Bu, yakın zamanda karşılaştığım boolean dönüşümü yapmanın en kolay yolu. Eklemeyi düşündüm.

JSON.parse('true');


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

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

console.log(trueResponse);
console.log(falseResponse);

Cevap #7

Düzenli ifadeleri kullanabilirsiniz:

/*
 * 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' regardless
    // of capitalization and regardless of surrounding white-space.
    //
    regex=/^\s*(true|1|on)\s*$/i

    return regex.test(s);
}

Eğer String sınıfını genişletmeyi seviyorsanız, şunu yapabilirsiniz:

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

alert("true".bool());

Bunu almak için String nesnesini genişletmek isteyen (yorumlara bakın) ama sıralanabilirlik konusunda endişelenen ve String nesnesini genişleten diğer kodlarla çakışma konusunda endişelenenler için:

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

(Elbette eski tarayıcılarda çalışmaz ve Firefox yanlış gösterirken Opera, Chrome, Safari ve IE doğru gösterir. Hata 720760)

Cevap #8

Wood-eye dikkatli ol. 500'den fazla oy almış en iyi cevabı uyguladıktan sonra sonuçları gördükten sonra, aslında faydalı bir şey paylaşma zorunluluğu hissediyorum:

En kısa ama çok katı olan yöntemle başlayalım:

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

Ve uygun, daha hoşgörülü bir şekilde sonlandırın:

var parseBool = function(str, strict) 
{
    // console.log(typeof str);
    // strict: JSON.parse(str)
    
    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, '-');
    }
    
    // var isNum = string.match(/^[0-9]+$/) != null;
    // var isNum = /^\d+$/.test(str);
    if(!isNaN(str))
        return (parseFloat(str) != 0);
        
    return false;
}

Test etme :

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

Cevap #9

@Steven'in cevabının en iyisi olduğunu düşündüm ve gelen değer sadece bir string olsaydı olduğundan çok daha fazla durumu ele aldı. Bunu biraz genişletmek ve şunları önermek istedim:

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

Tüm false durumlarını kapsamak gerekli değildir; eğer zaten hesaba katmanız gereken tüm true durumlarını biliyorsanız. Bu metoda, true bir değer olarak geçebilecek herhangi bir şeyi geçirebilirsiniz (veya başka değerler ekleyebilirsiniz, oldukça basittir), ve geri kalan her şey false olarak kabul edilir.

Cevap #10

JSON parse ile evrensel çözüm:

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

GÜNCELLEME (JSON olmadan):

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

Bunu test etmek için ayrıca bir fiddle da oluşturdum http://jsfiddle.net/remunda/2GRhG/

Cevap #11

Çözümün iyi.

Bu durumda === kullanmak sadece saçma olurdu, çünkü alanın value değeri her zaman bir String olacaktır.

Cevap #12

Boolean nesnesinin bir 'parse' yöntemi yoktur. Boolean('false') true döner, bu yüzden bu işe yaramaz. !!'false' de true döner, bu yüzden bu da işe yaramaz.

Eğer 'true' stringinin boolean true değerini ve 'false' stringinin boolean false değerini döndürmesini istiyorsanız, en basit çözüm eval() kullanmaktır. eval('true') true döndürür ve eval('false') false döndürür.

eval() kullanırken performans ve güvenlik etkilerini akılda bulundurun.

Cevap #13

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

Bu, 'false', 'f', 'no', 'n' ve '0' (büyük/küçük harf duyarsız) dışında, her yanlış değer için false ve her doğru değer için true döndürür.

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

Cevap #14

Cevap çok ve birini seçmek zor. Benim durumumda, seçim yaparken önceliğim performans, bu yüzden burada biraz ışık tutabileceğini umduğum bu jsPerf'i oluşturdum.

Sonuç özeti (ne kadar yüksek olursa o kadar iyi):

  1. Koşullu ifade: 2.826.922
  2. Bool nesnesinde switch case: 2.825.469
  3. JSON'a Dönüştürme: 1.867.774
  4. !! dönüşümler: 805.322
  5. String Prototipi: 713,637

Her birine dair daha fazla bilgiyi (artıları ve eksileri) bulabileceğiniz ilgili yanıta bağlıdırlar; özellikle yorumlarda.

Cevap #15

Bu kabul edilmiş cevaptan alınmıştır, ama gerçekten çok zayıf bir noktası var ve aldığı oy sayısına çok şaşırdım, sorunu şu ki, bunun duruma duyarlı olması nedeniyle string'in durumunu dikkate almanız gerekiyor

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

Cevap #16

Aşağıdakileri kullanırım:

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

Bu fonksiyon, "false" (büyük/küçük harf duyarsız) ve "0" stringleri dışında olağan Boolean dönüşümünü gerçekleştirir.

Cevap #17

En basit çözüm 🙌🏽

ES6+ ile

mantıksal NOT'u iki kez [ !! ] kullanarak string'e dönüştürmeyi sağlayın

Sadece bu ifadeyi yapıştır...

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

Ve onu kendi dizgenle geç!

stringToBoolean('')                 // false
stringToBoolean('false')            // false
stringToBoolean('true')             // true
stringToBoolean('hello my friend!') // true

const betterStringToBoolean = (string) => 
  string === 'false' || string === 'undefined' || string === 'null' || string === '0' ?
  false : !!string

Bu ifadeyi kolayca genişletmek için istediğiniz diğer dizeleri dahil edebilirsiniz...:

betterStringToBoolean('undefined')     // false
betterStringToBoolean('null')          // false
betterStringToBoolean('0')             // false
betterStringToBoolean('false')         // false
betterStringToBoolean('')              // false
betterStringToBoolean('true')          // true
betterStringToBoolean('anything else') // true

Cevap #18

Aradığınız ifade basitçe şudur

/^true$/i.test(myValue)

olarak

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

Bu, myValue'yi büyük/küçük harfe duyarsız bir şekilde bir düzenli ifadeye karşı test eder ve prototipi değiştirmez.

Örnekler:

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

Cevap #19

JSON.parse öğesini aşağıdaki gibi kullanabilirsiniz:

   
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if(result==true)
  alert('this is true');
else 
  alert('this is false');

bu durumda .toLowerCase önemlidir

Cevap #20

includes'in önerilmemiş olmasına şaşırdım

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

Gerçekten için kontrolü değiştirebilir veya daha fazla koşul ekleyebilirsiniz (ör. null, '').

Cevap #21

Zaten çok fazla cevap mevcut. Ancak aşağıdakiler bazı durumlarda faydalı olabilir.

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

Bu, birinin boolean olmayan değerlerle örnekler verdiği durumlarda faydalı olabilir.

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

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

Cevap #22

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

Cevap #23

Hem string ("true", "false") hem de boolean'ı boolean'a dönüştürmek için

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

flag nerede olabilir

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

Cevap #24

Bu fonksiyon, string ile Boolean true/false değerini de işleyebilir.

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

Aşağıdaki gösterim:

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

Cevap #25

Tek Satır

Sadece “false” dizesini dikkate almamız gerekiyor çünkü diğer tüm dizeler ("true" dahil) zaten true.

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

Test

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

Daha kapsamlı bir versiyon

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

Test

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

Cevap #26

Bunu kullanıyorum

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"

Cevap #27

Neden bunun gibi bir şey denemiyorsun

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

Gerçek veya yanlış dışında başka bir metin verildiğinde, büyük küçük harf fark etmeksizin bir hata döndürecek ve sayıları da yakalayacaktır

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

İlgili makaleler