check-more-types
Advanced tools
The check-more-types npm package provides a variety of type checking and assertion functions that enhance JavaScript's type testing capabilities. It offers a wide range of predicates for more precise type validation, making it easier to enforce type safety in JavaScript applications.
Primitive type checks
This feature allows for checking JavaScript's primitive types such as strings, numbers, and booleans. It's useful for basic type validation.
const check = require('check-more-types');
// checks if a value is a string
check.string('hello'); // true
// checks if a value is a number
check.number(42); // trueComplex type checks
This feature extends the library's capabilities to more complex types, such as arrays of specific types or objects matching a schema. It's particularly useful for validating data structures.
const check = require('check-more-types');
// checks if a value is an array of strings
check.arrayOfStrings(['hello', 'world']); // true
// checks if a value is an object with specific properties
check.schema({
name: check.string,
age: check.number
})({ name: 'John', age: 30 }); // trueCustom predicates
check-more-types allows for the creation of custom predicates, enhancing its flexibility and allowing users to define their own specific type checks.
const check = require('check-more-types');
// defines a custom predicate for checking if a number is even
check.mixin({
even: function (n) { return check.number(n) && n % 2 === 0; }
});
// uses the custom predicate
check.even(42); // trueJoi is a powerful schema description language and data validator for JavaScript. Compared to check-more-types, Joi offers a more comprehensive API for defining complex validation schemas, making it better suited for validating nested objects and complex data structures.
Prop-types is a library for type checking React component props. While check-more-types is more general-purpose, prop-types is specifically designed for React applications, offering a straightforward way to ensure components receive props of the correct type.
Validator is a library that provides string validation and sanitization. Unlike check-more-types, which offers a broad range of type checks, Validator focuses on string validation, offering functions for format validation, sanitization, and more.
Large collection of predicates, inspired by check-types.js
See Readable conditions for advice and examples.
node: npm install check-more-types --save
var check = require('check-more-types');
console.assert(check.bit(1), 'check.bit works');
browser bower install check-more-types --save
<script src="check-more-types.js"></script>
check.ext)secure)url)check.positive)check.negative)strings)check.number is part of the check-types library, but as a note, it does not pass
null, undefined or NaN values
check.number(null); // false
check.not.number(undefined); // true
check.number(NaN); // false
Really simple regex email check. Should not be relied to be robust.
check.email('me@foo.bar') // true
check.email('me.foo.bar') // false
check.ext)Confirms that given file name has expected extension
check.extension('txt', 'foo/bar.txt') // true
It is curried, so you can create convenient methods
const isJs = check.extension('js')
isJs('script.js') // true
There are a couple of convenient shortcuts, like check.isJs, check.isJson, check.isJpg
Check if a number odd or even
check.odd(2) // false
check.odd(3) // true
check.even(2) // true
Returns true if passed argument is positive number less or equal to largest allowed port number 65535
Returns true if passed argument is number between 0 and 1024
Returns true if passed argument is a port number and larger than 1024
Returns true if given argument is an instance of type Error
secure)Returns true if the provided url starts with https://. Alias secure.
Returns true if the provided url starts with http://
url)Returns true if the given string is http or https url.
Returns true if given array contains an item, or given string contains substring.
check.contains(['foo', 42], 'foo'); // true
check.contains('apple', 'pp'); // true
check.defined(0); // true
check.defined(1); // true
check.defined(true); // true
check.defined(false); // true
check.defined(null); // true
check.defined(''); // true
check.defined(); // false
check.defined(root.doesNotExist); // false
check.defined({}.doesNotExist); // false
check.semver('1.0.2'); // true
check.semver('1.0.2-alpha'); // false
check.positive)check.positive(100); // true
check.not.positive(-1); // true
check.negative)check.negative(-10); // true
check.not.negativeNumber(1); // true
check.type('string', 'foo'); // true
check.type('number', 42); // true
check.type is curried.
check.bit(0); // true
check.bit(1); // true
check.bit('1'); // false
check.bit(2); // false
check.bit(true); // false
Returns true for primitive JavaScript types
check.primitive(42); // true
check.primitive(true); // true
check.primitive('foo'); // true
check.primitive([]); // false
Also returns true for Symbol ES6 syntax.
check.zero(0); // true
check.zero(); // false
check.zero(null); // false
check.git('url string');
var colors = ['red', 'green', 'blue'];
var color = 'green';
check.oneOf(colors, color); // true
check.oneOf(colors, 'brown'); // false
Function is curried
var foo = {}
var bar = {}
check.same(foo, foo); // true
check.same(foo, bar); // false
// primitives are compared by value
check.same(0, 0); // true
check.same('foo', 'foo'); // true
check.same should produce same result as ===.
Confirms length of a string or an Array. The function is curried and can guess the argument order
check.length([1, 2], 2); // true
check.length('foo', 3); // true
// argument order
check.length(3, 'foo'); // true
// curried call
check.length('foo')(3); // true
check.length(3)('foo'); // true
check.sameLength([1, 2], ['a', 'b']); // true
check.sameLength('ab', 'cd'); // true
// different types
check.sameLength([1, 2], 'ab'); // false
var foo = {}
var bar = {}
check.allSame([foo, foo, foo]); // true
check.allSame([foo, foo, bar]); // false
// primitives are compared by value
check.allSame([0, 0]); // true
check.allSame(['foo', 'foo', 'foo']); // true
check.allSame([false, 0]); // false
check.unit(0); // true
check.unit(1); // true
check.unit(0.1); // true
check.unit(1.2); // false
check.unit(-0.1); // false
check.hexRgb('#FF00FF'); // true
check.hexRgb('#000'); // true
check.hexRgb('#aaffed'); // true
check.hexRgb('#00aaffed'); // false
check.hexRgb('aaffed'); // false
check.bool(true); // true
check.bool(false); // true
check.bool(0); // false
check.bool(1); // false
check.bool('1'); // false
check.bool(2); // false
check.emptyString(''); // true
check.emptyString(' '); // false
check.emptyString(0); // false
check.emptyString([]); // false
check.empty([]); // true
check.empty(''); // true
check.empty({}); // true
check.empty(0); // false
check.empty(['foo']); // false
check.unempty([]); // false
check.unempty(''); // false
check.unempty({}); // false
check.unempty(0); // true
check.unempty(['foo']); // true
check.unempty('foo'); // true
check.unemptyArray(null); // false
check.unemptyArray(1); // false
check.unemptyArray({}); // false
check.unemptyArray([]); // false
check.unemptyArray(root.doesNotExist); // false
check.unemptyArray([1]); // true
check.unemptyArray(['foo', 'bar']); // true
strings)// second argument is checkLowerCase
check.arrayOfStrings(['foo', 'Foo']); // true
check.arrayOfStrings(['foo', 'Foo'], true); // false
check.arrayOfStrings(['foo', 'bar'], true); // true
check.arrayOfStrings(['FOO', 'BAR'], true); // false
Returns true if all items in an array are numbers
check.arrayOf(check.unemptyString, ['foo', '']); // false
check.arrayOf(check.unemptyString, ['foo', 'bar']); // true
// can be partially applied and combined with check.schema
var person = {
first: check.unemptyString,
last: check.unemptyString
};
var isPerson = check.schema.bind(null, person);
var arePeople = check.arrayOf.bind(null, isPerson);
var people = [{
first: 'foo',
last: 'bar'
}];
arePeople(people); // true
Why would you need check.arrayOf(predicate, x) and not simply use x.every(predicate)?
Because x might not be an Array.
Finds items that do not pass predicate
check.badItems(check.unemptyString, ['foo', '', 'bar']); // ['']
// second argument is checkLowerCase
check.arrayOfArraysOfStrings([['foo'], ['bar'}}); // true
check.arrayOfArraysOfStrings([['foo'], ['bar'}}, true); // true
check.arrayOfArraysOfStrings([['foo'], ['BAR'}}, true); // false
check.lowerCase('foo bar'); // true
check.lowerCase('*foo ^bar'); // true
check.lowerCase('fooBar'); // false
// non-strings return false
check.lowerCase(10); // false
var obj = {
foo: 'foo',
bar: 0
}
check.has(obj, 'foo'); // true
check.has(obj, 'bar'); // true
check.has(obj, 'baz'); // false
// non-object returns false
check.has(5, 'foo'); // false
check.has('foo', 'length'); // true
var obj = {
foo: 'foo',
bar: 'bar',
baz: 'baz'
}
var predicates = {
foo: check.unemptyString,
bar: function(value) {
return value === 'bar'
}
}
check.all(obj, predicates); // true
var obj = {
foo: 'foo',
bar: 'bar',
baz: 'baz'
}
var schema = {
foo: check.unemptyString,
bar: function(value) {
return value === 'bar'
}
}
check.schema(schema, obj); // true
check.schema(schema, {}); // false
check.spec is equivalent to check.all but with arguments reversed.
This makes it very convenient to create new validator functions using partial
argument application
The method is curried, thus you can easily create predicate function
var hasName = check.schema({ name: check.unemptyString });
hasName({ name: 'joe' }); // true
var personSchema = {
name: check.unemptyString,
age: check.positiveNumber
}
var isValidPerson = check.schema.bind(null, personSchema)
var h1 = {
name: 'joe',
age: 10
}
var h2 = {
name: 'ann'
// missing age property
}
isValidPerson(h1); // true
isValidPerson(h2); // false
If you want you can manually bind check.schema to first argument
var personSchema = {
name: check.unemptyString,
age: check.positiveNumber
};
var isValidPerson = check.schema.bind(null, personSchema);
var h1 = {
name: 'joe',
age: 10
};
var h2 = {
name: 'ann'
// missing age property
};
isValidPerson(h1); // true
isValidPerson(h2); // false
You can use Function.prototype.bind or any partial application method, for example
_.partial(check.schema, personSchema);.
Because bound schema parameter generates a valid function, you can nest checks using
schema composition. For example let us combine the reuse isValidPerson as part of
another check
var teamSchema = {
manager: isValidPerson,
members: check.unemptyArray
}
var team = {
manager: {
name: 'jim',
age: 20
},
members: ['joe', 'ann']
}
check.schema(teamSchema, team); // true
function foo() {
throw new Error('foo')
}
function bar() {}
function isValidError(err) {
return err.message === 'foo'
}
function isInvalid(err) {
check.instance(err, Error); // true
return false
}
check.raises(foo); // true
check.raises(bar); // false
check.raises(foo, isValidError); // true
check.raises(foo, isInvalid); // false
Every predicate function is also added to check.maybe object.
The maybe predicate passes if the argument is null or undefined,
or the predicate returns true.
check.maybe.bool(); // true
check.maybe.bool('true'); // false
var empty
check.maybe.lowerCase(empty); // true
check.maybe.unemptyArray(); // true
check.maybe.unemptyArray([]); // false
check.maybe.unemptyArray(['foo', 'bar']); // true
Every function has a negated predicate in check.not object
check.not.bool(4); // true
check.not.bool('true'); // true
check.not.bool(true); // false
Every predicate can also throw an exception if it fails
check.verify.arrayOfStrings(['foo', 'bar'])
check.verify.bit(1)
function nonStrings() {
check.verify.arrayOfStrings(['Foo', 1])
}
check.raises(nonStrings); // true
function nonLowerCase() {
check.verify.lowerCase('Foo')
}
check.raises(nonLowerCase); // true
You can add new predicates to check, check.maybe, etc. by using check.mixin(predicate)
method. If you do not pass a name, it will try using function's name.
function isBar(a) {
return a === 'bar'
}
check.mixin(isBar, 'bar')
check.bar('bar'); // true
check.bar('anything else'); // false
// supports modifiers
check.maybe.bar(); // true
check.maybe.bar('bar'); // true
check.not.bar('foo'); // true
check.not.bar('bar'); // false
Mixin will not override existing functions
function isFoo(a) {
return a === 'foo'
}
function isBar(a) {
return a === 'bar'
}
check.mixin(isFoo, 'isFoo')
check.isFoo; // isFoo
check.mixin(isBar, 'isFoo')
check.isFoo; // isFoo
Using check-more-types you can separate the inner function logic from checking input arguments. Instead of this
function add(a, b) {
la(check.number(a), 'first argument should be a number', a);
la(check.number(a), 'second argument should be a number', b);
return a + b;
}
you can use check.defend function
function add(a, b) {
return a + b
}
var safeAdd = check.defend(add, check.number, check.number)
add('foo', 2); // 'foo2'
// calling safeAdd('foo', 2) raises an exception
check.raises(safeAdd.bind(null, 'foo', 2)); // true
function add(a, b) {
if (typeof b === 'undefined') {
return 'foo'
}
return a + b
}
add(2); // 'foo'
var safeAdd = check.defend(add, check.number, check.maybe.number)
safeAdd(2, 3); // 5
safeAdd(2); // 'foo'
You can add extra message after a predicate
function add(a, b) {
return a + b
}
var safeAdd = check.defend(add, check.number, 'a should be a number', check.string, 'b should be a string')
safeAdd(2, 'foo'); // '2foo'
function addNumbers() {
return safeAdd(2, 3)
}
function checkException(err) {
err.message; // 'Argument 2: 3 does not pass predicate: b should be a string'
return true
}
check.raises(addNumbers, checkException); // true
This works great when combined with JavaScript module pattern as in this example
var add = (function() {
// inner private function without any argument checks
function add(a, b) {
return a + b
}
// return defended function
return check.defend(add, check.number, check.number)
}())
add(2, 3); // 5
// trying to call with non-numbers raises an exception
function callAddWithNonNumbers() {
return add('foo', 'bar')
}
check.raises(callAddWithNonNumbers); // true
Sometimes we want to execute a function depending on the condition, but without throwing an
exception. For these cases, there is check.then
function isSum10(a, b) {
return a + b === 10
}
function sum(a, b) {
return a + b
}
var onlyAddTo10 = check.then(isSum10, sum)
// isSum10 returns true for these arguments
// then sum is executed
onlyAddTo10(3, 7); // 10
onlyAddTo10(1, 2); // undefined
// sum is never called because isSum10 condition is false
Great for quickly checking string or array search results
check.found('foo'.indexOf('f')); // true
check.found('foo bar'.indexOf('bar')); // true
Returns true if the passed value is a regular expression.
Returns true if given object has promise methods (.then, etc)
Returns true if the given instance is a Date and is valid.
Curried shallow strict comparison
var foo = 'foo';
check.equal(foo, 'foo'); // true
var isFoo = check.equal('foo');
isFoo('foo'); // true
isFoo('bar'); // false
Combines multiple predicates into single one using OR logic
var predicate = check.or(check.bool, check.unemptyString);
predicate(true); // true
predicate('foo'); // true
predicate(42); // false
It treats non-functions as boolean values
var predicate = check.or(check.unemptyString, 42);
// will always return true
predicate('foo'); // true, because it is unempty string
predicate(false); // true, because 42 is truthy
Note: if there are any exceptions inside the individual predicate functions, they are
treated as false values.
Combines multiple predicates using AND. If the predicate is not a function, evaluates it as a boolean value.
function isFoo(x) { return x === 'foo'; }
check.and(check.unemptyString, isFoo); // only true for "foo"
Both check.or and check.and are very useful inside check.schema to create
more powerful predicates on the fly.
var isFirstLastNames = check.schema.bind(null, {
first: check.unemptyString,
last: check.unemptyString
});
var isValidPerson = check.schema.bind(null, {
name: check.or(check.unemptyString, isFirstLastNames)
});
isValidPerson({ name: 'foo' }); // true
isValidPerson({ name: {
first: 'foo',
last: 'bar'
}}); // true
Author: Kensho © 2014
Support: if you find any problems with this library, open issue on Github
This documentation was generated using grunt-xplain and grunt-readme.
The MIT License (MIT)
Copyright (c) 2014 Kensho
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
FAQs
Large collection of predicates.
The npm package check-more-types receives a total of 3,490,447 weekly downloads. As such, check-more-types popularity was classified as popular.
We found that check-more-types demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 3 open source maintainers 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
PyPI confirms no security flaws were exploited in the Ultralytics supply chain attack and highlights improvements for safer package publishing.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.