checkif.js

This library aims to perform various checks in the javascript environment.

Installation

checkif.js is distributed as a npm package.

npm install checkif.js

Documentation

The library is constituted of a set of checkers to perform different verifications.

is
- Types
- RegExp
- String
- Arithmetic
- Environment
- Time
all
any
has
hasOnly
atLeast
atMost
hasAtLeast
hasAtMost

`is`

import { is } from 'checkif.js';

Types

This group of methods allows to verify if a given value is from a specific type.

`null(value)`

Checks if a given value is null.

`undefined(value)`

Alias und(value)

Checks if a given value is undefined.

`nullable(value)`

Checks if a given value is null or undefined.

`nan(value)`

Checks if a given value is NaN. Same as Number.isNaN.

is.nan(NaN); // true
is.nan(Number.NaN); // true

`array(value)`

Alias arr(value)

Checks if a given value is an array. This method is the same as Array.isArray, if available.

is.array([]); // true
is.array(new Array(0)); // true

`boolean(value)`

Alias bool(value)

Checks if a given value is a boolean.

is.boolean(true); // true
is.boolean(new Boolean(0)); // true

`string(value)`

Alias str(value)

Checks if a given value is a string.

is.string(''); // true
is.string(String('')); // true
is.string(new String('')); // true

`char(value)`

Checks if a given value is a char.

is.char(' '); // true
is.char('1'); // true
is.char(1); // false

`date(value)`

Checks if a given value is a date.

is.date(new Date('November 23, 1998 03:24:00')); // true, my birthdate btw ;)

`number(value)`

Alias num(value)

Checks if a given value is a number.

is.number(Number(1)); // true
is.number(new Number(1)); // true
is.number(1); // true

`regexp(value)`

Alias reg(value)

Checks if a given value is a regular expression.

is.regexp(\a\); // true
is.regexp(RegExp()); // true
is.regexp(new RegExp()); // true

`object(value)`

Alias obj(value)

Checks if a given value is an object.

is.object({}); // true
is.object(String(1)); // true
is.object('1'); // false

`pureObject(value)`

Alias pure(value)

Checks if a given value is a pure JSON object.

is.pureObject({}); // true
is.pureObject({ value: 1 }); // true
is.pureObject(new Date()); // false

`function(value)`

Alias func(value)

Checks if a given value is a function.

is.function(function () { }); // true
is.function(x => x); // true
is.function(new Function('x', 'return x')); // true

`error(value)`

Alias err(value)

Checks if a given value is an error.

is.error(Error('Fatal error')); // true
is.error(new Error('Nothing works anymore')); // true

`domNode(value)`

Alias dom(value)

Checks if a given value is a DOM node.

// Browser
is.domNode(window.document.body); // true
// Node.js
let dom = new JSDOM(`<html !DOCTYPE><body></body></html>`);
is.domNode(dom.window.document.body); // true

`windowObject(value)`

Alias window(value)

Checks if a given value is a window object.

// Browser
is.windowObject(window); // true
// Node.js
let dom = new JSDOM(`<html !DOCTYPE></html>`)
is.windowObject(dom.window); // true

RegExp

This group of methods allows to verify if a given string is from a specific known type of value.

To be implemented

String

This group of methods allows to verify if a given string is a from a specific format.

`lowerCase(value)`

Check if a given string is lower case.

is.lowerCase('abc'); // true
is.lowerCase('abc 123'); // true
is.lowerCase('ABC'); // false

`upperCase(value)`

Check if a given string is upper case.

is.upperCase('ABC'); // true
is.upperCase('ABC 123'); // true
is.upperCase('abc'); // false

Arithmetic

This group of methods allows to verify if a given number is a from a specific class of numbers.

`even(value)`

Checks if a given value is even.

is.even(10); // true
is.even(11); // false

`odd(value)`

Checks if a given value is odd.

is.odd(9); // true
is.odd(10); // false

`integer(value)`

Alias int(value)

Checks if a given value is an integer.

is.integer(12); // true
is.integer(10.0); // true
is.integer(3.14); // false
is.integer(Number.MIN_VALUE); // false
is.integer(Infinity); // false
is.integer('6');// false

Environment

This group of methods allows to verify if the current environment is a specific environment.

To be implemented

Time

This group of methods allows to verify if a date is a specific kind.

`past(value)`

Checks if a given value is a Date object in the past.

is.past(new Date(0)); // true

let pastDate = new Date();
pastDate.setUTCFullYear(pastDate.getUTCFullYear() - 1);
is.past(pastDate); // true

let futureDate = new Date();
futureDate.setUTCFullYear(futureDate.getUTCFullYear() + 1);
is.past(futureDate); // false

`future(value)`

Checks if a given value is a Date object in the future.

let futureDate = new Date();
futureDate.setUTCFullYear(futureDate.getUTCFullYear() + 1);
is.future(futureDate); // true

is.future(new Date(0)); // false

let pastDate = new Date();
pastDate.setUTCFullYear(pastDate.getUTCFullYear() - 1);
is.future(pastDate); // false

`today(value)`

Checks if a given value is a Date object set today.

let date = new Date();
date.setUTCHours(12);
date.setUTCMinutes(30);

is.today(date); // true
is.today(new Date()); // true
is.today(new Date(0)); // false

let pastDate = new Date();
pastDate.setUTCFullYear(pastDate.getUTCFullYear() - 1);
is.today(pastDate); // false

let futureDate = new Date();
futureDate.setUTCFullYear(futureDate.getUTCFullYear() + 1);
is.today(futureDate); // false

`all`

all(enumerable, matcher, strict = false)

import { all } from 'checkif.js';

This method verifies if all elements in a given enumerable (array or object) match a specific value or function.

`all` on arrays

all([0, 0, 0, 0], 0); // true
all([2, 4, 6, 8], x => x%2 === 0); // true

all([0, 1, 2, 3], 1); // false

`all` on objects

all({ x: 1, y: 1 }, 1); // true
let a = {};
all({ x: a, y: a }, x => x === a); // true

all({ x: 0, y: new Number(0) }, function(x){ return x === 0; }); // false

Strict mode

The second parameter of all is automatically resolved as a matcher function when it's a function. But you may want to check if the values are exactly equal to the function (as a value). In this case, you should use the strict mode by setting the 3rd parameter to true (default false).

import { all } from 'checkif.js';

let _function = function (x) { ... };
all({ x: _function, y: _function }, _function, true); // true

Feel free to build complex logic for your checks.

import { all, is } from 'checkif.js';
all({ x: ['a', 'b'], y: ['a', 'c'] }, x => all(x, is.char)); // true

`any`

any(enumerable, matcher, strict = false)

This method verifies if any element in a given enumerable (array or object) matches a specific value or function.

import { any } from 'checkif.js';

any([0,1,2,3], 2); // true
any([0,1,2,3], x => x === 0); // true
any({ x : 1, y : 0}, x => x === 1); // true

any([0, 1, 2, 3], 1); // false
any({ x : 1, y : 1}, 2); // false
any([0,1,2,3], x => x === 5); //false

any also supports strict mode.

`has`

This group of methods allows to verify if a given enumerable (array or object) has an element verifying a specific condition. This checker contains the same methods as is. In fact, has.method(array) is equivalent to any(array, is.method).

import { any } from 'checkif.js';

has.uppercase(['abc', 'Abc', 'ABC']); // true
has.even({ x : 1, y : 2, z : 3}); // true
has.function({ x : function(){}}); // true

has.nan([0, 1, 2, 3]); // false
has.integer([1.2, 1.3]); // false
has.null([]); // false

`hasOnly`

This group of methods allows to verify if a given enumerable (array or object) has only elements verifying a specific condition. This checker contains the same methods as is.

hasOnly.method(array) is equivalent to all(array, is.method).

import { any } from 'checkif.js';

hasOnly.lowercase(['abc', 'def', 'ghi']); // true
hasOnly.integer({ x : 1, y : 2, z : 3}); // true
hasOnly.function({ x : function(){}, y : x => x}); // true

hasOnly.null([null, 1, 2, 3]); // false
hasOnly.odd([1, 2, 3]); // false

`atLeast`

atLeast(enumerable, count, matcher, strict = false)

Alias atl(enumerable, count, matcher, strict = false)

This method verifies if at least a number of elements in a given enumerable (array or object) match a specific value or function.

import { atLeast } from 'checkif.js';

atLeast([1,1,2,3], 2, 1); // true
atLeast([0,0,2,0], 3, x => x === 0); // true
atLeast({ x : 1, y : 0}, 1, x => x === 1); // true

atLeast([0, 1, 2, 3], 2, 1); // false
atLeast({ x : 1, y : 1}, 3, 2); // false
atLeast([0,1,2,3], 1, x => x === 5); //false

atLeast also supports strict mode.

`atMost`

atMost(enumerable, count, matcher, strict = false)

Alias atm(enumerable, count, matcher, strict = false)

This method verifies if at most a number of elements in a given enumerable (array or object) match a specific value or function.

import { atMost } from 'checkif.js';

atMost([0, 0, 1, 2], 2, 0); // true
atMost([true, true, true, false], 3, x => x === true); // true
atMost({ x: a, y: a }, 3, x => x === a); // true

atMost([0, 0, 1, 1], 1, 0); // false
atMost({ x: 1, y: 0 }, 0, 1); // false
let _function = function () { return true };
atMost({ x: _function, y: _function }, 1, _function); // false

atMost also supports strict mode.

`hasAtLeast`

hasAtLeast(count)

This group of methods allows to verify if a given enumerable (array or object) has at least a number of elements verifying a specific condition from is. hasAtLeast(count).method(enumerable) is equivalent to atLeast(enumerable, count, is.method).

`hasAtMost`

hasAtMost(count)

This group of methods allows to verify if a given enumerable (array or object) has at most a number of elements verifying a specific condition from is. hasAtMost(count).method(enumerable) is equivalent to atMost(enumerable, count, is.method).

Keep in mind that using the has* notation is less performant than using the equivalent atLeast or atMost function. Everytime has*(count) is called, the resulting functions are regenerated from is.

Contributing

Any help is wanted and welcome. You can check out our github issues and projects or our slack page.

Please follow our contributing guidelines.

Name		Name	Last commit message	Last commit date
Latest commit History 69 Commits
.github/ISSUE_TEMPLATE		.github/ISSUE_TEMPLATE
src		src
test		test
.babelrc		.babelrc
.editorconfig		.editorconfig
.eslintignore		.eslintignore
.eslintrc.json		.eslintrc.json
.gitignore		.gitignore
.npmignore		.npmignore
.release-it.json		.release-it.json
.travis.yml		.travis.yml
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
index.js		index.js
jest.config.ci.js		jest.config.ci.js
jest.config.js		jest.config.js
package-lock.json		package-lock.json
package.json		package.json
rollup.config.js		rollup.config.js

License

joeltankam/checkif.js

Folders and files

Latest commit

History

Repository files navigation

checkif.js

Installation

Documentation

is

Types

null(value)

undefined(value)

nullable(value)

nan(value)

array(value)

boolean(value)

string(value)

char(value)

date(value)

number(value)

regexp(value)

object(value)

pureObject(value)

function(value)

error(value)

domNode(value)

windowObject(value)

RegExp

String

lowerCase(value)

upperCase(value)

Arithmetic

even(value)

odd(value)

integer(value)

Environment

Time

past(value)

future(value)

today(value)

all

all on arrays

all on objects