将对象需要的键名与键值摘出来

需求：一个对象中可能有很多键值对，我们只需要某几个，比如，下面的对象obj只需要得到它的id，name,num

let obj= {'id':1,'name':'张三','age':23,'num':1,'real_name':'张三ss','percen':23}

let newObj = pickItems(obj, [
    'id',
    'name',
    'num'
  ])
console.log(newObj) // {'id':1,'name':'张三','num':1}

下方为具体方法

// "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
  }
}
/**
 * 摘取对象中需要的键值对
 *
 * @param {plainObject} obj  需要摘取的对象
 * @param {keyArray} keyList  所需的键值对的键名组成的数组
 */
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
}