@fabiospampinato/is
Advanced tools
The definitive collection of is* functions for runtime type checking. Lodash-compatible, tree-shakable, with types.
The definitive collection of is* functions for runtime type checking. Realms support, tree-shakable, with types.
Every function provided accepts a single argument of unknown type and returns a boolean, almost always as a TypeScript type guard.
npm install is@npm:@fabiospampinato/is
isArgumentsChecks if a value is an arguments object.
import {isArguments} from 'is';
const args = (function () { return arguments; })();
isArguments ( args ); // => true
isArguments ( [] ); // => false
isArrayBufferChecks if a value is an ArrayBuffer object.
import {isArrayBuffer} from 'is';
isArrayBuffer ( new ArrayBuffer ( 8 ) ); // => true
isArrayBuffer ( [] ); // => false
isArrayLikeObjectChecks if a value is an Array-like object, meaning a non-string and non-function with an integer length property.
import {isArrayLikeObject} from 'is';
isArrayLikeObject ( [] ); // => true
isArrayLikeObject ( { length: 1 } ); // => true
isArrayLikeObject ( 'foo' ); // => false
isArrayLikeObject ( isArrayLikeObject ); // => false
isArrayLikeChecks if a value is an Array-like object, meaning a non-function with an integer length property.
import {isArrayLike} from 'is';
isArrayLike ( [] ); // => true
isArrayLike ( { length: 1 } ); // => true
isArrayLike ( 'foo' ); // => true
isArrayLike ( isArrayLike ); // => false
isArrayChecks if a value is an Array.
import {isArray} from 'is';
isArray ( [] ); // => true
isArray ( {} ); // => false
isArrowFunctionChecks if a value is an arrow function. There's a detectable difference between regular and arrow functions.
import {isArrowFunction} from 'is';
isArrowFunction ( () => {} ); // => true
isArrowFunction ( function () {} ); // => false
isAsyncFunctionChecks if a value is an async function. Note that this will return false for async generator functions.
import {isAsyncFunction} from 'is';
isAsyncFunction ( async () => {} ); // => true
isAsyncFunction ( () => {} ); // => false
isAsyncGeneratorFunctionChecks if a value is an async generator function.
import {isAsyncGeneratorFunction} from 'is';
isAsyncGeneratorFunction ( function* () {} ); // => true
isAsyncGeneratorFunction ( function () {} ); // => false
isAsyncIterableChecks if a value is an async iterable.
import {isAsyncIterable} from 'is';
const myAsyncIterable = {
async * [Symbol.asyncIterator]() {
yield 'hello';
}
};
isAsyncIterable ( myAsyncIterable ); // => true
isAsyncIterable ( [] ); // => false
isAttributeChecks if a value is likely a DOM attribute.
import {isAttribute} from 'is';
isAttribute ( document.createAttribute ( 'foo' ) ); // => true
isAttribute ( body ); // => false
isBigIntChecks if a value is a bigint.
import {isBigInt} from 'is';
isBigInt ( 0n ); // => true
isBigInt ( 0 ); // => false
isBigInt64ArrayChecks if a value is a BigInt64Array.
import {isBigInt64Array} from 'is';
isBigInt64Array ( new BigInt64Array () ); // => true
isBigInt64Array ( [] ); // => false
isBigUint64ArrayChecks if a value is a BigUint64Array.
import {isBigUint64Array} from 'is';
isBigUint64Array ( new BigUint64Array () ); // => true
isBigUint64Array ( [] ); // => false
isBlobChecks if a value is a Blob.
import {isBlob} from 'is';
isBlob ( new Blob ( [] ) ); // => true
isBlob ( [] ); // => false
isBooleanChecks if a value is a boolean.
import {isBoolean} from 'is';
isBoolean ( true ); // => true
isBoolean ( false ); // => true
isBoolean ( 0 ); // => false;
isBoundFunctionChecks if a value is a bound function.
import {isBoundFunction} from 'is';
isBoundFunction ( (function () {}).bind ( this ) ); // => true
isBoundFunction ( () => {} ); // => true
isBoundFunction ( function () {} ); // => false
isBoxedBigIntCheck if a value is a boxed bigint.
import {isBoxedBigInt} from 'is';
isBoxedBigInt ( 0n ); // => false
isBoxedBigInt ( Object ( 0n ) ); // => true
isBoxedBooleanCheck if a value is a boxed boolean.
import {isBoxedBoolean} from 'is';
isBoxedBoolean ( true ); // => false
isBoxedBoolean ( Object ( true ) ); // => true
isBoxedNumberCheck if a value is a boxed number.
import {isBoxedNumber} from 'is';
isBoxedNumber ( 0 ); // => false
isBoxedNumber ( Object ( 0 ) ); // => true
isBoxedPrimitiveCheck if a value is a boxed primitive.
import {isBoxedPrimitive} from 'is';
isBoxedPrimitive ( 0 ); // => false
isBoxedPrimitive ( Object ( 0 ) ); // => true
isBoxedPrimitive ( Object ( 0n ) ); // => true
isBoxedStringCheck if a value is a boxed string.
import {isBoxedString} from 'is';
isBoxedString ( 'foo' ); // => false
isBoxedString ( Object ( 'foo' ) ); // => true
isBoxedSymbolCheck if a value is a boxed symbol.
import {isBoxedSymbol} from 'is';
isBoxedSymbol ( Symbol () ); // => false
isBoxedSymbol ( Object ( Symbol () ) ); // => true
isBufferChecks if a value is a Buffer.
import {isBuffer} from 'is';
isBuffer ( Buffer.from ( '' ) ); // => true
isBuffer ( [] ); // => false
isClassChecks if a value is an ES6 class. Note that classes lowered to work in ES5 are not actual classes anymore, there's a detectable difference when the class keyword is used.
import {isClass} from 'is';
isClass ( class Foo {} ); // => true
isClass ( isClass ); // => false
isCommentChecks if a value is likely a DOM comment.
import {isComment} from 'is';
isComment ( document.createComment ( 'foo' ) ); // => true
isComment ( body ); // => false
isDataViewChecks if a value is a DataView.
import {isDataView} from 'is';
isDataView ( new DataView ( new ArrayBuffer ( 2 ) ) ); // => true
isDataView ( [] ); // => false
isDateChecks if a value is a Date.
import {isDate} from 'is';
isDate ( new Date () ); // => true
isDate ( 0 ); // => false
isDefinedChecks if a value is not undefined, nor null.
import {isDefined} from 'is';
isDefined ( undefined ); // => false
isDefined ( null ); // => false
isDefined ( 0 ); // => true
isDocumentChecks if a value is likely a DOM document.
import {isDocument} from 'is';
isDocument ( document ); // => true
isDocument ( window ); // => false
isDocumentFragmentChecks if a value is likely a DOM document fragment.
import {isDocumentFragment} from 'is';
isDocumentFragment ( new DocumentFragment () ); // => true
isDocumentFragment ( document ); // => false
isDocumentTypeChecks if a value is likely a DOM document type.
import {isDocumentType} from 'is';
isDocumentType ( document.doctype ); // => true
isDocumentType ( document ); // => false
isElementChecks if a value is likely a DOM element.
import {isElement} from 'is';
isElement ( body ); // => true
isElement ( window ); // => false
isEmptyChecks if a value is an empty array, string, buffer, typed array, arguments object, map, set, prototype or regular object.
import {isEmpty} from 'is';
isEmpty ( [] ); // => true
isEmpty ( {} ); // => true
isEmpty ( 123 ); // => true
isEmpty ( [123] ); // => false
isErrorChecks if a value is an Error.
import {isError} from 'is';
isError ( new Error () ); // => true
isError ( { message: 'asd' } ); // => false
isEvenChecks if a value is an even integer.
import {isEven} from 'is';
isEven ( 2 ); // => true
isEven ( 1 ); // => false
isFalsyChecks if a value is falsy.
import {isFalsy} from 'is';
isFalsy ( 0 ); // => true
isFalsy ( '' ); // => true
isFalsy ( [] ); // => false
isFiniteChecks if a value is a finite number.
import {isFinite} from 'is';
isFinite ( 0 ); // => true
isFinite ( Infinity ); // => false
isFinite ( -Infinity ); // => false
isFinite ( NaN ); // => false
isFloatChecks if a value is a float.
import {isFloat} from 'is';
isFloat ( 1.2 ); // => true
isFloat ( 0 ); // => false
isFloat ( -1 ); // => false
isFloat32ArrayChecks if a value is a Float32Array.
import {isFloat32Array} from 'is';
isFloat32Array ( new Float32Array () ); // => true
isFloat32Array ( [] ); // => false
isFloat64ArrayChecks if a value is a Float64Array.
import {isFloat64Array} from 'is';
isFloat64Array ( new Float64Array () ); // => true
isFloat64Array ( [] ); // => false
isFrozenChecks if a value is frozen.
import {isFrozen} from 'is';
isFrozen ( Object.freeze ( {} ) ); // => true
isFrozen ( {} ); // => false
isFunctionChecks if a value is a function.
import {isFunction} from 'is';
isFunction ( isFunction ); // => true
isFunction ( { call: () => {} } ); // => false
isGeneratorFunctionChecks if a value is a generator function. Note that this will return false for async generator functions.
import {isGeneratorFunction} from 'is';
isGeneratorFunction ( function* () {} ); // => true
isGeneratorFunction ( function () {} ); // => false
isInt8ArrayChecks if a value is a Int8Array.
import {isInt8Array} from 'is';
isInt8Array ( new Int8Array () ); // => true
isInt8Array ( [] ); // => false
isInt16ArrayChecks if a value is a Int16Array.
import {isInt16Array} from 'is';
isInt16Array ( new Int16Array () ); // => true
isInt16Array ( [] ); // => false
isInt32ArrayChecks if a value is a Int32Array.
import {isInt32Array} from 'is';
isInt32Array ( new Int32Array () ); // => true
isInt32Array ( [] ); // => false
isIntegerChecks if a value is an integer.
import {isInteger} from 'is';
isInteger ( 0 ); // => true
isInteger ( -1 ); // => true
isInteger ( 1.2 ); // => false
isIterableChecks if a value is an iterable.
import {isIterable} from 'is';
isIterable ( [] ); // => true
isIterable ( {} ); // => false
isLengthChecks if a value could be a valid length index.
import {isLength} from 'is';
isLength ( 0 ); // => true
isLength ( -1 ); // => false
isLength ( 1.2 ); // => false
isLength ( Infinity ); // => false
isMapChecks if a value is a Map.
import {isMap} from 'is';
isMap ( new Map () ); // => true
isMap ( {} ); // => false
isNaNChecks if a value is exactly NaN.
import {isNaN} from 'is';
isNaN ( NaN ); // => true
isNaN ( undefined ); // => false
isNativeChecks if a value is likely a native function.
import {isNative} from 'is';
isNative ( [].push ); // => true
isNative ( isNative ); // => false
isNegativeZeroChecks if a value is a negative zero, which if you didn't know is detectably different from a positive zero, for real.
import {isNegativeZero} from 'is';
isNegativeZero ( -0 ); // => true
isNegativeZero ( 0 ); // => false
isNilChecks if a value is null or undefined.
import {isNil} from 'is';
isNil ( null ); // => true
isNil ( undefined ); // => true
isNil ( {} ); // => false
isNodeChecks if a value is likely a DOM node.
import {isNode} from 'is';
isNode ( document.body ); // => true
isNode ( undefined ); // => false
isNullChecks if a value is null.
import {isNull} from 'is';
isNull ( null ); // => true
isNull ( undefined ); // => false
isNumberChecks if a value is a number.
import {isNumber} from 'is';
isNumber ( 0 ); // => true
isNumber ( Infinity ); // => true
isNumber ( -Infinity ); // => true
isNumber ( NaN ); // => true
isNumber ( '0' ); // => false
isNumberLikeChecks if a string can be safely converted to a number.
import {isNumberLike} from 'is';
isNumberLike ( '3' ); // => true
isNumberLike ( '12.3' ); // => true
isNumberLike ( '1e100' ); // => true
isNumberLike ( '0xff' ); // => true
isNumberLike ( 'foo' ); // => false
isObjectLikeChecks if a value is an object (not necessarily a plain object).
import {isObjectLike} from 'is';
isObjectLike ( {} ); // => true
isObjectLike ( [] ); // => true
isObjectLike ( isObjectLike ); // => false
isObjectChecks if a value is not a primitive. This is the opposite of isPrimitive.
import {isObject} from 'is';
isObject ( {} ); // => true
isObject ( [] ); // => true
isObject ( isObject ); // => true
isObject ( 123 ); // => false
isOddChecks if a value is an odd integer.
import {isOdd} from 'is';
isOdd ( 1 ); // => true
isOdd ( 2 ); // => false
isPlainObjectChecks if a value is a plain object.
import {isPlainObject} from 'is';
isPlainObject ( {} ); // => true
isPlainObject ( [] ); // => false
isPlainObject ( isPlainObject ); // => false
isPrimitiveChecks if a value is a primitive. This is the opposite of isObject.
import {isPrimitive} from 'is';
isPrimitive ( null ); // => true
isPrimitive ( undefined ); // => true
isPrimitive ( '' ); // => true
isPrimitive ( 0 ); // => true
isPrimitive ( 0n ); // => true
isPrimitive ( true ); // => true
isPrimitive ( Symbol () ); // => true
isPrimitive ( {} ); // => false
isPrimitive ( isPrimitive ); // => false
isPromiseChecks if a value is a Promise.
import {isPromise} from 'is';
isPromise ( Promise.resolve () ); // => true
isPromise ( Promise.reject () ); // => true
isPromise ( { then: () => {} } ); // => false
isPrototypeChecks if a value is likely a prototype.
import {isPrototype} from 'is';
isPrototype ( Array.prototype ); // => true
isPrototype ( isPrototype ); // => false
isRegExpChecks if a value is likely a regex.
import {isRegExp} from 'is';
isRegExp ( /x/ ); // => true
isRegExp ( new RegExp ( 'x' ) ); // => true
isRegExp ( 'x' ); // => false
isSealedChecks if a value is sealed.
import {isSealed} from 'is';
isSealed ( Object.seal ( {} ) ); // => true
isSealed ( {} ); // => false
isSafeIntegerChecks if a value is an integer that can be represented faithfully in JavaScript.
import {isSafeInteger} from 'is';
isSafeInteger ( 0 ); // => true
isSafeInteger ( Number.MAX_SAFE_INTEGER ); // => true
isSafeInteger ( -Number.MAX_SAFE_INTEGER ); // => true
isSafeInteger ( Number.MAX_SAFE_INTEGER + 1 ); // => false
isSetChecks if a value is a Set.
import {isSet} from 'is';
isSet ( new Set () ); // => true
isSet ( [] ); // => false
isSharedArrayBufferChecks if a value is a SharedArrayBuffer object.
import {isSharedArrayBuffer} from 'is';
isSharedArrayBuffer ( new SharedArrayBuffer ( 8 ) ); // => true
isSharedArrayBuffer ( [] ); // => false
isStringChecks if a value is a string.
import {isString} from 'is';
isString ( 'foo' ); // => true
isString ( ['f', 'o', 'o'] ); // => false
isSymbolChecks if a value is a symbol.
import {isSymbol} from 'is';
isSymbol ( Symbol () ); // => true
isSymbol ( {} ); // => false
isTextChecks if a value is likely a DOM text.
import {isText} from 'is';
isText ( new Text ( 'foo' ) ); // => true
isText ( 'foo ); // => false
isTruthyChecks if a value is truthy.
import {isTruthy} from 'is';
isTruthy ( [] ); // => true
isTruthy ( 0 ); // => false
isTruthy ( '' ); // => false
isTypedArrayChecks if a value is a TypedArray.
import {isTypedArray} from 'is';
isTypedArray ( new Int8Array ( 8 ) ); // => true
isTypedArray ( [] ); // => false
isUint8ArrayChecks if a value is a Uint8Array.
import {isUint8Array} from 'is';
isUint8Array ( new Uint8Array () ); // => true
isUint8Array ( [] ); // => false
isUint8ClampedArrayChecks if a value is a Uint8ClampedArray.
import {isUint8ClampedArray} from 'is';
isUint8ClampedArray ( new Uint8ClampedArray () ); // => true
isUint8ClampedArray ( [] ); // => false
isUint16ArrayChecks if a value is a Uint16Array.
import {isUint16Array} from 'is';
isUint16Array ( new Uint16Array () ); // => true
isUint16Array ( [] ); // => false
isUint32ArrayChecks if a value is a Uint32Array.
import {isUint32Array} from 'is';
isUint32Array ( new Uint32Array () ); // => true
isUint32Array ( [] ); // => false
isUndefinedChecks if a value is undefined.
import {isUndefined} from 'is';
isUndefined ( undefined ); // => true
isUndefined ( null ); // => false
isWeakMapChecks if a value is a WeakMap.
import {isWeakMap} from 'is';
isWeakMap ( new WeakMap () ); // => true
isWeakMap ( new Map () ); // => false
isWeakRefChecks if a value is a WeakRef.
import {isWeakRef} from 'is';
isWeakRef ( new WeakRef ( WeakRef ) ); // => true
isWeakRef ( WeakRef ) ); // => false
isWeakReferableChecks if a value can be held weakly, via WeakRef, WeakMap and WeakSet.
import {isWeakReferable} from 'is';
isWeakReferable ( {} ); // => true
isWeakReferable ( 123 ) ); // => false
isWeakSetChecks if a value is a WeakSet.
import {isWeakSet} from 'is';
isWeakSet ( new WeakSet () ); // => true
isWeakSet ( new Set () ); // => false
isWindowChecks if a value is the Window object.
import {isWindow} from 'is';
isWindow ( globalThis.window ); // => true, in a browser environment
isWindow ( {} ) ); // => false
FAQs
The definitive collection of is* functions for runtime type checking. Lodash-compatible, tree-shakable, with types.
The npm package @fabiospampinato/is receives a total of 3 weekly downloads. As such, @fabiospampinato/is popularity was classified as not popular.
We found that @fabiospampinato/is demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
OpenSSF has published OSPS Baseline, an initiative designed to establish a minimum set of security-related best practices for open source software projects.
Security News
Michigan TypeScript founder Dimitri Mitropoulos implements WebAssembly runtime in TypeScript types, enabling Doom to run after processing 177 terabytes of type definitions.
Security News
vlt's new "reproduce" tool verifies npm packages against their source code, outperforming traditional provenance adoption in the JavaScript ecosystem.