pasar - variables boolean javascript




¿Cómo puedo convertir una cadena a boolean en JavaScript? (20)

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


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" (DEBE ser en minúsculas también).

Una cadena json no válida que se pasa a estas funciones a continuación lanzará una excepción .

Respuesta original:

¿Qué tal si?

JSON.parse("true");

o con jQuery

$.parseJSON("true");

Hacer:

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

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

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

No hagas

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á como true al usarlas. 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.


Como dijo @ Shadow2531, no puedes convertirlo directamente. También sugeriría que consideres entradas de cadena además de "verdadero" y "falso" que son "sinceros" y "falso" 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;
  }
}

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

El objeto booleano no tiene un método 'parse'. Boolean('false') devuelve true, por lo que no funcionará. !!'false' también devuelve true , por lo que tampoco funcionará.

Si desea que la cadena 'true' devuelva el valor booleano true y la cadena 'false' para devolver el valor boolean false , la solución más sencilla es utilizar eval() . eval('true') devuelve true y eval('false') devuelve false. Sin embargo, eval() en cuenta las implicaciones de rendimiento al utilizar eval() .


Escribí una función para que coincida con el filter_var de PHP que hace esto muy bien. Disponible en una gist: 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;
};

Esto se ha tomado de la respuesta aceptada, pero en realidad tiene un punto muy débil, y me sorprende la forma en que obtuvo ese recuento de upvotes, el problema con el que tiene que considerar el caso de la cadena porque esto es sensible a mayúsculas y minúsculas.

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

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"

La expresión que estás buscando es simplemente

/^true$/i.test(myValue)

como en

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

Esto prueba myValue contra 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

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 valor aceptable de 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 que es una exageración en mi mente, es lo suficientemente corto como para no requerir una función de utilidad y mantiene Otras convenciones de verdad / 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..

Ojo de madera tenga 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:

Empecemos por la forma más corta, pero muy estricta:

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

Y terminar de una manera más adecuada, 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]));}

Para convertir ambas cadenas ("true", "false") y boolean a boolean

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

Donde la flag puede ser

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

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

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

(Por supuesto, no funcionará en navegadores más antiguos y Firefox muestra falso, mientras que Opera, Chrome, Safari e IE se muestran verdaderos. Error 720760 )


Recuerda emparejar 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 se marca, se "establece" igual a verdadero. Esto se evalúa como verdadero / falso.


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

ACTUALIZACIÓN (sin JSON):

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

También creé fiddle para probarlo http://jsfiddle.net/remunda/2GRhG/


Tu solución está bien.

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


Yo uso lo siguiente:

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

Esta función realiza la coacción booleana habitual con la excepción de las cadenas "false" (no distingue mayúsculas y minúsculas) y "0".


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

function parseBool(value) {
    if (typeof value === "boolean") return value;

    if (typeof value === "number") {
        return value === 1 ? true : value === 0 ? false : undefined;
    }

    if (typeof value != "string") return undefined;

    return value.toLowerCase() === 'true' ? true : false;
}

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