Type Checking (Lang)

/**
 * Checks if `value` is classified as an `Array` object.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 */
function isArray(value);

var isArray = require('lodash.isarray');

isArray([1, 2, 3]);
// => true

isArray(document.body.children);
// => false

isArray('abc');
// => false

isArray(function() { return arguments; }());
// => false

/**
 * Checks if `value` is the language type of `Object`.
 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 */
function isObject(value);

var isObject = require('lodash.isobject');

isObject({});
// => true

isObject([1, 2, 3]);
// => true

isObject(function() {});
// => true

isObject(null);
// => false

/**
 * Checks if `value` is classified as a `String` primitive or object.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 */
function isString(value);

var isString = require('lodash.isstring');

isString('abc');
// => true

isString(1);
// => false

/**
 * Checks if `value` is classified as a `Number` primitive or object.
 *
 * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified
 * as numbers, use the `_.isFinite` method.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 */
function isNumber(value);

var isNumber = require('lodash.isnumber');

isNumber(3);
// => true

isNumber(Number.MIN_VALUE);
// => true

isNumber(Infinity);
// => true

isNumber('3');
// => false

/**
 * Checks if `value` is classified as a `Boolean` primitive or object.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 */
function isBoolean(value);

var isBoolean = require('lodash.isboolean');

isBoolean(false);
// => true

isBoolean(null);
// => false

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 */
function isFunction(value);

var isFunction = require('lodash.isfunction');

isFunction(function() {});
// => true

isFunction(/abc/);
// => false

/**
 * Checks if `value` is classified as a `Date` object.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 */
function isDate(value);

var isDate = require('lodash.isdate');

isDate(new Date);
// => true

isDate('Mon April 23 2012');
// => false

/**
 * Checks if `value` is an empty object, collection, map, or set.
 *
 * Objects are considered empty if they have no own enumerable string keyed
 * properties.
 *
 * Array-like values such as `arguments` objects, arrays, buffers, strings, or
 * jQuery-like collections are considered empty if they have a `length` of `0`.
 * Similarly, maps and sets are considered empty if they have a `size` of `0`.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is empty, else `false`.
 */
function isEmpty(value);

var isEmpty = require('lodash.isempty');

isEmpty(null);
// => true

isEmpty(true);
// => true

isEmpty(1);
// => true

isEmpty([1, 2, 3]);
// => false

isEmpty({ a: 1 });
// => false

/**
 * Performs a deep comparison between two values to determine if they are
 * equivalent.
 *
 * **Note:** This method supports comparing arrays, array buffers, booleans,
 * date objects, error objects, maps, numbers, `Object` objects, regexes,
 * sets, strings, symbols, and typed arrays.
 *
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 */
function isEqual(value, other);

var isEqual = require('lodash.isequal');

var object = { a: 1 };
var other = { a: 1 };

isEqual(object, other);
// => true

object === other;
// => false

/**
 * Checks if `value` is `null`.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
 */
function isNull(value);

var isNull = require('lodash.isnull');

isNull(null);
// => true

isNull(void 0);
// => false

/**
 * Checks if `value` is `undefined`.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
 */
function isUndefined(value);

var isUndefined = require('lodash.isundefined');

isUndefined(void 0);
// => true

isUndefined(null);
// => false

/**
 * Checks if `value` is `NaN`.
 *
 * **Note:** This method is based on [`Number.isNaN`](https://mdn.io/Number/isNaN)
 * and is not the same as global [`isNaN`](https://mdn.io/isNaN) which returns
 * `true` for `undefined` and other non-number values.
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
 */
function isNaN(value);

var isNaN = require('lodash.isnan');

isNaN(NaN);
// => true

isNaN(new Number(NaN));
// => true

isNaN(undefined);
// => false

/**
 * Checks if `value` is a finite primitive number.
 *
 * **Note:** This method is based on [`Number.isFinite`](https://mdn.io/Number/isFinite).
 *
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
 */
function isFinite(value);

var isFinite = require('lodash.isfinite');

isFinite(3);
// => true

isFinite(Number.MAX_VALUE);
// => true

isFinite(3.14);
// => true

isFinite(Infinity);
// => false

npm install lodash.isarray lodash.isobject lodash.isstring lodash.isnumber
npm install lodash.isboolean lodash.isfunction lodash.isdate lodash.isempty
npm install lodash.isequal lodash.isnull lodash.isundefined lodash.isnan
npm install lodash.isfinite