Convertir cadena a booleano en JavaScript

En esta guía, aprenda cómo convertir una cadena en un booleano en JavaScript, utilizando el operador de identidad (===), expresiones regulares, el envoltorio booleano y el operador doble no (!!), a través de un código práctico con buenas prácticas.

Introducción

Supongamos que tenemos valores booleanos almacenados en nuestra base de datos como cadenas y en base a esos valores queremos realizar alguna operación específica en nuestro sitio web/aplicación. En ese caso, tenemos que convertir esas cadenas en valores booleanos antes de usarlas en operaciones lógicas.

En este artículo, veremos varias formas de convertir valores de cadena a booleanos (verdadero o falso) en JavaScript.

Uso del operador de identidad (===) {#uso del operador de identidad}

El operador de identidad, también conocido como operador de igualdad estricta, devuelve verdadero solo si y solo si ambos valores que se comparan son del mismo tipo y tienen el mismo valor. En otras palabras, determina si el valor del lado izquierdo es igual al valor del lado derecho, y devuelve “verdadero” si lo es, y “falso” si no lo es.

{.icon aria-hidden=“true”}

Nota: Si desea obtener más información sobre la diferencia entre == (operador de igualdad estricta) y === (operador de igualdad flexible), debe leer nuestro "JavaScript : == vs === Operador"!

Esencialmente, compararemos nuestra cadena con la cadena "true". Por lo tanto, la salida será un booleano true solo si nuestra cadena es realmente "true". Cualquier otra cadena hará que el código devuelva el valor booleano falso:

1
2
let myString = "true"; 
let boolOutput = (myString === "true"); //returns true

{.icon aria-hidden=“true”}

Nota: Escribimos un valor de cadena con comillas - "true", y el valor booleano sin comillas - true. Usaremos esta notación a lo largo de todo este artículo.

Además, primero podemos convertir una cadena a minúsculas, solo para asegurarnos de que las mayúsculas y minúsculas no causen salidas defectuosas:

1
2
let myString = "True"; 
let boolOutput = (myString.toLowerCase() === "true"); // returns true

Como hemos dicho antes, el código anterior devolverá falso si nuestro valor de cadena no es igual a "verdadero":

1
2
3
4
5
6
7
8
let myString1 = "Test";
let boolOutput1 = (myString1 === "true"); //returns false

let myString1 = "Test";
let boolOutput1 = (myString1.toLowerCase() === "true"); //returns false

let myString = "True";
let boolOutput2 = (myString2 === "true"); //returns false

También podemos animar un poco las cosas introduciendo el operador ternario junto con el operador de igualdad. Todo lo que haremos será verificar si nuestra cadena es igual a "verdadero" y luego devolver un valor booleano de verdadero si hay una coincidencia o falso si no es así:

1
2
let myString = "true";
let boolOutput = myString.toLowerCase() == 'true' ? true : false; // returns true

Uso de expresiones regulares (RegEx)

Las expresiones regulares (RegEx) son patrones para hacer coincidir y probar combinaciones de caracteres de cadenas.

{.icon aria-hidden=“true”}

Nota: En este artículo, asumiremos que tienes al menos una comprensión básica de las expresiones regulares en general. Pero si necesitas ayuda para comprender las expresiones regulares en JavaScript, deberías considerar leer nuestra ["Guía de expresiones regulares y cadenas coincidentes en JavaScript"](/guia-de-expresiones-regulares-y-cadenas- coincide-en-javascript/)

Para el propósito de este artículo, usaremos la forma más básica de expresiones regulares en JavaScript: crearemos la expresión regular simple que coincida con "true" y la compararemos con nuestra cadena usando test() método:

1
2
let stringValue = "true"; 
let boolValue = (/true/).test(stringValue); //returns true

Notarás que esto realmente distingue entre mayúsculas y minúsculas, ya que devolverá falso si tiene una ligera inconsistencia entre mayúsculas y minúsculas:

1
2
let stringValue = "True"; 
let boolValue = (/true/).test(stringValue); //returns false

Para arreglar esto, podemos agregar /i al final de la expresión regular para garantizar una coincidencia que no distinga entre mayúsculas y minúsculas:

1
2
let stringValue = "True"; 
let boolValue = (/true/i).test(stringValue); //returns true

¿Usando la clase contenedora booleana?

JavaScript tiene un objeto ‘booleano’ integrado para almacenar valores booleanos. En realidad, es un envoltorio de objetos para valores booleanos: envuelve otros objetos, lo que los convierte en un valor booleano válido. Esto se hace probando el valor verdadero-falso de un objeto. En general, los objetos vacíos se evalúan como falso y los objetos que no están vacíos se evalúan como verdadero.

Cualquier cadena que no sea la cadena vacía se evaluará como verdadera utilizando el envoltorio Boolean:

1
2
3
4
let myString1 = Boolean('true'); //returns true
let myString2 = Boolean(''); // //returns false
let myString3 = Boolean('false'); //returns true
let myString4 = Boolean('True'); //returns true

Hay dos problemas principales aquí:

  • La primera es que devolverá true para una cadena vacía con al menos un carácter en blanco (espacio, tabulador, etc.), es por eso que debemos tener cuidado al usar este método:
1
const myString5 = Boolean(' '); //returns true
  • En segundo lugar, la conversión de una cadena de "falso" a un valor booleano de falso fallará porque cualquier cadena no vacía se convierte en verdadero.

Doble operador NOT - !!

Usar el operador NOT doble es igual a usar el operador NOT lógico (!) dos veces, lo que significa que invierte el resultado del operador NOT simple:

1
2
let myString1 = !'test'; // returns false
let myString2 = !''; // returns true

Cuando usamos el operador doble NOT, los valores se invierten, lo que significa que ahora estamos realizando una conversión booleana pura:

1
2
let myString1 = !!'test'; // returns true
let myString2 = !!''; // returns false

El operador doble NOT (!!) es bastante conciso pero hace lo mismo que el envoltorio Boolean. Sin embargo, es un poco más difícil de leer si no está familiarizado con el operador lógico NOT (!).

También debemos ser cautelosos cuando usamos este método ya que una cadena vacía con al menos un carácter en blanco aún devolverá verdadero y cuando tratamos de convertir una cadena de "falso" a un valor booleano de falso, esto seguirá sin funcionar (al igual que con el objeto Boolean).

Conclusión

En este artículo, hemos echado un vistazo a cuatro formas de convertir una cadena en un valor booleano en JavaScript. La forma más sencilla de hacerlo es usar el operador de igualdad estricta para comparar nuestro valor de cadena con "verdadero" - si la cadena es (estrictamente) igual a "verdadero", la salida será booleana verdadero . Alternativamente, puede usar el operador ternario junto con el operador de igualdad suelta para lograr lo mismo. Además, la coincidencia de expresiones regulares es un enfoque sólido.

Los últimos dos métodos, el objeto ‘booleano’ y el operador doble NOT, tienen una sintaxis más simple, pero su inconveniente es la forma en que tratan el valor ‘falso’: la cadena "falso" devolverá el valor booleano ‘verdadero’, lo que los hace aplicables solo a un pequeño subconjunto de casos de conversión.