Kann ich eine Zeichenfolge, die einen booleschen Wert darstellt (z. B. 'true', 'false'), in einen intrinsischen Typ in JavaScript konvertieren?

Ich habe ein verstecktes Formular in HTML, das basierend auf der Auswahl eines Benutzers in einer Liste aktualisiert wird. Dieses Formular enthält einige Felder, die boolesche Werte darstellen und dynamisch mit einem intrinsischen booleschen Wert gefüllt werden. Sobald dieser Wert jedoch in das ausgeblendete Eingabefeld eingefügt wird, wird er zu einer Zeichenfolge.

Die einzige Möglichkeit, den booleschen Wert des Felds zu ermitteln, nachdem es in eine Zeichenfolge konvertiert wurde, bestand darin, vom Literalwert seiner Zeichenfolgendarstellung abzuhängen.

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

Gibt es einen besseren Weg, dies zu erreichen?

Tun:

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

Sie können es strenger gestalten, indem Sie den Identitätsoperator ( ===) verwenden, der keine impliziten Typkonvertierungen durchführt, wenn die verglichenen Variablen unterschiedliche Typen haben, anstelle des Gleichheitsoperators ( ==).

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

Nicht:

Sie sollten wahrscheinlich vorsichtig sein, wenn Sie diese beiden Methoden für Ihre spezifischen Anforderungen verwenden:

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

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

Jede Zeichenfolge, die nicht die leere Zeichenfolge ist, truewird mithilfe dieser ausgewertet . Obwohl sie die saubersten Methoden sind, die ich mir für die boolesche Konvertierung vorstellen kann, sind sie meiner Meinung nach nicht das, wonach Sie suchen.

Warnung

Diese hoch bewertete Legacy-Antwort ist technisch korrekt, deckt jedoch nur ein ganz bestimmtes Szenario ab, wenn Ihr Zeichenfolgenwert GENAU "true"oder ist "false".

Eine ungültige JSON-Zeichenfolge, die an die folgenden Funktionen übergeben wird, löst eine Ausnahme aus .

Ursprüngliche Antwort:

Wie wäre es mit?

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

oder mit 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);
    }
}

Ich denke, das ist sehr universell:

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

Es geht:

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

Denken Sie daran, den Fall abzugleichen:

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

Wenn es sich um ein Kontrollkästchen für Formularelemente handelt, können Sie auch feststellen, ob das Kontrollkästchen aktiviert ist:

var isTrueSet = document.myForm.IS_TRUE.checked;

Angenommen, wenn es aktiviert ist, wird es gleich true "gesetzt". Dies wird als wahr / falsch bewertet.

Sie können reguläre Ausdrücke verwenden:

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

Wenn Sie die String-Klasse erweitern möchten, können Sie Folgendes tun:

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

alert("true".bool());

Für diejenigen (siehe Kommentare), die das String-Objekt erweitern möchten, um dies zu erhalten, sich jedoch Sorgen über die Aufzählbarkeit und über Konflikte mit anderem Code machen, der das String-Objekt erweitert:

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

(Funktioniert natürlich nicht in älteren Browsern und Firefox zeigt false an, während Opera, Chrome, Safari und IE true anzeigen . Bug 720760 )

Wood-Eye sei vorsichtig. Nachdem ich die Konsequenzen gesehen habe, nachdem ich die Top-Antwort mit mehr als 500 Upvotes angewendet habe, fühle ich mich verpflichtet, etwas zu posten, das tatsächlich nützlich ist:

Beginnen wir mit dem kürzesten, aber sehr strengen Weg:

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

Und beenden Sie mit einem angemessenen, toleranteren Weg:

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

Testen:

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

Ich dachte, dass @Stevens Antwort die beste war, und kümmerte mich um viel mehr Fälle, als wenn der eingehende Wert nur eine Zeichenfolge wäre. Ich wollte es etwas erweitern und Folgendes anbieten:

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

Es ist nicht erforderlich, alle falseFälle abzudecken, wenn Sie bereits alle trueFälle kennen, die Sie berücksichtigen müssten. Sie können alles an diese Methode übergeben, was für einen trueWert übergeben werden könnte (oder andere hinzufügen, es ist ziemlich einfach), und alles andere wird berücksichtigtfalse

Universelle Lösung mit JSON-Analyse:

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

UPDATE (ohne JSON):

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

Ich habe auch Geige erstellt, um es zu testen http://jsfiddle.net/remunda/2GRhG/

Ihre Lösung ist in Ordnung.

Die Verwendung ===wäre in diesem Fall einfach albern, da das Feld valueimmer ein Feld sein wird String.

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

Dies gibt falsefür jeden falsy Wert und truefür jeden truthy Wert mit Ausnahme 'false', 'f', 'no', 'n', und '0'(Groß- und Kleinschreibung).

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

Das Boolesche Objekt verfügt nicht über eine Analysemethode. Boolean('false')Gibt true zurück, sodass dies nicht funktioniert. !!'false'kehrt auch zurück true, so dass das auch nicht funktioniert.

Wenn Sie möchten, dass der String 'true'einen Booleschen Wert trueund der String 'false'einen Booleschen Wert zurückgibt false, ist die einfachste Lösung die Verwendung eval(). eval('true')gibt true und eval('false')false zurück. Beachten Sie jedoch die Auswirkungen auf die Leistung bei der Verwendung eval().

Dies wurde der akzeptierten Antwort entnommen, aber es hat wirklich einen sehr schwachen Punkt, und ich bin schockiert, wie es zu dieser Anzahl von Upvotes kam, das Problem damit, dass Sie den Fall der Zeichenfolge berücksichtigen müssen, da dies zwischen Groß- und Kleinschreibung unterscheidet

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

Ich benutze folgendes:

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

Diese Funktion führt den üblichen booleschen Zwang mit Ausnahme der Zeichenfolgen "false" (ohne Berücksichtigung der Groß- und Kleinschreibung) und "0" aus.

Es gibt viele Antworten und es ist schwer, eine auszuwählen. In meinem Fall priorisiere ich die Leistung bei der Auswahl, also erstelle ich diesen jsPerf , von dem ich hoffe, dass er hier etwas Licht ins Dunkel bringen kann.

Kurze Ergebnisse (je höher desto besser):

1. Bedingte Erklärung : 2.826.922
2. Fall auf Bool-Objekt schalten: 2.825.469
3. Casting zu JSON : 1.867.774
4. !! Conversions : 805.322
5. Prototyp des Strings: 713.637

Sie sind mit der entsprechenden Antwort verknüpft, in der Sie weitere Informationen (Vor- und Nachteile) zu jeder Antwort finden. speziell in den Kommentaren.

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

Der Ausdruck, den Sie suchen, ist einfach

/^true$/i.test(myValue)

wie in

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

Dies testet myValuegegen einen regulären Ausdruck, ohne Berücksichtigung der Groß- und Kleinschreibung, und ändert den Prototyp nicht.

Beispiele:

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

Um sowohl String ("true", "false") als auch Boolean in Boolean zu konvertieren

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

Wo flagkann sein

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

Es gibt bereits so viele Antworten. In einigen Szenarien kann das Folgende jedoch hilfreich sein.

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

Dies kann nützlich sein, wenn man Beispiele mit nicht-booleschen Werten verwendet.

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

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

Warum versuchst du nicht so etwas?

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

Es wird ein Fehler zurückgegeben, wenn unabhängig vom Fall ein anderer Text als wahr oder falsch angegeben wird, und es werden die Zahlen auch als erfasst

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

Diese Funktion kann sowohl Zeichenfolgen als auch Boolesche Werte für true / false verarbeiten.

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

Demonstration unten:

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

Ich benutze diesen

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"

Zweifellos ist der einfachste Weg (vorausgesetzt, Ihre Zeichenfolge ist "wahr" oder "falsch"):

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

Verwenden Sie für diese Art von Konvertierungen immer den Operator === anstelle des Operators ==!

Wie @ Shadow2531 sagte, können Sie es nicht einfach direkt konvertieren. Ich würde auch vorschlagen, dass Sie neben "true" und "false" auch String-Eingaben berücksichtigen, die "wahr" und "falsch" sind, wenn Ihr Code von anderen wiederverwendet / verwendet werden soll. Das benutze ich:

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

Sie müssen (in Ihrem Denken) den Wert Ihrer Auswahl und die Darstellung dieses Wertes trennen.

Wählen Sie in der JavaScript-Logik einen Punkt aus, an dem sie von String-Sentinels zu nativen Typen wechseln müssen, und führen Sie dort einen Vergleich durch, vorzugsweise dort, wo er für jeden zu konvertierenden Wert nur einmal ausgeführt wird. Denken Sie daran, zu klären, was passieren muss, wenn der String-Sentinel nicht dem Skript bekannt ist (dh verwenden Sie standardmäßig true oder false?).

Mit anderen Worten, ja, Sie müssen vom Wert der Zeichenfolge abhängen. :-)

Ich gehe von dieser Frage aus, dass drei Ziele erreicht werden sollen:

• Geben Sie true / false für wahrheitsgemäße und falsey-Werte zurück, aber auch true / false für mehrere Zeichenfolgenwerte, die wahrheitsgemäß oder falsch sind, wenn sie Boolesche Werte anstelle von Zeichenfolgen wären.
• Stellen Sie zweitens eine ausfallsichere Schnittstelle bereit, damit andere als die angegebenen Werte nicht fehlschlagen, sondern einen Standardwert zurückgeben
• Drittens tun Sie dies alles mit so wenig Code wie möglich.

Das Problem bei der Verwendung von JSON besteht darin, dass ein Javascript-Fehler auftritt. Diese Lösung ist nicht belastbar (obwohl sie 1 und 3 erfüllt):

JSON.parse("FALSE") // fails

Diese Lösung ist nicht präzise genug:

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

Ich arbeite daran, genau dieses Problem für Typecast.js zu lösen . Und die beste Lösung für alle drei Ziele ist diese:

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

Es funktioniert in vielen Fällen, schlägt nicht fehl, wenn Werte wie {} übergeben werden, und ist sehr präzise. Außerdem wird false als Standardwert zurückgegeben, anstatt undefiniert zu sein oder einen Fehler auszulösen, was bei der Entwicklung von lose typisiertem Javascript nützlicher ist. Bravo zu den anderen Antworten, die es vorgeschlagen haben!

Ich bin ein wenig spät, aber ich habe ein kleines Snippet , dies zu tun, es macht im Wesentlichen alle JScripts truthey / Falsey / verdreckt -ness sondern umfasst "false"als acceptible Wert für falsch.

Ich bevorzuge diese Methode gegenüber den genannten, da sie nicht von einem Drittanbieter zum Parsen des Codes (dh eval / JSON.parse) benötigt wird. Dies ist meiner Meinung nach übertrieben, sie ist kurz genug, um keine Dienstprogrammfunktion zu erfordern und zu warten andere Truthey / Falsey-Konventionen.

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

eine andere Lösung. 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
};

Testfälle werden im Knoten ausgeführt

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

Heiliger Gott, einige dieser Antworten sind einfach wild. Ich liebe JS und seine unendlichen Möglichkeiten, einen Bool zu häuten.

Meine Präferenz, die ich schockiert war, nicht schon zu sehen, ist:

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

Einzeiler

Wir müssen nur die "falsche" Zeichenfolge berücksichtigen, da jede andere Zeichenfolge (einschließlich "wahr") bereits vorhanden ist true.

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

Prüfung

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

Eine exaustivere Version

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

Prüfung

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