常用js工具函数--判断是否是数组、数字、对象等

// import path from 'path';
import crypto from 'crypto'

// "01:52:39.755000000"
export function timestr2float(codestr) {
  if (isValidString(codestr)) {
    let sum = 0.0
    let arr = codestr.split(':') || []
    if (arr.length > 0) {
      arr.forEach(i => {
        sum *= 60
        sum += parseFloat(i)
      })
    }
    return sum
  } else {
    return -1
  }
}
export function pickItems(obj, keyList) {
  let ret = {}
  if (isValidPlainObject(obj) && isValidKeyArray(keyList)) {   
    keyList.forEach(i => {
      let tmp = obj[i] || undefined
      if (tmp !== undefined) {
        ret[i] = tmp
      }
    })
  }
  return ret
}
export function subtract(list, sublist) {
  let idx
  if (isValidArray(list)) {
    if (isValidArray(sublist)) {
      sublist.forEach(item => {
        idx = list.indexOf(item)
        if (idx > -1) {
          list.splice(idx, 1)
        }
      })
    } else if (isValidPlainObject(sublist)) {
      idx = list.findIndex(sublist)
      if (idx > -1) {
        list.splice(idx, 1)
      }
    }
  }
  return list
}

/**
 * Type Conversion
 */
export function toNumber(id) {
  let num = parseInt(id)
  if (isNaN(num)) {
    return id
  } else {
    return num
  }
}

/**
 * Type Checking
 *
 * @param {plainObject} obj
 * @param {keyArray} keyList
 */
export function isValidPlainObject(arg) {
  // {}, new Object(): {__proto__: Object, prototype: undefined}
  if (isValidType(arg, 'Object')) {
    let isConstructorValid = arg.constructor === Object
    let isDunderProtoValid =
      isValidObject(arg.__proto__) && arg.__proto__ === Object.prototype
    // let isPrototypeValid = arg.prototype === undefined;
    // if (isConstructorValid && isDunderProtoValid && isPrototypeValid) {
    if (isConstructorValid && isDunderProtoValid) {
      return true
    }
  }
  return false
}

export function isValidKeyArray(arg) {
  // String, number, Symbol
  if (isValidArray(arg)) {
    let deduped = [...new Set(arg)]
    if (deduped.length === arg.length) {
      let ret = deduped.find(i => {
        return !(isValidString(i) || isValidNumber(i) || isValidSymbol(i))
      })
      if (ret === undefined) {
        return true
      }
    }
  }
  return false
}

export function isValidArray(arg) {
  return isValidType(arg, 'Array')
}
export function isValidId(arg) {
  return (isValidNumber(arg) && arg > 0) || isValidStringArg(arg)
}

export function isValidNumber(arg) {
  return isValidType(arg, 'Number')
}

export function isValidSymbol(arg) {
  return isValidType(arg, 'Symbol')
}

export function isValidObject(arg) {
  return isValidType(arg, 'Object')
}
export function isValidStringArg(arg) {
  return isValidString(arg) && arg.length > 0
}
export function isValidString(arg) {
  return isValidType(arg, 'String')
}

export function isValidFunction(arg) {
  return isValidType(arg, 'Function')
}

export function isValidType(arg, typeStr) {
  // Number, String, Boolean, Function, Object, Array, Date, RegExp, Map, Set, NaN, Undefined, Symbol
  return getType(arg) === typeStr
}

export function getType(arg) {
  let raw = Object.prototype.toString.apply(arg)
  let argType = raw.substring(8, raw.length - 1)
  if (argType === 'Number' && isNaN(arg)) {
    return 'NaN'
  }
  return argType
}

/**
 * Hash Cipher Decipher
 */

export function toMd5Hex(password) {
  let hasher = getMd5Hasher()
  return hasher.update(password).digest('hex')
}

export function getMd5Hasher() {
  return getHasher('md5')
}

export function getHasher(type = 'md5') {
  return crypto.createHash(type)
}

export function fftokenize(id, username, password) {
  return toMd5Hex(id + username + password + Date.now())
}