Hur kan jag konvertera en sträng till boolean i JavaScript?

Kan jag konvertera en sträng som representerar ett booleanvärde (t.ex. 'true', 'false') till en intrinsisk typ i JavaScript?

Jag har ett dolt formulär i HTML som uppdateras baserat på en användares val i en lista. Detta formulär innehåller några fält som representerar booleska värden och fylls dynamiskt med ett inneboende booleskt värde. Men när detta värde väl placeras i det dolda inmatningsfältet blir det en sträng.

Det enda sättet jag kunde hitta för att bestämma fältets booleska värde, när det hade konverterats till en sträng, var att förlita mig på det bokstavliga värdet av dess strängrepresentation.

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

Finns det ett bättre sätt att åstadkomma detta?

Svar #1

Gör :

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

Använd den strikta likhetsoperatören (===), som inte gör några implicita typomvandlingar när de jämförda variablerna har olika typer.

Detta kommer att sätta isTrueSet till ett boolean true om strängen är "true" och till ett boolean false om det är strängen "false" eller inte alls inställt.

För att göra det skiftlägesokänsligt, försök:

var isTrueSet = /^true$/i.test(myValue);
// or
var isTrueSet = (myValue?.toLowerCase?.() === 'true');
// or
var isTrueSet = (String(myValue).toLowerCase() === 'true');

Gör inte:

Du bör vara försiktig med att använda dessa två metoder för dina specifika behov.

var myBool = Boolean("false"); // evaluates to true
var myBool = !!"false"; // evaluates to true

Alla strängar som inte är den tomma strängen kommer att utvärderas till true genom att använda dem. Även om de är de renaste metoderna jag kan tänka på när det gäller boolean-konvertering, tror jag inte att de är vad du letar efter.

Svar #2

Varning

Detta mycket uppröstade gamla svar är tekniskt korrekt men täcker bara ett mycket specifikt scenario, när ditt strängvärde är EXAKT "true" eller "false".

En ogiltig json-sträng som skickas till dessa funktioner nedan KOMMER att utlösa ett undantag.

Originalt svar:

Hur är det?

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

eller med jQuery

$.parseJSON("TRUE".toLowerCase());

Svar #3

const stringToBoolean = (stringValue) => {
    switch(stringValue?.toLowerCase()?.trim()){
        case "true": 
        case "yes": 
        case "1": 
          return true;

        case "false": 
        case "no": 
        case "0": 
        case null: 
        case undefined:
          return false;

        default: 
          return JSON.parse(stringValue);
    }
}

Svar #4

Jag tror att detta är mycket mer universellt:

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

Det går:

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

Svar #5

Kom ihåg att matcha skiftläge:

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

Dessutom, om det är ett formulärelement-checkbox, kan du också upptäcka om checkboxen är markerad:

var isTrueSet = document.myForm.IS_TRUE.checked;

Förutsatt att om det är markerat, är det "inställt" på true. Detta utvärderas som sant/falskt.

Svar #6

Det här är det lättaste sättet att göra boolean-omvandling som jag stött på nyligen. Tänkte lägga till det.

JSON.parse('true');

let trueResponse = JSON.parse('true');

let falseResponse = JSON.parse('false');

console.log(trueResponse);
console.log(falseResponse);

Svar #7

Du kan använda reguljära uttryck:

/*
 * 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' regardless
    // of capitalization and regardless of surrounding white-space.
    //
    regex=/^\s*(true|1|on)\s*$/i

    return regex.test(s);
}

Om du gillar att utöka String-klassen kan du göra:

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

alert("true".bool());

För de som (se kommentarerna) skulle vilja utöka String-objektet för att få detta men är oroliga för enumererbarhet och är oroliga för kollisioner med annan kod som utökar String-objektet:

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

(Fungerar förstås inte i äldre webbläsare och Firefox visar false medan Opera, Chrome, Safari och IE visar true. Bug 720760)

Svar #8

Wood-eye var försiktig. Efter att ha sett konsekvenserna av att tillämpa det bästa svaret med över 500 upp-röster, känner jag mig tvungen att posta något som faktiskt är användbart:

Låt oss börja med det kortaste, men mycket strikta sättet:

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

Och avsluta med ett korrekt, mer tolerant sätt:

var parseBool = function(str, strict) 
{
    // console.log(typeof str);
    // strict: JSON.parse(str)
    
    if (str == null)
    {
        if (strict)
            throw new Error("Parameter 'str' is null or undefined.");

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

Testning :

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

Svar #9

Jag tyckte att @Stevens svar var det bästa, och det tog hand om många fler fall än om det inkommande värdet bara var en sträng. Jag ville utöka det lite och erbjuda följande:

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

Det är inte nödvändigt att täcka alla false-fall om du redan känner till alla true-fall som du måste ta hänsyn till. Du kan skicka in vad som helst i denna metod som skulle kunna passera som ett true-värde (eller lägga till andra, det är ganska enkelt), och allt annat skulle anses vara false

Svar #10

Universell lösning med JSON-tolkning:

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

UPPDATERA (utan JSON):

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

Jag skapade också en fiddle för att testa det http://jsfiddle.net/remunda/2GRhG/

Svar #11

Din lösning är bra.

Att använda === skulle bara vara dumt i det här fallet, eftersom fältets value alltid kommer att vara en String.

Svar #12

Boolean-objektet har ingen 'parse'-metod. Boolean('false') returnerar true, så det fungerar inte. !!'false' returnerar också true, så det fungerar inte heller.

Om du vill att strängen 'true' ska returnera boolean true och strängen 'false' ska returnera boolean false, så är den enklaste lösningen att använda eval(). eval('true') returnerar true och eval('false') returnerar false.

Tänk dock på prestanda- och säkerhetskonsekvenserna när du använder eval().

Svar #13

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

Detta returnerar false för varje falskt värde och true för varje sant värde utom för 'false', 'f', 'no', 'n' och '0' (skiftlägesokänsligt).

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

Svar #14

Det finns många svar och det är svårt att välja ett. I mitt fall prioriterar jag prestandan när jag väljer, så jag skapade detta jsPerf som jag hoppas kan kasta lite ljus här.

Sammanfattning av resultat (ju högre desto bättre):

Villkorssats: 2,826,922
Switch case på Bool-objekt: 2,825,469
Konvertering till JSON: 1,867,774
!! konverteringar: 805 322
Strängens prototyp: 713,637

De är kopplade till det relaterade svaret där du kan hitta mer information (för- och nackdelar) om varje, särskilt i kommentarerna.

Svar #15

Detta har tagits från det accepterade svaret, men egentligen har det en mycket svag punkt, och jag är chockad över hur det fick det antalet upp-röster, problemet med det är att du måste ta hänsyn till fallet på strängen eftersom detta är skiftlägeskänsligt

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

Svar #16

Jag använder följande:

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

Denna funktion utför den vanliga Booleanska tvångskonverteringen med undantag för strängarna "false" (skiftlägesokänsligt) och "0".

Svar #17

Enklaste lösningen 🙌🏽

med ES6+

använd logiska INTE två gånger [ !! ] för att få strängen konverterad

Bara klistra in detta uttryck...

const stringToBoolean = (string) => string === 'false' ? false : !!string

Och skicka din sträng till den!

stringToBoolean('')                 // false
stringToBoolean('false')            // false
stringToBoolean('true')             // true
stringToBoolean('hello my friend!') // true

const betterStringToBoolean = (string) => 
  string === 'false' || string === 'undefined' || string === 'null' || string === '0' ?
  false : !!string

Du kan inkludera andra strängar efter behov för att enkelt utöka användningen av detta uttryck...:

betterStringToBoolean('undefined')     // false
betterStringToBoolean('null')          // false
betterStringToBoolean('0')             // false
betterStringToBoolean('false')         // false
betterStringToBoolean('')              // false
betterStringToBoolean('true')          // true
betterStringToBoolean('anything else') // true

Svar #18

Uttrycket du letar efter är helt enkelt

/^true$/i.test(myValue)

som i

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

Detta testar myValue mot ett reguljärt uttryck, skiftlägesokänsligt, och ändrar inte prototypen.

Exempel:

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

Svar #19

du kan använda JSON.parse på följande sätt:

   
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if(result==true)
  alert('this is true');
else 
  alert('this is false');

i detta fall är .toLowerCase viktigt

Svar #20

Jag är förvånad över att includes inte föreslogs

let bool = "false"
bool = !["false", "0", 0].includes(bool)

Du kan ändra kontrollen för verkligen eller inkludera fler villkor (t.ex. null, '').

Svar #21

Det finns redan så många svar tillgängliga. Men följande kan vara användbart i vissa scenarier.

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

Detta kan vara användbart där man exempelvis använder icke-boolean värden.

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

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

Svar #22

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

Svar #23

För att konvertera både sträng ("true", "false") och boolean till boolean

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

Var flag kan vara

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

Svar #24

Denna funktion kan hantera strängar samt Boolean true/false.

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

Demonstration nedan:

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

Svar #25

En rad

Vi behöver bara ta hänsyn till strängen "false" eftersom alla andra strängar (inklusive "true") redan är true.

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

Test

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

En mer uttömmande version

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