types.js

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

<script src="https://cdn.jsdelivr.net/gh/yaohaixiao/types.js/types.min.js"></script>
Download Zip

Base

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

is(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

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.isIPAddress('126.11.15.255') // -> IP address
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

isValue(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是否有效的数据（非null、undefined或者正负无穷数值），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

Primitive Values

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

isBigInt(val)

Description

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

Since：
0.6.0
Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 BigInt 类型，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

isBoolean(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Boolean 类型，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

isNull(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 null，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

isNumber(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Number 类型，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

isString(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 String 类型，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

isSymbol(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Symbol 类型，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

isUndefined(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 undefined，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

Keyed Collections

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

isMap(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Map 类型，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

isSet(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Set 类型，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

isWeakMap(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 WeakMap 类型，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

isWeakSet(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 WeakSet 类型，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

Array

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

isArguments(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 arguments 对象，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

isArray(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Array 类型，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

isArrayLike(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是类似 Array 类型，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

isArrayLikeObject(val)

Description

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

Parameters

val
Type：
Object | Array

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

Returns

Type：
Boolean。

true - 表示检测数据是 ArrayLike 的对象数据，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

isEmptyArray(val)

Description

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

Since：
0.6.0

Parameters

val
Type：
Array

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

Returns

Type：
Boolean。

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

Typed Arrays

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

isTypedArray(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 TypedArray 类型，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

isArrayBuffer(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 ArrayBuffer 类型，false 则表示不是。

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

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

isDataView(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 DataView 类型，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

isInt8Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Int8Array 类型，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

isInt16Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Int16Array 类型，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

isInt32Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Int32Array 类型，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

isUint8Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Uint8Array 类型，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

isUint8ClampedArray(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Uint8ClampedArray 类型，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

isUint16Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Uint16Array 类型，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

isUint32Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Uint32Array 类型，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

isFloat32Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Float32Array 类型，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

isFloat64Array(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Float64Array 类型，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

isBigInt64Array(val)

Description

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

Since：
0.6.0

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 BigInt64Array 类型，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

isBigUint64Array(val)

Description

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

Since：
0.6.0

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 BigUint64Array 类型，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

Object

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

isBinary(val)

Description

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

Since：
1.11.0

Parameters

val
Type：
Buffer | String

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

Returns

Type：
Boolean。

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

isBuffer(val)

Description

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

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

Since：
1.6.0
Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Buffer 类型，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

isDate(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Date 类型，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

isEmptyObject(val)

Description

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

Parameters

val
Type：
Object

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

Returns

Type：
Boolean。

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

isError(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据为 Error 类型，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

isHash(val)

Description

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

Since：
0.4.0
Category：
Lang

Parameters

val
Type：
Object

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

Returns

Type：
Boolean。

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

isObject(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Object 类型，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

isObjectLike(val)

Description

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

Parameters

val
Type：
Object

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

Returns

Type：
Boolean。

true - 表示检测数据是类似 Object 类型，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

isPlainObject(val)

Description

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

Parameters

val
Type：
Object

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

Returns

Type：
Boolean。

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

isPromise(val)

Description

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

Category：
Lang
Since：
1.3.0

Parameters

val
Type：
Object

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

Returns

Type：
Boolean。

true - 表示检测数据是 Promise 对象，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.isPrototype(null) // => false
Types.isPrototype(val) // => false
Types.isPrototype('') // => false
Types.isPrototype(12) // => false
Types.isPrototype(false) // => false
Types.isPrototype(BigInt(12)) // => false
Types.isPrototype(Symbol('prop')) // => false


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

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

isPrototype(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

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

isRegExp(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 RegExp (正则表达式)类型，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

isXML(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是合法的 XML 格式，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

Function

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

isConstructor(val)

Description

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

Category：
Lang

Parameters

val
Type：
Function | Object

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

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

isFunction(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 Function 类型，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

isNativeFunction(val)

Description

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

Parameters

val
Type：
Function

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

Returns

Type：
Boolean。

true - 表示检测数据是 JavaScript 内置函数，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

Number

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

isEven(val)

Description

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

Parameters

val
Type：
Number

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

Returns

Type：
Boolean。

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

isFloat(val)

Description

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

Category：
Lang

Parameters

val
Type：
Number

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

Returns

Type：
Boolean。

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

isInfinite(val)

Description

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

Parameters

val
Type：
Number

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

Returns

Type：
Boolean。

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

isInteger(val)

Description

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

Category：
Lang

Parameters

val
Type：
Number

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

Returns

Type：
Boolean。

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

isLength(val)

Description

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

Parameters

val
Type：
Number

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

Returns

Type：
Boolean。

true - 表示检测数据是有效 length 值，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

isNumeric(val)

Description

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

Category：
Lang

Parameters

val
Type：
Number | String

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

Returns

Type：
Boolean。

true - 表示检测数据是数字(只能是 number 类型或者 '123123' 这样的数字字符串)，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

isOdd(vaL)

Description

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

Parameters

val
Type：
Number

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

Returns

Type：
Boolean。

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

isPrime(num)

Description

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

Parameters

num
Type：
Number

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

Returns

Type：
Boolean。

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

String

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

isAlpha(str)

Description

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

Parameters

str
Type：
String

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

Returns

Type：
Boolean。

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

isBase64(val)

Description

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

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据是 Base64 类型，false 则表示不是。

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

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

isBlank(val)

Description

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

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

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

isChinese(str)

Description

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

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

  1. 中文汉字
  2. 象形文字扩展 A-H
  3. 兼容象形文字符
  4. 兼容表意文字增补字符
  5. 中文标点符号
  6. 兼容标点符号

其中：

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

Since：
1.2.0

Parameters

str
Type：
String

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

includePunctuation
Type：
Boolean

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

Returns

Type：
Boolean。

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

isEmail(val)

Description

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

Category：
Lang

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据是合法的 Email 格式，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])+)\])/

isEmpty(val)

Description

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

Category：
Lang

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

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

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

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

isGuid(str)

Description

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

Alias：
isUUID

Parameters

str
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据(数值)为合法的 UUID 字符串，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

isHex(val)

Description

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

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据(数值)为16 进制数值，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

isHTML(val)

Description

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

Since：
0.5.0
Category：
Lang

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据为合法的 HTML 代码，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

isIPAddress(val)

Description

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

Category：
Lang

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据是合法的 IP 地址格式，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

isJSON(val)

Description

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

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据是合法的 JSON 格式，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

isPhoneNumber(val)

Description

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

Category：
Lang

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

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

isSVG(val)

Description

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

Since：
1.11.0

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据为合法的 SVG 代码，false 则表示不是。

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

// HTML 标签：
Types.isHTML('<!doctype html>') // -> true
Types.isSVG('<!doctype html>') // -> false
Types.isHTML('\n\n<!doctype html><html>') // -> true
Types.isSVG('\n\n<!doctype html><html>') // -> false

// SVG 标签：
const svg = '<?xml version="1.0" encoding="UTF-8"?><svg></svg>'
expect(is(svg)).toBe('svg')
// 包含 xml 声明：
expect(isSVG(svg)).toBe(true)

const svg = '<\!doctype svg><svg></svg>'
expect(is(svg)).toBe('svg')
// 包含 doctype 声明：
expect(isSVG(svg)).toBe(true)

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>'
expect(is(svg)).toBe('svg')
// 仅包含 SVG 标签：
expect(isSVG(svg)).toBe(true)

isTime(str)

Description

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

Since：
1.4.0

Parameters

str
Type：
String

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

type
Type：
String

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

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

Returns

Type：
Boolean。

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

isURL(val)

Description

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

Category：
Lang

Parameters

val
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据是合法的 URL 格式，false 则表示不是。

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

isUUID(str)

Description

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

Parameters

str
Type：
String

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

Returns

Type：
Boolean。

true - 表示检测数据(数值)为合法的 UUID 字符串，false 则表示不是。

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.isOdd('') // -> false
Types.isOdd('xxxA987FBC9-4BED-3078-CF07-9141BA07C9F3') // -> false
Types.isOdd('934859') // -> false
Types.isOdd('A987FBC94BED3078CF079141BA07C9F') // -> false

DOM

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

isDOM(val)

Description

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

Parameters

val
Type：
Object

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

Returns

Type：
Boolean。

true - 表示检测数据是 DOM 类型数据，false 则表示不是。

import Types from '@yaohaixiao/types.js'
// 或者单独引用 isTextNode() 方法
// 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.isElement($items) // -> true

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

isElement(val)

Description

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

Category：
Lang

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 HTMLElement (元素节点)类型，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()

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

isFragment(val)

Description

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

Since：
0.6.0

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 DocumentFragment 文档碎片，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

isHTMLCollection(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 HTMLNodeList (元素集合)类型，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

isTextNode(val)

Description

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

Parameters

val
Type：
Any

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

Returns

Type：
Boolean。

true - 表示检测数据是 HTMLTextNode (文本节点)类型，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

isVNode(val)

Description

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

Parameters

val
Type：
Object

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

Returns

Type：
Boolean。

true - 表示检测数据是 VNode (VUE虚拟节点)类型，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>

Copyright © 2023 Robert Yao, all right reserved.

Code licensed under MIT License

Documentation licensed under CC BY 3.0

View on GitHub · Issues