1. /*
    2. * @Description: 数据类型判断
    3. * @Author: huhaonan@sics.ac.cn
    4. * @Date: 2021-12-10 17:24:17
    5. * @LastEditors: huhaonan@sics.ac.cn
    6. * @LastEditTime: 2022-01-07 10:45:21
    7. */
    8. const toString = Object.prototype.toString
    10. export function isType(value: unknown, type: string) {
    11.   return toString.call(value) === `[object ${type}]`
    12. }
    14. // 提取数据原始类型
    15. export function getType(value: unknown): string {
    16.   return toString
    17.     .call(value)
    18.     .replace(/^\[object /, '')
    19.     .replace(/]$/, '')
    20. }
    21. // 提取数据原始类型
    22. const toRawType = (value) => { 
    23.   return Object.prototype.toString.call(value).slice(8, -1)
    24. } // 示例 toRawType('');  'String' toRawType([]);  'Array'
    28. // 是否为原始数据类型
    29. export function isPrimitive(value: unknown) {
    30.   return (
    31.     typeof value === 'string' ||
    32.     typeof value === 'number' ||
    33.     // $flow-disable-line
    34.     typeof value === 'symbol' ||
    35.     typeof value === 'boolean'
    36.   )
    37. }
    39. export function isNull(value: unknown): value is null {
    40.   return value === null
    41. }
    43. export function isDef<T = unknown>(value?: T): value is T {
    44.   return typeof value !== 'undefined'
    45. }
    46. export function isUndefined<T = unknown>(value?: T): value is T {
    47.   return value === undefined
    48. }
    50. export function isNil(value: any): value is null | undefined {
    51.   /**
    52.   * isNil(null) => true
    53.   * isNil() => true
    54.   */
    55.   return value === null || value === undefined
    56. }
    58. export function isNullAndUnDef(value: unknown): value is null | undefined {
    59.   return isUndefined(value) && isNull(value)
    60. }
    62. export function isNullOrUnDef(value: unknown): value is null | undefined {
    63.   return isUndefined(value) || isNull(value)
    64. }
    66. export function isBoolean(value: unknown): value is boolean {
    67.   return isType(value, 'Boolean')
    68. }
    70. export function isNumber(value: unknown): value is number {
    71.   return isType(value, 'Number')
    72. }
    73. //是否整数
    74. export const isInteger = Number.isInteger
    75. ? Number.isInteger
    76. : function (num: any): boolean {
    77.   return isNumber(num) && num % 1 === 0
    78. }
    80. // 是否正数
    81. export function isPositive(num: any): boolean {
    82.   return isNumber(num) && num > 0
    83. }
    84. // 是否负数
    85. export function isNegative(num: unknown): boolean {
    86.   return isNumber(num) && num < 0
    87. }
    88. // 是否偶数
    89. export function isEven(num: unknown): boolean {
    90.   return isNumber(num) && num % 2 === 0
    91. }
    92. // 是否奇数
    93. export function isOdd(num: any): boolean {
    94.   return isNumber(num) && num % 2 !== 0
    95. }
    97. export function isDecimal(num: any): boolean {
    98.   return isNumber(num) && num % 1 !== 0
    99. }
    101. export function isString(value: unknown): value is string {
    102.   return isType(value, 'String')
    103. }
    105. // isIntegerKey 判断是不是数字型的字符串
    106. export const isIntegerKey = (key) => isString(key) &&
    107.     key !== 'NaN' &&
    108.     key[0] !== '-' &&    '' + parseInt(key, 10) === key;
    109. // 例子:
    110. // isIntegerKey('a'); // false
    111. // isIntegerKey('0'); // true
    112. // isIntegerKey('011'); // false
    113. // isIntegerKey('11'); // true
    114. // isIntegerKey('-11'); // false
    115. // isIntegerKey(11); // false
    116. // isIntegerKey('NaN'); // false
    118. // 引用数据类型
    120. export function isArray(value: any): value is Array<any> {
    121.   return value && Array.isArray(value)
    122. }
    124. // 是否类数组结构
    125. export function isArrayLike(value: any): boolean {
    126.   /**
    127.   * isArrayLike([1, 2, 3]) => true
    128.   * isArrayLike(document.body.children) => true
    129.   * isArrayLike('abc') => true
    130.   * isArrayLike(Function) => false
    131.   */
    132.   return value !== null && typeof value !== 'function' && isFinite(value.length)
    133. }
    135. export interface ObjectType<T> {
    136.   [key: string]: T
    137. }
    138. // export function isObject(value: any): value is Record<any, any> {
    139. //   return value !== null && isType(value, 'Object')
    140. // }
    141. export function isObject<T = any>(value: any): value is T {
    142.   /**
    143.   * isObject({}) => true
    144.   * isObject([1, 2, 3]) => true
    145.   * isObject(Function) => true
    146.   * isObject(null) => false
    147.   */
    148.   const type = typeof value
    149.   return (value !== null && type === 'object') || type === 'function'
    150. }
    152. export function isObjectLike(value: any): value is ObjectType<any> {
    153.   /**
    154.   * isObjectLike({}) => true
    155.   * isObjectLike([1, 2, 3]) => true
    156.   * isObjectLike(Function) => false
    157.   * isObjectLike(null) => false
    158.   */
    159.   return value !== null && typeof value === 'object'
    160. }
    162. export function isPrototype(value: any): boolean {
    163.   const Ctor = value && value.constructor
    164.   const proto =
    165.         (typeof Ctor === 'function' && Ctor.prototype) || Object.prototype
    166.   return value === proto
    167. }
    169. export function isFunction(value: unknown) {
    170.   return typeof value === 'function'
    171. }
    172. /**
    173. * 是否是参数类型
    174. *
    175. * @param {Object} value 测试的值
    176. * @return {Boolean}
    177. */
    178. export function isArguments(value: any): boolean {
    179.   return isType(value, 'Arguments')
    180. }
    182. // export function isEmpty<T = unknown>(value: T): value is T {
    183. //   if (isArray(value) || isString(value)) {
    184. //     return value.length === 0
    185. //   }
    187. //   if (value instanceof Map || value instanceof Set) {
    188. //     return value.size === 0
    189. //   }
    191. //   if (isObject(value)) {
    192. //     return Object.keys(value).length === 0
    193. //   }
    195. //   return false
    196. // }
    197. /**
    198. * @Description: 是否为空
    199. * @param {any} value
    200. */
    201. export function isEmpty(value: any): boolean {
    202.   /**
    203.   * isEmpty(null) => true
    204.   * isEmpty() => true
    205.   * isEmpty(true) => true
    206.   * isEmpty(1) => true
    207.   * isEmpty([1, 2, 3]) => false
    208.   * isEmpty('abc') => false
    209.   * isEmpty({ a: 1 }) => false
    210.   */
    211.   const hasOwnProperty = Object.prototype.hasOwnProperty
    212.   if (isNil(value)) {
    213.     return true
    214.   }
    215.   if (isArrayLike(value)) {
    216.     return !value.length
    217.   }
    218.   const type = getType(value)
    219.   if (type === 'Map' || type === 'Set') {
    220.     return !value.size
    221.   }
    222.   if (isPrototype(value)) {
    223.     return !Object.keys(value).length
    224.   }
    225.   for (const key in value) {
    226.     if (hasOwnProperty.call(value, key)) {
    227.       return false
    228.     }
    229.   }
    230.   return true
    231. }
    233. export function isRegExp(value: unknown): value is RegExp {
    234.   return isType(value, 'RegExp')
    235. }
    237. export function isDate(value: unknown): value is Date {
    238.   return isType(value, 'Date')
    239. }
    241. export function isFormData(val: unknown) {
    242.   return typeof FormData !== 'undefined' && val instanceof FormData
    243. }
    245. export function isPromise<T = any>(value: unknown): value is Promise<T> {
    246.   return (
    247.     isType(value, 'Promise') &&
    248.     isObject(value) &&
    249.     isFunction(value.then) &&
    250.     isFunction(value.catch)
    251.   )
    252. }
    254. export function isError(value: any): value is Error {
    255.   return isType(value, 'Error')
    256. }
    258. /**
    259. * @Description: 两个数据是否相同
    260. * @param {any} value
    261. * @param {any} other
    262. */
    263. export function isEqual(value: any, other: any): boolean {
    264.   if (value === other) {
    265.     return true
    266.   }
    267.   if (!value || !other) {
    268.     return false
    269.   }
    270.   if (isString(value) || isString(other)) {
    271.     return false
    272.   }
    273.   if (isArrayLike(value) || isArrayLike(other)) {
    274.     if (value.length !== other.length) {
    275.       return false
    276.     }
    277.     let rst = true
    278.     for (let i = 0; i < value.length; i++) {
    279.       rst = isEqual(value[i], other[i])
    280.       if (!rst) {
    281.         break
    282.       }
    283.     }
    284.     return rst
    285.   }
    286.   if (isObjectLike(value) || isObjectLike(other)) {
    287.     const valueKeys = Object.keys(value)
    288.     const otherKeys = Object.keys(other)
    289.     if (valueKeys.length !== otherKeys.length) {
    290.       return false
    291.     }
    292.     let rst = true
    293.     for (let i = 0; i < valueKeys.length; i++) {
    294.       rst = isEqual(value[valueKeys[i]], other[valueKeys[i]])
    295.       if (!rst) {
    296.         break
    297.       }
    298.     }
    299.     return rst
    300.   }
    301.   return false
    302. }
    304. /**
    305. * @Description: 两个数据是否相同,不依赖其他函数，来自https://www.30secondsofcode.org/js/s/equals/
    306. * @param {any} value
    307. * @param {any} other
    308. */
    309. const equals = (a: any, b: any): boolean => {
    310.   if (a === b) return true;
    312.   if (a instanceof Date && b instanceof Date)
    313.     return a.getTime() === b.getTime();
    315.   if (!a || !b || (typeof a !== "object" && typeof b !== "object"))
    316.     return a === b;
    318.   if (a.prototype !== b.prototype) return false;
    320.   const keys = Object.keys(a);
    321.   if (keys.length !== Object.keys(b).length) return false;
    323.   return keys.every((k) => equals(a[k], b[k]));
    324. };
    326. export function isWindow(value: any): value is Window {
    327.   return typeof window !== 'undefined' && isType(value, 'Window')
    328. }
    330. // export function isElement(value: unknown): value is Element {
    331. //   return isObject(value) && !!value.tagName
    332. // }
    333. /**
    334. * 判断是否HTML元素
    335. * @return {Boolean} 是否HTML元素
    336. */
    337. export function isElement(o: any): boolean {
    338.   return o instanceof Element || o instanceof HTMLDocument
    339. }
    341. export const isServer = typeof window === 'undefined'
    343. export const isClient = !isServer
    345. export function isUrl(path: string): boolean {
    346.   const reg =
    347.         /(((^https?:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+(?::\d+)?|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)$/
    348.   return reg.test(path)
    349. }