如何检查类型是否为布尔

我如何检查一个变量的类型是否为布尔类型?

我的意思是，有一些替代方案，比如:

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

但这对我来说不太好。

有没有更清洁的方式来实现这个目标?

437875 次浏览
小开
最佳答案

这就是typeof的作用。括号是可选的，因为它是操作符。

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

你可以使用纯Javascript来实现这一点:

var test = true;
if (typeof test === 'boolean')
console.log('test is a 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 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

小开

我将使用Lodash: isBoolean检查传入的变量是基元布尔值还是布尔包装器对象，从而解释所有情况。

小开

对于纯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"

在反应中，如果使用propTypes，你可以像这样检查一个值是否为布尔值:

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

如果使用打印稿，你也可以使用类型布尔:

let isDone: boolean = false;

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

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

或者像:

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

叫它!

isBoolean(false); //return true

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

小开

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

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

如果你想让你的函数也可以验证布尔对象，最有效的解决方案必须是:

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

使用或不使用jQuery，有三种“普通”方法来检查这一点。

  1. 首先是强制布尔值，然后检查它是否等于原始值:

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

  2. Doing a simple typeof check:

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

  3. Doing a completely overkill and unnecessary instantiation of a class wrapper on a primative:

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

The third will only return true if you create a new Boolean class and pass that in.

To elaborate on primitives coercion (as shown in #1), all primitives types can be checked in this way:

  • Boolean:

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

  • Number:

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

  • String:

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

有时我们只需要一种方法来检验。Typeof不能用于date等。所以我用

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

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

小开

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

  • 您需要在参与的每个项目中重新创建它们
  • 其他开发人员可能有不同的习惯，或者需要检查您的函数的源代码，以查看您使用的检查的实现，以了解您的检查的弱点
  • 你会感到沮丧，当你试图写一行在控制台现场不属于你的项目

只要记住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 // false
    • ！!'test' === 'test' // false
    • let val = new Date();！!Val === Val // false
    • ！!True === True // True
    • ！!False === False // true
      • 李< / ul > < / >
小开

在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';
小开

基准:

都很相似……

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
小开

更新:前面的解决方案是更具体的，你可以选择哪个值你想考虑作为布尔值，你可以添加到regex，如果你需要一个更通用的解决方案，不想添加一个库，然后检查下面的解决方案(从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>');

小开
检查真假最简单的方法是: (typeof value === "boolean"), 但如果value是Boolean类的实例，则它将返回"object"。因此，为了处理这个问题，我们必须添加另一个条件来检查是否: (value instanceof Boolean) < / p >

代码片段:

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

提交答案