How can I check if a variable's type is of type Boolean?
I mean, there are some alternatives such as:
if(jQuery.type(new Boolean()) === jQuery.type(variable))
//Do something..
But that doesn't seem pretty to me.
Is there a cleaner way to achieve this?
This question is related to
javascript
jquery
types
If you want your function can validate boolean objects too, the most efficient solution must be:
function isBoolean(val) {
return val === false || val === true || val instanceof Boolean;
}
You can create a function that checks the typeof
for an argument.
function isBoolean(value) {
return typeof value === "boolean";
}
In nodejs by using node-boolify we can use 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
val === false || val === true
.typeof variable == typeof true
.The shortest, but not readable at all: !!val === val
.
Explanation:
Tests:
There are three "vanilla" ways to check this with or without jQuery.
First is to force boolean evaluation by coercion, then check if it's equal to the original value:
function isBoolean( n ) {
return !!n === n;
}
Doing a simple typeof
check:
function isBoolean( n ) {
return typeof n === 'boolean';
}
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;
}
if(['true', 'yes', '1'].includes(single_value)) {
return true;
}
else if(['false', 'no', '0'].includes(single_value)) {
return false;
}
if you have a string
With pure JavaScript, you can just simply use typeof
and do something like typeof false
or typeof true
and it will return "boolean"
...
But that's not the only way to do that, I'm creating functions below to show different ways you can check for Boolean in JavaScript, also different ways you can do it in some new frameworks, let's start with this one:
function isBoolean(val) {
return val === false || val === true;
}
Or one-line ES6 way ...
const isBoolean = val => 'boolean' === typeof val;
and call it like!
isBoolean(false); //return true
Also in Underscore source code they check it like this(with the _. at the start of the function name):
isBoolean = function(obj) {
return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
};
Also in jQuery you can check it like this:
jQuery.type(true); //return "boolean"
In React, if using propTypes, you can check a value to be boolean like this:
MyComponent.propTypes = {
children: PropTypes.bool.isRequired
};
If using TypeScript, you can use type boolean also:
let isDone: boolean = false;
Also another way to do it, is like converting the value to boolean and see if it's exactly the same still, something like:
const isBoolean = val => !!val === val;
or like:
const isBoolean = val => Boolean(val) === val;
and call it!
isBoolean(false); //return true
It's not recommended using any framework for this as it's really a simple check in JavaScript.
I would go with Lodash: isBoolean checks whether the passed-in variable is either primitive boolean or Boolean wrapper object and so accounts for all cases.
One more decision with es2015 arrow function
const isBoolean = val => typeof val === 'boolean';
You can use pure Javascript to achieve this:
var test = true;
if (typeof test === 'boolean')
console.log('test is a boolean!');
BENCHMARKING:
All pretty similar...
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
Sometimes we need a single way to check it. typeof not working for date etc. So I made it easy by
Date.prototype.getType() { return "date"; }
Also for Number
, String
, Boolean
etc. we often need to check the type in a single way...
Creating functions like isBoolean
which contains oneliner typeof v === "boolean"
seems very unhandy in long term. i am suprised that almost everyone suggest to create your own function. It seems to be same cancer as extending native prototypes.
just memoize typeof v === "boolean"
and that's all.
Add a template to your IDE to be able to put it by some three letter shortcut and be happy.
The most reliable way to check type of a variable in JavaScript is 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"
The reason for this complication is that typeof true
returns "boolean"
while typeof new Boolean(true)
returns "object"
.
If you just want to check for a primitive value
typeof variable === 'boolean'
If for some strange reason you have booleans created with the constructor, those aren't really booleans but objects containing a primitive boolean value, and one way to check for both primitive booleans and objects created with new Boolean
is to do :
function checkBool(bool) {
return typeof bool === 'boolean' ||
(typeof bool === 'object' &&
bool !== null &&
typeof bool.valueOf() === 'boolean');
}
function checkBool(bool) {_x000D_
return typeof bool === 'boolean' || _x000D_
(typeof bool === 'object' && _x000D_
bool !== null &&_x000D_
typeof bool.valueOf() === 'boolean');_x000D_
}_x000D_
_x000D_
console.log( checkBool( 'string' )); // false, string_x000D_
console.log( checkBool( {test: 'this'} )); // false, object_x000D_
console.log( checkBool( null )); // false, null_x000D_
console.log( checkBool( undefined )); // false, undefined_x000D_
console.log( checkBool( new Boolean(true) )); // true_x000D_
console.log( checkBool( new Boolean() )); // true_x000D_
console.log( checkBool( true )); // true_x000D_
console.log( checkBool( false )); // true
_x000D_
Source: Stackoverflow.com