Wie kann ich in JavaScript eine Zeichenkette in einen Booleschen Wert umwandeln?

Question

Kann ich eine Zeichenkette, die einen booleschen Wert repräsentiert (z. B. 'true', 'false'), in einen intrinsischen Typ in JavaScript umwandeln?

Ich habe ein verstecktes Formular in HTML, das auf der Grundlage der Auswahl eines Benutzers in einer Liste aktualisiert wird. Dieses Formular enthält einige Felder, die boolesche Werte darstellen und dynamisch mit einem eigenen booleschen Wert befüllt werden. Sobald dieser Wert jedoch in das verborgene Eingabefeld eingegeben wird, wird er zu einem String.

Die einzige Möglichkeit, den booleschen Wert des Feldes nach der Konvertierung in eine Zeichenkette zu bestimmen, bestand darin, sich auf den literalen Wert der Zeichenkettendarstellung zu verlassen.

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

Gibt es eine bessere Möglichkeit, dies zu erreichen?

Answer 1

Ich habe festgestellt, dass die Verwendung von '1' und ein leerer Wert '' für boolesche Werte funktioniert weit mehr vorhersehbar als 'true' oder 'false' String-Werte ... speziell mit HTML-Formulare seit uninitialized/leere Werte in Dom-Elemente wird konsequent zu falsch, während auswerten jede Wert in ihnen wird als wahr ausgewertet.

Zum Beispiel:

<input type='button' onclick='this.value = tog(this.value);' />

<script type="text/javascript">

    function tog(off) {
        if(off) {
            alert('true, toggle to false');
            return '';
        } else {
            alert('false, toggle to true');
            return '1';
        }
    }   
</script>

Schien einfach ein einfacher Weg zu sein, bisher war es sehr konsistent/einfach... vielleicht kann jemand einen Weg finden, dies zu brechen?

Answer 2

Es wäre schön, wenn es eine Funktion für das String-Objekt gäbe, die dies für uns erledigt, aber wir können leicht unsere eigenen Prototypen hinzufügen, um das String-Objekt zu erweitern.

Fügen Sie diesen Code irgendwo in Ihrem Projekt ein, bevor Sie ihn verwenden.

String.prototype.toBoolean = function() {
   return String(this.valueOf()).toLowerCase() === true.toString();
};

Probieren Sie es so aus:

var myValue = "false"
console.log("Bool is " + myValue.toBoolean())
console.log("Bool is " + "False".toBoolean())
console.log("Bool is " + "FALSE".toBoolean())
console.log("Bool is " + "TRUE".toBoolean())
console.log("Bool is " + "true".toBoolean())
console.log("Bool is " + "True".toBoolean())

Das Ergebnis der ursprünglichen Frage wäre dann also folgendes:

var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue.toBoolean();

Answer 3

/// Convert something to boolean
function toBoolean( o ) {
    if ( null !== o ) {
        let t = typeof o;
        if ( "undefined" !== typeof o ) {
            if ( "string" !== t ) return !!o;
            o = o.toLowerCase().trim();
            return "true" === o || "1" === o;
        }
    }
    return false;
}

toBoolean(false) --> false
toBoolean(true) --> true
toBoolean("false") --> false
toBoolean("true") --> true
toBoolean("TRue") --> true
toBoolean("1") --> true
toBoolean("0") --> false
toBoolean(1) --> true
toBoolean(0) --> false
toBoolean(123.456) --> true
toBoolean(0.0) --> false
toBoolean("") --> false
toBoolean(null) --> false
toBoolean() --> false

Answer 4

Wenn es einen anderen Code gibt, der den booleschen Wert in eine Zeichenkette umwandelt, müssen Sie genau wissen, wie dieser Code wahre/falsche Werte speichert. Entweder das oder Sie müssen Zugriff auf eine Funktion haben, die diese Umwandlung umkehrt.

Es gibt unendlich viele Möglichkeiten, boolesche Werte in Zeichenketten darzustellen ("true", "Y", "1", usw.). Daher sollten Sie sich nicht auf einen universellen String-zu-Booleschen-Konverter wie Boolean(myValue) verlassen. Sie müssen eine Routine verwenden, die die ursprüngliche Umwandlung von Booleschen Werten in Zeichenketten rückgängig macht, was auch immer das ist.

Wenn Sie wissen, dass er wahre Boolesche Werte in "wahre" Zeichenketten umwandelt, ist Ihr Beispielcode in Ordnung. Allerdings sollten Sie === statt == verwenden, damit es keine automatische Typumwandlung gibt.

Answer 5

In nodejs durch Verwendung von node-boolify es ist möglich

Boolesche Konvertierungsergebnisse

Boolify(true); //true
Boolify('true'); //true
Boolify('TRUE'); //null
Boolify(1); //true
Boolify(2); //null
Boolify(false); //false
Boolify('false'); //false
Boolify('FALSE'); //null
Boolify(0); //false
Boolify(null); //null
Boolify(undefined); //null
Boolify(); //null
Boolify(''); //null