of-type

    3.0.4 • Public • Published

    Description

    of-type is a very light module that checks if the given value is of the expected type (or types).

    Also see typeof-arguments to validate types of the arguments passed through functions.
    Also see typeof-properties to validate types of the objects' properties.

    Implementation

    with NodeJS

    npm install of-type

    const type = require('of-type');
     
    type('hello world!', 'string'); //true
    type(true, 'boolean|number|string'); //true
    type(new Date(), /date/i); //true

    with Browser

    Add of-type.js library to the HTML file.

    The library is located in ./dist/of-type.js directory.
    It is a webpack&babel bundled cross-browser library version.
    The library is accessible as ofType variable in the global (window) scope.

    <head>
      <script src='of-type.js'></script> 
      <script>
        ofType('hello world!', 'string'); //true
      </script> 
    </head>

    Tests

    > git clone https://github.com/devrafalko/of-type.git
    > cd of-type
    > npm install
    > npm test        //run tests in node
    > npm test deep   //run tests in node with errors shown
    

    Usage

    type(val, type)

    val

    It is any value|object which type should be checked.

    type [String|RegExp|null|undefined|Function|Array]

    The val value|object is expected to be of type type. There are many ways to check the val type. Choose the most convenient one:

    [String]

    • Possible values:
      • 'null', 'undefined'
      • any value that equals to val.constructor.name, eg:
        'string', 'number', 'regexp', 'array', 'object', 'boolean','buffer', etc.
    • The [String] type is case insensitive:
      • 'String', 'string', 'StRiNg' checks if the val is of [String] type
      • 'RegExp', 'REGEXP', 'regexp' checks if the val is of [RegExp] type
    • The [String] type can contain multiple types, separated with |:
      • 'array|object' checks if the val is of [Array] OR [Object] type
      • 'undefined|null' checks if the val is of undefined OR null type
    • See the samples

    [RegExp]

    • Possible values:
      • /null/, /undefined/
      • any value matching the val.constructor.name, eg: /String/, /Number/, /RegExp/, /Array/, /Object/, /Boolean/,/Buffer/, /Promise/, etc.
    • Use all regular expression's features to match the type in a desired way:
      • /Str/, /Err/, /Reg/, /B/
      • /.+Error$/, /^RegExp$/,
      • /^[A-Z][a-z]+$/
    • For the case insensitivity use i flag:
      • /string/i, /regexp/i, /TYPEERROR/i
    • For multiple values use regexp (x|y) expression:
      • /String|Number/, /TypeError|Error/, /(obj|str)/i
    • See the samples

    [Function|Array|null|undefined]

    • Possible values:
      • null, undefined
      • any [Function] constructor, eg: String, TypeError, Promise, Array, etc.
    • For multiple values use array:
      • [String, Object, Array, null]
      • [null, undefined, Boolean]
    • See the samples

    When you use bundlers or minifiers, use [String|RegExp] type wisely as bundlers may change the names of functions|constructors|classes in the output file and eg. type(myInstance, 'MyClass') that returns true before compilation, may return false after compilation, if the bundler minifies the 'MyClass' constructor name.

    Extra types:

    [String] 'arguments' | [RegExp] /arguments/

    • The type 'arguments' or /arguments/ returns true for the function's arguments object
    • See the samples

    [String] 'instance' | [RegExp] /instance/

    • The type 'instance' or /instance/ returns true for the instance of the user's class|constructor
      • type(MyInstance, 'instance'); //true
    • It returns false for instances of built-in (native) constructors
      • [], 'hello world', {}
    • It returns false for instances that are the global|window's properties
    • See the samples

    [String] 'objectable' | [RegExp] /objectable/

    • The type 'objectable' or /objectable/ returns true for the objects that are the instances of Object constructor
      • {}, [], new String('hello world'), new Boolean(1)
    • It returns false for the primitive values and simple values
      • 'hello world', true, 10, null, undefined
    • See the samples

    [String] 'truthy' | [RegExp] /truthy/

    • The type 'truthy' or /truthy/ returns true for the values like:
      • 'abc', true, 1, -1, {}, [], function(){}
    • See the samples

    [String] 'falsy' | [RegExp] /falsy/

    • The type 'falsy' or /falsy/ returns true for the values like:
      • '', false, 0, null, undefined, NaN
    • See the samples

    [String] 'any' | [RegExp] /any/ | [Array] [] | [String] ""

    • The type 'any' or /any/ or empty array [] or empty string "" returns true for the values of any type
    • See the samples

    Return value

    The function type() returns true if the val argument is of expected type.
    The function type() returns false if the val argument is not of expected type.

    Tips

    Missing the val or type arguments will always return false (without throwing error).

    type(); //false  
    type(undefined, undefined); //true  
    type(undefined); //false

    Samples

    [String] type

    import type from `of-type`;
     
    type('hello world', 'String'); //true
    type(10, 'Number'); //true
    type(null, 'null'); //true
    type(undefined, 'undefined'); //true
    type([1,2,3], 'Array'); //true
    type([1,2,3], 'Object'); //false
    type(true, 'Boolean'); //true
    type(type, 'function'); //true
    type(/hello/, 'RegExp'); //true
    type({ framework: 'React' }, 'Object'); //true
     
    type('hello world', 'string'); //true
    type('hello world', 'STRING'); //true
    type('hello world', 'str'); //false
    type(true, 'BOOLEAN'); //true
    type(false, 'BoOlEaN'); //true
    type(false, 'Bool'); //false
    type(null, 'NULL'); //true
     
    type(new Date(), 'DATE'); //true
    type(new Array(1,2,3), 'array'); //true
    type(new Buffer(0), 'buffer'); //true
    type(new String('hello world'), 'string'); //true
     
    type(()=>{}, 'function'); //true
    type((()=>'hello world')(), 'string'); //true
     
    type(Date, 'date'); //false
    type(Date, 'function'); //true
    type(Array, 'Function'); //true
     
    type(new Error(), 'error'); //true
    type(new TypeError(), 'typeerror'); //true
    type(new SyntaxError(), 'syntaxerror'); //true
    type(new SyntaxError(), 'error'); //false
     
    type(document.createElement('DIV'), 'htmldivelement'); //true
    type(document.createElement('DIV'), 'element'); //false
    type(document.createElement('LI'), 'HtmlLiElement'); //true
     
    type((function(){ return arguments; })(), 'object'); //true; constructor.name === "Object"
     
    class Name{};
    type(new Name(), 'Name'); //true
    type(new Name(), 'name'); //true
    type(new Name(), 'object'); //false; constructor.name === 'Name'
     
    type(10, 'string|number'); //true
    type(10, 'string|array'); //false
    type(null, 'undefined|null'); //true

    [RegExp] type

    import type from `of-type`;
     
    type('hello world', /String/); //true
    type(10, /Number/); //true
    type(null, /null/); //true
    type(undefined, /undefined/); //true
    type([1,2,3], /Array/); //true
    type([1,2,3], /Object/); //false
    type(true, /Boolean/); //true
    type(type, /Function/); //true
    type(/hello/, /RegExp/); //true
    type({ framework: 'React' }, /Object/); //true
     
    type('hello world', /string/); //false
    type('hello world', /STRING/); //false
    type('hello world', /string/i); //true
    type('hello world', /STRING/i); //true
    type('hello world', /Str/); //true
    type('hello world', /^str/i); //true
    type(true, /BOOLEAN/); //false
    type(false, /BoOlEaN/); //false
    type(true, /BOOLEAN/i); //true
    type(false, /BoOlEaN/i); //true
    type(false, /Bool/); //true
    type(false, /bool/i); //true
    type(null, /NULL/); //false
    type(null, /NULL/i); //true
     
    type({}, /^[A-Z][a-z]+$/); //true
    type(true, /^[A-Z][a-z]+$/); //true
    type(null, /^[A-Z][a-z]+$/); //false
    type(undefined, /^[A-Z][a-z]+$/); //false
     
    type((function(){ return arguments; })(), /object/i); //true; constructor.name === "Object"
     
    type(document.createElement('DIV'), /^html.*element$/i); //true
    type(document.createElement('DIV'), /^[a-z]+div[a-z]+$/i); //true
    type(document.createElement('A'), /anchor/i); //true
    type(document.createElement('UL'), /html[uo]listelement/i); //true
    type(document.createElement('OL'), /html[uo]listelement/i); //true
     
    type(10, /string|number/i); //true
    type(undefined, /und|null/i); //true
    type(new SyntaxError(), /(syntax|type)error/i); //true
    type(new TypeError(), /(syntax|type)error/i); //true
    type(new Error(), /(syntax|type)?error/i); //true
     
    class Name(){};
    type(new Name(), /Name/); //true
    type(new Name(), /name/); //false
    type(new Name(), /name/i); //true
    type(new Name(), /Object/); //false; constructor.name === 'Name'

    constructor, null and undefined

    import type from `of-type`;
     
    type('hello world', String); //true
    type(10, Number); //true
    type(null, null); //true
    type(undefined, undefined); //true
    type(null, undefined); //false
    type({}.name, undefined); //true
    type([1,2,3], Array); //true
    type([1,2,3], Object); //false
    type(true, Boolean); //true
    type(type, Function); //true
    type(/hello/, RegExp); //true
    type({ framework: 'React' }, Object); //true
    type((function(){ return arguments; })(), Object); //true; constructor.name === "Object"
     
    type(new Date(), Date); //true
    type(new Array(1,2,3), Array); //true
    type(new Buffer(0), Buffer); //true
    type(new String('hello world'), String); //true
     
    type(()=>{}, Function); //true
    type((()=>'hello world')(), String); //true
     
    type(Date, Date); //false
    type(Date, Function); //true
    type(Array, Function); //true
     
    type(new Error(), Error); //true
    type(new TypeError(), TypeError); //true
    type(new SyntaxError(), SyntaxError); //true
    type(new SyntaxError(), Error); //false
    type(new RangeError(), [Error, TypeError, RangeError]); //true
     
    class Name{};
    type(new Name(), Name); //true
    type(new Name(), Object); //false; constructor.name === 'Name'
     
    type(10, [String, Number]); //true
    type(10, [String, Array]); //false
    type(null, [undefined, null]); //true

    arguments type

    import type from `of-type`;
     
    function hello(){
      return arguments;
    }
     
    type(hello(), 'arguments'); //true
    type(hello(), 'ARGUMENTS'); //true
    type(hello(), 'arg'); //false
    type(hello(), /arguments/); //true
    type(hello(), /ARGUMENTS/); //false
    type(hello(), /ARGUMENTS/i); //true
    type(hello(), /arg/); //false
     
    type(hello(), 'arguments|object|instance'); //true
    type(hello(), /arguments|undefined/); //true

    instance type

    import type from `of-type`;
     
    class Name{ }
     
    type(new Name(), 'instance'); //true
    type(new Name(), 'INSTANCE'); //true
    type(new Name(), 'inst'); //false
    type(new Name(), /instance/); //true
    type(new Name(), /INSTANCE/); //false
    type(new Name(), /INSTANCE/i); //true
    type(new Name(), /inst/); //false
     
    type({}, 'instance'); //false
    type([], 'instance'); //false
    type(Array, 'instance'); //false
    type(new Error(), /instance/); //false
    type('hello world', /instance/) //false
     
    global.Framework = class Framework{ };
    window.Cars = class Cars{ };
     
    type(new Framework(), 'instance'); //false
    type(new Framework(), /instance/); //false
    type(new Cars(), 'instance'); //false
    type(new Cars(), /instance/); //false
     
    type({}, 'instance|object'); //true
    type(new String(), /instance|objectable/); //true

    objectable type

    import type from `of-type`;
    type('hello world', 'objectable'); //false
    type(10, 'objectable'); //false
    type(null, 'objectable'); //false
    type(undefined, 'objectable'); //false
    type(true, 'objectable'); //false
    type({}, 'objectable'); //true
    type({}.name, 'objectable'); //false
    type([1,2,3], 'objectable'); //true
    type(/hello/, 'objectable'); //true
    type(type, 'objectable'); //true
    type((function(){ return arguments; })(), 'objectable'); //true; (arguments instanceof Object) === true
     
    class Name{}
    type(new Name(), 'objectable'); //true
    type(new String('hello world'), 'objectable'); //true
    type(new Number(10), 'objectable'); //true
    type(new Error(), 'objectable'); //true
     
    type({}, 'objectable'); //true
    type({}, 'OBJECTABLE'); //true
    type({}, 'obj'); //false
    type({}, /objectable/); //true
    type({}, /OBJECTABLE/); //false
    type({}, /OBJECTABLE/i); //true
    type({}, /objecta/); //false; as it's unrecognizable custom type
    type({}, /obj/i); //true; as it still matches constructor.name === 'Object'
     
    type(0, 'objectable|falsy'); //true
    type('hello world', /objectable|string/i); //true
    type({}, /object(able)?/i); //true
    type([], /object(able)?/i); //true

    truthy type

    import type from `of-type`;
     
    type('hello world', 'truthy'); //true
    type('', 'truthy'); //false
    type(new String(''), 'truthy'); //true
    type(new String('').valueOf(), 'truthy');  //false
    type(10, 'truthy'); //true
    type(0, 'truthy'); //false
    type(null, 'truthy'); //false
    type(undefined, 'truthy'); //false
    type([1,2,3], 'truthy'); //true
    type([], 'truthy'); //true
    type(true, 'truthy'); //true
    type(false, 'truthy'); //false
    type(type, 'truthy'); //true
    type(/hello/, 'truthy'); //true
    type({ framework: 'React' }, 'truthy'); //true
    type({}.name, 'truthy'); //false
     
    type(true, 'truthy'); //true
    type(true, 'TRUTHY'); //true
    type(true, 'tru'); //false
    type(true, /truthy/); //true
    type(true, /TRUTHY/); //false
    type(true, /TRUTHY/i); //true
    type(true, /tru/); //false; as it's unrecognizable custom type
     
    type(undefined, 'truthy|null'); //false
    type(0, 'truthy|number'); //true
    type(false, /truthy|Boolean/); //true

    falsy type

    import type from `of-type`;
    type('hello world', 'falsy'); //false
    type('', 'falsy'); //true
    type(new String(''), 'falsy'); //false
    type(new String('').valueOf(), 'falsy');  //true
    type(10, 'falsy'); //false
    type(0, 'falsy'); //true
    type(null, 'falsy'); //true
    type(undefined, 'falsy'); //true
    type([1,2,3], 'falsy'); //false
    type([], 'falsy'); //false
    type(true, 'falsy'); //false
    type(false, 'falsy'); //true
    type(type, 'falsy'); //false
    type(/hello/, 'falsy'); //false
    type({ framework: 'React' }, 'falsy'); //false
    type({}.name, 'falsy'); //true
     
    type(false, 'falsy'); //true
    type(false, 'FALSY'); //true
    type(false, 'fal'); //false
    type(false, /falsy/); //true
    type(false, /FALSY/); //false
    type(false, /FALSY/i); //true
    type(false, /fal/); //false; as it's unrecognizable custom type
     
    type([], 'falsy|objectable'); //true
    type(10, 'falsy|number'); //true
    type(true, /falsy|Boolean/); //true

    any type

    import type from `of-type`;
     
    type('hello world', 'any'); //true
    type('', 'any'); //true
    type(new String(''), 'any'); //true
    type(10, 'any'); //true
    type(0, /any/); //true
    type(null, /any/); //true
    type(undefined, /any/); //true
    type([1,2,3], /any/); //true
    type([], []); //true
    type(true, []); //true
    type(false, []); //true
    type(type, []); //true
    type(/hello/, ''); //true
    type({ framework: 'React' }, ''); //true
    type({}.name, ''); //true
     
    type({}, 'any'); //true
    type({}, 'ANY'); //true
    type({}, 'an'); //false
    type({}, /any/); //true
    type({}, /ANY/); //false
    type({}, /ANY/i); //true
    type({}, /an/); //false; as it's unrecognizable custom type

    Install

    npm i of-type

    DownloadsWeekly Downloads

    5,850

    Version

    3.0.4

    License

    MIT

    Unpacked Size

    24.4 kB

    Total Files

    4

    Last publish

    Collaborators

    • devrafalko