描述

返回一个对象，这个对象由忽略属性之外的object自身和继承的可枚举属性组成 v3.0.4+ 可以理解成lodash中omit和omitBy集合

1.示例

import { omit } from 'sf-utils2'

// 数组形式
const object = { a: 1, b: '2', c: 3 }
omit(object, ['a', 'c']) // => { 'b': '2' }

// 字符串形式，
const object = { a: 1, b: '2', c: 3 }
omit(object, 'a,c') // => { 'b': '2' }

// 方法形式，
const object = { a: 1, b: '2', c: 3 }
console.log($sf.omit(object, (item, key) => ['a', 'c'].includes(key))) // => { 'b': '2' }

2.入参说明

参数	说明	类型	是否必填	默认值
obj	目标对象	Object	是
predicate	要被忽略的属性或者过滤自定义方法，（注：单独指定或指定在数组中或者方法过滤），字符串类型时，属性字段是以,动态拼接起来	String、String[]、Function	是

3.源码

import isPlainObject from '@/base/isPlainObject'
import isString from '@/base/isString'
import deepClone from '@/object/deepClone'
import arrayToObj from '@/array/arrayToObj'
import hasOwn from '@/object/hasOwn'
import isArray from '@/base/isArray'
import isFunction from '@/base/isFunction'

/**
 * 反向版  pick; 这个方法一个对象，这个对象由忽略属性之外的object自身和继承的可枚举属性组成。（注：可以理解为删除object对象的属性）。
 * @param {Object} obj
 * @param {String|String[]|Function} predicate
 * @return {{}|*|*[]}
 */
function omit(obj = {}, predicate) {
  if (!isPlainObject(obj)) return obj
  let innerObj = deepClone(obj)
  if (isString(predicate)) {
    // 字符串 切割,
    const splits = predicate.split(',').filter(Boolean)
    const splitsObj = arrayToObj(splits)
    Object.entries(obj).forEach(([k, v]) => {
      if (hasOwn(splitsObj, k)) delete innerObj[k]
    })
  } else if (isArray(predicate)) {
    // 数组
    const tempObj = arrayToObj(predicate)
    Object.entries(obj).forEach(([k, v]) => {
      if (hasOwn(tempObj, k)) delete innerObj[k]
    })
  } else if (isFunction(predicate)) {
    // 是方法
    Object.entries(obj).forEach(([k, v]) => {
      if (predicate(k, v)) delete innerObj[k]
    })
  }
  return innerObj
}

export default omit