Develop Reference

Js) what will be the simplest way to check null or '' as false but not 0?

I usually used if(value) to check value is null or not. But now I know false or 0 can be false. So I used if(value == null) but in this time, that null doesn't contain '' like.
I want to check that 0, false(have specific value) as true, and I want to check that '', undefined, null as false
What will be good way to check these values simply? Is there something to notice bout like this more?

Maybe this small helper function helps? Play with it in Stackblitz.
test();
test(42);
test(Infinity);
test(null);
test(0);
test({});
test(new Map());
function test(someValue) {
if (hasValue(someValue)) {
return console.log(`${someValue} is truthy`);
}
return console.log(`${someValue} is falsy`);
}
function hasValue(v) {
// Objects are always considered values
if (v instanceof Object) {
return true;
}
const falsies2Check = [false, 0, '', null, undefined, Infinity];
return falsies2Check.find(f => f === v || isNaN(v)) === undefined ? true : false;
}

Just check for the possible values normally.
const isFalsy = param => (param === null) || (param === "") || (typeof param === "undefined")
isFalsy(null); // true
isFalsy(0); // false
I want to check that 0, false(have specific value) as true.
if(!isFalsy(value))

How to check the type of an element in a array in Jacascript [duplicate]

Does anyone know how can I check whether a variable is a number or a string in JavaScript?

If you're dealing with literal notation, and not constructors, you can use typeof:.
typeof "Hello World"; // string
typeof 123; // number
If you're creating numbers and strings via a constructor, such as var foo = new String("foo"), you should keep in mind that typeof may return object for foo.
Perhaps a more foolproof method of checking the type would be to utilize the method found in underscore.js (annotated source can be found here),
var toString = Object.prototype.toString;
_.isString = function (obj) {
return toString.call(obj) == '[object String]';
}
This returns a boolean true for the following:
_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true

Best way to do that is using isNaN + type casting:
Updated all-in method:
function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }
The same using regex:
function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); }
------------------------
isNumber('123'); // true
isNumber('123abc'); // false
isNumber(5); // true
isNumber('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber(' '); // false

The best way I have found is to either check for a method on the string, i.e.:
if (x.substring) {
// do string thing
} else{
// do other thing
}
or if you want to do something with the number check for a number property,
if (x.toFixed) {
// do number thing
} else {
// do other thing
}
This is sort of like "duck typing", it's up to you which way makes the most sense. I don't have enough karma to comment, but typeof fails for boxed strings and numbers, i.e.:
alert(typeof new String('Hello World'));
alert(typeof new Number(5));
will alert "object".

Since ES2015 the correct way to check if a variable
holds a valid number is Number.isFinite(value)
Examples:
Number.isFinite(Infinity) // false
Number.isFinite(NaN) // false
Number.isFinite(-Infinity) // false
Number.isFinite(0) // true
Number.isFinite(2e64) // true
Number.isFinite('0') // false
Number.isFinite(null) // false

You're looking for isNaN():
console.log(!isNaN(123));
console.log(!isNaN(-1.23));
console.log(!isNaN(5-2));
console.log(!isNaN(0));
console.log(!isNaN("0"));
console.log(!isNaN("2"));
console.log(!isNaN("Hello"));
console.log(!isNaN("2005/12/12"));
See JavaScript isNaN() Function at MDN.

Check if the value is a string literal or String object:
function isString(o) {
return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}
Unit test:
function assertTrue(value, message) {
if (!value) {
alert("Assertion error: " + message);
}
}
function assertFalse(value, message)
{
assertTrue(!value, message);
}
assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");
Checking for a number is similar:
function isNumber(o) {
return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

Try this,
<script>
var regInteger = /^-?\d+$/;
function isInteger( str ) {
return regInteger.test( str );
}
if(isInteger("1a11")) {
console.log( 'Integer' );
} else {
console.log( 'Non Integer' );
}
</script>

Best way to do this:
function isNumber(num) {
return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};
This satisfies the following test cases:
assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));
assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
var clas = Object.prototype.toString.call(obj).slice(8, -1);
return obj !== undefined && obj !== null && clas === type;
}
//basic usage
is('String', 'test'); // true
is('Array', true); // false
Or adapt it to return an unknown type:
function realTypeOf(obj) {
return Object.prototype.toString.call(obj).slice(8, -1);
}
//usage
realTypeOf(999); // 'Number'
May 12, 2012 Update:
Full example at Javascript: A Better typeof.

Simple and thorough:
function isNumber(x) {
return parseFloat(x) == x
};
Test cases:
console.log('***TRUE CASES***');
console.log(isNumber(0));
console.log(isNumber(-1));
console.log(isNumber(-500));
console.log(isNumber(15000));
console.log(isNumber(0.35));
console.log(isNumber(-10.35));
console.log(isNumber(2.534e25));
console.log(isNumber('2.534e25'));
console.log(isNumber('52334'));
console.log(isNumber('-234'));
console.log(isNumber(Infinity));
console.log(isNumber(-Infinity));
console.log(isNumber('Infinity'));
console.log(isNumber('-Infinity'));
console.log('***FALSE CASES***');
console.log(isNumber(NaN));
console.log(isNumber({}));
console.log(isNumber([]));
console.log(isNumber(''));
console.log(isNumber('one'));
console.log(isNumber(true));
console.log(isNumber(false));
console.log(isNumber());
console.log(isNumber(undefined));
console.log(isNumber(null));
console.log(isNumber('-234aa'));

Here's an approach based on the idea of coercing the input to a number or string by adding zero or the null string, and then do a typed equality comparison.
function is_number(x) { return x === x+0; }
function is_string(x) { return x === x+""; }
For some unfathomable reason, x===x+0 seems to perform better than x===+x.
Are there any cases where this fails?
In the same vein:
function is_boolean(x) { return x === !!x; }
This appears to be mildly faster than either x===true || x===false or typeof x==="boolean" (and much faster than x===Boolean(x)).
Then there's also
function is_regexp(x) { return x === RegExp(x); }
All these depend on the existence of an "identity" operation particular to each type which can be applied to any value and reliably produce a value of the type in question. I cannot think of such an operation for dates.
For NaN, there is
function is_nan(x) { return x !== x;}
This is basically underscore's version, and as it stands is about four times faster than isNaN(), but the comments in the underscore source mention that "NaN is the only number that does not equal itself" and adds a check for _.isNumber. Why? What other objects would not equal themselves? Also, underscore uses x !== +x--but what difference could the + here make?
Then for the paranoid:
function is_undefined(x) { return x===[][0]; }
or this
function is_undefined(x) { return x===void(0); }

Or just use the invert of isNaN():
if(!isNaN(data))
do something with the number
else
it is a string
And yes, using jQuery's $.isNumeric() is more fun for the buck.

Can you just divide it by 1?
I assume the issue would be a string input like: "123ABG"
var Check = "123ABG"
if(Check == Check / 1)
{
alert("This IS a number \n")
}
else
{
alert("This is NOT a number \n")
}
Just a way I did it recently.

I think converting the var to a string decreases the performance, at least this test performed in the latest browsers shows so.
So if you care about performance, I would, I'd use this:
typeof str === "string" || str instanceof String
for checking if the variable is a string (even if you use var str = new String("foo"), str instanceof String would return true).
As for checking if it's a number I would go for the native: isNaN; function.

uh, how about just:
function IsString(obj) {
return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}
After further review many months later, this only guarantees obj is an object that has the method or property name toLowerCase defined. I am ashamed of my answer. Please see top-voted typeof one.

Beware that typeof NaN is... 'number'
typeof NaN === 'number'; // true

jQuery uses this:
function isNumber(obj) {
return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}

This solution resolves many of the issues raised here!
This is by far the most reliable method I have used by far. I did not invent this, and cannot recall where I originally found it. But it works where other techniques fail:
// Begin public utility /getVarType/
// Returns 'Function', 'Object', 'Array',
// 'String', 'Number', 'Boolean', or 'Undefined'
getVarType = function ( data ){
if (undefined === data ){ return 'Undefined'; }
if (data === null ){ return 'Null'; }
return {}.toString.call(data).slice(8, -1);
};
// End public utility /getVarType/
Example of correctness
var str = new String();
console.warn( getVarType(str) ); // Reports "String"
console.warn( typeof str ); // Reports "object"
var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num ); // Reports "object"
var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list ); // Reports "object"

Jsut an FYI, if you're using jQuery you have
$.isNumeric()
to handle this. More details on http://api.jquery.com/jQuery.isNumeric/

the best way i found which also thinks of positive and negative numbers is from :
O'Reilly Javascript and DHTML Cookbook :
function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn't cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
oneChar = str.charAt(i).charCodeAt(0);
// OK for minus sign as first character
if (oneChar = = 45) {
if (i = = 0) {
continue;
} else {
alert("Only the first character may be a minus sign.");
return false;
}
}
// OK for one decimal point
if (oneChar = = 46) {
if (!oneDecimal) {
oneDecimal = true;
continue;
} else {
alert("Only one decimal is allowed in a number.");
return false;
}
}
// characters outside of 0 through 9 not OK
if (oneChar < 48 || oneChar > 57) {
alert("Enter only numbers into the field.");
return false;
}
}
return true;
}

Errr? Just use regular expressions! :)
function isInteger(val) {
return val.match(/^[0-9]$/)
}
function isFloat(val) {
return val.match(/^[0-9]*/\.[0-9]+$/)
}

since a string as '1234' with typeof will show 'string', and the inverse cannot ever happen (typeof 123 will always be number), the best is to use a simple regex /^\-?\d+$/.test(var). Or a more advanced to match floats, integers and negative numbers, /^[\-\+]?[\d]+\.?(\d+)?$/
The important side of .test is that it WON'T throw an exception if the var isn't an string, the value can be anything.
var val, regex = /^[\-\+]?[\d]+\.?(\d+)?$/;
regex.test(val) // false
val = '1234';
regex.test(val) // true
val = '-213';
regex.test(val) // true
val = '-213.2312';
regex.test(val) // true
val = '+213.2312';
regex.test(val) // true
val = 123;
regex.test(val) // true
val = new Number(123);
regex.test(val) // true
val = new String('123');
regex.test(val) // true
val = '1234e';
regex.test(val) // false
val = {};
regex.test(val) // false
val = false;
regex.test(val) // false
regex.test(undefined) // false
regex.test(null) // false
regex.test(window) // false
regex.test(document) // false
If you are looking for the real type, then typeof alone will do.

#BitOfUniverse's answer is good, and I come up with a new way:
function isNum(n) {
return !isNaN(n/0);
}
isNum('') // false
isNum(2) // true
isNum('2k') // false
isNum('2') //true
I know 0 can't be dividend, but here the function works perfectly.

typeof works very well for me in most case. You can try using an if statement
if(typeof x === 'string' || typeof x === 'number') {
console.log("Your statement");
}
where x is any variable name of your choice

Type checking
You can check the type of variable by using typeof operator:
typeof variable
Value checking
The code below returns true for numbers and false for anything else:
!isNaN(+variable);

XOR operation can be used to detect number or string.
number ^ 0 will always give the same number as output and string ^ 0 will give 0 as output.
Example:
1) 2 ^ 0 = 2
2) '2' ^ 0 = 2
3) 'Str' ^ 0 = 0

function IsNumeric(num) {
return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}

For detecting numbers, the following passage from JavaScript: The Good Parts by Douglas Crockford is relevant:
The isFinite function is the best way of determining whether a value can be used as a number because it rejects NaN and Infinity . Unfortunately, isFinite will attempt to convert its operand to a number, so it is not a good test if a value is not actually a number. You may want to define your own isNumber function:
var isNumber = function isNumber(value) { return typeof value === 'number' &&
isFinite(value);
};

Simply use
myVar.constructor == String
or
myVar.constructor == Number
if you want to handle strings defined as objects or literals and saves you don't want to use a helper function.

Very late to the party; however, the following has always worked well for me when I want to check whether some input is either a string or a number in one shot.
return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);

Checking if multiple variables is not null, undefined or empty in an efficient way

At the moment I have an if condition like this:
if(
(variable != null && variable != '' && !variable) &&
(variable2 != null && variable2 != '' && !variable2) &&
(variable3 != null && variable3 != '' && !variable3)
//etc..
)
I need to use it to check if multiple variables have value (were not left out), but I feel like this is a messy solution and wanted to ask if there is a more efficient way? Maybe additional checks as well?

Because if(variable) ignores any falsy value, this will work for you
if(variable && variable2 && variable3)
The following values are always falsy in JS:
false.
0 (zero)
"" (empty string)
null.
undefined.
NaN (a special Number value meaning Not-a-Number!)
Update:-
If there is a case when you want to execute if block even if the value is 0, you have to add an extra check saying either 0 or some other value.
if((variable || variable === 0) && (variable2 || variable2 === 0) && (variable3 || variable3 === 0))

If IE support matter to you (IE9+), you could use the following solution.
You could use Array.prototype.some(). In a nutshell this array method will return true if any of the elements in the array meet a certain condition. This condition will be el == null this will work because undefined == null and null == null both resolve in true
See this stackoverflow post for more information
Which equals operator (== vs ===) should be used in JavaScript comparisons?
Array.prototype.some() browser support (93% time of writing) here
var a = 5;
var b = null;
var c = undefined;
if ( [a,b,c].some(el => el == null) ) {
console.log("You f*d up")
}
Or you could use Array.prototype.includes()
See support (93% time of writing) here here
var a = 5;
var b = null;
var c = undefined;
if ( [a,b,c].includes(undefined) || [a,b,c].includes(null) ) {
console.log("You f*d up")
}
If you want good browser support and you don't mind an external library, use lodash.
var a = 5;
var b = null;
var c = undefined;
if ( _.some([a,b,c], el => _.isNil(el)) ) {
console.log("You f*d up")
}
<script src="https://cdn.jsdelivr.net/lodash/4.17.4/lodash.min.js"></script>

If your variables are containing some values that are truthy, like a string, and that is considered positive in your condition, then you could simply check using Array.prototype.every()...
if (![var1, var2, var3].every(Boolean)) {
throw new exc;
}
Which will check to ensure every variable has a truthy value.

I assume you are checking for truthy values? If so, you can just do:
variable && variable2 && variable3

See JavaScript: What is the difference between if (!x) and if (x == null)?
!variable will be true for all falsy values so you only have to
if(variable1 && variable2 && variable3 && ...)

Long hand -
if (var1 !== null || var1 !== undefined || var1 !== '') {
let var2 = var1;
}
Short hand -
const var2 = var1 || '';

let variable null;
let variable2 undefined;
let variable3 'string';
let variable4 '';
let variable5 true;
let variable6 false;
let variable7 0;
let variable8 1;
Validating multiple values using the filter function. One could expect this example to return true as the count would be 5 for (variable, variable2, variable4, variable6, variable7)
if([variable, variable2, variable3, variable4, variable5, variable6, variable7, variable8]
.filter(q=>!q).length > 0) {
//take action
}

How to check if type is Boolean

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?

That's what typeof is there for. The parentheses are optional since it is an operator.
if (typeof variable == "boolean") {
// variable is a boolean
}

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.

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) {
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

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;
}

You can use pure Javascript to achieve this:
var test = true;
if (typeof test === 'boolean')
console.log('test is a boolean!');

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;
}

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.

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

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

the easiest way to check for true and false is :
(typeof value === "boolean") ,
but if value is an instance of the Boolean class, then it will return "object". so to handle that we must add another condition to check if :
(value instanceof Boolean)
the code snippet :
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");

You can create a function that checks the typeof for an argument.
function isBoolean(value) {
return typeof value === "boolean";
}

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.
you need to recreate them in every project you are involved
other developers might have different habits,, or need to check source of your function to see which impementation of check you use, to know what are weak points of your check
you will be fruustrated when you will try to write one liner in console on site which doesn't belong to your project
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.

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

One more decision with es2015 arrow function
const isBoolean = val => typeof val === 'boolean';

The most readable: val === false || val === true.
Also readable: typeof variable == typeof true.
The shortest, but not readable at all: !!val === val.
Explanation:
[!!] The double exclamation mark converts the value into a Boolean.
[===] The triple equals test for strict equality: both the type (Boolean) and the value have to be the same.
If the original value is not a Boolean one, it won't pass the triple equals test. If it is a Boolean variable, it will pass the triple equals test (with both type & value).
Tests:
!!5 === 5 // false
!!'test' === 'test' // false
let val = new Date(); !!val === val // false
!!true === true // true
!!false === false // true

Update: The previous solution is more specific, you can choose which value you want to consider as a boolean and you can add that in regex, If you need a more general solution and don't want to add a library then check out the below solution(taken from lodash's boolean)
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]')
}
Previous Solution
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>');

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

How can I check if two values are not equal to null with javascript?

I have the following code:
var store = window.localStorage;
var a = store.getItem('AccountID');
var b = store.getItem('CityID')
How can I make it so my refreshGrid("Page"); function only runs if both of these are set to values?

If you want to check that they are explicity null, just compare the values to null:
if(a !== null && b !== null) {
//Neither is null
}
If you are storing values in there that should always evaluate to true, you can skip the equality checks (if nothing is stored in that particular storage item this will still fail, since null is falsy):
if(a && b) {
//Neither is falsy
}

You can use this:
var a; var b;
if (a == null && b == null) {
//a and b are null
}
OR
if (!a && !b) {
   //a and b are null, undefined, 0 or false
}
For James: alert(null == undefined) // returns true
Hope this helps.

Use a guard condition at the top of your function:
function myFunction() {
if(a==null || b==null) return;
// ... rest of the code here
}

I think the following code is what your looking for.
if(!!a && !!b){
alert("this is not null")
}else{
alert("this is null")
}