6 Star 7 Fork 1

前端巨浪 / typeofit

Create your Gitee Account
Explore and code with more than 6 million developers,Free private repositories !:)
Sign up
Clone or download
Cancel
Notice: Creating folder will generate an empty file .keep, because not support in Git
Loading...
README.md

typeofit.js

npm npm Github file size npm

Using typeofit.js to get the real JavaScript type of a value.

Use CDN in browser

<script type="text/javascript" src="https://unpkg.com/typeofit@1.9.0/typeofit.min.js"></script>

Install

Install with npm:

$ npm install typeofit

Install width bower

$ bower install typeofit

Usage

es5, browser and es6 ready

var typeofit = require('typeofit');
var projects;

// is()
typeofit.is(null); // -> 'null'
typeofit.is(1); // -> 'number'
typeofit.is('robert'); // -> 'string'
typeofit.is(false); // -> 'boolean'
typeofit.is(projects); // -> 'undefined'

// isArray() 
typeofit.isArray([2,3]); // -> true 

// isArrayLike() 
typeofit.isArrayLike(document.getElementsByTagName('div')); // -> true 

// isArguments
function checkArguments(){
    typeofit.isArguments(arguments); // -> true
}
checkArguments();

// isArrayBuffer()
typeofit.isArrayBuffer(new ArrayBuffer(8);); // -> true

/* ===== ES2017 Arrays ===== */
// isInt8Array()
typeofit.isInt8Array( new Int8Array() ); // -> true
// isUint8Array() 
typeofit.isUint8Array( new Uint8Array() ); // -> true
// isUint8ClampedArray() 
typeofit.isUint8ClampedArray( new Uint8ClampedArray() ); // -> true
// isInt16Array() 
typeofit.isInt16Array( new Int16Array() ); // -> true
// isUint16Array() 
typeofit.isUint16Array( new Uint16Array() ); // -> true
// isInt32Array() 
typeofit.isInt32Array( new Int32Array() ); // -> true
// isUint32Array() 
typeofit.isUint32Array( new Uint32Array() ); // -> true
// isFloat32Array() 
typeofit.isFloat32Array( new Float32Array() ); // -> true
// isFloat64Array() 
typeofit.isFloat64Array( new Float64Array() ); // -> true

// isBase64()
typeofit.isBase64('a2V5MT12YWx1ZTEma2V5Mj12YWx1ZTI'); // -> true 

// isBlank()
typeofit.isBlank('  '); // -> true

// isBoolean()
typeofit.isBoolean(false); // -> true 

// isDataView() 
typeofit.isDataView(new DataView(new ArrayBuffer(8))); // -> true 

// isDate() 
typeofit.isDate(new Date()); // -> true 

// isElement() 
typeofit.isElement(document.getElementById('wrap')); // -> true 

// isEmpty() 
typeofit.isEmpty(''); // -> true

// isEmptyObject 
typeofit.isEmptyObject({}); // -> true 

// isError() 
typeofit.isError(new Error('this is an error.')); // -> true 

// isEven() 
typeofit.isEven(2); // -> true

// isFloat() 
typeofit.isFloat(2.4); // -> true

// isFunction() 
typeofit.isFunction(parseInt); // -> true 

// isHex()
typeofit.isHex('#ffffff')); // -> true

// isHTMLCollection()
typeofit.isHTMLCollection(document.getElementsByTagName('div')); // -> true 

// isInfinite()
typeofit.isInfinite(Infinity); // -> true

// isInteger()
typeofit.isInteger(2); // -> true 

// isJSON()
typeofit.isJSON("[\"1\",\"2\",3]"); // -> true

// isMap()
typeofit.is(new Map([
    ['name', 'Robert'],
    ['Gender', 'Male']
])); // -> 'map'

// isNull() 
typeofit.isNull(null); // -> true 

// isNumber() 
typeofit.isNumber(0xffffff); // -> true 

// isNumeric() 
typeofit.isNumeric('0.3'); // -> true 

// isObject() 
typeofit.isObject(Math); // -> true 

// isOdd()
typeofit.isOdd(3); // -> true

// isPlainObject() 
typeofit.isPlainObject({name:'Robert'}); // -> true 

// isHash() 
typeofit.isHash({name:'Robert'}); // -> true 

// isRegExp() 
typeofit.isRegExp(/^\s+$/ig); // -> true 

// isSet() 
typeofit.isSet(new Set([1,2,3,4])); // -> true

// isString() 
typeofit.isString('string'); // -> true 

// isSymbol() 
typeofit.isSymbol(Symbol('string')); // -> true 

// isTextNode() 
typeofit.isTextNode(document.createTextNode('a text node')); // -> true 
 
// isUndefined()
typeofit.isUndefined(projects); // -> true 

// isValue()
typeofit.isValue([2,34]); // -> true 

// isWeakMap()
typeofit.isWeakMap(new WeakMap({},'Robert')); // -> true

// isWeakSet()
typeofit.isWeakSet(new WeakSet([
    {'name': 'Robert'},
    window
])); // -> true

// isXML()
typeofit.isXML( new require('xmldom').DOMParser.parseFromString(
    '<xml xmlns="a" xmlns:c="./lite">\n'+
    '\t<child>test</child>\n'+
    '\t<child></child>\n'+
    '\t<child/>\n'+
    '</xml>','text/xml')); // -> true

API Documentation

is

is ( val ) 方法返回检测数据的数据类型字符串:

  • 'array' - 数组
  • 'arraybuffer' - 固定长度的二进制数据缓冲区
  • 'arguments' - (函数的)参数对象
  • 'int8array' - int8array 数组
  • 'uint8array' - uint8array 数组
  • 'uint8clampedarray' - uint8clampedarray 数组
  • 'int16array' - int16array 数组
  • 'uint16array' - uint16array 数组
  • 'int32array' - int32array 数组
  • 'uint32array' - uint32array 数组
  • 'float32array' - float32array 数组
  • 'float64array' - float64array 数组
  • 'boolean' - 布尔值
  • 'map' - Map
  • 'null' - 空值
  • 'undefined' - 未定义
  • 'number' - 数字
  • 'set' - Set
  • 'string' - 字符串
  • 'object' - 对象
  • 'dataview' - DataView 视图
  • 'date' - 日期
  • 'error' - 错误
  • 'collection' - HTML NodeList 对象
  • 'function' - 函数
  • 'element' - HTML 元素节点
  • 'text' - HTML 文本节点
  • 'regexp' - 正则表达式对象
  • 'weakmap' - WeakMap
  • 'weakset' - WeakSet
  • 'whitespace' - 空字符串

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

Example

var CustomizeObject;

typeofit.is(null); // -> 'null'
typeofit.is(1); // -> 'number'
typeofit.is('robert'); // -> 'string'
typeofit.is(false); // -> 'boolean'
typeofit.is(CustomizeObject); // -> 'undefined'
typeofit.is(function(){}); // -> 'function'
typeofit.is(new Date()); // -> 'date'
typeofit.is(new Error('THIS IS NEW ERROR')); // -> 'error'
typeofit.is(/s+/g); // -> 'regexp'
typeofit.is({}); // -> 'object'
typeofit.is([1, 2, 3, 4, 5]); // -> 'array'
typeofit.is(Symbol()); // -> 'symbol'
typeofit.is(new ArrayBuffer(8)); // -> 'arraybuffer'

function sum (a, b){
    typeofit.is(arguments);
    return a + b;
}
sum( 5, 6 );

// 请在浏览器环境中测试 DOM 相关数据
typeofit.is(document.getElementById('body')); // -> 'element'
typeofit.is(document.createTextNode('')); // -> 'whitespace'
typeofit.is(document.createTextNode('text')); // -> 'textnode'
typeofit.is(document.getElementsByTagName('script')); // -> 'collection'

isArray

isArray ( val ) 方法用来检测测试数据的数据类型是否为 Array (数组)类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Array 类型返回 true,否则返回 false

Example

// True
typeofit.isArray([]); // -> true
typeofit.isArray(new Array()); // -> true
typeofit.isArray('this is string could split it into array'.split(' ')); // -> true

// False
// 虽然 HTMLNodeList 的看起来像数组,但它并不是数组
typeofit.isArray(document.getElementsByTagName('li')); // -> false
// arguments 对象看起来也像数组,但是它也不是数组
function sum (a, b){
    console.log(typeofit.isArray(arguments)); // -> false
    return a + b;
}
sum( 5, 6 );
typeofit.isArray({0:1,1:2}); // -> false
typeofit.isArray( new Int8Array() ); // -> false

isArrayLike

isArrayLike ( val ) 方法用来检测测试数据的数据类型是否为类似数组(array、arguments 对象或者 HTMLNodeList 对象)类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 array、arguments 或者 HTMLNodeList 类型返回 true,否则返回 false。

Example

typeofit.isArrayLike([1, 2, 3, 4, 5]); // -> true

// HTMLNodeList 是类似数组类型的数据
typeofit.isArrayLike(document.getElementsByTagName('li')); // -> true

// arguments 对象也是类似数组类型的数据
function sum(a, b){
    typeofit.isArrayLike(arguments); // -> true
    return a + b;
}
sum(5, 6);

typeofit.isArrayLike( new Int8Array() ); // -> false

isArguments

isArguments ( val ) 方法用来检测测试数据是否为 arguments 对象。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 arguments 对象返回 true,否则返回 false

Example

typeofit.isArguments([]); // -> false

function test(){
    typeofit.isArguments(arguments); // -> true
}
test();

isArrayBuffer

isArrayBuffer ( val ) 方法用来检测测试数据是否为 ArrayBuffer 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 ArrayBuffer 类型返回 true,否则返回 false

Example

typeofit.isArrayBuffer([]); // -> false
typeofit.isArrayBuffer(new ArrayBuffer(8)); // -> true

isInt8Array

isInt8Array ( val )方法用来检测测试数据是否为 Int8Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Int8Array 类型返回 true,否则返回 false。

Example

typeofit.isInt8Array( numbers ); // -> false

function test(){
    typeofit.isInt8Array( arguments );
}
test(); // -> false

typeofit.isInt8Array( new Int8Array() ); // -> true

isUint8Array

isUint8Array ( val )方法用来检测测试数据是否为 Uint8Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Uint8Array 类型返回 true,否则返回 false。

Example

typeofit.isUint8Array( numbers ); // -> false

function test(){
    typeofit.isUint8Array( arguments );
}
test(); // -> false

typeofit.isInt8Array( new Uint8Array() ); // -> true

isUint8ClampedArray

isUint8ClampedArray ( val )方法用来检测测试数据是否为 Uint8ClampedArray 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Uint8ClampedArray 类型返回 true,否则返回 false。

Example

typeofit.isUint8ClampedArray( numbers ); // -> false

function test(){
    typeofit.isUint8ClampedArray( arguments );
}
test(); // -> false

typeofit.isUint8ClampedArray( new Uint8ClampedArray() ); // -> true

isInt16Array

isInt16Array ( val )方法用来检测测试数据是否为 Int16Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Int16Array 类型返回 true,否则返回 false。

Example

typeofit.isInt16Array( numbers ); // -> false

function test(){
    typeofit.isInt16Array( arguments );
}
test(); // -> false

typeofit.isInt16Array( new Int16Array() ); // -> true

isUint16Array

isUint16Array ( val )方法用来检测测试数据是否为 Uint16Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Uint16Array 类型返回 true,否则返回 false。

Example

typeofit.isUint16Array( numbers ); // -> false

function test(){
    typeofit.isUint16Array( arguments );
}
test(); // -> false

typeofit.isUint16Array( new Uint16Array() ); // -> true

isInt32Array

isInt32Array ( val )方法用来检测测试数据是否为 Int32Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Int32Array 类型返回 true,否则返回 false。

Example

typeofit.isInt32Array( numbers ); // -> false

function test(){
    typeofit.isInt32Array( arguments );
}
test(); // -> false

typeofit.isInt32Array( new Int32Array() ); // -> true

isUint32Array

isUint32Array ( val )方法用来检测测试数据是否为 Uint32Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Uint32Array 类型返回 true,否则返回 false。

Example

typeofit.isUint32Array( numbers ); // -> false

function test(){
    typeofit.isUint32Array( arguments );
}
test(); // -> false

typeofit.isUint32Array( new Uint32Array() ); // -> true

isFloat32Array

isFloat32Array ( val )方法用来检测测试数据是否为 Float32Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Float32Array 类型返回 true,否则返回 false。

Example

typeofit.isFloat32Array( numbers ); // -> false

function test(){
    typeofit.isFloat32Array( arguments );
}
test(); // -> false

typeofit.isFloat32Array( new Float32Array() ); // -> true

isFloat64Array

isFloat64Array ( val )方法用来检测测试数据是否为 Float64Array 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Float64Array 类型返回 true,否则返回 false。

Example

typeofit.isFloat64Array( numbers ); // -> false

function test(){
    typeofit.isFloat64Array( arguments );
}
test(); // -> false

typeofit.isFloat64Array( new Float64Array() ); // -> true

isBase64

isBase64 ( val )方法用来检测测试数据是否为一个基于 base64 编码的字符串。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 base64 编码的字符串返回 true,否则返回 false。

Example

typeofit.isBase64('a2V5MT12YWx1ZTEma2V5Mj12YWx1ZTI'); // -> true
typeofit.isBase64('asdadf'); // -> false

isBlank

isBlank ( val )方法用来检测测试数据是否只包空格。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 只包含空格返回 true,否则返回 false。

Example

typeofit.isBlank('  '); // -> true
typeofit.isBlank(new String()); // -> false
typeofit.isBlank(''); // -> true

isBoolean

isBoolean ( obj )方法用来检测测试数据是否为 Boolean 类型

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Boolean 类型则返回 true,否则返回 false。

Example

var projects;

typeofit.isBoolean(!!0); // -> true
typeofit.isBoolean(1); // -> false
typeofit.isBoolean(false); // -> true
typeofit.isBoolean(true); // -> true
typeofit.isBoolean(Boolean('1')); // -> true
typeofit.isBoolean(new Boolean('')); // -> false
typeofit.isBoolean(''); // -> false
typeofit.isBoolean(null); // -> false
typeofit.isBoolean(NaN); // -> false
typeofit.isBoolean(projects); // -> false

isConstructor

isConstructor ( fn ) 方法用来检测测试函数是否为构造函数

Parameters

val

Type: Function

必选,要测试的(构造)函数。

Returns

Type: Boolean

fn 是构造函数返回 true,否则返回 false。

Example

var fn = function(){};
var ff = class {};
var f = () => console.log('no constructable');

typeofit.isConstructor(fn); // -> true
typeofit.isConstructor(ff); // -> true
typeofit.isConstructor(f); // -> false
typeofit.isConstructor(Math); // -> false
typeofit.isConstructor(Boolean); // -> true
typeofit.isConstructor(Array); // -> true
typeofit.isConstructor(Function); // -> true
typeofit.isConstructor(Date); // -> true
typeofit.isConstructor(RegExp); // -> true
typeofit.isConstructor(Object); // -> true

isDataView

isDataView ( val ) 方法用来检测测试数据是否为 DataView 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 DataView 类型返回 true,否则返回 false

Example

var buffer = new ArrayBuffer(8);
var dv = new DataView(buffer);

typeofit.isDataView(buffer); // -> false
typeofit.isDataView(dv); // -> true

isDate

isDate ( val )方法用来检测测试数据的数据类型是否为 Date 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 为 Date 类型返回 true,否则返回 false

Example

var time = new Date();

typeofit.isDate(time); // -> true
typeofit.isDate('2017-07-06'); // -> false
typeofit.isDate(time.getFullYear()); // -> false

isElement

isElement ( val )方法用来检测测试数据的数据类型是否为 HTML 元素节点。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 为 HTML 元素节点返回 true,否则返回 false。

Example

var wrap = document.createElement('div');
var text = document.createTextNode('this is a text node.');

typeofit.isElement(wrap); // -> true
typeofit.isElement(text); // -> false

isEmpty

isEmpty ( val )方法用来检测测试数据是否为空字符串。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是空字符串返回 true,否则返回 false。

Example

typeofit.isEmpty(''); // -> true
typeofit.isEmpty(String()); // -> true
typeofit.isEmpty(new String()); // -> false
typeofit.isEmpty(' '); // -> false

isEmptyObject

isEmptyObject ( val )方法用来检测测试数据是否为空(单体)对象。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是空对象返回 true,否则返回 false。

Example

function Person(name,age){
   this.name = name;
   this.age = age;
}

typeofit.isEmptyObject({}); // -> true
typeofit.isEmptyObject([]); // true
typeofit.isEmptyObject(Person); // true
typeofit.isEmptyObject(new Object()); // true
typeofit.isEmptyObject(new Boolean()); // true
typeofit.isEmptyObject(new Function('alert(\'function\')')); // true
typeofit.isEmptyObject(new Array()); // true
typeofit.isEmptyObject(new Date('2017-12-11')); // true
typeofit.isEmptyObject(new RegExp('\s+','ig')); // true
typeofit.isEmptyObject(null); // true
typeofit.isEmptyObject(new String()); // true
typeofit.isEmptyObject(new String('string')); // false
typeofit.isEmptyObject({name:'robert'}); // -> false
typeofit.isEmptyObject(new Person('robert',30)); // false
typeofit.isEmptyObject(['']); // false

isError

isError ( val )方法用来检测测试数据是否为 Error 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Error 类型返回 true,否则返回 false。

Example

typeofit.isError({}); // -> false
typeofit.isError(new Error()); // -> true

isEven

isEven ( val )方法用来检测测试数据的数据类型是否为偶数。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是偶数返回 true,否则返回 false。

Example

typeofit.isEven(2); // -> true
typeofit.isEven(3); // -> false
typeofit.isEven(2.2); // -> false

isFloat

isFloat ( val )方法用来检测测试数据是否为浮点数。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是浮点数返回 true,否则返回 false。

Example

typeofit.isFloat(2.4); // -> true
typeofit.isFloat(Number("3.4556645445E7")); // -> true
typeofit.isFloat(Number("3.4556645445E10")); // -> false
typeofit.isFloat(2); // -> false
typeofit.isFloat(0xffffff); // -> false
typeofit.isFloat(NaN); // -> false

isFunction

isFunction ( val )方法用来检测测试数据是否为 Function 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Function 类型返回 true,否则返回 false。

Example

typeofit.isFunction(function empty(){}); // -> true
typeofit.isFunction(parseInt); // -> true
typeofit.isFunction(Array); // -> true
typeofit.isFunction(Boolean); // -> true
typeofit.isFunction(Date); // -> true
typeofit.isFunction(Math); // -> false
typeofit.isFunction(Number); // -> true
typeofit.isFunction(Object); // -> true
typeofit.isFunction(RegExp); // -> true
typeofit.isFunction(String); // -> true

isHash

isHash ( val ) 方法用来检测测试数据是普通对象(它是方法 isPlainObject 的别名)。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是普通对象返回 true,否则返回 false。

Example

typeofit.isHash({}); // -> true
typeofit.isHash(Object.create(null)); // -> true
typeofit.isHash(function empty(){}); // -> false
typeofit.isHash([]); // -> false
typeofit.isHash(null); // -> false
typeofit.isHash(document.getElementById('wrap')); // -> false

isHex

isHex ( val )方法用来检测测试数据是否为 16 进制编码的字符串。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 16 进制编码的字符串返回 true,否则返回 false。

Example

typeofit.isHex('#ffffff')); // -> true
typeofit.isHex('f3f3f3')); // -> true
typeofit.isHex('#h1f1f1'); // -> false
typeofit.isHex('sdadfa'); // -> false

isHTMLCollection

isHTMLCollection ( val )方法用来检测数据的是否为 HTMLNodeList 对象。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 HTMLNodeList 对象返回 true,否则返回 false。

Example

typeofit.isHTMLCollection(document.getElementById('isJSON')); // -> false
typeofit.isHTMLCollection(document.getElementsByTagName('li')); // -> true

isInfinite

isInfinite ( val ) 方法用来检测测试数据的数据是正无穷或者负无穷。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是正无穷或者负无穷返回 true,否则返回 false。

Example

typeofit.isInfinite(2.4); // -> false
typeofit.isInfinite(Infinity); // -> true

isInteger

isInteger ( val )方法用来检测测试数据是否为整数。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是整数返回 true,否则返回 false。

Example

typeofit.isInteger(2.4); // -> false
typeofit.isInteger(2); // -> true
typeofit.isInteger(0xffffff); // -> true
typeofit.isInteger(NaN); // -> false
typeofit.isInteger(Number("3.4556645445E7"); // -> false

isJSON

isJSON ( val )方法用来检测测试数据是否为 JSON 格式字符串数据。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 JSON 格式字符串数据返回 true,否则返回 false。

Example

typeofit.isJSON("\"this is a JSON string.\""); // -> true
typeofit.isJSON("[\"1\",\"2\",3]"); // -> true
typeofit.isJSON("3"); // -> true
typeofit.isJSON("{\"prop\":\"JSON\"}"); // -> true
typeofit.isJSON({prop:'JSON'}); // -> false
typeofit.isJSON("{prop:'JSON'}"); // -> false

isMap

isMap ( val )方法用来检测测试数据是否为 Map 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Map 类型返回 true,否则返回 false。

Example

var map = new Map([
    ['name', 'Robert'],
    ['Gender', 'Male']
]);

typeofit.is(map) // -> 'map'

typeofit.isMap(map); // -> true
typeofit.isMap(['name','robert']) // -> false

isNativeFunction

isNativeFunction ( fn ) 方法用来检测测试函数是否为系统内置函数

Parameters

val

Type: Function

必选,要测试的函数。

Returns

Type: Boolean

fn 是系统内置函数返回 true,否则返回 false。

Example

var fn = function(){};
var ff = class {};
var f = () => console.log('no constructable');

typeofit.isNativeFunction(fn); // -> false
typeofit.isNativeFunction(ff); // -> false
typeofit.isNativeFunction(f); // -> false
typeofit.isNativeFunction(Math); // -> true
typeofit.isNativeFunction(Boolean); // -> true
typeofit.isNativeFunction(Array); // -> true
typeofit.isNativeFunction(Function); // -> true
typeofit.isNativeFunction(Date); // -> true
typeofit.isNativeFunction(RegExp); // -> true
typeofit.isNativeFunction(Object); // -> true

isNull

isNull ( val )方法用来检测测试数据是否为 null。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 为 null 返回 true,否则返回 false。

Example

var projects;
typeofit.isNull(null); // -> true
typeofit.isNull({}); // -> false
typeofit.isNull(projects); // -> false

isNumber

isNumber ( obj )方法用来检测测试数据是否为 Number 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Number 类型返回 true,否则返回 false。

Example

typeofit.isNumber(2); // -> true
typeofit.isNumber(2.4); // -> true
typeofit.isNumber(0xffffff); // -> true
typeofit.isNumber(NaN); // -> true
typeofit.isNumber('33'); // -> false

isNumeric

isNumeric ( val )方法用来检测测试数据是否是一个数字(只能是 number 类型或者 '123123' 这样的数字字符串)。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是一个数字返回 true,否则返回false。

Example

typeofit.isNumeric(2); // -> true
typeofit.isNumeric(2.4); // -> true
typeofit.isNumeric(0xffffff); // -> true
typeofit.isNumeric('33'); // -> true
typeofit.isNumeric('0xffffff'); // -> true
typeofit.isNumeric(NaN); // -> false

isObject

isObject ( val )方法用来检测测试数据是否为对象。使用 isObject() 方法测试单体对象和函数都返回值都是 true。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 为对象返回 true,否则返回 false。

Example

// True
typeofit.isObject(function empty(){}); // -> true
typeofit.isObject({}); // -> true
typeofit.isObject(Object.create(null)); // -> true
typeofit.isObject(Object.create({})); // -> true
typeofit.isObject(new Function()); // -> true

// False
typeofit.isObject([]); // -> false
typeofit.isObject(null); // -> false
typeofit.isObject(document.getElementById('wrap')); // -> false

isOdd

isOdd ( val )方法用来检测测试数据的数据类型是否为奇数。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是奇数返回 true,否则返回 false。

Example

typeofit.isOdd(3); // -> true
typeofit.isOdd(2); // -> false
typeofit.isOdd(3.1); // -> false

isPlainObject

isPlainObject ( val )方法用来检测测试数据是否为普通对象。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是普通对象返回 true,否则返回 false。

Example

typeofit.isPlainObject({}); // -> true
typeofit.isPlainObject(Object.create(null)); // -> true
typeofit.isPlainObject(function empty(){}); // -> false
typeofit.isPlainObject([]); // -> false
typeofit.isPlainObject(null); // -> false
typeofit.isPlainObject(document.getElementById('wrap')); // -> false

isRegExp

isRegExp ( val )方法用来检测测试数据是否为正则表达式。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是正则表达式返回 true,否则返回 false。

Example

typeofit.isRegExp(new RegExp('\s+','ig')); // -> true
typeofit.isRegExp(/\s+/ig); // -> true

isSet

isSet ( val )方法用来检测测试数据是否为 isSet 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 isSet 类型返回 true,否则返回 false。

Example

var mySet = new Set([1,2,3,4]);

typeofit.is(mySet) // -> 'set'

typeofit.isSet(mySet); // -> true
typeofit.isSet([1,2,3,4]) // -> false

isString

isString ( val )方法用来检测测试数据是否为字符串。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是字符串返回 true,否则返回 false。

Example

typeofit.isString('string'); // -> true
typeofit.isString(String('string')); // -> true
typeofit.isString(new String('string')); // -> false

isSymbol

isSymbol ( val )方法用来检测测试数据是否为 Symbol 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 Symbol 类型返回 true,否则返回 false。

Example

var sym = Symbol('foo');
var symObj = Object(sym);

typeofit.is(sym) // -> 'symbol'
typeofit.isSymbol(sym); // -> true

typeofit.is(symObj) // -> 'object'
typeofit.isSymbol(symObj); // -> false

isTextNode

isTextNode ( val )方法用来检测测试数据是否为文本节点。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是文本节点返回 true,否则返回 false。

Example

typeofit.isTextNode(document.createElement('p')); // -> false
typeofit.isTextNode(document.createTextNode('p')); // -> true

isUndefined

isUndefined ( val )方法用来检测测试数据是否 undefined(未定义)。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 undefined(未定义)返回 true,否则返回 false。

Example

var projects;

typeofit.isUndefined(projects); // -> true
typeofit.isUndefined([]); // -> false
typeofit.isUndefined(''); // -> false
typeofit.isUndefined(0); // -> false
typeofit.isUndefined(NaN); // -> false
typeofit.isUndefined({}); // -> false

isValue

isValue ( val )方法用来检测测试数据是否为有效的数据。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是有效的数据返回 true,否则返回 false。

Example

var projects;

typeofit.isValue(projects); // -> false
typeofit.isValue(function empty(){}); // -> true
typeofit.isValue(/\s+/ig); // -> true
typeofit.isValue([]); // -> true
typeofit.isValue(''); // -> true
typeofit.isValue(0); // -> true
typeofit.isValue(NaN); // -> false
typeofit.isValue( null ); // -> false
typeofit.isValue({}); // -> true

isWeakMap

isWeakMap ( val )方法用来检测测试数据是否为 WeakMap 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 WeakMap 类型返回 true,否则返回 false。

Example

var map = new Map([
    ['name', 'Robert'],
    ['Gender', 'Male']
]);

var weakmap = new WeakMap({},'Robert');

typeofit.is(weakmap); // -> 'weakmap'

typeofit.isWeakMap(weakmap); // -> true
typeofit.isWeakMap(map); // -> false

isWeakSet

isWeakSet ( val )方法用来检测测试数据是否为 WeakSet 类型。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 是 WeakSet 类型返回 true,否则返回 false。

Example

var weakset = new WeakSet([
    {'name': 'Robert'},
    window
]);

var set = new Set([1,2,3]);

typeofit.is(weakset) // -> 'weakset'

typeofit.isWeakSet(weakset); // -> true
typeofit.isWeakSet(set) // -> false

isXML

isValue ( obj )方法返回检测数据的是否为 XML 格式数据。

Parameters

val

Type: Any
Default: ``

必选,要检测的数据。

Returns

Type: Boolean

'val' 为 XML 返回 true,否则返回 false。

Example

const jsdom = require("jsdom");
const { JSDOM } = jsdom;
const DOMParser = require('xmldom').DOMParser;
const HTMLDOM = new JSDOM('<html><head><title>isXML</title></head><body><p>p1</p><p>p2</p><p>p3</p></body></html>');
const XMLDOM = new DOMParser().parseFromString(
    '<xml xmlns="a" xmlns:c="./lite">\n'+
        '\t<child>test</child>\n'+
        '\t<child></child>\n'+
        '\t<child/>\n'+
    '</xml>','text/xml');

typeofit.isXML(XMLDOM); // -> true
typeofit.isXML(HTMLDOM); // -> false

Changes Log

https://github.com/yaohaixiao/typeofit/releases

License

JavaScript Code Licensed under MIT License.

API Documentation Licensed under CC BY 3.0

Comments ( 0 )

Sign in for post a comment

About

A set of useful methods that helps the developers to detect almost all kinds of value types in JavaScript. spread retract
JavaScript
MIT
Cancel

Releases

No release

Gitee Metrics

Contributors

All

Activities

load more
can not load any more
JavaScript
1
https://git.oschina.net/yaohaixiao/typeofit.git
git@git.oschina.net:yaohaixiao/typeofit.git
yaohaixiao
typeofit
typeofit
master

Search