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


2554

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


50
"¿Hay una mejor manera de lograr esto?" - Ciertamente hay una peor manera: Dstring=(string==String(string?true:false))?(string?true:false):(!string?true:fa‌​lse);
Mark K Cowan

3
Maneje fácilmente cadenas y bobinas:function parseBool(val) { return val === true || val === "true" }
WickyNilliams

1
@ Markfunction checkBool(x) { if(x) {return true;} else {return false;} }
Sebi

2
@Sebi: Olvidó documentarlo:if (checkBool(x) != false) { ... } else { ... }
Mark K Cowan

3
!!(parseInt(value) || value === "true")
Andrew Luca

Respuestas:


3483

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.


196
myValue === 'true';es precisamente equivalente a myValue == 'true';. No hay ningún beneficio en el uso de ===más de ==aquí.
Tim Down

551
Sigo los consejos y el uso de Crockford=== y !==siempre que tenga sentido, que es casi siempre.
guinaps

55
¿Qué pasa con "VERDADERO" en mayúsculas, por ejemplo?
BMiner

102
@guinaps Usualmente sigo los consejos de Crockford, pero el escenario ==vs. ===es uno de los pocos en los que no. Estoy totalmente en desacuerdo con que "casi siempre" tiene sentido usarlo ===. Los idiomas de tipo libre existen porque no queremos preocuparnos por el tipo; si verificamos algo así if (price >= 50)no nos importa si comenzó como una cadena. Yo digo, la mayoría de las veces, queremos que los tipos sean malabarizados. En los raros casos en los que no queremos malabarismos de tipo (por ejemplo if (price === null)), entonces usamos ===. Esto es lo que he hecho durante años y nunca he tenido un problema.
JMTyler

169
@JMTyler podría estar pasando por alto el programador de mantenimiento que vendrá después. ¡Utilice siempre el operador de comparación adecuado! Si conoce "con seguridad" los tipos en ambos lados, pero no usa ===, no tendré ese conocimiento cuando consulte su código más adelante. Si su código se reutiliza, esto puede convertirse en una pesadilla. Si REALMENTE desea que sus tipos se "malaboren" como dice, entonces use '==', pero demasiados desarrolladores de JS tropezarán con esto demasiado fácilmente, mejor para ajustar su código. ¿Con qué frecuencia quiero que la cadena 'falso' signifique booleano 'verdadero'?
aikeru

687

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

6262
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. El punto de la pregunta, creo, no es simplemente resolver estos casos exactos, sino también ser resistentes a otros casos.
BishopZ

3
@Luke esta solución es exactamente lo que necesitaba; bueno, envolviéndolo en un intento ... atrapado sin embargo. Quería convertir a bool solo si era un valor booleano en la cadena; de lo contrario, solo use la cadena provista. ¡Esto funciona! Gracias.
jedmao

47
Es bastante simple decirlo JSON.parse("TRUE".toLowerCase())para que se pueda analizar correctamente.
Yuck

27
¿Por qué hay tantos votos a favor? Esto es ineficiente y horrible. ¿Qué sigue? 'true'.length === 4?
Maksim Vi.

21
@MaksimVi. typeof str==="string"&& str.length===4&& str.charAt(0)==="t" && str.charAt(1)==="r" && str.charAt(2)==="u" && str.charAt(3)==="e"&& true===true && true!==false && false===false// solo para estar seguro
Vitim.us

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

43
En realidad se puede simplificar. 1) No hay necesidad de probar "true", "yes"y "1". 2) toLowerCaseno vuelve null. 3) Boolean(string)es lo mismo que string!==""aquí. =>switch(string.toLowerCase()) {case "false": case "no": case "0": case "": return false; default: return true;}
Robert

15
@Robert, agradable, pero preferiría tener el valor predeterminado como en su falselugar.
drigoangelo

@drigoangelo Tener default: return true;es ciertamente posible. Pero cambiaría el comportamiento de la función.
Robert

2
Pensé que esta era la mejor respuesta, y quería dar más detalles aquí: stackoverflow.com/questions/263965/…
BrDaHa

99
si está normalizando datos llamando a .toLowerCase (), entonces es posible que también desee agregar trim () para eliminar espacios en blanco
jCuga

174

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

20
Cuando puede recibir una cadena en mayúsculas o un booleano, entoncesString(a).toLowerCase() === 'true'
pauloya

String("what about input like this that isn't a bool?") == "true"
Thomas Eding

66
@ThomasEding false ... ¿qué quieres que regrese?
Snowburnt

2
incluso podría acortarse al no usar el String()constructor:true+'' === 'true' // true
Todd

1
Por cierto, para 1 o 0 también debería ser falso o verdadero
Miguel

128

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.


3
Esto arrojará una excepción si myValuesucede null, trueo algún otro tipo ...
mik01aj

116

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 )


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 debe repararse. 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 generalmente una mala idea extender los objetos integrados. Tampoco serían ampliables públicamente si ese fuera el caso.
Shadow2531

41
@DTrejo @Szymon No estoy de acuerdo. Este es exactamente el tipo de cosa para la que se sobrecarga el prototipo. Si tiene miedo de romper el código (pobre) que se basa en ... en, hay formas de ocultar las propiedades de la enumeración. Ver Object.defineProperty.
devios1

Para seguir la convención, lo llamaríaparseBool
guzart

8
El análisis booleano no pertenece a la clase String ... terminaría con cualquier cantidad de analizadores de basura y conversión allí. -1 a los prototipos cambiantes en general. -1 a soluciones que no funcionan entre navegadores. -1 por mal diseño.
Thomas W

1
Aquí hay una comparación de rendimiento de todas las respuestas. stackoverflow.com/a/28588344/2824333
sospedra

50

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

Solo recuerde que los navegadores más antiguos pueden necesitar un polyfill JSON si usa el primer método.
DRaehal

1
¿Qué tan rápido es convertir una cadena "falsa" a un falsevalor booleano JSON.parse? En términos de CPU, rendimiento de la memoria
Verde

¿No sería más fácil comenzar con if (str) {...} para eliminar cualquier cosa que ya sea falsa? Y dentro de esta condición if, solo tiene que preocuparse por devolver true, porque ya termina con return false.
Larphoid

Tenga en cuenta que puede acortar muchas de las pruebas de cadena con (["true", "yes", "1"]. IndexOf (str.toLowerCase (). Trim ())! = -1) y usar una reserva de Boolean (str) para cubrir cosas como 'nulo'
Scott

38

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


Utilizo este, ya que cubre cosas que obtienes de atributos XML / HTML ElementNodes comoautocomplete="on"
philk

2
Añadiría .trim () antes aLowerCase ()
Luis Lobo Borobia el

34

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/


1
La versión 'sin JSON' tiene algún defecto: val = "0"; console.log (!! (+ val || String (val) .toLowerCase (). replace (!! 0, ''))); produce verdad
Etienne

3
getBool(undefined)se bloqueará al usar la versión original de JSON y volverá verdadero para la segunda versión. Aquí hay una tercera versión que devuelve false: function getBool (val) {var num; return val! = null && (! isNaN (num = + val)? !! num: !! String (val) .toLowerCase (). replace (!! 0, '')); }
Ron Martinez

31

Tu solución está bien.

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


17
¿Por qué crees que sería tonto usarlo ===? En términos de rendimiento, sería exactamente el mismo si ambos tipos son cadenas. De todos modos, prefiero usar ===ya que siempre evito el uso de ==y !=. Justificaciones: stackoverflow.com/questions/359494/…
Mariano Desanze

3
Ya valueque siempre será un stringni ==ni ===son tontos. Ambas son la herramienta adecuada para este trabajo. Solo difieren cuando los tipos no son iguales. En ese caso, ===simplemente regresa falsemientras ==ejecuta un intrincado algoritmo de coerción de tipo antes de la comparación.
Robert

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

20

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 .


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 para 'Javascript eval malware'
GrahamMc

2
Estoy de acuerdo en que var isTrueSet = (myValue === 'true');es la mejor respuesta.
Thdoan

Me gusta que sea conciso. Pero falla espectacularmente en el caso básico de eval('TRUE'); probando una vez más, eso eval()es malo.
Muñeco de nieve

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

1
@ 10basetom: Muy correcto. Debe incluir .toLowerCase()en la respuesta es mi punto. No estoy tratando de forzar nada. Mayúsculas TRUEes un valor lo suficientemente común como para ser devuelto por muchos widgets de IU.
Muñeco de nieve

18

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

16

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


16

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.


"Algo salió mal" al intentar ver la prueba
jsPerf

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
Puede usar true.toString () en lugar de "true" para estar aún más limpio :-)
tillda

No cambie los globales, trate de mantener sus cambios aislados, tal vez cree uno nuevo en su function parseBooleanlugar
Steel Brain

13

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

12

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"

12

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

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

10

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


9

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"

Esto es bueno, pero solo funciona con el tipo de cadena. Imagine que esto necesita ser usado 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 lo queramos?
MarceloBarbosa

Esto se ve elegante. ¡Gran trabajo! Sin embargo, noté que la sobrecarga de prototipos básicos en grandes aplicaciones JS (que también necesitan pruebas unitarias) podría dar lugar a 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ías). Usted ha sido advertido. ;)
cassi.lup

una variante suya que también acepta la función booleana StringOrElse2Bool (sob) {if (typeof sob === "string") {return ["no", "false", "0", "off"]. indexOf (sob.toLowerCase ())! == -1? falso verdadero; } else {return !! sob}
bortunac

8

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!


44
¿De qué conversión estabas hablando? :-)
YMMD

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

8

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

7

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. :-)


7

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!


Solo para volver a sus objetivos, el único problema con su tercera y mejor solución es que no cumple con el Objetivo n. ° 1: solo devolverá verdadero por un valor de 'true', pero no por ningún aporte verdadero. Para que cumpla con el Objetivo n. ° 1, es solo un poco más conciso que la Solución n. ° 2 y mucho menos legible.
JMTyler

return /^(true|yes|1|t|y)$/i.test(str);
Kevin Boucher

7

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

7

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
> 

7

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;

6

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.