types.js | 专注于检测 JavaScript 数据类型的工具库

types.js 提供以下基础的数据类型检测方法。

Since：: 0.2.0

Description

is(val) 方法返回检测 val 数据类型的字符串（名称）。

Parameters

val

Type：: Any

（必须）待检测的数据。

Returns

Type：: String。

返回确切的数据类型名称。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 is() 方法
// import is from '@yaohaixiao/types.js/is'
import { DOMParser } from 'xmldom'

let Example
let args
const buffer = new ArrayBuffer(8)
const dv = new DataView(buffer)
const XML = 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'
)

function test(age){
  args = arguments
  return age
}

test(40)

// 基础值类型
Types.is('types.js') // -> string
Types.is(' ') // -> blank
Types.is('Z29vZA==') // -> base64
Types.is('中国梦') // -> chinese
Types.is('type.js@gmail.com') // -> email
Types.is('') // -> empty
Types.is('3C8021B0-423D-475D-BECF-63ED5ED34563') // -> guid
Types.is('3C8021B0423D475DBECF63ED5ED34563') // -> guid
Types.is('#ffffff') // -> hex
Types.is('<h2>中国梦</h2>') // -> html
Types.is('126.11.15.255') // -> IP address
Types.is('110105491231002') // -> ID number
Types.is('11010519491231002X') // -> ID number
Types.is('{"prop":"JSON"}') // -> json
Types.is('11:23 am') // -> time
Types.is('Jul 08 2023') // -> time
Types.is(2023) // -> integer
Types.is(3.0) // -> integer
Types.is(3.01) // -> float
Types.is(Infinity) // -> infinite
Types.is(true) // -> boolean
Types.is(null) // -> null
Types.is(Example) // -> undefined
Types.is(Symbol()) // -> symbol
Types.is(BigInt(42)) // -> bigint

// Set/WeakSet/Map/WeakMap
Types.is(new Set()) // -> set
Types.is(new WeakSet()) // -> weakset
Types.is(new Map()) // -> map
Types.is(new WeakMap()) // -> weakmap

// Object 对象相关
Types.is({}) // -> object
Types.is(new Object()) // -> object
Types.is(Object.prototype) // -> prototype
Types.is(XML) // -> xml
Types.is(Object.create(null)) // -> object
Types.is(new String()) // -> object
Types.is(new Number()) // -> object
Types.is(new Boolean()) // -> object
Types.is(new Error()) // -> error
Types.is(new Date()) // -> data
Types.is(new RegExp('/s/')) // -> regexp
Types.is(/\s+/ig) // -> regexp
Types.is(() => {}) // -> function
Types.is(args) // -> arguments
Types.is(dv) // -> dataview
Types.is(document.querySelector('#list')) // -> element
Types.is(document.querySelectorAll('.item')) // -> coolection
Types.is(document.createTextNode('text')) // -> text
Types.is(document.createDocumentFragment()) // -> fragment

// Array 相关
Types.is([]) // -> array
Types.is(new ArrayBuffer(8)) // -> arraybubber
Types.is(new Int8Array([])) // -> int8array
Types.is(new Int16Array([])) // -> int16array
Types.is(new Int32Array([])) // -> int32array
Types.is(new Uint8Array([])) // -> uint8array
Types.is(new Uint8ClampedArray([])) // -> uint8clampedarray
Types.is(new Uint16Array([])) // -> uint16array
Types.is(new Uint32Array([])) // -> uint32array
Types.is(new Float32Array([])) // -> float32array
Types.is(new Float64Array([])) // -> float64array
Types.is(new BigInt64Array(64)) // -> bigint64array
Types.is(new BigUint64Array(64)) // -> biguint64array

Since：: 0.2.0

Description

isEmpty(val) 方法用来检测测试数据是否为空字符串、数组、对象或者空的 arguments 参数。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

true - 表示检测数据为空字符串，false 则表示不是。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isEmpty() 方法
// import isEmpty from '@yaohaixiao/types.js/isEmpty'

Types.isEmpty(null) // -> true

// 字符串
Types.isEmpty('') // -> true
Types.isEmpty(String()) // -> true
Types.isEmpty(' ') // -> false

// 数组
Types.isEmpty([]) // -> true
Types.isEmpty([1]) // -> false

// 对象
Types.isEmpty(new String()) // -> true
Types.isEmpty({}) // -> true
Types.isEmpty({a: 1}) // -> false

// arguments 参数
let args
const fn = function () {arg = arguments}

fn()

Types.isEmpty(fn.prototype) // -> false
Types.isEmpty(args) // -> true

fn(1)

Types.isEmpty(args) // -> false

// buffer
left buffer = Buffer.alloc(0)

isEmpty(buffer) => true

buffer = Buffer.alloc(10)

isEmpty(buffer) => false

Since：: 2.7.0

Description

isFalsy(val) 方法用来检测测试数据是否为在布尔上下文中被视为 false 的值。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: String。

'val' 在布尔上下文中被视为 true 的值，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isFalsy() 方法
// import isFalsy from '@yaohaixiao/types.js/isFalsy'

Types.isFalsy(false) // true
Types.isFalsy(0) // true
Types.isFalsy('') // true
Types.isFalsy(null) // true
Types.isFalsy(undefined) // true
Types.isFalsy(NaN) // true

Types.isFalsy(true) // false
Types.isFalsy(1) // false
Types.isFalsy('hello') // false
Types.isFalsy({}) // false
Types.isFalsy([]) // false

Since：: 2.7.0

Description

isNil(val) 方法用来检测测试数据是否为在布尔上下文中被视为 false 的值。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: String。

'val' 是 Null 或者 undefined，返回 true，否则返回 false。。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isNil() 方法
// import isNil from '@yaohaixiao/types.js/isNil'

Types.isNil(null) // => true

Types.isNil(void 0) // => true

Types.isNil(undefined) // => true

Types.isNil(NaN) // => false

Types.isNil('') // => false

Since：: 2.6.0

Description

isPrimitive(val) 方法用来检测测试数据是否为原始值类型。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是原始值类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isPrimitive() 方法
// import isPrimitive from '@yaohaixiao/types.js/isPrimitive'

let num
const MAX_SAFE_INTEGER = 9007199254740991
const bigint = BigInt(MAX_SAFE_INTEGER + 1)

// True
Types.isPrimitive(1) // -> true
Types.isPrimitive('num') // -> true
Types.isPrimitive(false) // -> true
Types.isPrimitive(null) // -> true
Types.isPrimitive(num) // -> true
Types.isPrimitive(Symbol('foo')) // -> true
Types.isPrimitive(bigint) // -> true

// False
Types.isPrimitive([]) // -> false
Types.isPrimitive({}) // -> false
Types.isPrimitive(()=>{}) // -> false

Since：: 2.8.0

Description

isTruly(val) 方法用来检测测试数据是否为在布尔上下文中被视为 true 的值。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: String。

'val' 在布尔上下文中被视为 true 的值，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isTruly() 方法
// import isTruly from '@yaohaixiao/types.js/isTruly'

Types.isTruly(true); // -> true
Types.isTruly(1); // -> true
Types.isTruly("hello"); // -> true
Types.isTruly({}); // -> true
Types.isTruly([]); // -> true

Types.isTruly(false); // -> false
Types.isTruly(0); // -> false
Types.isTruly(''); // -> false
Types.isTruly(null); // -> false
Types.isTruly(undefined); // -> false
Types.isTruly(NaN); // -> false

Since：: 0.2.0

Description

isValue(val) 方法用来检测测试数据是否有效的数据（非null、undefined、NaN或者正负无穷数值）。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是有效的数据（非null、undefined或者正负无穷数值），返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isValue() 方法
// import isValue from '@yaohaixiao/types.js/isValue'

const fn = () => {}
let projects
function empty(){}

// 非有效数据
Types.isValue(projects) // -> false
Types.isValue(NaN) // -> false
Types.isValue(null) // -> false
Types.isValue(Infinity) // -> false
Types.isValue(-Infinity) // -> false

// 有效数据
Types.isValue(0) // -> true
Types.isValue('') // -> true
Types.isValue(false) // -> true
Types.isValue([]) // -> true
Types.isValue({}) // -> true
Types.isValue(/\s+/ig) // -> true
Types.isValue(new Date()) // -> true
Types.isValue(empty) // -> true
Types.isValue(fn) // -> true

types.js 提供以下方法来检测 Primitive Values（基础值类型）相关的数据类型。

Since：: 0.6.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 BigInt 类型返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isBigInt() 方法
// import isBigInt from '@yaohaixiao/types.js/isBigInt'

const MAX_SAFE_INTEGER = 9007199254740991
const bigint = BigInt(MAX_SAFE_INTEGER + 1)

Type.is(bigint) // -> 'bigint'

Types.isBigInt(MAX_SAFE_INTEGER) // -> false
Types.isBigInt(bigint) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isBoolean() 方法
// import isBoolean from '@yaohaixiao/types.js/isBoolean'

let projects

// False
Types.isBoolean(1) // -> false
Types.isBoolean('') // -> false
Types.isBoolean(null) // -> false
Types.isBoolean(NaN) // -> false
Types.isBoolean(projects) // -> false

// True
Types.isBoolean(!!0) // -> true
Types.isBoolean(false) // -> true
Types.isBoolean(true) // -> true
Types.isBoolean(Boolean('1')) // -> true
Types.isBoolean(new Boolean('')) // -> false
Types.isBoolean(!!projects) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isNull() 方法
// import isNull from '@yaohaixiao/types.js/isNull'

let project

Types.isNull('') // -> false
Types.isNull({}) // -> false
Types.isNull(project) // -> false
Types.isNull(0) // -> false
Types.isNull(false) // -> false
Types.isNull(Object.create(null)) // -> false

Types.isNull(null) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isNumber() 方法
// import isNumber from '@yaohaixiao/types.js/isNumber'

// True
Types.isNumber(0) // -> true
Types.isNumber(.4) // -> true
Types.isNumber(3.4E2) // -> true
Types.isNumber(0xffffff) // -> true
Types.isNumber(NaN) // -> true
Types.isNumber(Infinity) // -> true
Types.isNumber(-Infinity) // -> true

// False
Types.isNumber('2') // -> false
Types.isNumber(2 + '1') // -> false
Types.isNumber(new Number()) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isString() 方法
// import isString from '@yaohaixiao/types.js/isString'

const text = document.createTextNode('text')

Types.isString('') // -> true
Types.isString(String(2)) // -> true
Types.isString(2 + '0') // -> true

Types.isString(2) // -> false
Types.isString(new String()) // -> false
Types.isString(text) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isSymbol() 方法
// import isSymbol from '@yaohaixiao/types.js/isSymbol'

const sym = Symbol('foo')
const symObj = Object(sym)

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

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

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 undefined（未定义）返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isUndefined() 方法
// import isUndefined from '@yaohaixiao/types.js/isUndefined'

let projects

Types.isUndefined(projects) // -> true

Types.isUndefined([]) // -> false
Types.isUndefined('') // -> false
Types.isUndefined(0) // -> false
Types.isUndefined(NaN) // -> false
Types.isUndefined({}) // -> false
Types.isUndefined(null) // -> false

types.js 提供以下 Arguments 对象相关的类型检测方法。

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isArguments() 方法
// import isArguments from '@yaohaixiao/types.js/isArguments'

const argsLike = { '0': 3, '1': 4, length: 2 }
const $items = document.querySelectorAll('.item')
let args

function sum(a, b){
  args = arguments

  return a + b
}

sum(3, 5)

Types.isArguments(argsLike) // -> false
Types.isArguments([]) // -> false
Types.isArguments(items) // -> false

Types.is(args) // -> 'arguments'
Types.isArguments(args) // -> true

Since：: 2.6.0

Description

isEmptyArguments(val) 方法用来检测测试 arguments 对象长度为 0。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是长度为 0 的 arguments 对象，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isEmptyArguments() 方法
// import isEmptyArguments from '@yaohaixiao/types.js/isEmptyArguments'

let args
const fn = function () {arg = arguments}

fn()

Types.isEmptyArguments(args) // -> true

fn(1)

Types.isEmptyArguments(args) // -> false

types.js 提供以下方法来检测 Array 相关的数据类型。

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isArguments() 方法
// import isArray from '@yaohaixiao/types.js/isArray'

const LooksLike = { '0':1, '1':2, length: 2 }
let args

function sum (a, b){
  args = arguments
  return a + b
}

// True
Types.isArray([]) // -> true
Types.isArray(new Array()) // -> true
Types.isArray('type.js'.split('')) // -> true

// False
// 虽然  arguments 对象看起来也像数组，但是它也不是数组
Types.isArray(args) // -> false
// 虽然 HTMLNodeList 的看起来像数组，但它并不是数组
Types.isArray(document.getElementsByTagName('li')) // -> false
Types.isArray(LooksLike) // -> false
Types.isArray(new Int8Array()) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isArrayLike() 方法
// import isArrayLike from '@yaohaixiao/types.js/isArrayLike'

let args

function sum(a, b){
    args = arguments // -> true
    return a + b
}

sum(5, 6)

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

// arguments 对象是类似数组类型的数据
Types.isArrayLike(args) // -> true

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

Types.isArrayLike({ '0': 1, '1': 2, length: 2 }) // -> false
Types.isArrayLike( new Int8Array() ) // -> false

Since：: 0.2.0

Description

isArrayLikeObject(val) 方法用来检测测试数据是否为 ArrayLike 的对象数据。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 ArrayLike 的对象数据，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isArrayLikeObject() 方法
// import isArrayLikeObject from '@yaohaixiao/types.js/isArrayLikeObject'

const $items = document.querySelectorAll('.item')
const obj = { '0': 1, '1': 2, length: 2 }
let args
function getAge(age) {
  args = arguments
  return age + 18
}

getAge(30)

Types.isArrayLikeObject([]) // -> true

Types.is($items) // -> 'collection'
Types.isArrayLikeObject($items) // -> true

Types.isArrayLikeObject(args) // -> true

Types.isArrayLikeObject(obj) // -> false
Types.isArrayLikeObject({}) // -> false

Since：: 0.6.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是数据空数组，返回 true，否则 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isEmptyArray() 方法
// import isEmptyArray from '@yaohaixiao/types.js/isEmptyArray'

Types.isEmptyArray([]) // -> true
Types.isEmptyArray(['']) // -> true
Types.isEmptyArray(new Array()) // -> true

Types.isEmptyArray(new Array(8)) // -> false

types.js 提供以下方法来检测 Typed Arrays 相关的数据类型。

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isArrayBuffer() 方法
// import isArrayBuffer from '@yaohaixiao/types.js/isArrayBuffer'

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

Since：: 0.6.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 BigInt64Array 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isBigInt64Array() 方法
// import isBigInt64Array from '@yaohaixiao/types.js/isBigInt64Array'

const arr = [9007199254740992]
cong bigint64 = new BigInt64Array(42)

Type.is(bigint) // -> 'bigint64array'

Types.isBigInt64Array(arr) // -> false
Types.isBigInt64Array(bigint64) // -> true

Since：: 0.6.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 BigUint64Array 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isBigUint64Array() 方法
// import isBigUint64Array from '@yaohaixiao/types.js/isBigUint64Array'

const arr = [9007199254740992]
cong bigint64 = new BigInt64Array(42)

Type.is(bigint) // -> 'bigint64array'

Types.isBigUint64Array(arr) // -> false
Types.isBigUint64Array(bigint64) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 isDataView 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isDataView() 方法
// import isDataView from '@yaohaixiao/types.js/isDataView'

const buffer = new ArrayBuffer(8)
const dv = new DataView(buffer)

Types.isDataView(buffer) // -> false
Types.isDataView(dv) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isFloat32Array() 方法
// import isFloat32Array from '@yaohaixiao/types.js/isFloat32Array'

const numbers = [ 2, 4 ]
let args

function test(a){
  args = arguments
  return a === 'test'
}

test()

Types.isFloat32Array(numbers) // -> false
Types.isFloat32Array(new Array(32)) // -> false
Types.isFloat32Array(args) // -> false
Types.isFloat32Array(new Float32Array()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isFloat64Array() 方法
// import isFloat64Array from '@yaohaixiao/types.js/isFloat64Array'

const numbers = [ 2, 4 ]
let args

function test(a){
  args = arguments
  return a === 'test'
}

test()

Types.isFloat64Array(numbers) // -> false
Types.isFloat64Array(new Array(32)) // -> false
Types.isFloat64Array(args) // -> false
Types.isFloat64Array(new Float64Array()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isInt8Array() 方法
// import isInt8Array from '@yaohaixiao/types.js/isInt8Array'

Types.isInt8Array([]) // -> false
Types.isInt8Array(new Array(8)) // -> false
Types.isInt8Array(new Int8Array([])) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isInt16Array() 方法
// import isInt16Array from '@yaohaixiao/types.js/isInt16Array'

const numbers = [ 2, 4 ]
let args

function test(a){
  args = arguments
  return a === 'test'
}

test()

Types.isInt16Array(numbers) // -> false
Types.isInt16Array(new Array(16)) // -> false
Types.isInt16Array(args) // -> false
Types.isInt16Array(new Int16Array()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isInt32Array() 方法
// import isInt32Array from '@yaohaixiao/types.js/isInt32Array'

const numbers = [ 2, 4 ]
let args

function test(a){
  args = arguments
  return a === 'test'
}

test()

Types.isInt32Array(numbers) // -> false
Types.isInt32Array(new Array(32)) // -> false
Types.isInt32Array(args) // -> false
Types.isInt32Array(new Int32Array()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 Uint8Array 类型，返回 true，否则返回 false。import Types from '@yaohaixiao/types.js' // 或者单独引用 isUint8Array() 方法 // import isUint8Array from '@yaohaixiao/types.js/isUint8Array' const numbers = [ 2, 4 ] let args function test(a){ args = arguments return a === 'test' } test() Types.isUint8Array(numbers) // -> false Types.isUint8Array(new Array(32)) // -> false Types.isUint8Array(args) // -> false Types.isUint8Array(new Uint8Array()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isUint8ClampedArray() 方法
// import isUint8ClampedArray from '@yaohaixiao/types.js/isUint8ClampedArray'

const numbers = [ 2, 4 ]
let args

function test(a){
  args = arguments
  return a === 'test'
}

test()

Types.isUint8ClampedArray(numbers) // -> false
Types.isUint8ClampedArray(new Array(32)) // -> false
Types.isUint8ClampedArray(args) // -> false
Types.isUint8ClampedArray(new Uint8ClampedArray()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isUint16Array() 方法
// import isUint16Array from '@yaohaixiao/types.js/isUint16Array'

const numbers = [ 2, 4 ]
let args

function test(a){
  args = arguments
  return a === 'test'
}

test()

Types.isUint16Array(numbers) // -> false
Types.isUint16Array(new Array(32)) // -> false
Types.isUint16Array(args) // -> false
Types.isUint16Array(new Uint16Array()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isUint32Array() 方法
// import isUint32Array from '@yaohaixiao/types.js/isUint32Array'

const numbers = [ 2, 4 ]
let args

function test(a){
  args = arguments
  return a === 'test'
}

test()

Types.isUint32Array(numbers) // -> false
Types.isUint32Array(new Array(32)) // -> false
Types.isUint32Array(args) // -> false
Types.isUint32Array(new Uint32Array()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 TypedArray 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isTypedArray() 方法
// import isTypedArray from '@yaohaixiao/types.js/isTypedArray'

const numbers = [ 2, 4 ]
let args

function test(str) {
  args = arguments
  return str
}

test('str')

Types.isTypedArray( args ) // -> false
Types.isTypedArray( numbers ) // -> false
Types.isTypedArray( new Array() ) // -> false

Types.isTypedArray(new Int8Array([])) // -> true
Types.isTypedArray(new Int16Array([])) // -> true
Types.isTypedArray(new Int32Array([])) // -> true

Types.isTypedArray(new Uint8ClampedArray([])) // -> true
Types.isTypedArray(new Uint8Array([])) // -> true
Types.isTypedArray(new Uint16Array([])) // -> true
Types.isTypedArray(new Uint32Array([])) // -> true

Types.isTypedArray(new Float32Array([])) // -> true
Types.isTypedArray(new Float64Array([])) // -> true

Types.isTypedArray(new BigInt64Array(42)) // -> true
Types.isTypedArray(new BigUint64Array(42)) // -> true

types.js 提供以下方法来检测 Element 相关的数据类型。

Since：: 1.9.0

Description

isDOM(val) 方法用来检测测试数据是否为 DOM 类型数据：DOM 节点，TextNode，NodeList 和 DocumentFragment）。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 DOM 类型数据，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isDOM() 方法
// import isDOM from '@yaohaixiao/types.js/isDOM'

const $list = document.getElementById('list')
const $fragment = document.createDocumentFragment()
const $items = document.querySelectorAll('.item')
const $text = document.createTextNode('text')

Types.is($list) // -> 'element'
Types.isDOM($list) // -> true

Types.is($fragment) // -> 'fragment'
Types.isDOM($fragment) // -> true

Types.is($items) // -> 'collection'
Types.isDOM($items) // -> true

Types.is($text) // -> 'text'
Types.isDOM($text) // -> true

Since：: 0.2.0

Description

isElement(val) 方法用来检测测试数据是否为 Element 实例。

注意：isElement 调整后，是一个更通用的接口，它可以表示任何类型的元素节点，不仅包括 HTML 元素，还包括 SVG（可缩放矢量图形）元素、MathML（数学标记语言）元素等。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isElement() 方法
// import isElement from '@yaohaixiao/types.js/isElement'

const $list = document.getElementById('list')
const $div = document.createElement('div')
const $text = document.createTextNode('text')
const $items = document.querySelectorAll('.item')
const $fragment = document.createDocumentFragment()
const svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg')

Types.isElement(svgElement) // -> true
Types.isHTMLElement(svgElement) // -> false

Types.is($list) // -> 'element'
Types.isElement($list) // -> true

Types.is($div) // -> 'element'
Types.isElement($div) // -> true

Types.is($text) // -> 'text'
Types.isElement($text) // -> false

Types.is($items) // -> 'collection'
Types.isElement($items) // -> false

Types.is($fragment) // -> 'collection'
Types.isElement($fragment) // -> false

Types.isElement([]) // -> false

Since：: 0.6.0

Description

isFragment(val) 方法用来检测测试数据是否为 DocumentFragment 文档碎片。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 DocumentFragment 文档碎片，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isFragment() 方法
// import isFragment from '@yaohaixiao/types.js/isFragment'

const $list = document.getElementById('list')
const $div = document.createElement('div')
const $text = document.createTextNode('text')
const $items = document.querySelectorAll('.item')
const $fragment = document.createDocumentFragment()

Types.is($list) // -> 'element'
Types.isElement($list) // -> true
Types.isFragment($list) // -> false

Types.is($div) // -> 'element'
Types.isElement($div) // -> true
Types.isFragment($div) // -> false

Types.is($text) // -> 'text'
Types.isElement($text) // -> false
Types.isFragment($text) // -> false

Types.is($items) // -> 'collection'
Types.isElement($items) // -> false
Types.isFragment($items) // -> false

Types.is($fragment) // -> 'fragment'
Types.isElement($fragment) // -> false
Types.isFragment($items) // -> true

Since：: 0.2.0

Description

isHTMLCollection(val) 方法用来检测测试数据是否为 HTMLNodeList (元素集合)类型。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isHTMLCollection() 方法
// import isHTMLCollection from '@yaohaixiao/types.js/isHTMLCollection'

const $list = document.getElementById('list')
const $div = document.createElement('div')
const $text = document.createTextNode('text')
const $items = document.querySelectorAll('.item')
const $fragment = document.createDocumentFragment()

Types.is($list) // -> 'element'
Types.isElement($list) // -> true
Types.isHTMLCollection($list) // -> false

Types.is($div) // -> 'element'
Types.isElement($div) // -> true
Types.isHTMLCollection($div) // -> false

Types.is($text) // -> 'text'
Types.isElement($text) // -> false
Types.isHTMLCollection($text) // -> false

Types.is($items) // -> 'collection'
Types.isElement($items) // -> false
Types.isHTMLCollection($items) // -> true

Types.is($fragment) // -> 'fragment'
Types.isElement($fragment) // -> false
Types.isHTMLCollection($items) // -> false

Since：: 2.7.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isHTMLElement() 方法
// import isHTMLElement from '@yaohaixiao/types.js/isHTMLElement'

const $list = document.getElementById('list')
const $div = document.createElement('div')
const $text = document.createTextNode('text')
const $items = document.querySelectorAll('.item')
const $fragment = document.createDocumentFragment()

Types.is($list) // -> 'element'
Types.isHTMLElement($list) // -> true

Types.is($div) // -> 'element'
Types.isHTMLElement($div) // -> true

Types.is($text) // -> 'text'
Types.isHTMLElement($text) // -> false

Types.is($items) // -> 'collection'
Types.isHTMLElement($items) // -> false

Types.is($fragment) // -> 'collection'
Types.isHTMLElement($fragment) // -> false

Since：: 2.7.0

Description

isNode(val) 方法用来检测测试数据是否为 Node 实例。

注意：在 JavaScript 的 DOM（文档对象模型）中，Node、Element 和 HTMLElement 是非常重要的概念，它们代表了不同层次的抽象，用于描述和操作 HTML 文档中的各种元素和节点。以下是它们之间的区别：

继承关系

它们之间存在着明确的继承层次结构，具体如下：

Node 是所有节点类型的基类，它处于继承层次的最顶层。
Element 继承自 Node，是所有元素节点的基类。
HTMLElement 继承自 Element，专门用于表示 HTML 元素。

因此，isNode() 方法可以检测任何类型的 Node 元素。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 Node 实例，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isNode() 方法
// import isNode from '@yaohaixiao/types.js/isNode'

const div = document.createElement('div')
Types.isNode(div) // -> true
Types.isElement(div) // -> true
Types.isHTMLElement(div) // -> true

const text = document.createTextNode('text')
Types.isNode(text) // -> true
Types.isElement(text) // -> false
Types.isHTMLElement(text) // -> false

const fragment = document.createDocumentFragment()
Types.isNode(fragment) // -> true
Types.isElement(fragment) // -> false
Types.isHTMLElement(fragment) // -> false

const svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
Types.isNode(svgElement) // -> true
Types.isElement(svgElement) // -> true
Types.isHTMLElement(svgElement) // -> false

Types.isNode({}) // -> false

Since：: 2.7.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 ShadowRoot 对象，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isShadowRoot() 方法
// import isShadowRoot from '@yaohaixiao/types.js/isShadowRoot'

// 测试 ShadowRoot 未定义的情况
const originalShadowRoot = global.ShadowRoot

// 临时将 ShadowRoot 设置为 undefined
global.ShadowRoot = undefined
Types.isShadowRoot({}) // -> false

// 恢复原始的 ShadowRoot
global.ShadowRoot = originalShadowRoot

// 测试传入真正的 ShadowRoot 实例
const div = document.createElement('div')
const shadowRoot = div.attachShadow({ mode: 'open' })

Types.isShadowRoot(shadowRoot) // -> true

// 测试传入非 ShadowRoot 实例
Types.isShadowRoot({}) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 HTMLTextNode (文本节点)类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isTextNode() 方法
// import isTextNode from '@yaohaixiao/types.js/isTextNode'

const $list = document.getElementById('list')
const $div = document.createElement('div')
const $fragment = document.createDocumentFragment()
const $items = document.querySelectorAll('.item')
const $text = document.createTextNode('text')

Types.is($list) // -> 'element'
Types.isElement($list) // -> true
Types.isTextNode($list) // -> false

Types.is($div) // -> 'element'
Types.isElement($div) // -> true
Types.isTextNode($div) // -> false

Types.is($fragment) // -> 'fragment'
Types.isFragment($fragment) // -> true
Types.isTextNode($fragment) // -> false

Types.is($items) // -> 'collection'
Types.isHTMLCollection($items) // -> true
Types.isTextNode($items) // -> false

Types.is($text) // -> 'collection'
Types.isElement($text) // -> false
Types.isTextNode($text) // -> true

Since：: 0.2.0

Description

isVNode(val) 方法用来检测测试数据是否为 VNode (VUE虚拟节点)类型。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 VNode (VUE虚拟节点)类型，返回 true，否则返回 false。

<template>
   <dev-header ref="header"></dev-header>
</template>

<script>
import Types from '@yaohaixiao/types.js'
// 或者单独引用 isVNode() 方法
// import isVNode from '@yaohaixiao/types.js/isVNode'

export default {
  name: 'PageHeader',
  mounted() {
    const $header = this.$refs.header

    Types.isVNode($header) // -> true
  }
}
</script>

Since：: 2.7.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 Constructor 构造函数，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isWindow() 方法
// import isWindow from '@yaohaixiao/types.js/isWindow'

const $list = document.getElementById('list')

Types.is($list) // -> 'element'
Types.isWindow($list) // -> false

Types.isWindow(window) // -> true

const nonWindowObject = {
  // 模拟部分 Window 对象的属性，但不完整
  document: {},
  location: {},
  // 缺少 alert 和 setInterval 属性
}

Types.isWindow(nonWindowObject) // -> false

Types.isWindow(null) // -> false

types.js 提供以下方法来检测 Function 相关的数据类型。

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

true - 表示检测数据是构造函数，false 则表示不是。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isConstructor() 方法
// import isConstructor from '@yaohaixiao/types.js/isConstructor'

const fn = function(){};
const ff = class {};
const callback = () => {}

Types.isConstructor(fn) // -> true
Types.isConstructor(ff) // -> true
Types.isConstructor(callback) // -> false
Types.isConstructor(console.log) // -> false

Types.isConstructor(Math) // -> false
Types.isConstructor(Boolean) // -> true
Types.isConstructor(Array) // -> true
Types.isConstructor(Function) // -> true
Types.isConstructor(Date) // -> true
Types.isConstructor(RegExp) // -> true
Types.isConstructor(Object) // -> true
Types.isConstructor(Promise) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isFunction() 方法
// import isFunction from '@yaohaixiao/types.js/isFunction'

const blank = () => {}
const fn = new Function()

function empty(){}

Types.isFunction(empty) // -> true
Types.isFunction(blank) // -> true
Types.isFunction(fn) // -> true
Types.isFunction(parseInt) // -> true
Types.isFunction(Array) // -> true
Types.isFunction(Boolean) // -> true
Types.isFunction(Date) // -> true
Types.isFunction(Number) // -> true
Types.isFunction(Object) // -> true
Types.isFunction(RegExp) // -> true
Types.isFunction(String) // -> true

Types.isFunction(Math) // -> false
Types.isFunction(console) // -> false

Since：: 0.2.0

Description

isNativeFunction(val) 方法用来检测测试数据是否为 JavaScript 内置函数。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

val 是系统内置函数，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isNativeFunction() 方法
// import isNativeFunction from '@yaohaixiao/types.js/isNativeFunction'

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

Types.isNativeFunction(fn) // -> false
Types.isNativeFunction(ff) // -> false
Types.isNativeFunction(f) // -> false
Types.isNativeFunction(document.domain) // -> false

Types.isNativeFunction(Boolean) // -> true
Types.isNativeFunction(String) // -> true
Types.isNativeFunction(Number) // -> true
Types.isNativeFunction(Object) // -> true
Types.isNativeFunction(Data) // -> true
Types.isNativeFunction(RegExp) // -> true
Types.isNativeFunction(Error) // -> true
Types.isNativeFunction(Math.floor) // -> true
Types.isNativeFunction(console.log) // -> true
Types.isNativeFunction(alert) // -> true

Since：: 0.2.0

Description

isPrototype(val) 方法用来检测是否为 prototype 对象。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 Prototype 对象，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isPrototype() 方法
// import isPrototype from '@yaohaixiao/types.js/isPrototype'

const Yao= {
  age: 40,
  career: 'programmer'
}

const Programmer = function(name, age) {
  this.name = name
  this.age = age
  this.isDead = false

  return this
}

Programmer.prototype.career = 'programmer'
Programmer.prototype.getWorkDone = function() {
  this.isDead = true
  return this
}

Types.isPrototype(null) // => false

Types.isPrototype(Object) // => false
Types.isPrototype(Object.prototype) // => true

Types.isPrototype(Programmer) // => false
Types.isPrototype(Yao.__proto__) // => true

types.js 提供以下方法来检测 Keyed Collections 相关的数据类型。

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isMap() 方法
// import isMap from '@yaohaixiao/types.js/isMap'

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

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

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

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isSet() 方法
// import isSet from '@yaohaixiao/types.js/isSet'

const set = new Set([1, 2, 3, 4])
const arr = [1, 2, 3, 4]

Types.is(set) // -> 'set'
Types.isSet(set) // -> true

Types.is(arr) // -> 'array'
Types.isSet(arr) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isWeakMap() 方法
// import isWeakMap from '@yaohaixiao/types.js/isWeakMap'

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

const weakmap = new WeakMap()

weakmap.set({}, 37)

Types.is(weakmap) // -> 'weakmap'
Types.isWeakMap(weakmap) // -> true

Types.is(map) // -> 'map'
Types.isWeakMap(map) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isWeakSet() 方法
// import isWeakSet from '@yaohaixiao/types.js/isWeakSet'

const set = new Set([1, 2, 3, 4])
const weakset = new WeakSet()

weakset.add({name: 'Robert'})

Types.is(set) // -> 'set'
Types.isSet(set) // -> true
Types.isWeakSet(set) // -> false

Types.is(weakset) // -> 'weakset'
Types.isSet(weakset) // -> false
Types.isWeakSet(weakset) // -> true

types.js 提供以下方法来检测 Number 相关的数据类型。

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isEven() 方法
// import isEven from '@yaohaixiao/types.js/isEven'

Types.isEven(2) // -> true
Types.isEven(2.0) // -> true
Types.isEven('2') // -> false

Types.isEven(3) // -> false
Types.isEven(2.2) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Number

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isFloat() 方法
// import isFloat from '@yaohaixiao/types.js/isFloat'

Types.isFloat(.1) // -> true
Types.isFloat(1.01) // -> true
Types.isFloat(Number("3.4556645445E7")) // -> true
Types.isFloat(Number("3.4556645445E10")) // -> false
Types.isFloat(2.0) // -> false
Types.isFloat(0xffffff) // -> false
Types.isFloat(NaN) // -> false
Types.isFloat(Infinity) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isInfinite() 方法
// import isInfinite from '@yaohaixiao/types.js/isInfinite'

Types.isInfinite(2.4) // -> false

Types.isInfinite(Infinity) // -> true
Types.isInfinite(-Infinity) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isInteger() 方法
// import isInteger from '@yaohaixiao/types.js/isInteger'

// False
Types.isInteger(2.4) // -> false
Types.isInteger(3.4234E3) // -> false
Types.isInteger('1') // -> false
Types.isInteger(Number('3.4556645445E7')) // -> false
Types.isInteger(NaN) // -> false
Types.isInteger(Infinity) // -> false
Types.isInteger(-Infinity) // -> false

// True
Types.isInteger(2) // -> true
Types.isInteger(2.0) // -> true
Types.isInteger(3.4234E4) // -> true
Types.isInteger(0xffffff) // -> true
Types.isInteger(Number('1')) // -> true
Types.isInteger(parseInt('1.0', 10)) // -> true
Types.isInteger(Math.ceil(2.6)) // -> true

Since：: 0.2.0

Description

isLength(val) 方法用来检测测试数据是否为有效 length 值。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是有效 length 值，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isLength() 方法
// import isLength from '@yaohaixiao/types.js/isLength'

// True
Types.isLength(256) // -> true
Types.isLength(0x00ff11) // -> true
Types.isLength(9007199254740991) // -> true

// False
Types.isLength(9007199254740992) // -> false
Types.isLength(Infinity) // -> false
Types.isLength(-1) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isNumeric() 方法
// import isNumeric from '@yaohaixiao/types.js/isNumeric'

Types.isNumeric(2) // -> true
Types.isNumeric(2.4) // -> true
Types.isNumeric(-2) // -> true
Types.isNumeric(0xffffff) // -> true
Types.isNumeric(3.1415926E8) // -> true
Types.isNumeric('33') // -> true
Types.isNumeric('0xffffff') // -> true

Types.isNumeric(NaN) // -> false
Types.isNumeric(Infinity) // -> false
Types.isNumeric(-Infinity) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isOdd() 方法
// import isOdd from '@yaohaixiao/types.js/isOdd'

Types.isOdd(3) // -> true
Types.isOdd(3.0) // -> true
Types.isOdd(3.01E2) // -> true
Types.isOdd(0x000011) // -> true

Types.isOdd(2.0) // -> false
Types.isOdd('2') // -> false
Types.isOdd(3.01E3) // -> false
Types.isOdd(0x000010) // -> false
Types.isOdd(NaN) // -> false
Types.isOdd(Infinity) // -> false

Since：: 2.1.0

Description

isPrime(val) 方法用来检测测试数据是否为质(素)数。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是质数，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isPrime() 方法
// import isPrime from '@yaohaixiao/types.js/isPrime'

Types.isPrime(3) // -> true
Types.isPrime(7) // -> true
Types.isPrime(11) // -> true

Types.isPrime(0) // -> false
Types.isPrime(1) // -> false
Types.isPrime(2) // -> false
Types.isPrime(9) // -> false

Since：: 2.7.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是安全的 Integer 值，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isSafeInteger() 方法
// import isSafeInteger from '@yaohaixiao/types.js/isSafeInteger'

isSafeInteger(3) // => true

isSafeInteger(Number.MIN_VALUE) // => false

isSafeInteger(Infinity) // => false

isSafeInteger('3') // => false

types.js 提供以下方法来检测 Object 相关的数据类型。

Since：: 1.11.0

Description

isBinary(val) 方法用来检测测试数据是二进制（字符串）数据。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是二进制（字符串）数据，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isUint16Array() 方法
// import isBinary from '@yaohaixiao/types.js/isBinary'

const buffer = Buffer.alloc(15)

Types.isBinary('Z29vZA==') // -> false
Types.isBinary(isArrayBuffer(8)) // -> false

Types.is(buffer) // -> 'uint8array'
isBinary(buffer) // -> true
isBinary(buffer.toString()) // -> true

Since：: 1.6.0

Description

isBuffer(val) 方法用来检测测试数据是否为 Buffer 类型（运行环境：Node.js）。

注意：Node.js 中实现的 Buffer 对象，实际的数据格式是：Uint8Array 类型的数组。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 Buffer 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isBuffer() 方法
// import isBuffer from '@yaohaixiao/types.js/isBuffer'

const buffer = Buffer.alloc(15)

Types.isBuffer(new ArrayBuffer(8)) // -> false
Types.isBuffer(new Uint8Array(2)) // -> false

Types.is(buffer) => 'uint8array'
Types.isBuffer(buffer) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 Date 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isDate() 方法
// import isDate from '@yaohaixiao/types.js/isDate'

const time = new Date()

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

Since：: 0.2.0

Description

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

Parameters

val

Type：: Object

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是空（单体）对象，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isEmptyObject() 方法
// import isEmptyObject from '@yaohaixiao/types.js/isEmptyObject'

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

Types.isEmptyObject({}) // -> true
Types.isEmptyObject([]) // true
Types.isEmptyObject(Person) // true
Types.isEmptyObject(new Object()) // true
Types.isEmptyObject(new Boolean()) // true
Types.isEmptyObject(new Array()) // true
Types.isEmptyObject(new Date('2017-12-11')) // true
Types.isEmptyObject(new RegExp('\s+','ig')) // true
Types.isEmptyObject(new String()) // true

Types.isEmptyObject(new Function()) // false
Types.isEmptyObject(['']) // false
Types.isEmptyObject(null) // false
Types.isEmptyObject({name:'type.js'}) // -> false
Types.isEmptyObject(new Person('yaohaixiao',30)) // false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isError() 方法
// import isError from '@yaohaixiao/types.js/isError'

const error = function Error(){}

Types.isError(new error()) // -> false
Types.isError(new Error()) // -> true

Since：: 0.4.0

Description

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

Parameters

val

Type：: Object

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isHash() 方法
// import isHash from '@yaohaixiao/types.js/isHash'

let udf

// 基础类型
Types.isHash(2) // -> false
Types.isHash('str') // -> false
Types.isHash(false) // -> false
Types.isHash(null) // -> false
Types.isHash(udf) // -> false

// 引用类型
Types.isHash(new Function()) // -> false
Types.isHash(function(){}) // -> false
Types.isHash(() => {}) // -> false
Types.isHash(class{}) // -> false

Types.isHash(new class{}) // -> true
Types.isHash({}) // -> true
Types.isHash(Object.create(null)) // -> true
Types.isHash(new Object()) // -> true
Types.isHash([]) // -> true
Types.isHash(/s+/ig) // -> true
Types.isHash(new String()) // -> true
Types.isHash(new Number()) // -> true
Types.isHash(new Boolean()) // -> true
Types.isHash(new Array()) // -> true
Types.isHash(new Date()) // -> true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isObject() 方法
// import isObject from '@yaohaixiao/types.js/isObject'

const $list = document.getElementById('list')

// True
Types.isObject({}) // => true
Types.isObject(Object) // => true
Types.isObject(new Object()) // => true
Types.isObject(Object.create(null)) // => true
Types.isObject([]) // => true
Types.isObject(() => {}) // => true
Types.isObject(class {}) // => true
Types.isObject($list) // => true

// False
Types.isObject('null') // => false
Types.isObject(1) // => false
Types.isObject(false) // => false
Types.isObject(Symbol('ok')) // => false
Types.isObject($list) // => false

// 针对 null，type.js 认为不是一个有效对象
// 以避免将 null 作为普通对象操作导致的错误
Types.isObject(null) // => false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是类似 Object 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isObjectLike() 方法
// import isObjectLike from '@yaohaixiao/types.js/isObjectLike'

// True
Types.isObjectLike(function empty(){}) // -> true
Types.isObjectLike({}) // -> true
Types.isObjectLike(Object.create(null)) // -> true
Types.isObjectLike(Object.create({})) // -> true
Types.isObjectLike(new Function()) // -> true

// False
Types.isObjectLike([]) // -> false
Types.isObjectLike(null) // -> false
Types.isObjectLike(document.getElementById('wrap')) // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）val 待检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isPlainObject() 方法
// import isPlainObject from '@yaohaixiao/types.js/isPlainObject'

let udf

// 基础类型
Types.isPlainObject(2) // -> false
Types.isPlainObject('str') // -> false
Types.isPlainObject(false) // -> false
Types.isPlainObject(null) // -> false
Types.isPlainObject(udf) // -> false

// 引用类型
Types.isPlainObject(new Function()) // -> false
Types.isPlainObject(function(){}) // -> false
Types.isPlainObject(() => {}) // -> false
Types.isPlainObject(class{}) // -> false

Types.isPlainObject(new class{}) // -> true
Types.isPlainObject({}) // -> true
Types.isPlainObject(Object.create(null)) // -> true
Types.isPlainObject(new Object()) // -> true
Types.isPlainObject([]) // -> true
Types.isPlainObject(/s+/ig) // -> true
Types.isPlainObject(new String()) // -> true
Types.isPlainObject(new Number()) // -> true
Types.isPlainObject(new Boolean()) // -> true
Types.isPlainObject(new Array()) // -> true
Types.isPlainObject(new Date()) // -> true

Since：: 1.3.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是 Promise 对象，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isPromise() 方法
// import isPromise from '@yaohaixiao/types.js/isPromise'

const resolve = Promise.resolve
const reject = Promise.reject
const request = new Promise((resolve, reject) => {})
let val

// 非对象参数
Types.isPromise(null) // => false
Types.isPromise(val) // => false
Types.isPromise('') // => false
Types.isPromise(12) // => false
Types.isPromise(false) // => false
Types.isPromise(BigInt(12)) // => false
Types.isPromise(Symbol('prop')) // => false


// 对象参数
Types.isPromise([]) // => false
Types.isPromise({}) // => false
Types.isPromise(class {}) // => false
Types.isPromise(() => {}) // => false

Types.isPromise(request) // => true
Types.isPromise(Promise.all([resolve, resolve]) // => true
Types.isPromise(Promise.any([resolve, reject]) // => true
Types.isPromise(resolve) // => true

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isRegExp() 方法
// import isRegExp from '@yaohaixiao/types.js/isRegExp'

const patternOne = new RegExp('\\s+','ig')
const patternTwo = /\s+/ig
const patternStr = '/\\s+/ig'

Types.is(patternOne) // -> 'regexp'
Types.isRegExp(patternOne) // -> true

Types.is(patternTwo) // -> 'regexp'
Types.isRegExp(patternTwo) // -> true

Types.is(patternStr) // -> 'string'
Types.isRegExp(patternStr) // -> false

Since：: 2.7.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

options

Type：: Object

Default：: {}

（可选）options 这是一个解构赋值的参数。它是一个对象，默认值为空对象 {}。对象中有一个属性 checkOpen，其默认值为 true。checkOpen 用于控制是否检查流的打开状态（即可读或可写状态）。

Returns

Type：: Boolean。

'val' 是 Stream 类型，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isStream() 方法
// import isStream from '@yaohaixiao/types.js/isStream'

// 测试流对象
const validStream = {
  writable: true,
  pipe: () => {}
}

Types.isStream(validStream) // -> true

// 测试非流对象
const nonStream = {
  notAStreamProperty: 'value'
}

Types.isStream(nonStream) // -> false

// 测试 null
Types.isStream(null) // -> false

// 测试 checkOpen 为 false 的情况
const obj = {
  pipe: () => {}
}

Types.isStream(obj, { checkOpen: false }) // -> true

Since：: 0.2.0

Description

isXML(val) 方法用来检测测试数据是否为合法的 XML 格式。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isXML() 方法
// import isXML from '@yaohaixiao/types.js/isXML'

import jsdom from 'jsdom'
import { DOMParser } from 'xmldom'

const { JSDOM } = jsdom;

const HTML = new JSDOM('<html><head><title>isXML</title></head><body><p>p1</p><p>p2</p><p>p3</p></body></html>')
const XML = 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')

Types.isXML(XML) // -> true

Types.isXML('html') // -> false
Types.isXML(HTML) // -> false

types.js 提供以下方法来检测 String 相关的数据类型。

Since：: 2.1.0

Description

isAlpha(val) 方法用来检测测试数据是否仅包含英文字符。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是仅包含英文字符，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isAlpha() 方法
// import isAlpha from '@yaohaixiao/types.js/isAlpha'

Types.isAlpha('aaa') // -> true
Types.isAlpha('good') // -> true

Types.isAlpha('ok!') // -> false
Types.isAlpha('is alpha') // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isBase64() 方法
// import isBase64 from '@yaohaixiao/types.js/isBase64'

Types.isBase64('Z29vZA==') // -> true
Types.isBase64('aXNCYXNlNjQ=2') // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isBlank() 方法
// import isBlank from '@yaohaixiao/types.js/isBlank'

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

Since：: 1.2.0

Description

isChinese(val, includePunctuation) 方法用来检测测试数据(字符串)是否为中文字符。

Wiki 介绍中文字符（Unified Ideographs）包含以下内容：

中文汉字
象形文字扩展 A-H
兼容象形文字符
兼容表意文字增补字符
中文标点符号
兼容标点符号

其中：

只是看上去像汉字，因此在 isChinese() 方法中没有纳入到汉字字符。

Parameters

val

Type：: Any

（必须）要检测的数据。

includePunctuation

Type：: Boolean

（可选）是否包含标点符号：默认值：true

Returns

Type：: Boolean。

'val' 是 Chinese 中文字符，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isChinese() 方法
// import isChinese from '@yaohaixiao/types.js/isChinese'

let chinese

// 非字符串
Types.isChinese(null) // -> false
Types.isChinese(chinese) // -> false
Types.isChinese({}) // -> false
Types.isChinese([]) // -> false
Types.isChinese(Symbol('symbol')) // -> false

// Ascii 字符
Types.isChinese(12) // -> false
Types.isChinese('chinese') // -> false
Types.isChinese('+=*/') // -> false

// 汉字字符
Types.isChinese('汉字字符：尅靈') // -> true
Types.isChinese('扩展字符：㐥𠁜𪝹𫞺𫡡𭀔𭍓') // -> true

// 标点符号
Types.isChinese('标点符号：。，、；：×·—…（）『』【】《》？！‘’“”～') // -> true
Types.isChinese('兼容标点符号：︰︱︲︳︴︵︶︷︸︹︺︻︼︽︾︿﹀﹁﹂﹃﹄﹅﹆﹇﹈﹉﹊﹋﹌﹍﹎﹏') // -> true

// 不包含标点符号，则以下检测无法通过
Types.isChinese('标点符号：。，、；：×·—…（）『』【】《》？！‘’“”～', false) // -> false

Since：: 0.2.0

Description

isEmail(val) 方法用来检测测试数据是否为合法的 Email 格式。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是正确 Email 格式字符串，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isEmail() 方法
// import isEmail from '@yaohaixiao/types.js/isEmail'

Types.isEmail('yaohaixiao@gmail.com') // => true
Types.isEmail('yaohaixiao@gmail.c') // => true
Types.isEmail('haixiao-yao@gmail.com') // => true
Types.isEmail('haixiao_yao@gmail.com') // => true
Types.isEmail('haixiao&yao@gmail.com') // => true
Types.isEmail('haixiao~yao@gmail.com') // => true
Types.isEmail('haixiao+yao@gmail.com') // => true
Types.isEmail('haixiao^yao@gmail.com') // => true
Types.isEmail('haixiao%yao@gmail.com') // => true
Types.isEmail('haixiao$yao@gmail.com') // => true
Types.isEmail('haixiao.yao@gmail.com') // => true
Types.isEmail('haixiao/yao@gmail.com') // => true
Types.isEmail('haixiao#yao@gmail.com') // => true
Types.isEmail('yao{haixiao@gmail.com') // => true
Types.isEmail('yao|haixiao@gmail.com') // => true
Types.isEmail('yao}haixiao@gmail.com') // => true

Types.isEmail('yaohaixiao#gmail.com') // => false
Types.isEmail('yao\haixiao@gmail.com') // => false
Types.isEmail('yao[haixiao@gmail.com') // => false

验证 Email 格式的正则表达式

没有能够完美校验 Email 格式的正则表达式，以下几个示例是笔者找到的相对校验规则比较严谨的正则表达式，需要的朋友可以根据自己的需要选取使用。

// Types.js
const patternTypeJs = /^([a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)$/

// W3C
const patternW3C = /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/

// JavaScript
const patternJs = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/

// RFC 5322 Official Standard
const patternRFC5322 = /(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/

Since：: 0.2.0

Alias：: isUUID

Description

isGuid(val) 方法用来检测测试数据是否为合法的 UUID 字符串。

Parameters

val

Type：: Any

必须，要检测的数据。

Returns

Type：: Boolean。

'val' 是合法的 UUID 字符串，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isGuid() 方法
// import isGuid from '@yaohaixiao/types.js/isGuid'

Types.isGuid('749d0000-0194-1005-2e05-08d61613bf2f') // -> true
Types.isGuid('d3aa88e2-c754-41e0-8ba6-4198a34aa0a2') // -> true
Types.isGuid('00000000-0000-0000-0000-000000000000') // -> true
Types.isGuid('{0e40c5ab-1d9b-ee11-983e-e0be0335d021}') // -> true
Types.isGuid('08dbe0f11c8641cf8afe6b2824e8f8f5') // -> true

Types.isGuid('') // -> false
Types.isGuid('xxxA987FBC9-4BED-3078-CF07-9141BA07C9F3') // -> false
Types.isGuid('934859') // -> false
Types.isGuid('A987FBC94BED3078CF079141BA07C9F') // -> false

Since：: 0.2.0

Description

isHex(val) 方法用来检测测试数据的(数值)是否为 16 进制数值。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isHex() 方法
// import isHex from '@yaohaixiao/types.js/isHex'

Types.isHex('#ffffff') // -> true
Types.isHex('f3f3f3') // -> true
Types.isHex('#h1f1f1') // -> false
Types.isHex('h1f1x1') // -> false

Since：: 0.5.0

Description

isHTML(val) 方法用来检测测试数据是否为合法的 HTML 代码。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是合法的 HTML 代码，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isHTML() 方法
// import isHTML from '@yaohaixiao/types.js/isHTML'

// 包含 doctype 标签：
Types.isHTML('<!doctype html>') // -> true
Types.isHTML('\n\n<!doctype html><html>') // -> true

// 包含：<html>，<body> 或者 <x-*> 标签：
Types.isHTML('<html>') // -> true
Types.isHTML('<html></html>') // -> true
Types.isHTML('<html lang="en"></html>') // -> true
Types.isHTML('<html><body></html>') // -> true
Types.isHTML('<html><body class="no-js"></html>') // -> true
Types.isHTML('<x-unicorn>') // -> true

// 包含任何合法的 HTML 标签：
Types.isHTML('<p>foo</p>') // -> true
Types.isHTML('<a href="#">foo</a>') // -> true
Types.isHTML('<br />') // -> true

// 无法匹配 XML 标签：
Types.isHTML('<attribute>address</attribute>') // -> false
Types.isHTML('<address>Wuhan City</address>') // -> false
Types.isHTML('<age>20</age>') // -> false
Types.isHTML('<gender>mail</gender>') // -> false
Types.isHTML('<career>programmer</career>') // -> false

Since：: 2.6.0

Description

isIDNumber(val) 方法用来检测测试数据是否为（中国）身份证号码。

Parameters

val

Type：: Any

（必须）要检测的数据（身份证号码）。

Returns

Type：: Boolean。

'val' 是合法的（中国）身份证号码（格式），返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isIDNumber() 方法
// import isIDNumber from '@yaohaixiao/types.js/isIDNumber'

// 有效的 15 位身份证号码
Types.isIDNumber('110105491231002'); // -> true

// 无效的 15 位身份证号码
Types.isIDNumber('123456789012345'); // -> false

// 有效的 18 位身份证号码（校验码为 X）
Types.('11010519491231002X'); // -> true

// 无效的 18 位身份证号码（校验码错误）
Types.isIDNumber('110105194912310029'); // -> false

// 无效的 18 位身份证号码（非法字符 Y）
Types.isIDNumber('11010519491231002Y'); // -> false

// 无效的 18 位身份证号码
Types.isIDNumber('123456789012345678'); // -> false

// 长度不符合
Types.isIDNumber('11010519491231002'); // -> false
Types.isIDNumber('11010519491231002XX'); // -> false

// 格式错误
Types.isIDNumber('A1010519491231002X'); // -> false
Types.isIDNumber('11010519491231002x'); // -> false

// 非字符串
Types.isIDNumber(110105194912310021); // -> false

Since：: 0.2.0

Description

isIPAddress(val) 方法用来检测测试数据是否为合法的 IP 地址格式。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是合法的 IP 地址格式字符串，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isIPAddress() 方法
// import isIPAddress from '@yaohaixiao/types.js/isIPAddress'

// IPv4
Types.isIPAddress('126.11.15.33') // -> true
Types.isIPAddress('255.255.255.255') // -> true
Types.isIPAddress('126.11.15.255') // -> false
Types.isIPAddress('126.11.15.256') // -> false
Types.isIPAddress('126.11.15.a56') // -> false
Types.isIPAddress('126.11.15.') // -> false

// IPv6
Types.isIPAddress('FC00:0000:130F:0000:0000:09C0:876A:130B') // -> true
Types.isIPAddress('FC00:0000:130F:0000:0000:09C0:876A:130') // -> true
Types.isIPAddress('FC00:0000:130F:0000:0000:09C0:876A') // -> false
Types.isIPAddress('FC00:0000:130F:0000:0000:09C0:876A:X130') // -> false

Since：: 0.2.0

Description

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

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

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

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isJSON() 方法
// import isJSON from '@yaohaixiao/types.js/isJSON'

// String
Types.isJSON('') // -> false
Types.isJSON("") // -> false
Types.isJSON("json") // -> true

// Number
Types.isJSON(3) // -> false
Types.isJSON("3") // -> true

// Boolean
Types.isJSON(false) // -> false
Types.isJSON("false") // -> true

// Object
Types.isJSON(null) // -> false
Types.isJSON("null") // -> true

Types.isJSON({ prop: 'JSON' }) // -> false
Types.isJSON("{\"prop\":\"JSON\"}") // -> true

// Array
Types.isJSON([1, 2, 3]) // -> false
Types.isJSON("[1, 2, 3]") // -> true

Since：: 0.2.0

Description

isPhoneNumber(val) 方法用来检测测试数据是否为合法的电话号码格式。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是合法的电话号码格式字符串，返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isPhoneNumber() 方法
// import isPhoneNumber from '@yaohaixiao/types.js/isPhoneNumber'

// 移动电话号码
Types.isPhoneNumber(13901030304) // -> false
Types.isPhoneNumber('1390103030a') // => false

Types.isPhoneNumber('+86 13901030304') // -> true
Types.isPhoneNumber('13901030304') // -> true
Types.isPhoneNumber('139-010-30304') // -> true
Types.isPhoneNumber('139.010.30304') // -> true

// 固定电话号码
Types.isPhoneNumber('+86 84923296') // -> true
Types.isPhoneNumber('027 84923296') // -> true
Types.isPhoneNumber('(027) 84923296') // -> true
Types.isPhoneNumber('(027)84923296') // -> true
Types.isPhoneNumber('027-84923296') // -> true
Types.isPhoneNumber('027.84923296') // -> true
Types.isPhoneNumber('027 849-23296') // -> true
Types.isPhoneNumber('027-849-23296') // -> true

Since：: 1.11.0

Description

isSVG(val) 方法用来检测测试数据是否为合法的 SVG 代码。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是合法的 SVG 代码（字符串），返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isHTML() 方法
// import isSVG from '@yaohaixiao/types.js/isSVG'

Types.isSVG('<!doctype html>') // -> false

const svg = '<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 26 28">' +
            '<path d="M22 15.5v7.5c0"></path>' +
            '</svg>'

Types.isSVG(svg) // -> true

Since：: 1.4.0

Description

isTime(val, type) 方法用来检测测试数据是否为有效的时间（字符串）。

Parameters

val

Type：: Any

（必须）要检测的数据。

type

Type：: String

（可选）测试的时间类型:

time - 时间；
date - 日期；
不传 - 时间或者日期皆可

Returns

Type：: Boolean。

'val' 是有效的时间（字符串），返回 true，否则返回 false。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isTime() 方法
// import isTime from '@yaohaixiao/types.js/isTime'

let chinese

// 非字符串
Types.isTime(123) // -> false
Types.isTime(false) // -> false
Types.isTime(null) // -> false
Types.isTime(chinese) // -> false
Types.isTime(Symbol('symbol')) // -> false
Types.isTime(BigInt(42)) // -> false
Types.isTime({}) // -> false
Types.isTime([]) // -> false
Types.isTime(() => {}) // -> false

// 字符串
Types.isTime('time') // -> false

// 时间
// 12小时格式时间
Types.isTime('1:23', 'time') // -> true
Types.isTime('01:23', 'time') // -> true
Types.isTime('11:23 am', 'time') // -> true
Types.isTime('11:23 AM', 'time') // -> true
Types.isTime('11:23 pm', 'time') // -> true
Types.isTime('5:23 PM', 'time') // -> true

Types.isTime('23:01 pm', 'time') // -> false

// 24小时格式时间
Types.isTime('3:34', 'time') // -> true
Types.isTime('03:45', 'time') // -> true
Types.isTime('18:16:01', 'time') // -> true
Types.isTime('23:34:59', 'time') // -> true

Types.isTime('03:60', 'time') // -> false
Types.isTime('24:01', 'time') // -> false

// 日期
Types.isTime('2001.01.01') // -> true
Types.isTime('2001/01/01') // -> true
Types.isTime('2001-01-01') // -> true
Types.isTime('2001-01-32') // -> false
Types.isTime('2001-13-00') // -> false

Types.isTime('01.01.2001') // -> true
Types.isTime('01/11/2001') // -> true
Types.isTime('31-12-2001') // -> true
Types.isTime('31-13-2001') // -> false
Types.isTime('32.12.2001') // -> false

Types.isTime('Jul 08 2023 11:15:11', 'date') // -> true
Types.isTime('Jul 32 2023 11:15:34', 'date') // -> false

Since：: 0.2.0

Description

isURL(val) 方法用来检测测试数据是否为合法的 URL 格式。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是合法的 URL 格式（字符串），返回 true，否则返回。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isURL() 方法
// import isURL from '@yaohaixiao/types.js/isURL'

// IP 访问
Types.isURL('http://127.0.0.1') // -> true
Types.isURL('https://127.0.0') // -> false
Types.isURL('https://127.0.0.') // -> false

Types.isURL('http://127.0.0.1:8080') // -> true
Types.isURL('http://127.0.0.1:8080#top') // -> true
Types.isURL('http://127.0.0.1:8080?id=22') // -> true
Types.isURL('http://127.0.0.1/console') // -> true
Types.isURL('http://127.0.0.1:8080/workbench/?id=2#projects') // -> true

// 域名访问
Types.isURL('http://localhost') -> false
Types.isURL('ftp://www.yaohaixiao.com') -> false

Types.isURL('http://www.yaohaixiao.') -> false
Types.isURL('http://www.yaohaixiao.c') -> false
Types.isURL('http://www.yaohaixiao.c1') -> false

Types.isURL('https://www.yaohaixiao.cn') -> true
Types.isURL('https://www.yaohaixiao.com') -> true
Types.isURL('https://www.yaohaixiao.com:8083') -> true
Types.isURL('https://www.yaohaixiao.com/blog#top') -> true
Types.isURL('https://www.yaohaixiao.com/blog/?page=2') -> true
Types.isURL('https://www.yaohaixiao.com:8083/blog?page=2#top') -> true

Since：: 0.2.0

Description

isUUID(val) 方法用来检测测试数据是否为合法的 UUID 字符串。

Parameters

val

Type：: Any

（必须）要检测的数据。

Returns

Type：: Boolean。

'val' 是合法的 UUID 格式（字符串），返回 true，否则返回。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isUUID() 方法
// import isUUID from '@yaohaixiao/types.js/isUUID'

Types.isUUID('749d0000-0194-1005-2e05-08d61613bf2f') // -> true
Types.isUUID('d3aa88e2-c754-41e0-8ba6-4198a34aa0a2') // -> true
Types.isUUID('00000000-0000-0000-0000-000000000000') // -> true
Types.isUUID('{0e40c5ab-1d9b-ee11-983e-e0be0335d021}') // -> true
Types.isUUID('08dbe0f11c8641cf8afe6b2824e8f8f5') // -> true

Types.isUUID('') // -> false
Types.isUUID('xxxA987FBC9-4BED-3078-CF07-9141BA07C9F3') // -> false
Types.isUUID('934859') // -> false
Types.isUUID('A987FBC94BED3078CF079141BA07C9F') // -> false