说明：

Question

是否有一种干净的方法来返回一个新对象，该对象省略了原始对象包含的某些属性，而不必使用像lodash这样的东西？

Answer 1

const {omittedPropertyA, omittedPropertyB, ...remainingObject} = originalObject;

说明：

使用ES7

您可以使用对象解构和 spread运算符来省略javascript对象的属性：

const animalObject = { 'bear': 1, 'snake': '2', 'cow': 3 };
 
const {bear, ...other} = animalObject

// other is: { 'snake': '2', 'cow:'  3}

来源：https://remotedevdaily.com/two-ways-to-omit-properties-from-a-javascript-object/

Answer 2

如果您知道要保留保留的属性列表以及省略，则以下“白名单”方法应该有效：

const exampleFilter = ({ keepMe, keepMeToo }) => ({ keepMe, keepMeToo })

console.log(
  exampleFilter({
    keepMe: 'keepMe',
    keepMeToo: 'keepMeToo',
    omitMe: 'omitMe',
    omitMeToo: 'omitMeToo'
  })
)

Answer 3

const x = {obj1: 1, obj2: 3, obj3:26};


const {obj1,obj2, ...rest} = x;
console.log(rest)

<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/4.9.1/d3.min.js"></script>

Answer 4

npm上的blacklist包有一个非常灵活的api。

使用对象休息传播提议（第3阶段）的情境技巧。

const {a, b, ...rest} = {a: 1, b: 2, c: 3, d: 4};
a // 1
b // 2
rest // {c: 3, d: 4}

这通常用于您想要使用一些属性的反应组件，并将其余的作为道具传递给<div {...props} />或类似的。

Answer 5

使用带有递归的ES7，省略和排列键。

function omit(keys, obj) {
  if (!keys.length) return obj
  const { [keys.pop()]: omitted, ...rest } = obj;
  return omit(keys, rest);
}

这是基于@Eddie Cooro答案的。

Answer 6

function omitKeys(obj, keys) {
        var target = {}; 

        for (var i in obj) { 
            if (keys.indexOf(i) >= 0) continue;
            if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; 

            target[i] = obj[i]; 
        } 

        return target; 
    }

Answer 7

尚未提及的解决方案：

省略单个

o = {a: 5, b: 6, c: 7}
Object.fromEntries(Object.entries(o).filter(e => e[0] != 'b'))
// Object { a: 5, c: 7 }

省略多个

o = {a: 1, b: 2, c: 3, d: 4}
exclude = new Set(['a', 'b'])
Object.fromEntries(Object.entries(o).filter(e => !exclude.has(e[0])))
// Object { c: 3, d: 4 }

使用上面的 Set 是因为它会导致线性复杂度，即使 exclude 中的元素数量与 o 中的元素数量在同一个渐近等价类中。< /p>

Answer 8

您可以使用Object.assign（），删除

var not = ["a", "b"]; // properties to delete from obj object
var o = Object.assign({}, obj);
for (let n of not) delete o[n];

可选地

var props = ["c", "d"];
let o = Object.assign({}, ...props.map(prop => ({[prop]:obj[prop]})));

Answer 9

当然，为什么不能这样：

var original = {
  name: 'Rory',
  state: 'Bored',
  age: '27'
};

var copied = Object.assign({}, original);
delete copied.age;

console.log(copied);

https://jsfiddle.net/4nL08zk4/

Answer 10

一个解决方案，我确信还有很多其他解决方案。

＆＃13;

const testObj = {
    prop1: 'value1',
    prop2: 'value2',
    prop3: 'value3'
};

const removeProps = (...propsToFilter) => obj => {
   return Object.keys(obj)
   .filter(key => !propsToFilter.includes(key))
   .reduce((newObj, key) => {
       newObj[key] = obj[key];
       return newObj;
   }, {});
};


console.log(removeProps('prop3')(testObj));
console.log(removeProps('prop1', 'prop2')(testObj));

＆＃13;

编辑：我总是忘记delete ...

＆＃13;

const testObj = {
    prop1: 'value1',
    prop2: 'value2',
    prop3: 'value3'
};

const removeProps = (...propsToFilter) => obj => {
   const newObj = Object.assign({}, obj);
   propsToFilter.forEach(key => delete newObj[key]);
   return newObj;
};


console.log(removeProps('prop3')(testObj));
console.log(removeProps('prop1', 'prop2')(testObj));

＆＃13;

Answer 11

var obj = {
  a: 1,
  b: 2,
  c: 3,
  d: {
    c: 3,
    e: 5
  }
};

Object.extract = function(obj, keys, exclude) {
  var clone = Object.assign({}, obj);
  if (keys && (keys instanceof Array)) {
    for (var k in clone) {
      var hasKey = keys.indexOf(k) >= 0;
      if ((!hasKey && !exclude) || (hasKey && exclude)) {
        delete clone[k];
      }
    }
  }
  return clone;
};

console.log('Extract specified keys: \n-----------------------');
var clone1 = Object.extract(obj, ['a', 'd']);
console.log(clone1);
console.log('Exclude specified keys: \n-----------------------');
var clone2 = Object.extract(obj, ['a', 'd'], true);
console.log(clone2);

Answer 12

如果您已经使用lodash，则也可以执行(pInst == NULL)来获取没有数组中提供的属性的新Object。

Answer 13

在现代环境中，您可以使用以下代码段：

function omit(key, obj) {
  const { [key]: omitted, ...rest } = obj;
  return rest;
}

Answer 14

我看到了这个问题，我想删除一个特定的密钥，而不是一个完整的方法，所以这是我的建议：

const originalObj = {wantedKey: 111, anotherWantedKey: 222, unwantedKey: 1010};
const cleanedObj = Object.assign({unwantedKey: undefined}, originalObj);

如何在JavaScript中省略对象的特定属性

14 个答案:

说明：

省略单个

省略多个