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"

Najprostszym sposobem (zakładając, że ciąg będzie „prawda” lub „fałsz”), jest:

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

Zawsze używaj operatora === zamiast operatora == dla tego typu konwersji!

Jak powiedział @ Shadow2531, nie można po prostu przekonwertować go bezpośrednio. Sugerowałbym również, abyś wziął pod uwagę ciąg znaków oprócz „prawda” i „fałsz”, które są „prawda” i „falsey”, jeśli twój kod będzie ponownie używany / używany przez innych. Oto, czego używam:

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

Musisz oddzielić (w swoim myśleniu) wartość swoich wyborów i reprezentację tej wartości.

Wybierz punkt w logice JavaScript, w którym muszą przejść z wartowników łańcuchowych na typ rodzimy i dokonać porównania tam, najlepiej tam, gdzie robi się to tylko raz dla każdej wartości, którą należy przekonwertować. Pamiętaj, aby zająć się tym, co musi się zdarzyć, jeśli wartownik nie jest tym, który zna skrypt (tj. Czy domyślnie przyjmujesz wartość true czy false?)

Innymi słowy, tak, musisz polegać na wartości łańcucha. :-)

Uważam, że ma ono na celu spełnienie trzech celów:

• Zwraca true / false dla wartości true i falsey, ale także zwraca true / false dla wielu wartości stringów, które byłyby true lub falsey, gdyby były booleanami zamiast stringów.
• Po drugie, zapewnij elastyczny interfejs, aby wartości inne niż określone nie zawiodły, a raczej zwróciły wartość domyślną
• Po trzecie, zrób to wszystko z możliwie najmniejszym kodem.

Problem z używaniem JSON polega na tym, że nie działa, powodując błąd JavaScript. To rozwiązanie nie jest elastyczne (choć spełnia wymagania 1 i 3):

JSON.parse("FALSE") // fails

To rozwiązanie nie jest wystarczająco zwięzłe:

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

Pracuję nad rozwiązaniem tego dokładnego problemu w przypadku pliku Typecast.js . A najlepszym rozwiązaniem dla wszystkich trzech celów jest ten:

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

Działa w wielu przypadkach, nie zawodzi, gdy przekazywane są wartości takie jak {} i jest bardzo zwięzły. Zwraca także wartość false jako wartość domyślną, a nie niezdefiniowaną lub zgłaszającą błąd, co jest bardziej przydatne w luźno napisanym języku JavaScript. Brawo dla innych odpowiedzi, które to sugerowały!

Jestem trochę późno, ale mam mały fragment, aby to zrobić, to zasadniczo zachowuje wszystkie JScripts truthey / falsey / brudny -ness ale zawiera "false"jako acceptible wartości dla fałszu.

Wolę tę metodę od tych wymienionych, ponieważ nie polega ona na analizie kodu przez inną firmę (np .: eval / JSON.parse), co jest moim zdaniem przesadą, jest wystarczająco krótkie, aby nie wymagać funkcji narzędzia i utrzymuje inne konwencje truthey / falsey.

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

inne rozwiązanie. 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
};

przypadki testowe działają w węźle

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

Boże, niektóre z tych odpowiedzi są po prostu dzikie. Uwielbiam JS i jego nieskończoną liczbę sposobów na skórkę bool.

Moje preferencje, których nie byłem zaskoczony, to:

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

Jedna wkładka

Musimy tylko uwzględnić „fałszywy” ciąg, ponieważ jakikolwiek inny ciąg (w tym „prawda”) już istnieje true.

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

Test

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

Bardziej wyczerpująca wersja

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