两种常见的方法是解构和传统的类似lodash的选择/省略实现。它们之间的主要实际区别是，解构需要一个键列表是静态的，不能省略它们，包括不存在的选择键，即它是包含的。这可能是可取的，也可能是不可取的，并且不能为析构语法而更改。

考虑到:

var obj = { 'foo-bar': 1, bar: 2, qux: 3 };

定期选择foo-bar, bar, baz键的预期结果:

{ 'foo-bar': 1, bar: 2 }

包容性挑选的预期结果:

{ 'foo-bar': 1, bar: 2, baz: undefined }

解构

析构语法允许用函数参数或变量对对象进行解构和重组。

限制在于键的列表是预定义的，它们不能像问题中描述的那样被列为字符串。如果键是非字母数字，例如foo-bar，则析构将变得更加复杂。

优点是它的性能解决方案对ES6来说是很自然的。

缺点是键的列表是重复的，在列表很长的情况下，这会导致冗长的代码。由于在这种情况下解构会重复对象文字语法，因此可以原样复制和粘贴列表。

IIFE

const subset = (({ 'foo-bar': foo, bar, baz }) => ({ 'foo-bar': foo, bar, baz }))(obj);

临时变量

const { 'foo-bar': foo, bar, baz } = obj;
const subset = { 'foo-bar': foo, bar, baz };

字符串列表

任意选择的键列表由字符串组成，如问题所要求的。这允许不预定义它们，并使用包含键名的变量，['foo-bar'， someKey，…moreKeys]。

ECMAScript 2017有Object。entry和Array.prototype。包括，ECMAScript 2019有object . fromentry，它们可以在需要时填充。

一行程序

考虑到要选择的对象包含额外的键，通常从列表中迭代键比从对象键更有效，如果需要省略键，反之亦然。

Pick (ES5)

var subset = ['foo-bar', 'bar', 'baz']
.reduce(function (obj2, key) {
  if (key in obj) // line can be removed to make it inclusive
    obj2[key] = obj[key];
  return obj2;
}, {});

自己的 （ES5）

var subset = Object.keys(obj)
.filter(function (key) { 
  return ['baz', 'qux'].indexOf(key) < 0;
})
.reduce(function (obj2, key) {
  obj2[key] = obj[key];
  return obj2;
}, {});

拾取 （ES6）

const subset = ['foo-bar', 'bar', 'baz']
.filter(key => key in obj) // line can be removed to make it inclusive
.reduce((obj2, key) => (obj2[key] = obj[key], obj2), {});

省略 （ES6）

const subset = Object.keys(obj)
.filter(key => ['baz', 'qux'].indexOf(key) < 0)
.reduce((obj2, key) => (obj2[key] = obj[key], obj2), {});

挑选 （ES2019）

const subset = Object.fromEntries(
  ['foo-bar', 'bar', 'baz']
  .filter(key => key in obj) // line can be removed to make it inclusive
  .map(key => [key, obj[key]])
);

省略 （ES2019）

const subset = Object.fromEntries(
  Object.entries(obj)
  .filter(([key]) => !['baz', 'qux'].includes(key))
);

可重用的功能

一行程序可以表示为类似于Lodash pick或省略的可重用帮助函数，其中通过参数pick(obj， 'foo-bar'， 'bar'， 'baz')传递键列表。

const pick = (obj, ...keys) => Object.fromEntries(
  keys
  .filter(key => key in obj)
  .map(key => [key, obj[key]])
);

const inclusivePick = (obj, ...keys) => Object.fromEntries(
  keys.map(key => [key, obj[key]])
);

const omit = (obj, ...keys) => Object.fromEntries(
  Object.entries(obj)
  .filter(([key]) => !keys.includes(key))
);

我知道它不是最干净的，但它简单易懂。

function obj_multi_select(obj, keys){
    let return_obj = {};
    for (let k = 0; k < keys.length; k++){
        return_obj[keys[k]] = obj[keys[k]];
    };
    return return_obj;
};

还有一个解决方案:

var subset = {
   color: elmo.color,
   height: elmo.height 
}

到目前为止，这看起来比任何答案都更具可读性，但也许这只是我的想法!

在这个问题中，解构为动态命名的变量在JavaScript中是不可能的。

要动态设置键，可以使用reduce函数而不改变对象，如下所示:

const get子集= (obj，…keys) =>个key。Reduce ((a, c) =>({…A， [c]: obj[c]})， {}); Const elmo = { 颜色:红色, 讨厌:没错, 高度:“未知”, Meta: {1: '1'， 2: '2'} ｝ const子集= get子集(elmo， 'color'， '烦人') console.log(子集)

应该注意的是，你是在每次迭代中创建一个新对象，而不是更新一个克隆。——mpen

下面是一个使用reduce和单个克隆的版本(更新传入的初始值以reduce)。

const get子集= (obj，…keys) =>个key。Reduce ((acc, curr) => { Acc [curr] = obj[curr] 返回acc }, {}) Const elmo = { 颜色:红色, 讨厌:没错, 高度:“未知”, Meta: {1: '1'， 2: '2'} ｝ const子集= get子集(elmo， '烦人'，'height'， 'meta') console.log(子集)

如何:

function sliceObj(obj) {
  var o = {}
    , keys = [].slice.call(arguments, 1);
  for (var i=0; i<keys.length; i++) {
    if (keys[i] in obj) o[keys[i]] = obj[keys[i]];
  }
  return o;
}

var subset = sliceObj(elmo, 'color', 'height');

使用对象解构和属性简写

Const对象= {a: 5, b: 6, c: 7}; const = (({a、c }) => ({ a、c}))(对象); console.log(选择);// {a: 5, c: 7}

---

来自Philipp Kewisch:

这实际上只是一个被即时调用的匿名函数。所有这些都可以在MDN上的解构分配页面上找到。这是一个展开的形式

Let unwrap = ({a, c}) => ({a, c}); 让unwrap2 = function({a, c}){返回{a, c};}; Let selected = unwrap({a: 5, b: 6, c: 7}); 让picke2 = unwrap2({a: 5, b: 6, c: 7}) console.log(选) console.log (picked2)