Czy mogę przekonwertować ciąg reprezentujący wartość logiczną (np. „Prawda”, „fałsz”) na typ wewnętrzny w JavaScript?

Mam ukryty formularz w HTML, który jest aktualizowany na podstawie wyboru użytkownika na liście. Ta forma zawiera niektóre pola, które reprezentują wartości logiczne i są dynamicznie wypełniane wewnętrzną wartością logiczną. Jednak po umieszczeniu tej wartości w ukrytym polu wejściowym staje się ciągiem.

Jedynym sposobem, w jaki mogłem znaleźć wartość logiczną pola, po przekształceniu w ciąg, było poleganie na dosłownej wartości jego reprezentacji.

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

Czy istnieje lepszy sposób na osiągnięcie tego?

Zrobić:

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

Można to zaostrzyć za pomocą operatora tożsamości ( ===), który nie dokonuje żadnych domyślnych konwersji typu, gdy porównywane zmienne mają różne typy, zamiast operatora równości ( ==).

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

Nie:

Prawdopodobnie powinieneś zachować ostrożność przy stosowaniu tych dwóch metod do swoich konkretnych potrzeb:

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

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

Każdy ciąg, który nie jest pustym ciągiem, oceni je trueprzy użyciu. Chociaż są to najczystsze metody, jakie mogę wymyślić w odniesieniu do konwersji boolowskiej, myślę, że nie są tym, czego szukasz.

Ostrzeżenie

Ta wysoce pozytywna, starsza odpowiedź jest technicznie poprawna, ale obejmuje tylko bardzo konkretny scenariusz, gdy wartość ciągu to DOKŁADNIE "true"lub "false".

Niepoprawny ciąg json przekazany do tych funkcji poniżej ZWRÓCI wyjątek .

Oryginalna odpowiedź:

Co powiesz na?

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

lub z 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);
    }
}

Myślę, że to jest bardzo uniwersalne:

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

To idzie:

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

Pamiętaj, aby dopasować wielkość liter:

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

Ponadto, jeśli jest to pole wyboru elementu formularza, możesz również wykryć, czy to pole wyboru jest zaznaczone:

var isTrueSet = document.myForm.IS_TRUE.checked;

Zakładając, że jeśli jest zaznaczone, to jest „ustawione” równe true. To ocenia się jako prawda / fałsz.

Możesz użyć wyrażeń regularnych:

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

Jeśli chcesz rozszerzyć klasę String, możesz:

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

alert("true".bool());

Dla tych (patrz komentarze), którzy chcieliby rozszerzyć obiekt String, aby uzyskać to, ale martwią się o możliwość wyliczenia i martwią się kolizją z innym kodem, który rozszerza obiekt String:

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

(Oczywiście nie działa w starszych przeglądarkach, a Firefox pokazuje false, podczas gdy Opera, Chrome, Safari i IE pokazują true. Bug 720760 )

Drewno-oko uważaj. Po zapoznaniu się z konsekwencjami po zastosowaniu najwyższej odpowiedzi z ponad 500 głosami pozytywnymi czuję się zobowiązany do opublikowania czegoś, co jest naprawdę przydatne:

Zacznijmy od najkrótszego, ale bardzo ścisłego sposobu:

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

I zakończ w odpowiedni, bardziej tolerancyjny sposób:

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

Testowanie:

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

Pomyślałem, że odpowiedź @Steven była najlepsza i zająłem się znacznie większą liczbą przypadków, niż gdyby przychodząca wartość była tylko łańcuchem. Chciałem go trochę rozszerzyć i zaoferować:

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

Nie falsemusisz uwzględniać wszystkich spraw, jeśli znasz już wszystkie truesprawy, które musisz uwzględnić. Możesz przekazać do tej metody wszystko, co może przekazać truewartość (lub dodać inne, to całkiem proste), a wszystko inne będzie brane pod uwagęfalse

Uniwersalne rozwiązanie z parsowaniem 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

AKTUALIZACJA (bez JSON):

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

Stworzyłem również skrzypce, aby to przetestować http://jsfiddle.net/remunda/2GRhG/

Twoje rozwiązanie jest w porządku.

Użycie ===byłoby po prostu głupie w tym przypadku, ponieważ pole valuezawsze będzie oznaczało String.

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

Spowoduje to powrót falsedo każdej wartości falsy i truedla każdej wartości truthy wyjątkiem 'false', 'f', 'no', 'n'oraz '0'(bez uwzględniania wielkości liter).

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

Obiekt boolowski nie ma metody „parsowania”. Boolean('false')zwraca true, więc to nie zadziała. !!'false'również zwraca true, więc to też nie zadziała.

Jeśli chcesz, aby ciąg 'true'zwracał wartość logiczną, truea ciąg 'false'zwracał wartość logiczną false, najprostszym rozwiązaniem jest użycie eval(). eval('true')zwraca true i eval('false')zwraca false. Pamiętaj jednak o wpływie na wydajność podczas korzystania eval().

Zostało to zaczerpnięte z przyjętej odpowiedzi, ale tak naprawdę ma bardzo słaby punkt i jestem zszokowany, skąd wzięła się ta liczba głosów pozytywnych, problem z tym, że musisz wziąć pod uwagę wielkość ciągu znaków, ponieważ rozróżnia się wielkość liter

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

Używam następujących:

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

Ta funkcja wykonuje zwykły logiczny przymus, z wyjątkiem ciągów „false” (bez rozróżniania wielkości liter) i „0”.

Istnieje wiele odpowiedzi i trudno jest wybrać jedną. W moim przypadku wybieram priorytet wydajności, więc tworzę ten plik jsPerf, który, mam nadzieję, może tu rzucić nieco światła.

Podsumowanie wyników (im wyższy, tym lepszy):

1. Oświadczenie warunkowe : 2 826 922
2. Włącz skrzynkę na obiekcie Bool : 2 825 469
3. Przesyłanie do JSON : 1 867 774
4. !! konwersje : 805,322
5. Prototyp sznurka: 713,637

Są one powiązane z odpowiednią odpowiedzią, w której można znaleźć więcej informacji (za i przeciw) na temat każdego z nich; szczególnie w komentarzach.

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

Po prostu szukasz wyrażenia

/^true$/i.test(myValue)

jak w

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

Testuje myValueto na wyrażenie regularne, bez rozróżniania wielkości liter i nie modyfikuje prototypu.

Przykłady:

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

Aby przekonwertować zarówno ciąg znaków („prawda”, „fałsz”), jak i wartość logiczną na wartość logiczną

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

Gdzie flagmoże być

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

Dostępnych jest już tak wiele odpowiedzi. Ale w niektórych sytuacjach przydatne mogą być następujące czynności.

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

Może to być przydatne, gdy jeden z przykładów nie zawiera wartości boolowskich.

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

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

dlaczego nie spróbujesz czegoś takiego

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

Zwróci błąd, gdy podany zostanie jakiś inny tekst, a nie prawda lub fałsz, bez względu na wielkość liter, a także przechwyci liczby jako

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

Ta funkcja może obsługiwać zarówno ciąg znaków, jak i logiczną wartość true / false.

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

Pokaz poniżej:

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

Używam tego

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"