parse - ¿Cómo puedo convertir una cadena a boolean en JavaScript?
var to boolean in javascript (30)
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");
¿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'');
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.
¿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
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
Debe separar (en su opinión) el valor de sus selecciones y la representación de ese valor.
Elija un punto en la lógica de JavaScript en el que necesitan pasar de los centinelas de cadena al tipo nativo y haga una comparación allí, preferiblemente donde solo se haga una vez para cada valor que deba convertirse. Recuerde abordar lo que debe suceder si la cadena centinela no es una que el script conoce (es decir, ¿su valor predeterminado es verdadero o falso?)
En otras palabras, sí, debe depender del valor de la cadena. :-)
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;
};
Esta función puede manejar cadenas así como Boolean true / false.
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)));
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"
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í.
Breve de resultados (cuanto más alto mejor):
- Declaración condicional : 2,826,922
- Cambie la caja en el objeto Bool : 2,825,469
- Casting a JSON : 1,867,774
- !! conversiones : 805,322
- Prototipo de Cuerda : 713,637
Están vinculados a la respuesta relacionada donde puede encontrar más información (pros y contras) sobre cada una; Especialmente en los comentarios.
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..
Mi opinión sobre esta pregunta es que pretende satisfacer tres objetivos:
- Devuelva verdadero / falso para los valores de verdad y falso, pero también devuelva verdadero / falso para múltiples valores de cadena que serían verdaderos o falso si fueran booleanos en lugar de cadenas.
- Segundo, proporcione una interfaz resistente para que los valores distintos a los especificados no fallen, sino que devuelvan un valor predeterminado
- Tercero, haz 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. También devuelve falso como el valor predeterminado en lugar de undefined o lanzar un error, que es más útil en el desarrollo de JavaScript de tipo débil. Bravo a las otras respuestas que lo sugirieron!
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"
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 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 casos false si ya conoce todos los casos true los que tendría que tener en cuenta. Puede pasar cualquier cosa a este método que pueda pasar por un valor true (o agregar otros, es bastante sencillo), y todo lo demás se consideraría 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.
Sin lugar a dudas, la forma más fácil (suponiendo que la 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 estos tipos de conversiones!
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 .
Ya hay tantas respuestas disponibles. Pero lo siguiente 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 uno ejemplos con valores no booleanos.
getBoolean(''aa''); // false
getBoolean(false); //false
getBoolean(''false''); //false
getBoolean(''true''); // true
getBoolean(true); // true
getBoolean(1); // true
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
>
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.");
}
};
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);
}
}
var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) {
return !falsy.test(val) && !!val;
};
Esto devuelve false para cada valor falso y true para todo valor verdadero, excepto ''false'' , ''f'' , ''no'' , ''n'' y ''0'' (no distingue 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());