Assertions

Functions for testing the type of a value.

Most of these are trivially simple functions that are already one-liners. I find it easier to write (and read) isBoolean(foo) than typeof foo === 'boolean'.

isBoolean(value)

Determines if a value is a boolean. Returns true if the value is true or false. Otherwise it returns false.

isBoolean(true);         // true
isBoolean(false);        // true
isBoolean(1);            // false
isBoolean(0);            // false

Values that can be coerced to boolean values (e.g. the numbers 0 and 1) are not considered booleans and the function will return false.

isString(value)

Determines if a value is a string. Returns Boolean true or false.

isString('Hello World'); // true
isString(42);            // false

isNumber(value)

Determines if a value is a number. Returns Boolean true or false.

isNumber(42);      // true
isNumber(42.43);   // true
isNumber("42");    // false

isInteger(value)

Determines if a value is an integer. Returns Boolean true or false.

isInteger(42);      // true
isInteger(42.0);    // true
isInteger(42.43);   // false
isInteger("42");    // false

Note that numbers with decimal parts that are zero (e.g. 42.0) are considered to be integers.

isFloat(value)

Determines if a value is a floating point number. Returns Boolean true or false.

isFloat(42);      // false
isFloat(42.0);    // false
isFloat(42.43);   // true
isFloat("42");    // false

Note that numbers with decimal parts that are zero (e.g. 42.0) are considered to be integers and the function will return false in those cases.

isArray(value)

Determines if a value is an array. Returns Boolean true or false.

isArray([42, 43]);  // true
isArray("42, 43");  // false

isFunction(value)

Determines if a value is a function. Returns Boolean true or false.

isFunction( a => a + 1 );     // true
isFunction("badger badger");  // false

isRegExp(value)

Determines if a value is a RegExp object. Returns Boolean true or false.

isRegExp(/badger/);         // true
isRegExp("badger badger");  // false

isObject(value)

Determines if a value is an object.

Javascript's concept of an object is ambiguous because a number of different data types are considered to be objects, including Array and null. This function will return false for arrays and null values and only return true for values that are objects in the more traditional sense: an instance of a class (e.g. new Date()) or a data structure created with curly braces (e.g. { b: 'badger' }).

Returns Boolean true or false.

isObject(new Date());        // true
isObject({ b: 'badger' });   // true
isObject([10, 20]);          // false
isObject(null);              // false

isSimple(value)

Determines if a value is a "simple" scalar value, e.g. a string, number or boolean value.

isSimple('eleven');        // true
isSimple(11);              // true
isSimple(11.0);            // true
isSimple(true);            // true
isSimple(false);           // true
isSimple({ });             // false
isSimple([ ]);             // false
isSimple(null);            // false

isUndefined(value)

Determines if a value has the undefined value. Returns Boolean true or false.

Note that this does not include null. Use hasValue(value) or noValue(value) to test for a value being either undefined or null.

isUndefined(undefined); // true
isUndefined(null);      // false
isUndefined(0);         // false

isNull(value)

Determines if a value has the null value. Returns Boolean true or false.

Note that this does not include undefined values. Use hasValue(value) or noValue(value) to test for a value being either undefined or null.

isNull(null);      // true
isNull(undefined); // false
isNull(0);         // false

hasValue(value)

Determines if a value has a defined and non-null value. Returns Boolean true or false.

Note that this is subtly different from Javascript's idea of truth. This function will return true if the value is a boolean false or the number 0. However, it is the same as Javascript's Nullish coalescing operator?? which returns the right operand when the left operand is null or undefined.

hasValue(0);         // true
hasValue(false);     // true
hasValue(null);      // false
hasValue(undefined); // false

noValue(value)

Determines if a value does not have a defined and non-null value. It is the logical negation of hasValue(). Returns Boolean true or false.

noValue(null);      // true
noValue(undefined); // true
noValue(0);         // true
noValue(false);     // true

haveValue(...values)

Determines if all the values passed as arguments have defined and non-null value (via hasValue()). Returns Boolean true or false.

haveValue(0, 1, 2);         // true
haveValue(0, 1, undefined); // false

firstValue(...values)

Returns the first argument that has a defined and non-null value, tested using hasValue().

firstValues(0, 1, 2);         // 0
firstValues(undefined, 1, 2); // 1
firstValues(null, 2, 3);      // 2
firstValues(false, 3, 4);     // false

isEmpty(value)

Determines if an array or object value is empty. For an array it's equivalent to value.length === 0. For an object it's Object.keys(value).length === 0. Returns Boolean true or false.

isEmpty([ ])            // true
isEmpty({ })            // true
isEmpty([ 10 ])         // false
isEmpty({ a: 10 })      // false