Posso converter uma string que representa um valor booleano (por exemplo, 'true', 'false') em um tipo intrínseco em JavaScript?

Eu tenho um formulário oculto em HTML que é atualizado com base na seleção de um usuário em uma lista. Este formulário contém alguns campos que representam valores booleanos e são preenchidos dinamicamente com um valor booleano intrínseco. No entanto, quando esse valor é colocado no campo de entrada oculto, ele se torna uma sequência.

A única maneira que eu encontrei para determinar o valor booleano do campo, uma vez convertido em uma string, era depender do valor literal de sua representação em string.

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

Existe uma maneira melhor de conseguir isso?

Faz:

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

Você pode torná-lo mais rígido usando o operador de identidade ( ===), que não faz nenhuma conversão implícita de tipo quando as variáveis ​​comparadas têm tipos diferentes, em vez do operador de igualdade ( ==).

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

Não faça:

Você provavelmente deve ter cuidado ao usar esses dois métodos para suas necessidades específicas:

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

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

Qualquer string que não seja a vazia será avaliada trueusando-as. Embora sejam os métodos mais limpos que posso pensar em relação à conversão booleana, acho que não são o que você está procurando.

Atenção

Essa resposta herdada altamente votada é tecnicamente correta, mas cobre apenas um cenário muito específico, quando o valor da string é EXATAMENTE "true"ou"false" .

Uma string json inválida passada para essas funções abaixo lançará uma exceção .

Resposta original:

E se?

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

ou com 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);
    }
}

Eu acho que isso é muito universal:

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

Vai:

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

Lembre-se de combinar o caso:

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

Além disso, se for uma caixa de seleção de elemento de formulário, você também poderá detectar se a caixa de seleção está marcada:

var isTrueSet = document.myForm.IS_TRUE.checked;

Supondo que, se marcado, ele é "definido" igual a verdadeiro. Isso é avaliado como verdadeiro / falso.

Você pode usar expressões regulares:

/*
 * 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 você gosta de estender a classe String, pode fazer:

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

alert("true".bool());

Para aqueles (veja os comentários) que gostariam de estender o objeto String para obter isso, mas estão preocupados com a enumerabilidade e estão preocupados com o conflito com outro código que estende o objeto String:

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

(Não funciona em navegadores antigos, é claro, e o Firefox mostra falso, enquanto o Opera, Chrome, Safari e IE mostram verdadeiro. Bug 720760 )

Olho de madeira tenha cuidado. Depois de ver as consequências depois de aplicar a resposta principal com mais de 500 upvotes, sinto-me obrigado a postar algo que é realmente útil:

Vamos começar da maneira mais curta, mas muito rigorosa:

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

E termine com uma maneira adequada e mais tolerante:

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

Teste:

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

Eu pensei que a resposta de @Steven era a melhor e resolvi muito mais casos do que se o valor recebido fosse apenas uma string. Eu queria estender um pouco e oferecer o seguinte:

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

Não é necessário cobrir todo o false casos, se você já conhece todos os truecasos que precisaria considerar. Você pode passar qualquer coisa para esse método que possa passar por um truevalor (ou adicionar outros, é bem direto), e todo o resto seria consideradofalse

Solução universal com análise 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

ATUALIZAÇÃO (sem JSON):

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

Eu também criei o violino para testá-lo http://jsfiddle.net/remunda/2GRhG/

Sua solução está boa.

Usar ===seria tolo nesse caso, pois o campo valuesempre será umString .

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

Isso retorna falsepara cada valor Falsas e truepara cada valor truthy exceto para '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());

O objeto booleano não possui um método de 'análise'. Boolean('false')retorna true, para que não funcione. !!'false'também retorna true, para que não funcione também.

Se você deseja que a string 'true'retorne booleano truee a string 'false'retorne booleano false, a solução mais simples é usar eval(). eval('true')retorna verdadeiro e eval('false')retorna falso. Lembre-se das implicações de desempenho ao usá-lo eval().

Isso foi retirado da resposta aceita, mas na verdade tem um ponto muito fraco, e estou chocado com a quantidade de votos positivos, o problema com o qual você deve considerar o caso da string, porque isso diferencia maiúsculas de minúsculas

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

Eu uso o seguinte:

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

Essa função executa a coerção booleana usual, com exceção das seqüências de caracteres "false" (sem distinção entre maiúsculas e minúsculas) e "0".

Há muitas respostas e é difícil escolher uma. No meu caso, priorizo ​​o desempenho ao escolher, então crio esse jsPerf que espero que possa trazer alguma luz aqui.

Resumo dos resultados (quanto maior, melhor):

1. Declaração condicional : 2.826.922
2. Alternar maiúsculas e minúsculas no objeto Bool : 2.825.469
3. Transmitindo para JSON : 1.867.774
4. !! conversões : 805,322
5. Protótipo de sequência: 713,637

Eles estão vinculados à resposta relacionada, onde você pode encontrar mais informações (prós e contras) sobre cada um; especialmente nos comentários.

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

A expressão que você procura simplesmente é

/^true$/i.test(myValue)

como em

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

Isso testa myValue uma expressão regular, que não diferencia maiúsculas de minúsculas e não modifica o protótipo.

Exemplos:

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

Para converter string ("true", "false") e booleano em booleano

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

Onde flagpode estar

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

Já existem muitas respostas disponíveis. Mas seguir pode ser útil em alguns cenários.

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

Isso pode ser útil onde exemplos com valores não booleanos.

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

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

por que você não tenta algo assim

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

Ele retornará um erro quando algum outro texto for fornecido, em vez de verdadeiro ou falso, independentemente do caso, e capturará os números também como

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

Esta função pode lidar com strings e também com Boolean true / false.

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

Demonstração abaixo:

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

Eu estou usando esse

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"

De maneira geral, a maneira mais fácil (assumindo que sua string será 'true' ou 'false') é:

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

Sempre use o operador === em vez do operador == para esses tipos de conversões!

Como @ Shadow2531 disse, você não pode simplesmente convertê-lo diretamente. Eu também sugiro que você considere as entradas de string além de "true" e "false" que são 'verdade' e 'falsey' se o seu código for reutilizado / usado por outras pessoas. Isto é o que eu 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;
  }
}

Você precisa separar (em sua opinião) o valor de suas seleções e a representação desse valor.

Escolha um ponto na lógica JavaScript em que eles precisam fazer a transição dos sentinelas de seqüência de caracteres para o tipo nativo e faça uma comparação lá, preferencialmente onde isso é feito apenas uma vez para cada valor que precisa ser convertido. Lembre-se de abordar o que precisa acontecer se a string sentinel não for a que o script conhece (por exemplo, você usa true ou false?)

Em outras palavras, sim, você precisa depender do valor da string. :-)

Minha opinião sobre esta questão é que ela visa satisfazer três objetivos:

• Retorne true / false para valores truthy e falsey, mas também retorne true / false para vários valores de string que seriam truthy ou falsey se fossem booleanos em vez de strings.
• Segundo, forneça uma interface resiliente para que valores diferentes dos especificados não falhem, mas retorne um valor padrão
• Terceiro, faça tudo isso com o mínimo de código possível.

O problema com o uso de JSON é que ele falha ao causar um erro de Javascript. Esta solução não é resiliente (embora satisfaça 1 e 3):

JSON.parse("FALSE") // fails

Esta solução não é concisa o suficiente:

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

Estou trabalhando para resolver esse problema exato do Typecast.js . E a melhor solução para todos os três objetivos é esta:

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

Funciona para muitos casos, não falha quando valores como {} são passados ​​e é muito conciso. Além disso, ele retorna false como o valor padrão, em vez de indefinir ou lançar um erro, o que é mais útil no desenvolvimento de Javascript de baixa digitação. Bravo para as outras respostas que sugeriram!

Estou um pouco atrasado, mas tenho um pequeno trecho para fazer isso, ele essencialmente mantém todos os JScripts verdadeiros / falsos / imundos, mas inclui "false"como um valor aceitável para falso.

Prefiro esse método aos mencionados, porque não depende de terceiros para analisar o código (por exemplo: eval / JSON.parse), que é um exagero em minha mente, é curto o suficiente para não exigir uma função de utilitário e mantém outras convenções de 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..

outra solução. 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
};

casos de teste executados no nó

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

Santo Deus, algumas dessas respostas são simplesmente selvagens. Eu amo JS e seu número infinito de maneiras de criar um bool.

Minha preferência, que fiquei chocado ao não ver, é:

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

One Liner

Nós apenas precisamos considerar a string "false", já que qualquer outra string (incluindo "true") já é true.

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

Teste

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

Uma versão mais exaustiva

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

Teste

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