# describe-type
> The describe-type package contains a variety of package-level functions for timing code execution, retrieving information about object data type.
[![NPM][nodei_status_image]][nodei_status_url]
[![travis][travis]][travis-url]
[![appveyor][appveyor]][appveyor-url]
[![codecov][codecov]][codecov-url]
[![codacy][codacy]][codacy-url]
## Installation
### Using [npm](https://www.npmjs.com/package/npm "A package manager for everything")
```bash
npm i describe-type -S
```
### Using [bower](https://www.bower.io "A package manager for the web")
```bash
bower i describe-type -S
```
### Links to CDN
Use this URL for dev/testing
```html
```
Use this URL in production
```html
```
describe-type/is
> Evaluates whether an object is compatible or not with a specific data type.
:heavy_exclamation_mark:
Use the _[is.a](#api-a.an.type)_, _[is.an](#api-a.an.type)_ or _[is.type](#api-a.an.type)_ function instead of the _instanceof_ or
_[toString.call][toString.call]_ function for type comparisons.
#### Arguments
- **datatype**:[Function][Function] — The data type used to evaluate the _expression_ argument.
- **expression**:any — The value to check against the data type specified.
##### Result
- [Boolean][Boolean] — A value of _true_ if _datatype_ is compatible with the data type specified in _expression_, and _false_ otherwise.
#### Example
The following example creates an instance of the _Sprite_ class named _mySprite_ and uses the _[is.type](#api-a.an.type)_ function to test whether _mySprite_ is an instance of the _Sprite_.
```js
class Sprite {}
var mySprite = new Sprite();
console.log(is.type(Sprite, mySprite)); // true
console.log(is.type(Number, mySprite)); // false
console.log(is.type(Function, mySprite)); // false
```
### API
##### Common
- [a](#api-a.an.type)(expected :Function, value :any) :boolean
- [an](#api-a.an.type)(expected :Function, value :any)
- [type](#api-a.an.type)(expected :Function, value :any) :boolean
- [instanceOf](#api-instanceOf)(expected :Function, value :any) :boolean
- [defined](#api-defined)(value :any) :boolean
- [undef](#api-undef)(value :any) :boolean
- [nil](#api-nil)(value :any) :boolean
- [unfilled](#api-unfilled)(value :any) :boolean
- [filled](#api-filled)(value :any) :boolean
- [empty](#api-empty)(value :any) :boolean
- [equal](#api-equal)(valueA :any, valueB :any) :boolean
- [primitive](#api-primitive)(value :any) :boolean
- [exotic](#api-exotic)(value :any) :boolean
- [enumerable](#api-enumerable)(value :any) :boolean
- [hosted](#api-hosted)(key :string | number, host :object) :boolean
- [within](#api-within)(value :number, start :number, finish :number) :boolean
##### Arguments
- [args](#api-args)(value :any) :boolean
- [args.empty](#api-args.empty)(value :any) :boolean
##### Array
- [arraylike](#api-arraylike)(value :any) :boolean
- [arraylike.empty](#api-arraylike.empty)(value :any) :boolean
- [array](#api-array)(value :any) :boolean
- [array.of](#api-array.of)(expected :Function, value :any) :boolean
- [array.empty](#api-array.empty)(value :any) :boolean
##### Object
- [object](#api-object)(value :any) :boolean
- [object.empty](#api-object.empty)(value :any) :boolean
##### RegExp
- [regexp](#api-regexp)(value :any) :boolean
- [regexp.string](#api-regexp.string)(value :any) :boolean
- [regexp.flags](#api-regexp.flags)(value :any) :boolean
##### Stream
- [stream](#api-stream)(value :any) :boolean
- [stream.duplex](#api-stream.duplex)(value :any) :boolean
- [stream.transform](#api-stream.transform)(value :any) :boolean
- [stream.readable](#api-stream.readable)(value :any) :boolean
- [stream.writable](#api-stream.writable)(value :any) :boolean
##### String
- [string](#api-string)(value :any) :boolean
- [string.empty](#api-string.empty)(value :any) :boolean
##### Function
- [fn](#api-fn)(value :any) :boolean
- [fn.native](#api-fn.native)(value :any) :boolean
- [fn.callable](#api-fn.callable)(value :any) :boolean
- [fn.caste](#api-fn.caste)(value :any) :boolean
##### Boolean
- [bool](#api-bool)(value :any) :boolean
##### Date
- [date](#api-date)(value :any) :boolean
##### Number
- [number](#api-number)(value :any) :boolean
- [numeric](#api-numeric)(value :any) :boolean
- [int](#api-int)(value :any) :boolean
- [uint](#api-uint)(value :any) :boolean
- [infinity](#api-infinity)(value :any) :boolean
- [nan](#api-nan)(value :any) :boolean
- [odd](#api-odd)(value :any) :boolean
- [even](#api-even)(value :any) :boolean
- [decimal](#api-decimal)(value :any) :boolean
- [min](#api-min)(value: any, others: any[]) :boolean
- [max](#api-max)(value: any, others: any[]) :boolean
##### Error
- [error](#api-error)(value :any) :boolean
##### Symbol
- [symbol](#api-symbol)(value :any) :boolean
##### Element
- [element](#api-element)(value :any) :boolean
##### Buffer
- [buffer](#api-buffer)(value :any) :boolean
##### JSON
- [jsonlike](#api-jsonlike)(value :any) :boolean
##### Encoded binary
- [base64](#api-base64)(value :any) :boolean
- [hex](#api-hex)(value :any) :boolean
##### Colors
- [hexadecimal](#api-hexadecimal)(value :any) :boolean
- [rgb](#api-rgb)(value :any) :boolean
- [rgba](#api-rgba)(value :any) :boolean
#### Common
| :umbrella: |
▴is: A, An or Type |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/type] |
```js
const an = require('describe-type/is/an');
an(expected, value);
```
|
|
[ES6][es6:is/type] |
```js
import type from 'describe-type/is/type.next';
type(expected, value);
```
|
| :umbrella: |
▴is: Instance of |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/instanceOf] |
```js
const instanceOf = require('describe-type/is/instanceOf');
instanceOf(expected, value);
```
|
|
[ES6][es6:is/instanceOf] |
```js
import instanceOf from 'describe-type/is/instanceOf.next';
instanceOf(expected, value);
```
|
| :umbrella: |
▴is: Defined |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/defined] |
```js
const defined = require('describe-type/is/defined');
defined(value);
```
|
|
[ES6][es6:is/defined] |
```js
import defined from 'describe-type/is/defined.next';
defined(value);
```
|
| :umbrella: |
▴is: undefined |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/undef] |
```js
const undef = require('describe-type/is/undef');
undef(value);
```
|
|
[ES6][es6:is/undef] |
```js
import undef from 'describe-type/is/undef.next';
undef(value);
```
|
| :umbrella: |
▴is: null |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/nil] |
```js
const nil = require('describe-type/is/nil');
nil(value);
```
|
|
[ES6][es6:is/nil] |
```js
import nil from 'describe-type/is/nil.next';
nil(value);
```
|
| :umbrella: |
▴is: Unfilled |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/unfilled] |
```js
const unfilled = require('describe-type/is/unfilled');
unfilled(value);
```
|
|
[ES6][es6:is/unfilled] |
```js
import unfilled from 'describe-type/is/unfilled.next';
unfilled(value);
```
|
| :umbrella: |
▴is: Filled |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/filled] |
```js
const filled = require('describe-type/is/filled');
filled(value);
```
|
|
[ES6][es6:is/filled] |
```js
import filled from 'describe-type/is/filled.next';
filled(value);
```
|
| :umbrella: |
▴is: Empty |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/empty] |
```js
const empty = require('describe-type/is/empty');
empty(value);
```
|
|
[ES6][es6:is/empty] |
```js
import empty from 'describe-type/is/empty.next';
empty(value);
```
|
| :umbrella: |
▴is: Equal |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/equal] |
```js
const equal = require('describe-type/is/equal');
equal(valueA, valueB);
```
|
|
[ES6][es6:is/equal] |
```js
import equal from 'describe-type/is/equal.next';
equal(valueA, valueB);
```
|
| :umbrella: |
▴is: Primitive |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/primitive] |
```js
const primitive = require('describe-type/is/primitive');
primitive(value);
```
|
|
[ES6][es6:is/primitive] |
```js
import primitive from 'describe-type/is/primitive.next';
primitive(value);
```
|
| :umbrella: |
▴is: Exotic |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/exotic] |
```js
const exotic = require('describe-type/is/exotic');
exotic(value);
```
|
|
[ES6][es6:is/exotic] |
```js
import exotic from 'describe-type/is/exotic.next';
exotic(value);
```
|
| :umbrella: |
▴is: Enumerable |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/enumerable] |
```js
const enumerable = require('describe-type/is/enumerable');
enumerable(value);
```
|
|
[ES6][es6:is/enumerable] |
```js
import enumerable from 'describe-type/is/enumerable.next';
enumerable(value);
```
|
| :umbrella: |
▴is: Hosted |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/hosted] |
```js
const hosted = require('describe-type/is/hosted');
hosted(key, host);
```
|
|
[ES6][es6:is/hosted] |
```js
import hosted from 'describe-type/is/hosted.next';
hosted(key, host);
```
|
| :umbrella: |
▴is: Within |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/within] |
```js
const within = require('describe-type/is/within');
within(value, start, finish);
```
|
|
[ES6][es6:is/within] |
```js
import within from 'describe-type/is/within.next';
within(value, start, finish);
```
|
#### Arguments
| :umbrella: |
▴is: Arguments |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/args] |
```js
const args = require('describe-type/is/args');
args(value);
```
|
|
[ES6][es6:is/args] |
```js
import args from 'describe-type/is/args/index.next';
args(value);
```
|
| :umbrella: |
▴is: Arguments empty |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/args/args.empty] |
```js
const argsEmpty = require('describe-type/is/args/args.empty');
argsEmpty(value);
```
|
|
[ES6][es6:is/args/args.empty] |
```js
import argsEmpty from 'describe-type/is/args/args.empty.next';
argsEmpty(value);
```
|
#### Array
| :umbrella: |
▴is: Arraylike |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/arraylike] |
```js
const arraylike = require('describe-type/is/arraylike');
arraylike(value);
```
|
|
[ES6][es6:is/arraylike] |
```js
import arraylike from 'describe-type/is/arraylike/index.next';
arraylike(value);
```
|
| :umbrella: |
▴is: Arraylike empty |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/arraylike/arraylike.empty] |
```js
const arraylikeEmpty = require('describe-type/is/arraylike/arraylike.empty');
arraylikeEmpty(value);
```
|
|
[ES6][es6:is/arraylike/arraylike.empty] |
```js
import arraylikeEmpty from 'describe-type/is/arraylike/arraylike.empty.next';
arraylikeEmpty(value);
```
|
| :umbrella: |
▴is: Array |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/array] |
```js
const array = require('describe-type/is/array');
array(value);
```
|
|
[ES6][es6:is/array] |
```js
import array from 'describe-type/is/array/index.next';
array(value);
```
|
| :umbrella: |
▴is: Array empty |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/array/array.empty] |
```js
const arrayEmpty = require('describe-type/is/array/array.empty');
arrayEmpty(value);
```
|
|
[ES6][es6:is/array/array.empty] |
```js
import arrayEmpty from 'describe-type/is/array/array.empty.next';
arrayEmpty(value);
```
|
| :umbrella: |
▴is: Array of |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/array/array.of] |
```js
const arrayOf = require('describe-type/is/array/array.of');
arrayOf(value);
```
|
|
[ES6][es6:is/array/array.of] |
```js
import arrayOf from 'describe-type/is/array/array.of.next';
arrayOf(value);
```
|
#### Object
| :umbrella: |
▴is: Object |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/object] |
```js
const object = require('describe-type/is/object');
object(value);
```
|
|
[ES6][es6:is/object] |
```js
import object from 'describe-type/is/object/index.next';
object(value);
```
|
| :umbrella: |
▴is: Object empty |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/object/object.empty] |
```js
const objectEmpty = require('describe-type/is/object/object.empty');
objectEmpty(value);
```
|
|
[ES6][es6:is/object/object.empty] |
```js
import objectEmpty from 'describe-type/is/object/object.empty.next';
objectEmpty(value);
```
|
#### RegExp
| :umbrella: |
▴is: RegExp |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/regexp] |
```js
const regexp = require('describe-type/is/regexp');
regexp(value);
```
|
|
[ES6][es6:is/regexp] |
```js
import regexp from 'describe-type/is/regexp/index.next';
regexp(value);
```
|
| :umbrella: |
▴is: RegExp String |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/regexp/regexp.string] |
```js
const regexpString = require('describe-type/is/regexp/regexp.string');
regexpString(value);
```
|
|
[ES6][es6:is/regexp/regexp.string] |
```js
import regexpString from 'describe-type/is/regexp/regexp.string.next';
regexpString(value);
```
|
| :umbrella: |
▴is: RegExp Flags |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/regexp/regexp.flags] |
```js
const regexpFlags = require('describe-type/is/regexp/regexp.flags');
regexpFlags(value);
```
|
|
[ES6][es6:is/regexp/regexp.flags] |
```js
import regexpFlags from 'describe-type/is/regexp/regexp.flags.next';
regexpFlags(value);
```
|
#### Stream
| :umbrella: |
▴is: Stream |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/stream] |
```js
const stream = require('describe-type/is/stream');
stream(value);
```
|
|
[ES6][es6:is/stream] |
```js
import stream from 'describe-type/is/stream/index.next';
stream(value);
```
|
| :umbrella: |
▴is: Stream duplex |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/stream/stream.duplex] |
```js
const streamDuplex = require('describe-type/is/stream/stream.duplex');
streamDuplex(value);
```
|
|
[ES6][es6:is/stream/stream.duplex] |
```js
import streamDuplex from 'describe-type/is/stream/stream.duplex.next';
streamDuplex(value);
```
|
| :umbrella: |
▴is: Stream readable |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/stream/stream.readable] |
```js
const streamReadable = require('describe-type/is/stream/stream.readable');
streamReadable(value);
```
|
|
[ES6][es6:is/stream/stream.readable] |
```js
import streamReadable from 'describe-type/is/stream/stream.readable.next';
streamReadable(value);
```
|
| :umbrella: |
▴is: Stream writable |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/stream/stream.writable] |
```js
const streamWritable = require('describe-type/is/stream/stream.writable');
streamWritable(value);
```
|
|
[ES6][es6:is/stream/stream.writable] |
```js
import streamWritable from 'describe-type/is/stream/stream.writable.next';
streamWritable(value);
```
|
#### String
| :umbrella: |
▴is: String |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/string] |
```js
const string = require('describe-type/is/string');
string(value);
```
|
|
[ES6][es6:is/string] |
```js
import string from 'describe-type/is/string/index.next';
string(value);
```
|
| :umbrella: |
▴is: String empty |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/string/string.empty] |
```js
const stringEmpty = require('describe-type/is/string/string.empty');
stringEmpty(value);
```
|
|
[ES6][es6:is/string/string.empty] |
```js
import stringEmpty from 'describe-type/is/string/string.empty.next';
stringEmpty(value);
```
|
#### Function
| :umbrella: |
▴is: Function |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/fn] |
```js
const fn = require('describe-type/is/fn');
fn(value);
```
|
|
[ES6][es6:is/fn] |
```js
import fn from 'describe-type/is/fn/index.next';
fn(value);
```
|
| :umbrella: |
▴is: Function Native |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/fn/fn.native] |
```js
const fnNative = require('describe-type/is/fn/fn.native');
fnNative(value);
```
|
|
[ES6][es6:is/fn/fn.native] |
```js
import fnNative from 'describe-type/is/fn/fn.native.next';
fnNative(value);
```
|
| :umbrella: |
▴is: Function Callable |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/fn/fn.callable] |
```js
const fnCallable = require('describe-type/is/fn/fn.callable');
fnCallable(value);
```
|
|
[ES6][es6:is/fn/fn.callable] |
```js
import fnCallable from 'describe-type/is/fn/fn.callable.next';
fnCallable(value);
```
|
| :umbrella: |
▴is: Class |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/fn/fn.caste] |
```js
const fnCaste = require('describe-type/is/fn/fn.caste');
fnCaste(value);
```
|
|
[ES6][es6:is/fn/fn.caste] |
```js
import fnCaste from 'describe-type/is/fn/fn.caste.next';
fnCaste(value);
```
|
#### Boolean
| :umbrella: |
▴is: Boolean |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/bool] |
```js
const bool = require('describe-type/is/bool');
bool(value);
```
|
|
[ES6][es6:is/bool] |
```js
import bool from 'describe-type/is/bool.next';
bool(value);
```
|
#### Date
| :umbrella: |
▴is: Date |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/date] |
```js
const date = require('describe-type/is/date');
date(value);
```
|
|
[ES6][es6:is/date] |
```js
import date from 'describe-type/is/date.next';
date(value);
```
|
#### Number
| :umbrella: |
▴is: Number |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/number] |
```js
const number = require('describe-type/is/number');
number(value);
```
|
|
[ES6][es6:is/number] |
```js
import number from 'describe-type/is/number.next';
number(value);
```
|
| :umbrella: |
▴is: Numeric |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/numeric] |
```js
const numeric = require('describe-type/is/numeric');
numeric(value);
```
|
|
[ES6][es6:is/numeric] |
```js
import numeric from 'describe-type/is/numeric.next';
numeric(value);
```
|
| :umbrella: |
▴is: Integer |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/int] |
```js
const int = require('describe-type/is/int');
int(value);
```
|
|
[ES6][es6:is/int] |
```js
import int from 'describe-type/is/int.next';
int(value);
```
|
| :umbrella: |
▴is: Unsigned integer |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/uint] |
```js
const uint = require('describe-type/is/uint');
uint(value);
```
|
|
[ES6][es6:is/uint] |
```js
import uint from 'describe-type/is/uint.next';
uint(value);
```
|
| :umbrella: |
▴is: Infinity |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/infinity] |
```js
const infinity = require('describe-type/is/infinity');
infinity(value);
```
|
|
[ES6][es6:is/infinity] |
```js
import infinity from 'describe-type/is/infinity.next';
infinity(value);
```
|
| :umbrella: |
▴is: NaN |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/nan] |
```js
const nan = require('describe-type/is/nan');
nan(value);
```
|
|
[ES6][es6:is/nan] |
```js
import nan from 'describe-type/is/nan.next';
nan(value);
```
|
| :umbrella: |
▴is: Odd |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/odd] |
```js
const odd = require('describe-type/is/odd');
odd(value);
```
|
|
[ES6][es6:is/odd] |
```js
import odd from 'describe-type/is/odd.next';
odd(value);
```
|
| :umbrella: |
▴is: Even |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/even] |
```js
const even = require('describe-type/is/even');
even(value);
```
|
|
[ES6][es6:is/even] |
```js
import even from 'describe-type/is/even.next';
even(value);
```
|
| :umbrella: |
▴is: Decimal |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/decimal] |
```js
const decimal = require('describe-type/is/decimal');
decimal(value);
```
|
|
[ES6][es6:is/decimal] |
```js
import decimal from 'describe-type/is/decimal.next';
decimal(value);
```
|
| :umbrella: |
▴is: Minimum |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/min] |
```js
const min = require('describe-type/is/min');
min(value, others);
```
|
|
[ES6][es6:is/min] |
```js
import min from 'describe-type/is/min.next';
min(value, others);
```
|
| :umbrella: |
▴is: Maximum |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/max] |
```js
const max = require('describe-type/is/max');
max(value, others);
```
|
|
[ES6][es6:is/max] |
```js
import max from 'describe-type/is/max.next';
max(value, others);
```
|
#### Error
| :umbrella: |
▴is: Error |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/error] |
```js
const error = require('describe-type/is/error');
error(value);
```
|
|
[ES6][es6:is/error] |
```js
import error from 'describe-type/is/error.next';
error(value);
```
|
#### Symbol
| :umbrella: |
▴is: Symbol |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/symbol] |
```js
const symbol = require('describe-type/is/symbol');
symbol(value);
```
|
|
[ES6][es6:is/symbol] |
```js
import symbol from 'describe-type/is/symbol.next';
symbol(value);
```
|
#### Element
| :umbrella: |
▴is: Element |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/element] |
```js
const element = require('describe-type/is/element');
element(value);
```
|
|
[ES6][es6:is/element] |
```js
import element from 'describe-type/is/element.next';
element(value);
```
|
#### Buffer
| :umbrella: |
▴is: Buffer |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/buffer] |
```js
const buffer = require('describe-type/is/buffer');
buffer(value);
```
|
|
[ES6][es6:is/buffer] |
```js
import buffer from 'describe-type/is/buffer.next';
buffer(value);
```
|
#### JSON
| :umbrella: |
▴is: Jsonlike |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/jsonlike] |
```js
const jsonlike = require('describe-type/is/jsonlike');
jsonlike(value);
```
|
|
[ES6][es6:is/jsonlike] |
```js
import jsonlike from 'describe-type/is/jsonlike.next';
jsonlike(value);
```
|
#### Encoded binary
| :umbrella: |
▴is: Base64 |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/base64] |
```js
const base64 = require('describe-type/is/base64');
base64(value);
```
|
|
[ES6][es6:is/base64] |
```js
import base64 from 'describe-type/is/base64.next';
base64(value);
```
|
| :umbrella: |
▴is: Hex |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/hex] |
```js
const hex = require('describe-type/is/hex');
hex(value);
```
|
|
[ES6][es6:is/hex] |
```js
import hex from 'describe-type/is/hex.next';
hex(value);
```
|
#### Colors
| :umbrella: |
▴is: Hexadecimal |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/hexadecimal] |
```js
const hexadecimal = require('describe-type/is/hexadecimal');
hexadecimal(value);
```
|
|
[ES6][es6:is/hexadecimal] |
```js
import hexadecimal from 'describe-type/is/hexadecimal.next';
hexadecimal(value);
```
|
| :umbrella: |
▴is: RGB |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/rgb] |
```js
const rgb = require('describe-type/is/rgb');
rgb(value);
```
|
|
[ES6][es6:is/rgb] |
```js
import rgb from 'describe-type/is/rgb.next';
rgb(value);
```
|
| :umbrella: |
▴is: RGBA |
|
[UMD][umd:is] |
```html
```
|
|
[CJS][cjs:is/rgba] |
```js
const rgba = require('describe-type/is/rgba');
rgba(value);
```
|
|
[ES6][es6:is/rgba] |
```js
import rgba from 'describe-type/is/rgba.next';
rgba(value);
```
|
▴ back to top
describe-type/as
> Evaluates whether an expression specified by the first argument is a member of the data type specified by the second argument. If the first argument is a member of the data type, the result is the first argument. Otherwise, the result is the value _null_ unless the third value is set as default.
The expression used for the second argument must evaluate to a data type.
#### Arguments
- **datatype**:[Function][Function] — The data type used to evaluate the _expression_ argument.
- **expression**:* — The value to check against the data type specified.
- **defaultValue**:* — The fallback value.
##### Result
- [Object][Object] — The result is _expression_ if _expression_ is a member of the data type specified in _datatype_.
Otherwise, the result is the value _null_ or the _defaultValue_.
#### Example
The following example creates a simple array named _myArray_ and uses the _as_ function with various data types.
```js
var myArray = ['foo', 'bar', 'baz'];
console.log(as(Array, myArray)); // foo,bar,baz
console.log(as(Number, myArray)); // null
console.log(as(Boolean, myArray, undefined)); // undefined
```
#### Variants
- [as.any](#api-as.any)(datatype :Array<Function>, expression :*, defaultValue :*) :any
- [as.arrayOf](#api-as.arrayOf)(datatype :Function, expression :*, defaultValue :*) :any
#### Shortcuts
- [as.a](#api-as.a)(datatype :Function, expression :*, defaultValue :*) :any
- [as.an](#api-as.an)(datatype :Function, expression :*, defaultValue :*) :any
- [as.type](#api-as.type)(datatype :Function, expression :*, defaultValue :*) :any
#### Variants
| :umbrella: |
▴as: Any |
|
[UMD][umd:as] |
```html
```
|
|
[CJS][cjs:as/any] |
```js
const any = require('describe-type/as/any');
any([datatype1, datatype2, ...], currentValue, defaultValue);
```
|
|
[ES6][es6:as/any] |
```js
import any from 'describe-type/as/any.next';
any([datatype1, datatype2, ...], currentValue, defaultValue);
```
|
| :umbrella: |
▴as: Array of |
|
[UMD][umd:as] |
```html
```
|
|
[CJS][cjs:as/arrayOf] |
```js
const arrayOf = require('describe-type/as/arrayOf');
arrayOf(datatype, currentValue, defaultValue);
```
|
|
[ES6][es6:as/arrayOf] |
```js
import arrayOf from 'describe-type/as/arrayOf.next';
arrayOf(datatype, currentValue, defaultValue);
```
|
#### Shortcuts
| :umbrella: |
▴as: A |
|
[UMD][umd:as] |
```html
```
|
|
[CJS][cjs:as/a] |
```js
const a = require('describe-type/as/a');
a(datatype, currentValue, defaultValue);
```
|
|
[ES6][es6:as/a] |
```js
import a from 'describe-type/as/a.next';
a(datatype, currentValue, defaultValue);
```
|
| :umbrella: |
▴as: An |
|
[UMD][umd:as] |
```html
```
|
|
[CJS][cjs:as/a] |
```js
const an = require('describe-type/as/an');
an(datatype, currentValue, defaultValue);
```
|
|
[ES6][es6:as/a] |
```js
import an from 'describe-type/as/an.next';
an(datatype, currentValue, defaultValue);
```
|
| :umbrella: |
▴as: Type |
|
[UMD][umd:as] |
```html
```
|
|
[CJS][cjs:as/type] |
```js
const type = require('describe-type/as/type');
type(datatype, currentValue, defaultValue);
```
|
|
[ES6][es6:as/type] |
```js
import type from 'describe-type/as/type.next';
type(datatype, currentValue, defaultValue);
```
|
▴ back to top