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

Versuchen Sie diese Lösung (sie funktioniert hervorragend!):

function convertStrToBool(str)
    {
        switch(String(str).toLowerCase())
            {
                case 'undefined': case 'null': case 'nan': case 'false': case 'no': case 'f': case 'n': case '0': case 'off': case '':
                    return false;
                    break;
                default:
                    return true;
            };
    };

Answer 2

Der schnellste sichere Weg, eine Zeichenkette in einer Zeile Code in einen Booleschen Wert umzuwandeln

Eine der Funktionen, die helfen, die Codeausführung in Javascript zu beschleunigen, ist Kurzschluss-Auswertung :

Da logische Ausdrücke von links nach rechts ausgewertet werden, werden sie anhand der folgenden Regeln auf eine mögliche "Kurzschluss"-Auswertung geprüft:

• false && (irgendetwas) wird als Kurzschluss zu false ausgewertet.
• true || (irgendetwas) wird in einem Kurzschluss als true ausgewertet.

Wenn Sie also einen Zeichenkettenwert daraufhin testen wollen, ob er true de false en JSON.parse zu testen und die Leistung aufrechtzuerhalten, können Sie die || Operator, um den langsamen Code von der Ausführung auszuschließen, wenn der Testwert vom Typ Boolean ist.

test === true || ['true','yes','1'].indexOf(test.toString().toLowerCase()) > -1

Da die Array.prototype.indexOf() Methode ist ein Teil von ECMA-262 Standard in der 5. Auflage, benötigen Sie möglicherweise eine Polyfill für die Unterstützung der alten Browser.

// Production steps of ECMA-262, Edition 5, 15.4.4.14
// Reference: http://es5.github.io/#x15.4.4.14
if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(searchElement, fromIndex) {

    var k;

    // 1. Let O be the result of calling ToObject passing
    //    the this value as the argument.
    if (this == null) {
      throw new TypeError('"this" is null or not defined');
    }

    var O = Object(this);

    // 2. Let lenValue be the result of calling the Get
    //    internal method of O with the argument "length".
    // 3. Let len be ToUint32(lenValue).
    var len = O.length >>> 0;

    // 4. If len is 0, return -1.
    if (len === 0) {
      return -1;
    }

    // 5. If argument fromIndex was passed let n be
    //    ToInteger(fromIndex); else let n be 0.
    var n = +fromIndex || 0;

    if (Math.abs(n) === Infinity) {
      n = 0;
    }

    // 6. If n >= len, return -1.
    if (n >= len) {
      return -1;
    }

    // 7. If n >= 0, then Let k be n.
    // 8. Else, n<0, Let k be len - abs(n).
    //    If k is less than 0, then let k be 0.
    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

    // 9. Repeat, while k < len
    while (k < len) {
      // a. Let Pk be ToString(k).
      //   This is implicit for LHS operands of the in operator
      // b. Let kPresent be the result of calling the
      //    HasProperty internal method of O with argument Pk.
      //   This step can be combined with c
      // c. If kPresent is true, then
      //    i.  Let elementK be the result of calling the Get
      //        internal method of O with the argument ToString(k).
      //   ii.  Let same be the result of applying the
      //        Strict Equality Comparison Algorithm to
      //        searchElement and elementK.
      //  iii.  If same is true, return k.
      if (k in O && O[k] === searchElement) {
        return k;
      }
      k++;
    }
    return -1;
  };
}

Answer 3

Für TypeScript können wir die Funktion verwenden:

export function stringToBoolean(s: string, valueDefault: boolean = false): boolean {
    switch(s.toLowerCase())
    {
        case "true":
        case "1":
        case "on":
        case "yes":
        case "y":
            return true;

        case "false":
        case "0":
        case "off":
        case "no":
        case "n":
            return false;
    }

    return valueDefault;
}

Answer 4

Hier ist mein 1-Zeilen-Beitrag: Ich musste eine Zeichenkette auswerten und ausgeben, true, wenn 'true', false, wenn 'false' und eine Zahl, wenn etwas wie '-12.35673'.

val = 'false';

val = /^false$/i.test(val) ? false : ( /^true$/i.test(val) ? true : val*1 ? val*1 : val );

Answer 5

Einfache Lösung, die ich schon eine Weile benutze

function asBoolean(value) {

    return (''+value) === 'true'; 

}

// asBoolean(true) ==> true
// asBoolean(false) ==> false
// asBoolean('true') ==> true
// asBoolean('false') ==> false