Posso convertire una stringa che rappresenta un valore booleano (ad esempio, "vero", "falso") in un tipo intrinseco in JavaScript?

Ho un modulo nascosto in HTML che viene aggiornato in base alla selezione di un utente all'interno di un elenco. Questo modulo contiene alcuni campi che rappresentano valori booleani e sono dinamicamente popolati con un valore booleano intrinseco. Tuttavia, una volta inserito questo valore nel campo di input nascosto, diventa una stringa.

L'unico modo in cui sono riuscito a trovare il valore booleano del campo, una volta convertito in una stringa, era quello di dipendere dal valore letterale della sua rappresentazione in stringa.

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

C'è un modo migliore per raggiungere questo obiettivo?

Fare:

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

Potresti renderlo più rigoroso utilizzando l'operatore di identità ( ===), che non effettua conversioni di tipo implicite quando le variabili confrontate hanno tipi diversi, anziché l'operatore di uguaglianza ( ==).

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

Non:

Probabilmente dovresti essere cauto sull'uso di questi due metodi per le tue esigenze specifiche:

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

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

Qualsiasi stringa che non è la stringa vuota verrà valutata trueutilizzandola. Sebbene siano i metodi più puliti che posso pensare riguardo alla conversione booleana, penso che non siano quello che stai cercando.

avvertimento

Questa risposta legacy molto votata è tecnicamente corretta ma copre solo uno scenario molto specifico, quando il valore della stringa è ESATTAMENTE "true"o "false".

Una stringa json non valida passata a queste funzioni di seguito genererà un'eccezione .

Risposta originale:

Che ne dite di?

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

o con 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);
    }
}

Penso che questo sia molto universale:

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

Va:

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

Ricorda di abbinare il caso:

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

Inoltre, se è una casella di controllo di un elemento del modulo, puoi anche rilevare se la casella di controllo è selezionata:

var isTrueSet = document.myForm.IS_TRUE.checked;

Supponendo che se è selezionato, è "impostato" uguale a vero. Questo viene valutato come vero / falso.

Puoi usare espressioni regolari:

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

Se ti piace estendere la classe String puoi fare:

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

alert("true".bool());

Per quelli (vedi i commenti) che vorrebbero estendere l'oggetto String per ottenere questo, ma sono preoccupati per l'enumerabilità e sono preoccupati di scontrarsi con altro codice che estende l'oggetto String:

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

(Ovviamente non funziona nei browser più vecchi e Firefox mostra false mentre Opera, Chrome, Safari e IE mostrano true. Bug 720760 )

Wood-eye stai attento. Dopo aver visto le conseguenze dopo aver applicato la risposta migliore con oltre 500 voti, mi sento in dovere di pubblicare qualcosa che è effettivamente utile:

Cominciamo con il modo più breve, ma molto rigoroso:

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

E termina con un modo corretto e più tollerante:

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

test:

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

Ho pensato che la risposta di @Steven fosse la migliore e mi sono occupata di molti più casi che se il valore in entrata fosse solo una stringa. Volevo estenderlo un po 'e offrire quanto segue:

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

Non è necessario coprire tutti i falsecasi se si conoscono già tutti i truecasi di cui si dovrebbe tenere conto. Puoi passare qualsiasi cosa in questo metodo che potrebbe passare per un truevalore (o aggiungerne altri, è piuttosto semplice), e tutto il resto sarebbe consideratofalse

Soluzione universale con analisi 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

AGGIORNAMENTO (senza JSON):

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

Ho anche creato violino per testarlo http://jsfiddle.net/remunda/2GRhG/

La tua soluzione va bene

===In questo caso l' utilizzo sarebbe semplicemente sciocco, poiché il campo valuesarà sempre a String.

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

Ciò restituisce falseper ogni valore falsy e trueper ogni valore truthy eccezione 'false', 'f', 'no', 'n', e '0'(case-insensitive).

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

L'oggetto booleano non ha un metodo di "analisi". Boolean('false')ritorna vero, quindi non funzionerà. !!'false'ritorna anche true, quindi non funzionerà.

Se si desidera che la stringa 'true'restituisca il valore booleano truee che la stringa 'false'restituisca il valore booleano false, utilizzare la soluzione più semplice eval(). eval('true')restituisce true e eval('false')restituisce false. Tenere presente le implicazioni sulle prestazioni quando si utilizza eval()però.

Questo è stato preso dalla risposta accettata, ma in realtà ha un punto molto debole, e sono scioccato da come ha ottenuto quel conteggio di voti positivi, il problema con esso che devi considerare il caso della stringa perché è sensibile al maiuscolo / minuscolo

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

Io uso il seguente:

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

Questa funzione esegue la solita coercizione booleana ad eccezione delle stringhe "false" (senza distinzione tra maiuscole e minuscole) e "0".

Ci sono molte risposte ed è difficile sceglierne una. Nel mio caso, ho la priorità delle prestazioni quando scelgo , quindi creo questo jsPerf che spero possa far luce qui.

Breve risultato (più alto è il migliore):

1. Dichiarazione condizionale : 2.826.922
2. Cambia custodia sull'oggetto Bool : 2.825.469
3. Casting su JSON : 1.867.774
4. !! conversioni : 805.322
5. Prototipo di stringa : 713.637

Sono collegati alla relativa risposta in cui è possibile trovare ulteriori informazioni (pro e contro) su ciascuno; specialmente nei commenti.

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

L'espressione che stai cercando è semplicemente

/^true$/i.test(myValue)

come in

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

Ciò verifica myValueun'espressione regolare, senza distinzione tra maiuscole e minuscole e non modifica il prototipo.

Esempi:

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

Per convertire sia stringa ("vero", "falso") che booleano in booleano

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

Dove flagpuò essere

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

Ci sono già così tante risposte disponibili. Ma il seguito può essere utile in alcuni scenari.

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

Questo può essere utile laddove un esempio con valori non booleani.

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

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

perché non provi qualcosa del genere?

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

Restituirà un errore quando viene fornito un altro testo anziché vero o falso indipendentemente dal caso e acquisirà anche i numeri come

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

Questa funzione può gestire sia string / booleane true / false.

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

Dimostrazione di seguito:

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

Sto usando questo

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"

Giù le mani nel modo più semplice (supponendo che la stringa sia "vera" o "falsa") è:

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

Usa sempre l'operatore === invece dell'operatore == per questi tipi di conversioni!

Come ha detto @ Shadow2531, non puoi semplicemente convertirlo direttamente. Suggerirei anche di considerare input di stringa oltre a "true" e "false" che sono "verità" e "falsità" se il codice verrà riutilizzato / utilizzato da altri. Questo è quello che uso:

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

Devi separare (nel tuo pensiero) il valore delle tue selezioni e la rappresentazione di quel valore.

Scegli un punto nella logica JavaScript in cui devono passare dalle sentinelle di stringa al tipo nativo e fare un confronto lì, preferibilmente dove viene eseguito solo una volta per ogni valore che deve essere convertito. Ricorda di rispondere a ciò che deve accadere se la stringa sentinel non è quella che lo script conosce (ovvero, per impostazione predefinita, vero o falso?)

In altre parole, sì, è necessario dipendere dal valore della stringa. :-)

La mia opinione su questa domanda è che mira a soddisfare tre obiettivi:

• Restituisce vero / falso per i valori di verità e falsità, ma restituisce anche vero / falso per più valori di stringa che sarebbero veritieri o falsi se fossero booleani anziché stringhe.
• In secondo luogo, fornire un'interfaccia resiliente in modo che i valori diversi da quelli specificati non falliscano, ma piuttosto restituiscano un valore predefinito
• Terzo, fai tutto questo con il minor codice possibile.

Il problema con l'utilizzo di JSON è che non riesce causando un errore Javascript. Questa soluzione non è resistente (sebbene soddisfi 1 e 3):

JSON.parse("FALSE") // fails

Questa soluzione non è abbastanza concisa:

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

Sto lavorando per risolvere questo problema esatto per Typecast.js . E la migliore soluzione a tutti e tre gli obiettivi è questa:

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

Funziona in molti casi, non fallisce quando vengono passati valori come {} ed è molto conciso. Inoltre restituisce false come valore predefinito anziché non definito o genera un errore, il che è più utile nello sviluppo di Javascript non tipizzato. Bravo alle altre risposte che lo hanno suggerito!

Sono un po 'in ritardo, ma ho un piccolo frammento per farlo, essenzialmente mantiene tutti i jutScript truthey / falsey / sudici -ma ma include "false"come valore accettabile per falso.

Preferisco questo metodo a quelli menzionati perché non si basa su una terza parte per analizzare il codice (es: eval / JSON.parse), che è eccessivo nella mia mente, è abbastanza breve da non richiedere una funzione di utilità e mantiene altre convenzioni 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..

un'altra soluzione. 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
};

i casi di test vengono eseguiti nel nodo

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

Dio santo, alcune di queste risposte sono semplicemente selvagge. Adoro JS e il suo infinito numero di modi per scuoiare un bool.

La mia preferenza, che sono rimasto scioccato di non vedere già, è:

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

Una fodera

Dobbiamo solo tenere conto della stringa "false" poiché qualsiasi altra stringa (incluso "true") è già true.

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

Test

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

Una versione più esauriente

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