¿Puedo convertir una cadena que representa un valor booleano (por ejemplo, 'verdadero', 'falso') en un tipo intrínseco en JavaScript?

Tengo un formulario oculto en HTML que se actualiza según la selección de un usuario dentro de una lista. Este formulario contiene algunos campos que representan valores booleanos y se completan dinámicamente con un valor booleano intrínseco. Sin embargo, una vez que este valor se coloca en el campo de entrada oculto, se convierte en una cadena.

La única forma que pude encontrar para determinar el valor booleano del campo, una vez que se convirtió en una cadena, era depender del valor literal de su representación de cadena.

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

¿Hay una mejor manera de lograr esto?

Hacer:

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

Podría hacerlo más estricto utilizando el operador de identidad ( ===), que no realiza conversiones de tipo implícitas cuando las variables comparadas tienen tipos diferentes, en lugar del operador de igualdad ( ==).

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

No:

Probablemente debería tener cuidado al usar estos dos métodos para sus necesidades específicas:

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

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

Cualquier cadena que no sea la cadena vacía se evaluará al trueusarlas. Aunque son los métodos más limpios que se me ocurren en relación con la conversión booleana, creo que no son lo que estás buscando.

Advertencia

Esta respuesta heredada altamente votada es técnicamente correcta pero solo cubre un escenario muy específico, cuando su valor de cadena es EXACTAMENTE "true"o "false".

Una cadena json inválida pasada a estas funciones a continuación lanzará una excepción .

Respuesta original:

¿Qué tal si?

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

Creo que esto es mucho universal:

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

Recuerde hacer coincidir mayúsculas y minúsculas:

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

Además, si se trata de una casilla de verificación de elemento de formulario, también puede detectar si la casilla de verificación está marcada:

var isTrueSet = document.myForm.IS_TRUE.checked;

Suponiendo que si está marcada, se "establece" igual a verdadero. Esto se evalúa como verdadero / falso.

Puedes usar expresiones 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);
}

Si te gusta extender la clase String puedes hacer:

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

alert("true".bool());

Para aquellos (ver los comentarios) que deseen extender el objeto String para obtener esto, pero están preocupados por la enumeración y están preocupados por chocar con otro código que extiende el objeto String:

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

(No funcionará en navegadores antiguos, por supuesto, y Firefox muestra falso, mientras que Opera, Chrome, Safari e IE muestran verdadero. Error 720760 )

Ojo de madera ten cuidado. Después de ver las consecuencias después de aplicar la respuesta principal con más de 500 votos a favor, me siento obligado a publicar algo que sea realmente útil:

Comencemos con la forma más corta pero muy estricta:

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

Y termine con una forma adecuada y más 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;
}

Pruebas:

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

Pensé que la respuesta de @Steven era la mejor, y me ocupé de muchos más casos que si el valor entrante fuera solo una cadena. Quería extenderlo un poco y ofrecer lo siguiente:

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

No es necesario cubrir todos los falsecasos si ya conoce todos los truecasos que tendría que tener en cuenta. Puede pasar cualquier cosa a este método que pueda pasar por un truevalor (o agregar otros, es bastante sencillo), y todo lo demás se consideraríafalse

Solución universal con análisis 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

ACTUALIZACIÓN (sin JSON):

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

También creé el violín para probarlo http://jsfiddle.net/remunda/2GRhG/

Tu solución está bien.

Usar ===sería simplemente una tontería en este caso, ya que el campo valuesiempre será a String.

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

Esto devuelve falsepara cada valor Falsy y truepara cada valor Truthy a excepción de 'false', 'f', 'no', 'n', y '0'(mayúsculas y minúsculas).

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

El objeto booleano no tiene un método de 'análisis'. Boolean('false')devuelve verdadero, por lo que eso no funcionará. !!'false'también regresa true, así que eso no funcionará también.

Si desea que string 'true'devuelva boolean truey string 'false'que devuelva boolean false, entonces la solución más simple es usar eval(). eval('true')devuelve verdadero y eval('false')devuelve falso. Sin eval()embargo, tenga en cuenta las implicaciones de rendimiento al usar .

Esto se ha tomado de la respuesta aceptada, pero en realidad tiene un punto muy débil, y estoy sorprendido de cómo obtuvo esa cantidad de votos positivos, el problema es que debes considerar el caso de la cadena porque distingue entre mayúsculas y minúsculas.

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

Yo uso lo siguiente:

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

Esta función realiza la coerción booleana habitual, con la excepción de las cadenas "false" (sin distinción entre mayúsculas y minúsculas) y "0".

Hay muchas respuestas y es difícil elegir una. En mi caso, priorizo el rendimiento al elegir, así que creo este jsPerf que espero pueda arrojar algo de luz aquí.

Resumen de resultados (cuanto más alto, mejor):

1. Declaración condicional : 2.826.922
2. Cambie el caso en el objeto Bool : 2,825,469
3. Casting a JSON : 1,867,774
4. !! conversiones : 805,322
5. Prototipo de cuerda : 713,637

Están vinculados a la respuesta relacionada donde puede encontrar más información (pros y contras) sobre cada uno; especialmente en los comentarios.

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

La expresión que estás buscando simplemente es

/^true$/i.test(myValue)

como en

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

Esto prueba myValuecontra una expresión regular, no distingue entre mayúsculas y minúsculas, y no modifica el prototipo.

Ejemplos:

/^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 convertir cadenas ("verdadero", "falso") y booleano a booleano

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

Donde flagpuede ser

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

Ya hay tantas respuestas disponibles. Pero seguir puede ser útil en algunos escenarios.

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

Esto puede ser útil cuando hay ejemplos con valores no booleanos.

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

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

por qué no intentas algo como esto

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

Devolverá un error cuando se proporcione algún otro texto en lugar de verdadero o falso, independientemente del caso y capturará los números también como

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

Esta función puede manejar cadenas y booleanos verdadero / falso.

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

Demostración a continuación:

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

Estoy usando este

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"

Sin duda, la forma más fácil (suponiendo que su cadena sea 'verdadera' o 'falsa') es:

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

¡Utilice siempre el operador === en lugar del operador == para este tipo de conversiones!

Como dijo @ Shadow2531, no puedes convertirlo directamente. También te sugiero que consideres entradas de cadena además de "verdadero" y "falso" que son 'veraces' y 'falsas' si tu código va a ser reutilizado / usado por otros. Esto es lo que 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;
  }
}

Necesita separar (en su pensamiento) el valor de sus selecciones y la representación de ese valor.

Elija un punto en la lógica de JavaScript donde necesiten pasar de centinelas de cadena a tipo nativo y haga una comparación allí, preferiblemente donde solo se haga una vez por cada valor que deba convertirse. Recuerde abordar lo que debe suceder si la secuencia centinela no es una que el script conoce (es decir, ¿está predeterminado en verdadero o falso?)

En otras palabras, sí, debe depender del valor de la cadena. :-)

Mi opinión sobre esta pregunta es que tiene como objetivo satisfacer tres objetivos:

• Devuelve verdadero / falso para los valores de verdad y falsey, pero también devuelve verdadero / falso para los valores de cadenas múltiples que serían verdaderos o falsos si fueran booleanos en lugar de cadenas.
• En segundo lugar, proporcione una interfaz resistente para que los valores distintos de los especificados no fallen, sino que devuelvan un valor predeterminado
• Tercero, haga todo esto con el menor código posible.

El problema con el uso de JSON es que falla al causar un error de Javascript. Esta solución no es resistente (aunque satisface 1 y 3):

JSON.parse("FALSE") // fails

Esta solución no es lo suficientemente concisa:

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

Estoy trabajando para resolver este problema exacto para Typecast.js . Y la mejor solución para los tres objetivos es esta:

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

Funciona para muchos casos, no falla cuando se pasan valores como {} y es muy conciso. Además, devuelve falso como el valor predeterminado en lugar de indefinido o arrojando un error, que es más útil en el desarrollo de JavaScript sin tipo. Bravo por las otras respuestas que lo sugirieron!

Llego un poco tarde, pero tengo un pequeño fragmento para hacer esto, esencialmente mantiene todos los JScripts truthey / falsey / asqueroso, pero incluye "false"como un valor aceptable para falso.

Prefiero este método a los mencionados porque no depende de un tercero para analizar el código (es decir: eval / JSON.parse), lo cual es excesivo en mi opinión, es lo suficientemente corto como para no requerir una función de utilidad y mantiene otras convenciones 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..

otra solución. 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
};

los casos de prueba se ejecutan en el 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
> 

Dios santo, algunas de estas respuestas son simplemente salvajes. Me encanta JS y su infinito número de formas de pelar un bool.

Mi preferencia, que me sorprendió no ver ya, es:

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

Un trazador de líneas

Solo tenemos que tener en cuenta la cadena "falsa" ya que cualquier otra cadena (incluida la "verdadera") ya está true.

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

Prueba

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

Una versión más exhaustiva.

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

Prueba

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