check-type

Library to check variable type and properties in object.

Check Type

A type checking framework for Javascript.

Check type lets you check variable types and structures with the format check(x).is("y") and check(x).has("a.b")



check-type is available through the npm package manager.

For Node.js package management, you can install using npm.

npm install check-type

check-type is available through the bower package manager.

For front-end package management, you can install using Bower.

bower install check-type

check-type is available through the component package manager.

For package management, you can install using Component.

component install alistairjcbrown/check-type

For manual management, you can grab the Javascript file directly or clone the git repository. You will need to grab underscore.js as well.

# Grab the file
wget https://raw.githubusercontent.com/alistairjcbrown/check-type/master/check-type.min.js
 
# Clone the repo
git clone git@github.com:alistairjcbrown/check-type.git
var check = require("check-type").init();

The module can be required using Node.js built in require (See example).

<script src="/path/to/underscore"></script>
<script src="/path/to/check-type/check-type.min.js"></script>
<script>
    check.init();
</script> 

The module can be used in the browser through the <script> tag and will bind to window (See example).

The module supports the AMD format and uses define if available. Therefore it can be used as a RequireJS module (See Browser example, See Node.js example).

define([ "check-type" ], function(check) {
    check.init();
});

Built in tests and linting using Grunt to call JSHint and Mocha.

Get all of the developer dependecies by running:

npm install           # install dev dependencies
grunt lint            # Lint the code with JSHint
grunt test --nodejs   # Run all tests in node.js
grunt test --browser  # Run all tests in phantomjs
grunt test            # Run all tests in both environments
grunt go              # Run everything above

Open lib/test/check-type.test.html in browser

To prevent conlicts with other libraries using window.check, if check-type binds to window it will also provide a check.noConflict function to restore the variable to its previous value.

check-type will only bind to window in the browser environment when RequireJS is not available.

check-type does not come with type checking functionality. Instead, it simply provides the check interface. Type checking functions should be provided when calling check.init.

check.init can be called without parameters which will use the type checking functions from Underscore.js.

check.init can be called multiple times and will add type checking functions which have not already been defined. To override a previously defined type checking function, pass boolean true as the second parameter.

var check = require("check-type").init();
var check = require("check-type"),
    custom_functions = {
        "isEmail"function(value) {
            return value.indexOf("@") !== -1
        },
        "isEmpty"function(value) {
            return value === "empty";
        }
    },
 
// Initialise check with underscore type checking functions 
//  and custom checking functions, overriding underscore's isEmpty function 
check.init()
     .init(custom_functions, true);

This clears all of the internal stored type checking functions.

check.clear();

Once the check function has been initialised, it can utilise any defined type checking functions using is.

var my_string = "hello world";
check.init();
 
check(my_string).is("string"); // true 
check(my_string).is("number"); // false 
 
check(my_string).is("foo");    // throws Error for unsupported type 

You can also negate the check with is.not

var my_string = "hello world";
check.init();
 
check(my_string).is.not("string"); // false 
check(my_string).is.not("number"); // true 
 
check(my_string).is.not("foo");    // throws Error for unsupported type 

check-type can check for the presence of values within an object under a particular path.

var my_object = {
    hello: {
        world: false
    }
};
 
check(my_object).has("hello.world"); // true 
check(my_object).has("foo.bar");     // false 

check-type can check an object properties for specific types

var my_object = {
    "customer_number": 123456789,
    "password":        "abc123"
};
 
check(my_object).matches({
    "customer_number": "number",
    "password":        "string"
});
// true 
 
check(my_object).matches({
    "username": "string",
    "password": "string"
});
// false 

The functionality of check can be used in combination, for example when validating response data.

See the example below as a jsfiddle.

var custom_types = {};
 
custom_types.isUsername = function(value) {
    return /^\w+$/.test(value);
};
 
custom_types.isAuthObject = function(value) {
    return check(value).matches({
        "username": "username",
        "password": "string"
    });
};
 
// Initialise with underscorejs functions 
check.init();
 
// Add custom functions too 
check.init(custom_types);
function handleAuthentication(request) {
    var username, password;
 
    if (check(request).has("auth") &&
        check(request.auth).is("AuthObject")) {
 
        username = request.auth.username;
        password = request.auth.password;
 
        return {
            username: username,
            password: password
        };
 
    }
 
    return false;
}

Twitter @alistairjcbrown

Code signed using keybase as alistairjcbrown. Verify with keybase dir verify