Como verificar se o tipo é booleano

Como posso verificar se o tipo de uma variável é do tipo Booleano?

Quero dizer, existem algumas alternativas, como:

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

Mas isso não me parece bonito.

Existe uma maneira mais limpa de conseguir isso?

É para isso que typeofexiste. Os parênteses são opcionais, pois é um operador .

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

Se você deseja apenas verificar um valor primitivo

typeof variable === 'boolean'

Se, por algum motivo estranho, você tiver criado booleanos com o construtor, esses objetos não são realmente booleanos, mas objetos que contêm um valor booleano primitivo, e uma maneira de verificar os booleanos primitivos e os objetos criados com isso new Booleané:

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

Com JavaScript puro , você pode simplesmente usar typeofe fazer algo como typeof falseou typeof truee ele retornará"boolean" ...

Mas essa não é a única maneira de fazer isso, estou criando funções abaixo para mostrar maneiras diferentes de verificar booleanos em JavaScript, também maneiras diferentes de fazê-lo em alguns novos frameworks, vamos começar com este:

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

Ou caminho ES6 de uma linha ...

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

e chame assim!

isBoolean(false); //return true

Também no código-fonte de sublinhado , eles verificam assim (com o _. No início do nome da função):

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

Também no jQuery, você pode verificar assim:

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

Em React , se você estiver usando propTypes, poderá verificar um valor para ser booleano assim:

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

Se você estiver usando o TypeScript , também poderá usar o tipo booleano :

let isDone: boolean = false;

Outra maneira de fazer isso é como converter o valor em booleano e verificar se ainda é exatamente o mesmo, algo como:

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

ou como:

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

e chame!

isBoolean(false); //return true

Não é recomendável usar nenhuma estrutura para isso, pois é realmente uma verificação simples no JavaScript.

Existem três maneiras "baunilha" de verificar isso com ou sem o jQuery.

1. Primeiro é forçar a avaliação booleana por coerção e, em seguida, verifique se é igual ao valor original:

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

2. Fazendo uma typeofverificação simples :

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

3. Fazendo um exagero completamente e instanciação desnecessária de um wrapper de classe em um primitivo:

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

O terceiro retornará apenas true se você criar umnew Boolean classe e passar essa informação.

Para elaborar a coerção das primitivas (como mostrado no # 1), todos os tipos de primitivas podem ser verificados desta maneira:

• Boolean:

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

• Number:

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

• String:

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

Você pode usar Javascript puro para conseguir isso:

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

Se você deseja que sua função também possa validar objetos booleanos, a solução mais eficiente deve ser:

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

A maneira mais confiável de verificar o tipo de uma variável no JavaScript é a seguinte :

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"

A razão para essa complicação é que typeof trueretorna "boolean"enquanto typeof new Boolean(true)retorna "object".

Eu iria com o Lodash: isBoolean verifica se a variável passada é um objeto booleano primitivo ou wrapper booleano e, portanto, é responsável por todos os casos.

Você pode criar uma função que verifique se typeofhá um argumento.

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

Às vezes, precisamos de uma única maneira de verificar isso. typeof não funciona para a data etc. Então eu facilitei

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

Também para Number, String, Booleanetc., muitas vezes, precisa verificar o tipo em um único caminho ...

A criação de funções como a isBooleanque contém oneliner typeof v === "boolean"parece muito impraticável a longo prazo. Estou surpreso que quase todo mundo sugira criar sua própria função. Parece ser o mesmo câncer que a extensão de protótipos nativos.

• você precisa recriá-los em todos os projetos nos quais está envolvido
• outros desenvolvedores podem ter hábitos diferentes, ou precisam verificar a fonte de sua função para ver qual impementação de verificação você usa, para saber quais são os pontos fracos de sua verificação
• você ficará frustrado ao tentar escrever um liner no console no local que não pertence ao seu projeto

apenas memorize typeof v === "boolean"e é tudo. Adicione um modelo ao seu IDE para poder colocá-lo com um atalho de três letras e ser feliz.

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

se você tem uma string

• O mais legível: val === false || val === true .
• Também legível: typeof variable == typeof true .

• O mais curto, mas não legível: !!val === val .

  Explicação:

  • [!!] A dupla exclamação converte o valor em um booleano.
  • [===] O teste de triplo igual para igualdade estrita: o tipo (Boolean) e o valor devem ser iguais.
  • Se o valor original não for booleano, ele não passará no teste de triplo igual. Se for uma variável booleana, passará no teste de triplicar iguais (com tipo e valor).

  Testes:

  • !! 5 === 5 // falso
  • !! 'teste' === 'teste' // falso
  • deixe val = nova data (); !! val === val // falso
  • !! verdadeiro === verdadeiro // verdadeiro
  • !! false === false // verdadeiro

No nodejs usando o 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

Mais uma decisão com a função de seta es2015

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