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

typeof的目的。括号是可选的，因为它是运算符。

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

使用纯 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

同样在下划线源代码中，他们像这样检查它(在函数名称的开头使用 _.(：

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

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

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

在 React 中，如果使用 propType，你可以像这样检查一个值是否为布尔值：

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

如果使用 TypeScript，您还可以使用类型布尔值：

let isDone: boolean = false;

还有另一种方法，就像将值转换为布尔值，看看它是否完全相同，如下所示：

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

或类似：

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

并称呼它！

isBoolean(false); //return true

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

如果您只想检查基元值：

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

有三种"香草"方法可以在有或没有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;
   }
   

第三个只会在创建new Boolean类并将其传入时返回true。

为了详细说明基元强制(如 #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;
}

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

基准测试：

都非常相似...

const { performance } = require('perf_hooks');
const boolyah = true;
var t0 = 0;
var t1 = 0;
const loops = 1000000;
var results = { 1: 0, 2: 0, 3: 0, 4: 0 };
for (i = 0; i < loops; i++) {
    t0 = performance.now();
    boolyah === false || boolyah === true;
    t1 = performance.now();
    results['1'] += t1 - t0;
    t0 = performance.now();
    'boolean' === typeof boolyah;
    t1 = performance.now();
    results['2'] += t1 - t0;
    t0 = performance.now();
    !!boolyah === boolyah;
    t1 = performance.now();
    results['3'] += t1 - t0;
    t0 = performance.now();
    Boolean(boolyah) === boolyah;
    t1 = performance.now();
    results['4'] += t1 - t0;
}
console.log(results);
  // RESULTS
  // '0': 135.09559339284897,
  // '1': 136.38034391403198,
  // '2': 136.29421120882034,
  // '3': 135.1228678226471,
  // '4': 135.11531442403793

真假的最简单方法是： (typeof value === "boolean") ，但如果value是 Boolean 类的实例，那么它将返回 "object" .因此，要处理这个问题，我们必须添加另一个条件来检查是否： (value instanceof Boolean)

代码片段：

const value = false;
//const value = new Boolean(10);
//const value = new Boolean("hi");
if((typeof value === "boolean") || (value instanceof Boolean))
    console.log("boolean");
else
    console.log("not 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"。

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

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

有时我们需要一种方法来检查它。类型不适用于日期等。所以我通过

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

同样对于Number、String、Boolean等，我们经常需要以一种单一的方式检查类型......

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

如果你有一个字符串

使用 es2015 箭头函数的另一个决定

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

• 最具可读性：val === false || val === true。
• 也可读：typeof variable == typeof true .

• 最短但完全不可读的：!!val === val.

  解释：

  • [！！]双感叹号将该值转换为布尔值。
  • [===] 严格相等的三重等于检验：类型(布尔值(和值必须相同。
  • 如果原始值不是布尔值，则它将无法通过三等号测试。如果它是一个布尔变量，它将通过三重等于测试(具有类型和值(。

  测试：

  • ！！5 === 5//假
  ！
  • ！'测试' === '测试'//假
  • let val = new Date((; ！！val === val//false
  • ！！真 === 真//真
  • ！！假 === 假//真

更新：以前的解决方案更具体，您可以选择要考虑为布尔值的值，并且可以将其添加到正则表达式中，如果您需要更通用的解决方案并且不想添加库，请查看以下解决方案(取自 lodash 的布尔值(

function getTag(value) {
  if (value == null) {
    return value === undefined ? '[object Undefined]' : '[object Null]'
  }
  return toString.call(value)
}
function isObjectLike(value) {
  return typeof value === 'object' && value !== null
}
function isBoolean(value) {
  return value === true || value === false ||
    (isObjectLike(value) && getTag(value) == '[object Boolean]')
}

以前的解决方案

const isBoolean = (val) => {
  const boolValuesRegex = /true|false/; // Add other /true|false|1|0|on|off/
  if (val === undefined || val === null) return false;
  return boolValuesRegex.test(val.toString().toLowerCase());
}
const values = [true, false, 'true', 'false', 'TRUE', 'FALSE', 'sampletext', 1, undefined, null, (() => {}), {}, []];
document.body.innerHTML = values.map(x => `${x} - ${isBoolean(x)}`).join('</br>');

创建函数，如 isBoolean ，其中包含 oneliner typeof v === "boolean"从长远来看似乎非常不方便。我很惊讶几乎每个人都建议创建自己的函数。这似乎与扩展原生原型是相同的癌症。

• 您需要在您参与的每个项目中重新创建它们
• 其他开发人员可能有不同的习惯，或者需要检查你的函数的来源，看看你使用了哪种检查，以了解你的检查的弱点是什么。
• 当您尝试在站点的控制台中编写一个不属于您的项目的行时，您会感到沮丧

只要记住typeof v === "boolean"，仅此而已。将模板添加到您的 IDE，以便能够通过一些三个字母的快捷方式放置它并感到满意。

在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