概述
类型判断集合
目录
- PredicateOption (接口)
- isArguments (常量)
- getTypeName (函数)
- isArray (函数)
- isArrayLike (函数)
- isBoolean (函数)
- isDate (函数)
- isEmpty (函数)
- isEmptyArray (函数)
- isEmptyRecord (函数)
- isError (函数)
- isFinite (函数)
- isFunction (函数)
- isInteger (函数)
- isIterable (函数)
- isIterator (函数)
- isMaybe (函数)
- isNaN (函数)
- isNull (函数)
- isNumber (函数)
- isObject (函数)
- isRegExp (函数)
- isSameType (函数)
- isString (函数)
- isSymbol (函数)
- isTypeName (函数)
- isUndefined (函数)
- notEmpty (函数)
- notEmptyArray (函数)
- notEmptyRecord (函数)
- notMaybe (函数)
- Predicate (导出)
PredicateOption (接口)
签名
interface PredicateOption {}
isArguments (常量)
判断是否输入值为Argument
签名
export const isArguments: Refinement<unknown, unknown> = ...
v0.2.0 中添加
getTypeName (函数)
get type name
签名
export const getTypeName = (value: unknown): string => ...
示例
import { getTypeName } from 'macoolka-predicate'
assert(getTypeName({}) === 'Object')
v0.2.0 中添加
isArray (函数)
判断是否输入值为Array
签名
export const isArray = <T>(a: unknown): a is Array<T> => ...
示例
import { isArray } from 'macoolka-predicate'
assert(isArray([]))
assert(!isArray({}))
v0.2.0 中添加
isArrayLike (函数)
判断是否输入值为ArrayLike
签名
export const isArrayLike = (value: any) => ...
示例
import { isArrayLike } from 'macoolka-predicate'
assert(isArrayLike([]))
assert(isArrayLike({ length: 8 }))
assert(!isArrayLike({}))
v0.2.0 中添加
isBoolean (函数)
判断是否输入值为Boolean
签名
export const isBoolean: Refinement<unknown, boolean> =
(a: unknown): a is boolean => ...
示例
import { isBoolean } from 'macoolka-predicate'
assert(isBoolean(true))
assert(!isBoolean(1))
v0.2.0 中添加
isDate (函数)
判断是否输入值为Date
签名
export const isDate: Refinement<unknown, Date> = (a: unknown): a is Date => ...
示例
import { isDate } from 'macoolka-predicate'
assert(isDate(new Date()))
assert(!isDate('a'))
v0.2.0 中添加
isEmpty (函数)
判断是否输入值为Empty
示例
import { isEmpty } from 'macoolka-predicate'
assert(isEmpty(''))
assert(isEmpty(undefined))
assert(isEmpty(null))
assert(isEmpty({}))
assert(isEmpty([]))
assert(!isEmpty(['1']))
assert(!isEmpty({ a: 1 }))
v0.2.0 中添加
isEmptyArray (函数)
判断是否输入值为Empty Array
签名
export const isEmptyArray = (val: unknown): boolean => ...
示例
import { isEmptyArray } from 'macoolka-predicate'
assert(isEmptyArray([]))
assert(isEmptyArray(undefined))
assert(isEmptyArray(null))
assert(!isEmptyArray(['1']))
v0.2.0 中添加
isEmptyRecord (函数)
判断是否输入值为Empty Record
签名
export const isEmptyRecord = (val: unknown): boolean => ...
示例
import { isEmptyRecord } from 'macoolka-predicate'
assert(isEmptyRecord({}))
assert(isEmptyRecord(undefined))
assert(isEmptyRecord(null))
assert(!isEmptyRecord({ a: 1 }))
v0.2.0 中添加
isError (函数)
判断是否输入值为Error
签名
export const isError: Refinement<unknown, Error> =
(a: unknown): a is Error => ...
示例
import { isError } from 'macoolka-predicate'
assert(isError(new Error('')))
assert(!isError(''))
v0.2.0 中添加
isFinite (函数)
判断是否输入值为Finite
签名
export const isFinite: Predicate<unknown> = (val) => ...
示例
import { isFinite } from 'macoolka-predicate'
assert(isFinite(Number.MAX_VALUE))
assert(isFinite(Number.MIN_VALUE))
assert(isFinite('1'))
assert(!isFinite('a'))
v0.2.0 中添加
isFunction (函数)
判断是否输入值为Function
签名
export const isFunction: Refinement<unknown, Function> =
(a: unknown): a is Function => ...
示例
import { isFunction } from 'macoolka-predicate'
assert(isFunction(() => void 0))
assert(!isFunction(1))
v0.2.0 中添加
isInteger (函数)
判断是否输入值为Integer
签名
export const isInteger: Predicate<unknown> = (val: unknown) => ...
示例
import { isInteger } from 'macoolka-predicate'
assert(isInteger(1))
assert(!isInteger(1.1))
v0.2.0 中添加
isIterable (函数)
判断是否输入值为Iterable
签名
export const isIterable: Refinement<unknown, Iterable<unknown>> =
(a: unknown): a is Iterable<unknown> => ...
示例
import { isIterable } from 'macoolka-predicate'
assert(isIterable([]))
assert(!isIterable({}))
v0.2.0 中添加
isIterator (函数)
判断是否输入值为Iterator
签名
export const isIterator: Refinement<any, Iterator<unknown>> =
<T>(a: any): a is Iterator<T> => ...
示例
import { isIterator } from 'macoolka-predicate'
assert(isIterator({ next: () => void 0 }))
assert(!isIterator({}))
v0.2.0 中添加
isMaybe (函数)
判断是否输入值是否为null或者undefined
示例
import { isMaybe } from 'macoolka-predicate'
import * as assert from 'assert'
assert(isMaybe(undefined))
assert(isMaybe(null))
assert(!isMaybe(''))
v0.2.0 中添加
isNaN (函数)
判断是否输入值为NaN
签名
export const isNaN = (val: unknown) => ...
示例
import { isNaN } from 'macoolka-predicate'
assert(isNaN('a'))
assert(!isNaN(1))
v0.2.0 中添加
isNull (函数)
判断是否输入值是否为null
签名
export const isNull = <T>(val: T | null): val is null => ...
示例
import { isNull } from 'macoolka-predicate'
import * as assert from 'assert'
assert(isNull(null))
assert(!isNull(undefined))
v0.2.0 中添加
isNumber (函数)
判断是否输入值为isNumber
签名
export const isNumber: Refinement<unknown, number> = (a: unknown): a is number => ...
示例
import { isObject } from 'macoolka-predicate'
assert(isNumber(1))
assert(!isNumber('1'))
v0.2.0 中添加
isObject (函数)
判断是否输入值为Object
签名
export const isObject = (a: unknown): a is object => ...
示例
import { isObject } from 'macoolka-predicate'
assert(isObject({}))
assert(isObject({ a: 1 }))
assert(!isObject(2))
v0.2.0 中添加
isRegExp (函数)
判断是否输入值为RegExp
签名
export const isRegExp: Refinement<unknown, RegExp> = (a): a is RegExp => ...
示例
import { isRegExp } from 'macoolka-predicate'
assert(isRegExp(/^a/))
assert(!isRegExp(1))
v0.2.0 中添加
isSameType (函数)
判断是否输入值为相同类型
签名
export const isSameType = (a: unknown, b: unknown) => ...
示例
import { isString } from 'macoolka-predicate'
assert(isSameType('a', '3'))
assert(isSameType({ a: 1 }, { b: 2 }))
assert(!isSameType('a', { b: 2 }))
assert(!isSameType(1, false))
v0.2.0 中添加
isString (函数)
判断是否输入值是否为string
签名
export const isString: Refinement<unknown, string> = (a: unknown): a is string => ...
示例
import { isString } from 'macoolka-predicate'
assert(isString('a'))
assert(!isString(1))
v0.2.0 中添加
isSymbol (函数)
判断是否输入值为symbol
签名
export const isSymbol: Refinement<unknown, symbol> =
(a: unknown): a is symbol => ...
示例
import { isSymbol } from 'macoolka-predicate'
const a = Symbol('A')
assert(isSymbol(a))
assert(!isSymbol('b'))
v0.2.0 中添加
isTypeName (函数)
判断是否输入值为指定的类型名
签名
export const isTypeName = <T>(strTypeName: string): Refinement<unknown, T> =>
(a: unknown): a is T => ...
示例
import { isTypeName } from 'macoolka-predicate'
assert(isTypeName('Object')({}))
v0.2.0 中添加
isUndefined (函数)
判断是否输入值是否为undefined
签名
export const isUndefined: Refinement<unknown, undefined> = (val): val is undefined => ...
示例
import { isUndefined } from 'macoolka-predicate'
import * as assert from 'assert'
assert(isUndefined(undefined))
assert(!isUndefined(null))
v0.2.0 中添加
notEmpty (函数)
判断是否输入值为非空
示例
import { notEmpty } from 'macoolka-predicate'
assert(!notEmpty(''))
assert(!notEmpty(undefined))
assert(!notEmpty(null))
assert(!notEmpty({}))
assert(!notEmpty([]))
assert(notEmpty(['1']))
assert(notEmpty({ a: 1 }))
v0.2.0 中添加
notEmptyArray (函数)
判断是否输入值为Non Empty Array
签名
export const notEmptyArray = <T>(val: unknown): val is NonEmptyArray<T> => ...
示例
import { notEmptyArray } from 'macoolka-predicate'
assert(!notEmptyArray([]))
assert(!notEmptyArray(undefined))
assert(!notEmptyArray(null))
assert(notEmptyArray(['1']))
v0.2.0 中添加
notEmptyRecord (函数)
判断是否输入值为Non Empty Record
签名
export const notEmptyRecord = <T>(val: Maybe<T>): val is AtLeastOne<T> => ...
示例
import { notEmptyRecord } from 'macoolka-predicate'
assert(!notEmptyRecord({}))
assert(!notEmptyRecord(undefined))
assert(!notEmptyRecord(null))
assert(notEmptyRecord({ a: 1 }))
v0.2.0 中添加
notMaybe (函数)
判断是否输入值不为null或者undefined
示例
import { notMaybe } from 'macoolka-predicate'
import * as assert from 'assert'
assert(!notMaybe(undefined))
assert(!notMaybe(null))
assert(notMaybe(''))
v0.2.0 中添加
Predicate (导出)
签名
any