Boole değerini temsil eden bir dizeyi (örn., 'True', 'false') JavaScript'te gerçek bir türe dönüştürebilir miyim?

Bir liste içindeki kullanıcının seçimine göre güncellenen HTML gizli bir form var. Bu form, boole değerlerini temsil eden ve dinamik olarak gerçek bir boole değeriyle doldurulmuş bazı alanlar içerir. Ancak, bu değer gizli giriş alanına yerleştirildikten sonra bir dize olur.

Bir dizeye dönüştürüldüğünde, alanın boolean değerini belirlemenin tek yolu, dize temsilinin gerçek değerine bağlı olmaktı.

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

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

Yapmak:

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

===Karşılaştırılan değişkenler eşitlik operatörü ( ==) yerine farklı türlere sahip olduğunda örtük tür dönüşümü yapmayan kimlik operatörünü ( ) kullanarak bunu daha katı hale getirebilirsiniz .

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

Yapma:

Muhtemelen özel ihtiyaçlarınız için bu iki yöntemi kullanma konusunda dikkatli olmalısınız :

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

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

Boş dize olmayan herhangi bir dize truebunları kullanarak değerlendirilir . Boole dönüşümüyle ilgili aklınıza gelebilecek en temiz yöntemler olmasına rağmen, aradığınız şey olmadığını düşünüyorum.

Uyarı

Bu son derece yükseltilmiş eski yanıt teknik olarak doğrudur, ancak dize değeriniz TAM "true"veya olduğunda çok özel bir senaryoyu kapsar "false".

Bu işlevlerin altına geçersiz bir json dizesi İSTENECEK bir istisna atar .

Orijinal cevap:

Nasıl?

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

veya jQuery ile

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

Bunun çok evrensel olduğunu düşünüyorum:

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

Gider:

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

Davayı eşleştirmeyi unutmayın:

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

Ayrıca, bir form öğesi onay kutusuysa, onay kutusunun işaretli olup olmadığını da belirleyebilirsiniz:

var isTrueSet = document.myForm.IS_TRUE.checked;

İşaretlenirse, "true" değerine ayarlandığını varsayarsak. Bu doğru / yanlış olarak değerlendirilir.

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

    return regex.test(s);
}

String sınıfını genişletmeyi seviyorsanız şunları yapabilirsiniz:

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

alert("true".bool());

Bunu elde etmek için String nesnesini genişletmek isteyen ancak numaralandırılabilirlik konusunda endişelenen ve String nesnesini genişleten diğer kodlarla çakışma konusunda endişelenenler için (yorumlara bakın):

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 Opera, Chrome, Safari ve IE doğru görünürken Firefox yanlış gösterir. Hata 720760 )

Ahşap göze dikkat et. 500+ upvotes ile en iyi cevabı uyguladıktan sonra sonuçları gördükten sonra, gerçekten yararlı bir şey yayınlamak zorunda hissediyorum:

En kısa ama çok katı bir şekilde başlayalım:

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

Ve uygun, daha hoşgörülü bir yolla bitirin:

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

Test yapmak:

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'in cevabının en iyisi olduğunu düşündüm ve gelen değerin sadece bir dize olmasından çok daha fazla vakayı hallettim. Biraz uzatmak ve aşağıdakileri sunmak 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;
    }
}

Hesabınız olması gereken falsetüm truedavaları zaten biliyorsanız, tüm davaları kapsamak gerekli değildir . Bu yönteme, bir truedeğer için geçebilecek (veya başkalarını ekleyebileceğiniz, oldukça basit) herhangi bir şey iletebilirsiniz ve diğer her şey göz önünde bulundurulurfalse

JSON ayrıştırmasıyla 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,'');
}

Ayrıca test etmek için keman yarattım http://jsfiddle.net/remunda/2GRhG/

Çözümünüz iyi.

===Alanın valueher zaman bir olacağı için kullanmak bu durumda aptalca olacaktır String.

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

Bu döner falseher falsy değeri ve truehariç her truthy değeri için 'false', 'f', 'no', 'n', ve '0'(küçük harf duyarsız).

// 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 nesnesinin bir 'ayrıştırma' yöntemi yoktur. Boolean('false')true döndürür, böylece işe yaramaz. !!'false'Ayrıca geri döner true, böylece bu da çalışmaz.

Eğer dize istiyorsanız 'true'boolean dönmek trueve dize 'false'dönüş mantıksala falseardından basit çözüm kullanımı etmektir eval(). eval('true')true değerini ve eval('false')false değerini döndürür. eval()Gerçi kullanırken performans sonuçlarını unutmayın .

Bu kabul edilen cevaptan alınmıştır, ama gerçekten çok zayıf bir noktaya sahiptir ve bu kadar upvotes sayısını nasıl aldığına şok oldum, bununla ilgili dize durumunu dikkate almanız gereken sorun, bu büyük / küçük harfe duyarlıdır.

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

Aşağıdakileri kullanıyorum:

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

Bu işlev, "false" (büyük / küçük harf duyarsız) ve "0" dizeleri dışında, normal Boolean zorlamasını gerçekleştirir.

Bir sürü cevap var ve bir tane seçmek zor. Benim durumumda, ben seçim yaparken performans öncelik, bu yüzden bu jsPerf oluşturmak oluşturduğumu umuyorum.

Sonuçların özeti (ne kadar yüksekse o kadar iyidir):

1. Şartlı ifade : 2,826,922
2. Bool nesnesindeki anahtar kutusu : 2.825.469
3. JSON için Casting : 1,867,774
4. !! dönüşümler : 805.322
5. Dizi Prototipi : 713.637

Her biri hakkında daha fazla bilgi (artı ve eksiler) bulabileceğiniz ilgili cevaba bağlanırlar; özellikle yorumlarda.

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

Aradığınız ifade basitçe

/^true$/i.test(myValue)

de olduğu gibi

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

Bu myValue, büyük / küçük harfe duyarlı olmayan normal bir 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

Hem dizeyi ("true", "false") ve boole'yi boole'ye dönüştürmek için

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

Nerede flagolabilir

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

Zaten çok fazla cevap var. Ancak aşağıdaki senaryolarda takip etmek 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;
    });
}

Boolean olmayan değerlere sahip bir örnek olduğunda bu yararlı olabilir.

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

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

neden böyle bir şey denemiyorsun

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

Durumdan bağımsız olarak doğru veya yanlış yerine başka bir metin verildiğinde bir hata döndürür ve sayıları da

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

Bu işlev, string / Boolean true / false öğelerini işleyebilir.

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

Aşağıdaki gösteri:

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

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"

Eller aşağı en kolay şekilde (dize 'doğru' veya 'yanlış' olacağını varsayarak):

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

Bu tür dönüşümler için her zaman == operatörü yerine === operatörünü kullanın!

@ Shadow2531'in dediği gibi, onu doğrudan dönüştüremezsiniz. Ayrıca, kodunuz başkaları tarafından yeniden kullanılacak / kullanılacaksa, "doğru" ve "yanlış" olan "doğru" ve "yanlış" ın yanı sıra dize girişlerini de göz önünde bulundurmanızı öneririm. Ne kullanıyorum:

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

Seçimlerinizin değerini ve bu değerin temsilini ayırmanız gerekir.

JavaScript mantığında, dize sentinellerinden yerel türe geçmeleri gereken bir nokta seçin ve burada bir karşılaştırma yapın, tercihen dönüştürülmesi gereken her değer için sadece bir kez yapıldığı yer. Eğer sentinel dizginin betiğin bildiği bir şey değilse ne olması gerektiğini ele almayı unutmayın (örn. Varsayılanı doğru mu yoksa yanlış mı?)

Başka bir deyişle, evet, dizenin değerine bağlı olmanız gerekir. :-)

Bu soruyu benim üstlenmeme göre üç hedefi karşılamayı amaçlıyor:

• Doğruluk ve falsey değerleri için true / false döndürür, ancak dize yerine Boolean olsaydı doğruluk veya falsey olabilecek birden fazla dize değeri için true / false döndürür.
• İkinci olarak, belirtilenler dışındaki değerlerin başarısız olmaması yerine daha çok varsayılan bir değer döndürmesi için esnek bir arayüz sağlayın
• Üçüncü olarak, tüm bunları olabildiğince az kodla yapın.

JSON kullanımıyla ilgili sorun, bir Javascript hatasına neden olarak başarısız olmasıdır. Bu çözüm esnek değildir (1 ve 3'ü karşılasa da):

JSON.parse("FALSE") // fails

Bu çözüm yeterince kısa değil:

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

Typecast.js için tam olarak bu sorunu çözmeye çalışıyorum . Üç hedefe de en iyi çözüm şudur:

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

Birçok durumda çalışır, {} gibi değerler iletildiğinde başarısız olmaz ve çok özlüdür. Ayrıca, gevşek yazılan Javascript geliştirmede daha yararlı olan, tanımsız veya Hata atmak yerine varsayılan değer olarak false değerini döndürür. Bravo bunu öneren diğer cevaplara!

Biraz geç kaldım, ama bunu yapmak için küçük bir parçacığım var, aslında tüm JScripts truthey / falsey / filthy -ness'i korur, ancak "false"yanlış için kabul edilebilir bir değer içerir .

Bu yöntemi bahsedilenlere tercih ediyorum, çünkü kodumu ayrıştırmak için 3. bir tarafa güvenmiyor (yani: eval / JSON.parse), bence aşırıya kaçıyor, bir yardımcı program işlevi gerektirmeyecek kadar kısa ve diğer doğruluk / falsey sözleşmeleri.

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

başka bir çözüm. 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
};

düğümde çalışan test senaryoları

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

Kutsal tanrı bu cevapların bazıları sadece çılgınca. JS ve bir bool derisi için sonsuz sayıda yolu seviyorum.

Zaten görmemek için şok olduğum tercihim:

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

Bir Astar

Başka bir dize ("true" dahil) zaten olduğundan, yalnızca "false" dizesini hesaba katmamız gerekir true.

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

Ölçek

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

Daha exaustive bir versiyon

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

Ölçek

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