如何检查类型是否为布尔值

如何检查变量的类型是否为布尔型？

我的意思是，有一些替代方法，例如：

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

但这对我来说似乎并不好。

有没有更清洁的方法来实现这一目标？

那就是为什么typeof。括号是可选的，因为它是一个运算符。

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

如果您只想检查原始值

typeof variable === 'boolean'

如果出于某种奇怪的原因，您使用构造函数创建了布尔值，那么它们并不是真正的布尔值，而是包含原始布尔值的对象，同时检查原始布尔值和使用创建的对象的一种方法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

使用纯JavaScript，您只需使用typeof或执行类似typeof false或的操作typeof true，它将返回"boolean"...

但这不是做到这一点的唯一方法，我在下面创建函数以显示可在JavaScript中检查布尔值的不同方法，以及在某些新框架中可以执行此操作的不同方法，让我们从这个框架开始：

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

还是单行ES6方式...

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

并称之为！

isBoolean(false); //return true

同样在Underscore源代码中，它们按以下方式进行检查（在函数名的开头带有_。）：

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

同样在jQuery中，您可以像这样检查它：

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

在React中，如果使用propTypes，您可以像这样检查一个布尔值：

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

如果使用TypeScript，则还可以使用boolean类型：

let isDone: boolean = false;

还有另一种方法，例如将值转换为布尔值，看看它是否仍然完全相同，例如：

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

或类似：

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

叫它！

isBoolean(false); //return true

不建议为此使用任何框架，因为这实际上是JavaScript中的简单检查。

有或没有jQuery的三种“香草”方式来进行检查。

1. 首先是通过强制强制布尔评估，然后检查其是否等于原始值：

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

2. 做一个简单的typeof检查：

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

3. 在原始函数上完全过度杀伤和不必要地实例化类包装器：

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

仅true 当您创建一个new Boolean类并将其传递时，第三个才会返回。

要详细说明基元强制（如＃1所示），可以按以下方式检查所有基元类型：

• Boolean：

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

• Number：

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

• String：

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

您可以使用纯Javascript实现以下目的：

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

如果您希望函数也可以验证布尔对象，则最有效的解决方案必须是：

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

检查在JavaScript变量的类型，最可靠的方法是如下：

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"

这种复杂的原因是typeof true返回"boolean"而typeof new Boolean(true)返回"object"。

我将使用Lodash：isBoolean检查传入的变量是原始布尔值还是布尔包装对象，因此考虑所有情况。

您可以创建一个检查typeof参数的函数。

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

有时我们需要一种方法来检查它。typeof不能用于日期等。所以我很容易

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

也为Number，String，Boolean等我们经常需要检查的类型在一个单一的方式...

从长远来看，创建isBoolean包含oneliner之类的函数typeof v === "boolean"似乎非常不便。我很惊讶几乎每个人都建议创建自己的功能。似乎与扩展原生原型一样是癌症。

• 您需要在涉及的每个项目中重新创建它们
• 其他开发人员可能有不同的习惯，或者需要检查功能的来源以查看使用哪种检查支票，以了解检查的弱点是什么
• 当您尝试在现场的控制台中编写一个不属于您的项目的衬垫时，您会感到沮丧

只是记住而已typeof v === "boolean"。在您的IDE中添加一个模板，使其能够通过三个字母的快捷方式放入其中并感到高兴。

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

如果你有一个字符串

• 最可读的：val === false || val === true。
• 也可读：typeof variable == typeof true。

• 最短，但根本不可读：!!val === val。

  说明：

  • [!!] 双重感叹号将值转换为布尔值。
  • [===] 三重等于测试严格相等：类型（布尔值）和值必须相同。
  • 如果原始值不是布尔值，则不会通过三重等于测试。如果它是一个布尔变量，它将通过三重等于测试（类型和值均使用）。

  测试：

  • !! 5 === 5 //否
  • !!'test'==='test'//否
  • let val = new Date（）; !! val === val //否
  • !! true ===正确//正确
  • !!假===假//真

在nodejs中，通过使用node-boolify可以使用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

es2015箭头功能的另一个决定

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