使用PropPick包

pick('item1 item3', obj);
// {
//   item1: { key: 'sdfd', value:'sdfd' },
//   item3: { key: 'sdfd', value:'sdfd' }
// }

好吧，这样怎么样:

const myData = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

function filteredObject(obj, filter) {
  if(!Array.isArray(filter)) {
   filter = [filter.toString()];
  }
  const newObj = {};
  for(i in obj) {
    if(!filter.includes(i)) {
      newObj[i] = obj[i];
    }
  }
  return newObj;
}

像这样叫它:

filteredObject(myData, ['item2']); //{item1: { key: 'sdfd', value:'sdfd' }, item3: { key: 'sdfd', value:'sdfd' }}

上面的许多解决方案都重复调用Array.prototype.includes来处理raw中的每个键，这将使解决方案为O(n·m)(其中n是对象中键的数量，m是允许列表的长度)。

这可以通过使用一个允许的Set来避免，但是遍历允许的键并将它们复制到一个初始为空的对象中会得到非常简单，可读的代码，即O(m):

Const raw = { Item1: {key: 'sdfd'， value:'sdfd'}， Item2: {key: 'sdfd'， value:'sdfd'}， Item3:{键:'sdfd'，值:'sdfd'} }; Const allowed = ['item1'， 'item3']; Const filtered = {}; For(允许的const键){ If (key in raw) filter [key] = raw[key]; ｝ console.log(过滤);

如果你想避免复制继承的属性，你也可以使用raw. hasownproperty (key)来代替key in raw。

在循环过程中，当遇到某些属性/键时，不返回任何内容，并继续执行其余的:

const loop = product =>
Object.keys(product).map(key => {
    if (key === "_id" || key === "__v") {
        return; 
    }
    return (
        <ul className="list-group">
            <li>
                {product[key]}
                <span>
                    {key}
                </span>
            </li>
        </ul>
    );
});

如果你可以使用ES6语法，我发现最干净的方法是:

const data = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const { item2, ...newData } = data;

现在，newData包含:

{
  item1: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

或者，如果你将键存储为字符串:

const key = 'item2';
const { [key]: _, ...newData } = data;

在后一种情况下，[key]被转换为item2，但由于您使用的是const赋值，因此需要为赋值指定一个名称。_表示丢弃值。

更普遍的:

const { item2, ...newData } = data; // Assign item2 to item2
const { item2: someVarName, ...newData } = data; // Assign item2 to someVarName
const { item2: _, ...newData } = data; // Assign item2 to _
const { ['item2']: _, ...newData } = data; // Convert string to key first, ...

这不仅将您的操作减少到一行程序，而且还不需要知道其他键是什么(那些您想要保留的键)。

一个简单的效用函数是这样的:

function removePropFromObject(obj, prop) {
  const { [prop]: _, ...rest } = obj
  return { ...rest }
}

这里的答案肯定是合适的，但它们有点慢，因为它们需要对对象中的每个属性遍历白名单。下面的解决方案对于大型数据集来说要快得多，因为它只在白名单中循环一次:

Const data = { allowed1:“废话”, Allowed2: 'blah blah'， 记者:“哇”, superSensitiveInfo:“whooooah”, allowed3:“在那里” }; Const whitelist = ['allowed1'， 'allowed2'， 'allowed3']; 函数净化(数据，白名单){ 返回whitelist.reduce ( (result, key) => Data [key] !== undefined ？ 对象。赋值(result， {[key]: data[key]}) :结果, {} ）; ｝ Const result = sanitize(数据，白名单); console.log(结果);