¿Cómo puedo convertir una cadena a booleana en JavaScript?

2981

¿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 rellenan 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, fue depender del valor literal de su representación de cadena.

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

¿Existe una mejor manera de lograr esto?

19
  • 75
    "¿Hay una mejor manera de lograr esto?" - ciertamente hay una manera peor: Dstring=(string==String(string?true:false))?(string?true:false):(!string?true:fa‌​lse);Mark K Cowan 16/04/15 a las 10:25
  • 9
    Maneja fácilmente cuerdas y bools:function parseBool(val) { return val === true || val === "true" }WickyNilliams 10 de septiembre de 2015 a las 14:24
  • 3
    @Markfunction checkBool(x) { if(x) {return true;} else {return false;} }Sebi 29/11/2016 a las 15:10
  • 3
    @Sebi: Olvidaste documentarlo:if (checkBool(x) != false) { ... } else { ... }Mark K Cowan 29/11/2016 a las 18:21
  • 7
    !!(parseInt(value) || value === "true")Andrew Luca 22 de febrero de 2017 a las 3:58
4154

Hacer:

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

utilizando el operador de identidad ( ===), que no realiza ninguna conversión de tipo implícita cuando las variables comparadas tienen tipos diferentes.


No:

Probablemente debería tener cuidado al utilizar 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á truemediante su uso. Aunque son los métodos más limpios que se me ocurren con respecto a la conversión booleana, creo que no son lo que estás buscando.

2
  • 218
    myValue === 'true';es exactamente equivalente a myValue == 'true';. No hay ningún beneficio en el uso de ===más de ==aquí. Tim Down 26/08/10 a las 11:01
  • 626
    Sigo los consejos y uso de Crockford=== y !==siempre que tenga sentido, que es casi siempre. guinaps 10/02/11 a las 15:37
760

Advertencia

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

Una cadena json no válida pasada a estas funciones a continuación arrojará una excepción .


Respuesta original:

¿Qué tal si?

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

o con jQuery

$.parseJSON("TRUE".toLowerCase());
2
  • 71
    El problema con esto es que muchos valores potenciales generan un error de análisis que detiene la ejecución de JS. Entonces, ejecutar JSON.parse ("FALSE") bombardea Javascript. Creo que el punto de la pregunta no es simplemente resolver estos casos exactos, sino también ser resistente a otros casos. BishopZ 26/01/2013 a las 22:52
  • 50
    Es bastante simple decirlo JSON.parse("TRUE".toLowerCase())para que pueda analizar correctamente. Yuck 8 de agosto de 2013 a las 15:00
260
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);
    }
}
2
  • 47
    De hecho, se puede simplificar. 1) No hay necesidad de probar "true", "yes"y "1". 2) toLowerCaseno regresa null. 3) Boolean(string)es el mismo que string!==""aquí. =>switch(string.toLowerCase()) {case "false": case "no": case "0": case "": return false; default: return true;}Robert 25 de junio de 2013 a las 5:27
  • Tenga en cuenta que esto será predeterminado true, por ejemplo:stringToBoolean('banana') // truedav_i 7 de julio a las 13:25
223

Creo que esto es mucho más universal:

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

Va:

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false
1
  • 22
    Cuando puede recibir una cadena en mayúsculas o un booleano, entoncesString(a).toLowerCase() === 'true'pauloya 29 de febrero de 2012 a las 12:49
155

Recuerde hacer coincidir el caso:

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

Además, si es 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á marcado, se "establece" igual a verdadero. Esto se evalúa como verdadero / falso.

0
123

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 le gusta extender la clase String, puede 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 enumerabilidad 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 más antiguos, por supuesto, y Firefox muestra false, mientras que Opera, Chrome, Safari e IE muestran true. Error 720760 )

2
  • 10
    Siempre puede prefijar la función si tiene miedo de que interfiera con algún otro código. Si algún código aún se rompe, ese código es demasiado frágil y debería arreglarse. Si su función agregada hace que el objeto sea demasiado pesado donde causa un problema de rendimiento para otro código, entonces, obviamente, no desea hacer eso. Pero no creo que sea una mala idea ampliar los objetos integrados. Tampoco serían prorrogables públicamente si ese fuera el caso. Shadow2531 16/07/11 a las 19:06
  • 42
    @DTrejo @Szymon No estoy de acuerdo. Este es exactamente el tipo de cosas para las que está sobrecargado el prototipo. Si tiene miedo de que rompa el código (deficiente) que se basa en for..in, hay formas de ocultar las propiedades de la enumeración. Ver Object.defineProperty. devios1 12/09/11 a las 14:29
65

Wood-eye, 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 termina de una manera 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]));}
0
51

Pensé que la respuesta de @Steven era la mejor y se ocupó de muchos más casos que si el valor entrante fuera solo una cadena. Quería ampliarlo 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 debería 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

0
42

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

ACTUALIZAR (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/

2
  • 1
    La versión 'sin JSON' tiene algunos defectos: val = "0"; console.log (!! (+ val || String (val) .toLowerCase (). replace (!! 0, ''))); produce verdaderoEtienne 22/07/2014 a las 7:42
  • 3
    getBool(undefined)se bloqueará cuando se use la versión original de JSON y se volverá verdadero para la segunda versión. Aquí hay una tercera versión que devuelve falso: function getBool (val) {var num; return val! = null && (! isNaN (num = + val)? !! num: !! String (val) .toLowerCase (). replace (!! 0, '')); }Ron Martinez 21/08/2014 a las 13:25
35

Tu solución está bien.

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

2
  • 19
    ¿Por qué crees que sería una tontería usarlo ===? En términos de rendimiento, sería exactamente igual si ambos tipos fueran Strings. De todos modos, prefiero usar ===ya que siempre evito el uso de ==y !=. Justificaciones: stackoverflow.com/questions/359494/…Mariano Desanze 17/08/10 a las 19:01
  • 4
    Desde valuesiempre será un stringni ==tampoco ===son tontos. Ambos son la herramienta adecuada para este trabajo. Solo difieren cuando los tipos no son iguales. En ese caso, ===simplemente regresa falsemientras ==ejecuta un algoritmo de coerción de tipo intrincado antes de la comparación. Robert 25 de junio de 2013 a las 5:49
26
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());
22

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

Si desea que la cadena 'true'devuelva booleano truey la cadena 'false'devuelva booleano 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 usarlo .

6
  • Para comprender qué es "incorrecto" (o correcto) con eval, consulte artículos como javascriptweblog.wordpress.com/2010/04/19/how-evil-is-eval o busque en stackoverflow 'Javascript eval malware'GrahamMc 22/11/12 a las 8:52
  • 2
    Estoy de acuerdo en que var isTrueSet = (myValue === 'true');es la mejor respuesta. thdoan 28 de enero de 2013 a las 7:35
  • Me gusta que sea conciso. Pero falla espectacularmente para el caso básico de eval('TRUE'); probando una vez más que eso eval()es malo. Snowman 6 de agosto de 2015 a las 9:41
  • @Area 51 Detective Fiction, de la misma manera, JSON.parse('TRUE')de la respuesta a continuación también falla espectacularmente. Es bastante fácil forzar una condición de error en JavaScript (o en cualquier idioma, para el caso). Para tener en cuenta esto, primero debe normalizar la cadena, por ejemplo,var myValue = document.myForm.IS_TRUE.value.toLowerCase(); var isTrueSet = (myValue==='true' || myValue==='false') ? eval(myValue) : false;thdoan 7 de agosto de 2015 a las 6:10
  • 1
    @ 10basetom: Correcto. Deberías incluir .toLowerCase()en la respuesta es mi punto. No intento forzar nada. Las mayúsculas TRUEson un valor lo suficientemente común como para ser devuelto por muchos widgets de IU. Snowman 7 de agosto de 2015 a las 6:30
19

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

Breve resultado (cuanto más alto, mejor):

  1. Declaración condicional : 2.826.922
  2. Caja de interruptor en objeto Bool : 2.825.469
  3. Transmitiendo 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.

1
  • "algo salió mal" al intentar ver la prueba jsPerfspottedmahn 2 feb 2018 a las 17:16
19

Esto se ha tomado de la respuesta aceptada, pero en realidad tiene un punto muy débil, y me sorprende cómo obtuvo ese recuento de votos a favor, el problema es que debe considerar el caso de la cadena porque distingue entre mayúsculas y minúsculas

var isTrueSet = (myValue.toLowerCase() === 'true');
1
  • sin mencionar que .toLowerCasepodría arrojar si myValuees igual a nulloundefinedAngelo Oparah 14/06/20 a las 9:46
18

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 "falso" (no distingue entre mayúsculas y minúsculas) y "0".

0
14

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 resultar útil cuando se realizan ejemplos con valores no booleanos.

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

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true
0
13
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.");
  }
};
2
  • 2
    Puede usar true.toString () en lugar de "true" para ser aún más limpio :-)tillda 22/02/11 a las 11:03
  • No cambie los globales, intente mantener sus cambios aislados, tal vez cree uno nuevo en su function parseBooleanlugarSteel Brain 27/08/18 a las 17:29
13

La expresión que estás buscando simplemente es

/^true$/i.test(myValue)

como en

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

Esto prueba myValuecon 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
13

Para convertir cadenas ("verdadero", "falso") y booleano en booleano

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

Donde flagpuede estar

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

se puede utilizar de la JSON.parsesiguiente manera:

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

en este caso .toLowerCasees importante

1
  • Sin embargo, no se garantiza que devuelva un booleano. D. Pardal 3 jul.20 a las 16:26
12

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

La solución más simple 🙌🏽

con ES6 +

use el NO lógico dos veces [!! ] para convertir la cadena

Solo pega esta expresión ...

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

¡Y pásale tu cuerda!

stringToBoolean('')                 // false
stringToBoolean('false')            // false
stringToBoolean('true')             // true
stringToBoolean('hello my friend!') // true
🤙🏽 ¡Bonificación! 🤙🏽
const betterStringToBoolean = (string) => 
  string === 'false' || string === 'undefined' || string === 'null' || string === '0' ?
  false : !!string

Puede incluir otras cadenas a voluntad para ampliar fácilmente el uso de esta expresión ...:

betterStringToBoolean('undefined')     // false
betterStringToBoolean('null')          // false
betterStringToBoolean('0')             // false
betterStringToBoolean('false')         // false
betterStringToBoolean('')              // false
betterStringToBoolean('true')          // true
betterStringToBoolean('anything else') // true
3
  • ¿Qué tal '1'? ¿Debería convertirse en trueo false? Creo que debería ser true, ¿no? Pero usando su respuesta, regresaráfalseksugiarto 2 de junio a las 20:11
  • Supongo que estás haciendo algo mal hermano ... Acabo de probar el código y si ingresas ' 1 'la devolución es siempre true. No sé cómo lo consiguió, falsepero creo que debe estar arruinándolo de alguna maneraFelipe Chernicharo 2 de junio a las 22:15
  • ¡Oh, lo siento! Mi mal, estaba probando la primera función en su lugar. Gracias por aclarar esto. ksugiarto 3 de junio a las 15:38
10

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"
3
  • Esto es bueno, pero funciona solo con el tipo String. Imagine que esta necesidad debe ser utilizada por una variable que sea quizás "true"o true. Si viene el segundo, esto no funcionará. ¿Es posible hacer un document.prototypeuso de esto donde queramos? MarceloBarbosa 9 feb.15 a las 18:40
  • Esto se ve elegante. ¡Gran trabajo! Sin embargo, noté que la sobrecarga de prototipos básicos en aplicaciones JS grandes (que también necesitan pruebas unitarias) puede resultar en un comportamiento inesperado (es decir, cuando desea iterar con "for" a través de una matriz que tiene el prototipo sobrecargado, obtendrá algunas propiedades que normalmente no esperaría). Usted ha sido advertido. ;)cassi.lup 11 mar.15 a las 10:30
  • una variante suya que acepta la función booleana también StringOrElse2Bool (sollozo) {if (tipo de sollozo === "cadena") {return ["no", "falso", "0", "off"]. indexOf (sollozo.toLowerCase ())! == -1? falso verdadero; } else {return !! sollozo}bortunac 2/12/15 a las 11:48
10

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

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 en el que 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 el centinela de cadena no es uno que el script conoce (es decir, ¿está predeterminado en verdadero o falso?)

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

9

Un trazador de líneas

Solo necesitamos tener en cuenta la cadena "falsa", ya que cualquier otra cadena (incluido "verdadero") ya lo es 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
1
  • ¿Alguna razón específica para usar en !!vlugar de usar truedirectamente? Prashanth Hegde 24 de febrero a las 8:16
8

Sin duda, la forma más fácil (asumiendo que su cadena será '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!

2
  • 4
    ¿De qué conversión estabas hablando? :-)YMMD 18 de mayo de 2012 a las 0:41
  • 1
    Al comparar cadenas en javascript, no hay diferencia entre usar los operadores == o === cuando no se usan conversiones. Aquí está comparando con cadenas, por lo tanto, no hay conversiones de tipo. Ver stackoverflow.com/questions/359494/…ars265 28/12/12 a las 15:40
8

Como dijo @ Shadow2531, no puedes convertirlo directamente. También te sugiero que consideres las entradas de cadena además de "verdadero" y "falso" que sean "verdaderas" 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;
  }
}
8

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

casos de prueba ejecutados 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
> 
8

Santo Dios, algunas de estas respuestas son simplemente salvajes. Me encanta JS y sus infinitas formas de desollar 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;
0