javascript - values - string to boolean angular 4




Como posso converter uma string em booleano em JavaScript? (20)

Posso converter uma string representando 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 dentro de 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 string.

A única maneira que eu poderia encontrar para determinar o valor booleano do campo, uma vez que fosse convertido em uma string, dependia do valor literal de sua representação de string.

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

Existe uma maneira melhor de conseguir isso?


Aviso

Essa resposta legada altamente validada é tecnicamente correta, mas abrange apenas um cenário muito específico, quando seu valor de string é EXATAMENTE "true" ou "false" (também deve ser minúsculo).

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

Resposta original:

E se?

JSON.parse("true");

ou com jQuery

$.parseJSON("true");

Faz:

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

Você poderia torná-lo mais estrito usando o operador de identidade ( === ), que não faz nenhuma conversão de tipo implícito 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 ser cauteloso sobre o uso desses dois métodos para suas necessidades específicas:

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

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

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


Abaixe o caminho mais fácil (supondo que você string seja '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 entradas de strings além de "true" e "false" que sejam "truthy" e "falsey" se seu código for reutilizado / usado por outros. Isso é 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;
  }
}

Estou usando este aqui

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"

Eu achava que a resposta do @Steven era a melhor, e cuidava de muito mais casos do que se o valor de entrada 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 todos os casos false se você já conhece todos os casos true que você deve contabilizar. Você pode passar qualquer coisa para este método que poderia passar por um valor true (ou adicionar outros, é bastante simples), e todo o resto seria considerado false


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 strings "false" (sem distinção entre maiúsculas e minúsculas) e "0".


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

Breve dos resultados (quanto maior, melhor):

  1. Declaração condicional : 2.826.922
  2. Caso de comutador no objeto Bool : 2,825,469
  3. Fundindo para JSON : 1.867.774
  4. !! conversões : 805.322
  5. Protótipo de String : 713.637

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


Já existem tantas 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 em um exemplo com valores não booleanos.

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

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

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 estiver marcado, é "set" igual a true. Isso avalia como verdadeiro / falso.


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

Se você quiser que a string 'true' retorne true booleano e que a string 'false' retorne booleano false , a solução mais simples é usar eval() . eval('true') retorna true e eval('false') retorna falso. Tenha em mente as implicações de desempenho ao usar eval() embora.


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

Vamos começar com o caminho mais curto, mas muito rigoroso:

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

E termine de maneira correta 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]));}

Solução universal com JSON parse:

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 violino para testá-lo http://jsfiddle.net/remunda/2GRhG/


Sua solução está bem.

Usando === seria apenas bobo neste caso, como o value do campo será sempre uma String .


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

Escolha um ponto na lógica JavaScript em que eles precisem fazer a transição de sentinelas de string para o tipo nativo e fazer uma comparação lá, preferencialmente onde isso seja feito apenas uma vez para cada valor que precisar ser convertido. Lembre-se de abordar o que precisa acontecer se a sentinela de string não for uma que o script saiba (ou seja, você usa como padrão true ou false?)

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


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

Eu escrevi uma função para combinar com o filter_var do PHP, que faz isso muito bem. Disponível em uma essência: https://gist.github.com/CMCDragonkai/7389368

/**
 * Parses mixed type values into booleans. This is the same function as filter_var in PHP using boolean validation
 * @param  {Mixed}        value 
 * @param  {Boolean}      nullOnFailure = false
 * @return {Boolean|Null}
 */
var parseBooleanStyle = function(value, nullOnFailure = false){
    switch(value){
        case true:
        case 'true':
        case 1:
        case '1':
        case 'on':
        case 'yes':
            value = true;
            break;
        case false:
        case 'false':
        case 0:
        case '0':
        case 'off':
        case 'no':
            value = false;
            break;
        default:
            if(nullOnFailure){
                value = null;
            }else{
                value = false;
            }
            break;
    }
    return value;
};

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
> 

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

Isso retorna false para cada valor false e true para todos os valores true 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());

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






javascript