Question

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

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

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

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

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

Answer 1

那是typeof的用途。括号是可选的，因为它是运算符。

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

Answer 2

如果您只想检查原始值

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

Answer 3

使用纯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 中，如果使用propTypes，您可以像这样检查一个boolean值：

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检查。

Answer 4

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

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

Answer 5

有三个＆＃34;香草＆＃34;用或不用jQuery检查这个的方法。

首先强制进行布尔评估，然后检查它是否等于原始值：
```
function isBoolean( n ) {
    return !!n === n;
}
```

进行简单的typeof检查：

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

对一个主要的类包装器进行完全过度杀伤和不必要的实例化：
```
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;
}

Answer 6

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

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

Answer 7

我会选择Lodash：isBoolean检查传入的变量是基本布尔值还是布尔包装器对象，因此可以解释所有情况。

Answer 8

在JavaScript中检查变量类型的最可靠方法是the following：

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"。

Answer 9

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

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

Answer 10

有时我们需要一种方法来检查它。类型不适合约会等。所以我通过

轻松完成了

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

同样适用于Number，String，Boolean等。我们经常需要以单一方式检查类型......

Answer 11

创建包含oneliner isBoolean的{{1}}等函数从长远来看似乎非常不方便。我很惊讶几乎每个人都建议创建自己的功能。它似乎与扩展原生原型相同。

您需要在所涉及的每个项目中重新创建它们
其他开发者可能有不同的习惯，或者需要检查您的功能来源，看看您使用哪种检查功能，以了解检查的弱点
当您尝试在现场的控制台中编写一个不属于您的项目的内衬时，您将会被榨干

只记得typeof v === "boolean"以及所有内容。将模板添加到IDE中，以便能够通过三个字母的快捷方式添加它，并感到高兴。

Answer 12

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

如果您有字符串

Answer 13

可读性最高的val === false || val === true。
可读性：typeof variable == typeof true。
最短但根本不可读的!!val === val。

说明：
- [!!] 双重感叹号标记将值转换为布尔值。
- [===] 三重等于测试是否严格相等：类型（布尔值）和值必须相同。
- 如果原始值不是布尔值，则不会通过三重等于测试。如果它是布尔变量，它将通过三重等于测试（类型和值都为）。
测试：
- !! 5 === 5 //否
- !!'test'==='test'//错误
- 让val = new Date（）; !! val === val // false
- !! true === true // true
- !! false ===否//正确

Answer 14

Benchmarking：

都很相似...

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

Answer 15

在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

Answer 16

使用es2015箭头功能的另一个决定

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

Answer 17

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>');

如何检查type是否为Boolean

17 个答案: