Cómo verificar si el tipo es booleano

¿Cómo puedo verificar si el tipo de una variable es de tipo booleano?

Quiero decir, hay algunas alternativas como:

if(jQuery.type(new Boolean()) === jQuery.type(variable))
      //Do something..

Pero eso no me parece bonito.

¿Hay una forma más limpia de lograr esto?

Para eso typeofestá ahí. Los paréntesis son opcionales ya que es un operador .

if (typeof variable === "boolean"){
  // variable is a boolean
}

Si solo desea verificar un valor primitivo

typeof variable === 'boolean'

Si por alguna extraña razón tiene booleanos creados con el constructor, esos no son realmente booleanos, sino objetos que contienen un valor booleano primitivo, y una forma de verificar los booleanos primitivos y los objetos creados con new Booleanes hacer:

function checkBool(bool) {
    return typeof bool === 'boolean' || 
           (typeof bool === 'object' && 
            bool !== null            &&
           typeof bool.valueOf() === 'boolean');
}

function checkBool(bool) {
    return typeof bool === 'boolean' || 
           (typeof bool === 'object' && 
            bool !== null            &&
           typeof bool.valueOf() === 'boolean');
}

console.log( checkBool( 'string'          )); // false, string
console.log( checkBool( {test: 'this'}    )); // false, object
console.log( checkBool( null              )); // false, null
console.log( checkBool( undefined         )); // false, undefined
console.log( checkBool( new Boolean(true) )); // true
console.log( checkBool( new Boolean()     )); // true
console.log( checkBool( true              )); // true
console.log( checkBool( false             )); // true

Con JavaScript puro , simplemente puede usar typeofy hacer algo como typeof falseo typeof truey volverá "boolean"...

Pero esa no es la única forma de hacerlo, estoy creando funciones a continuación para mostrar diferentes formas en que puede verificar Boolean en JavaScript, también diferentes formas en que puede hacerlo en algunos marcos nuevos, comencemos con este:

function isBoolean(val) {
   return val === false || val === true;
}

O una línea ES6 forma ...

const isBoolean = val => 'boolean' === typeof val;

y llámalo como!

isBoolean(false); //return true

También en el código fuente de subrayado lo comprueban así (con el _. Al comienzo del nombre de la función):

isBoolean = function(obj) {
   return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
};

También en jQuery puedes verificarlo así:

jQuery.type(true); //return "boolean"

En React , si usa propTypes, puede verificar que un valor sea booleano como este:

MyComponent.propTypes = {
  children: PropTypes.bool.isRequired
};

Si usa TypeScript , puede usar type boolean también:

let isDone: boolean = false;

También otra forma de hacerlo, es como convertir el valor a booleano y ver si es exactamente igual, algo así como:

const isBoolean = val => !!val === val;

o como:

const isBoolean = val => Boolean(val) === val;

y llámalo!

isBoolean(false); //return true

No se recomienda usar ningún marco para esto, ya que es realmente una simple verificación en JavaScript.

Hay tres formas "vainilla" de verificar esto con o sin jQuery.

1. Primero es forzar la evaluación booleana por coerción, luego verifique si es igual al valor original:

   function isBoolean( n ) {
       return !!n === n;
   }

2. Haciendo un simple typeofchequeo:

   function isBoolean( n ) {
       return typeof n === 'boolean';
   }

3. Hacer una exageración completamente innecesaria e innecesaria de un contenedor de clase en una primitiva:

   function isBoolean( n ) {
       return n instanceof Boolean;
   }

El tercero solo regresará true si crea una new Booleanclase y la pasa.

Para profundizar en la coerción de primitivas (como se muestra en el n. ° 1), todos los tipos de primitivas se pueden verificar de esta manera:

• Boolean:

  function isBoolean( n ) {
      return !!n === n;
  }

• Number:

  function isNumber( n ) {
      return +n === n;
  }

• String:

  function isString( n ) {
      return ''+n === n;
  }

Puede usar Javascript puro para lograr esto:

var test = true;
if (typeof test === 'boolean')
   console.log('test is a boolean!');

Si desea que su función también pueda validar objetos booleanos, la solución más eficiente debe ser:

function isBoolean(val) {
  return val === false || val === true || val instanceof Boolean;
}

La forma más confiable de verificar el tipo de una variable en JavaScript es la siguiente :

var toType = function(obj) {
  return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
}
toType(new Boolean(true)) // returns "boolean"
toType(true); // returns "boolean"

La razón de esta complicación es que typeof trueregresa "boolean"mientras typeof new Boolean(true)regresa "object".

Yo iría con Lodash: isBoolean comprueba si la variable pasada es un objeto booleano primitivo o un objeto de envoltorio booleano y, por lo tanto, tiene en cuenta todos los casos.

Puede crear una función que verifique typeofsi hay un argumento.

function isBoolean(value) {
  return typeof value === "boolean";
}

A veces necesitamos una única forma de verificarlo. typeof no funciona para la fecha, etc. Así que lo hice fácil al

Date.prototype.getType() { return "date"; }

También para Number, String, Booleanetc a menudo necesitamos para comprobar el tipo de una sola manera ...

Crear funciones como la isBooleanque contiene oneliner typeof v === "boolean"parece muy desagradable a largo plazo. Me sorprende que casi todos sugieran crear su propia función. Parece ser el mismo cáncer que extender los prototipos nativos.

• necesitas recrearlos en cada proyecto en el que estés involucrado
• otros desarrolladores pueden tener hábitos diferentes, o necesitan verificar la fuente de su función para ver qué impedancia del cheque usa, para saber cuáles son los puntos débiles de su cheque
• se verá frustrado cuando intente escribir un revestimiento en la consola en el sitio que no pertenece a su proyecto

solo memorizar typeof v === "boolean"y eso es todo. Agregue una plantilla a su IDE para poder ponerla en un atajo de tres letras y ser feliz.

if(['true', 'yes', '1'].includes(single_value)) {
    return  true;   
}
else if(['false', 'no', '0'].includes(single_value)) {
    return  false;  
}

si tienes una cuerda

• La más legible: val === false || val === true.
• También puede leer: typeof variable == typeof true.

• El más corto, pero no se puede leer en absoluto: !!val === val.

  Explicación:

  • [!!] Los doble exclamación convierte el valor en booleano.
  • [===] El triple es igual prueba de para la igualdad estricta: tanto el tipo (booleano) como el valor tienen que ser iguales.
  • Si el valor original no es booleano, no pasará la prueba de triple igual. Si es una variable booleana, pasará la prueba de triple igual (con ambos tipos y valores).

  Pruebas:

  • !! 5 === 5 // falso
  • !! 'prueba' === 'prueba' // falso
  • let val = nueva Fecha (); !! val === val // falso
  • !! verdadero === verdadero // verdadero
  • !! falso === falso // verdadero

En nodejs usando node-boolify podemos usar isBoolean ();

        var isBoolean = require('node-boolify').isBoolean;
        isBoolean(true); //true
        isBoolean('true'); //true
        isBoolean('TRUE'); //false
        isBoolean(1); //true
        isBoolean(2); //false
        isBoolean(false); //true
        isBoolean('false'); //true
        isBoolean('FALSE'); //false
        isBoolean(0); //true
        isBoolean(null); //false
        isBoolean(undefined); //false
        isBoolean(); //false
        isBoolean(''); //false

Una decisión más con la función de flecha es2015

const isBoolean = val => typeof val === 'boolean';