如何获取javascript对象的子集'；s属性_Javascript_Object

如何获取javascript对象的子集'；s属性

javascript object

如何获取javascript对象的子集'；s属性,javascript,object,Javascript,Object,假设我有一个目标： elmo = { color: 'red', annoying: true, height: 'unknown', meta: { one: '1', two: '2'} }; 我想创建一个具有其属性子集的新对象 // pseudo code subset = elmo.slice('color', 'height') //=> { color: 'red', height: 'unknown' } 如何实现这一点？核心库中没有类似的内置功

假设我有一个目标：

elmo = { 
  color: 'red',
  annoying: true,
  height: 'unknown',
  meta: { one: '1', two: '2'}
};

我想创建一个具有其属性子集的新对象

 // pseudo code
 subset = elmo.slice('color', 'height')

 //=> { color: 'red', height: 'unknown' }

如何实现这一点？

核心库中没有类似的内置功能，但您可以使用对象分解来实现它

const {color, height} = sourceObject;
const newObject = {color, height};

你也可以写一个实用函数来实现它

const cloneAndPluck = function(sourceObject, keys) {
    const newObject = {};
    keys.forEach((obj, key) => { newObject[key] = sourceObject[key]; });
    return newObject;
};

const subset = cloneAndPluck(elmo, ["color", "height"]);

像Lodash这样的库也有

。.pick（）

核心库中没有类似的内置功能，但是您可以使用对象分解来实现它

const {color, height} = sourceObject;
const newObject = {color, height};

你也可以写一个实用函数来实现它

const cloneAndPluck = function(sourceObject, keys) {
    const newObject = {};
    keys.forEach((obj, key) => { newObject[key] = sourceObject[key]; });
    return newObject;
};

const subset = cloneAndPluck(elmo, ["color", "height"]);

像Lodash这样的库也有

.pick（）

那么：

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');

函数切片obj（obj）{
var o={}
，keys=[].slice.call（参数，1）；
对于（var i=0；i
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');

函数切片obj（obj）{
var o={}
，keys=[].slice.call（参数，1）；
对于（var i=0；i我建议看一看；它有很多非常有用的函数
例如，这正是您所寻求的：
var subset = _.pick(elmo, ['color', 'height']);

我建议看一看；它有很多很好的实用功能
例如，这正是您所寻求的：
var subset = _.pick(elmo, ['color', 'height']);

功能拼接（）
{
var ret=新对象（）；
对于（i=1；i
功能拼接（）
{
var ret=新对象（）；
对于（i=1；i

注意：虽然最初提出的问题是针对javascript的，但可以是
通过下面的解决方案完成jQuery
如果需要，可以扩展jquery。下面是一个片段的示例代码：
jQuery.extend({
  sliceMe: function(obj, str) {
      var returnJsonObj = null;
    $.each( obj, function(name, value){
        alert("name: "+name+", value: "+value);
        if(name==str){
            returnJsonObj = JSON.stringify("{"+name+":"+value+"}");
        }

    });
      return returnJsonObj;
  }
});

var elmo = { 
  color: 'red',
  annoying: true,
  height: 'unknown',
  meta: { one: '1', two: '2'}
};


var temp = $.sliceMe(elmo,"color");
alert(JSON.stringify(temp));

这是同样的小提琴：
注意：虽然最初提出的问题是针对javascript的，但可以是
通过下面的解决方案完成jQuery
如果需要，可以扩展jquery。下面是一个片段的示例代码：
jQuery.extend({
  sliceMe: function(obj, str) {
      var returnJsonObj = null;
    $.each( obj, function(name, value){
        alert("name: "+name+", value: "+value);
        if(name==str){
            returnJsonObj = JSON.stringify("{"+name+":"+value+"}");
        }

    });
      return returnJsonObj;
  }
});

var elmo = { 
  color: 'red',
  annoying: true,
  height: 'unknown',
  meta: { one: '1', two: '2'}
};


var temp = $.sliceMe(elmo,"color");
alert(JSON.stringify(temp));

这是同样的小提琴：
你也可以用
作为补充，假设您有一个“elmo”数组：
如果您想要相同的行为，使用lodash，您只需：
var subsets = _.map(elmos, function(elm) { return _.pick(elm, 'color', 'height'); });

你也可以使用
作为补充，假设您有一个“elmo”数组：
如果您想要相同的行为，使用lodash，您只需：
var subsets = _.map(elmos, function(elm) { return _.pick(elm, 'color', 'height'); });

虽然有点冗长，但您可以通过使用来完成其他人在2年前推荐的下划线/lodash
这种方法从另一个方面解决了这个问题：与其获取一个对象并将属性名传递给它进行提取，不如获取一个属性名数组并将其缩减为一个新对象
虽然在最简单的情况下更为详细，但这里的回调非常方便，因为您可以轻松满足一些常见要求，例如，将新对象的“color”属性更改为“color”，展平数组，等等——从一个服务/库接收对象并在某处构建所需的新对象时需要执行的任何操作，例如虽然下划线/lodash是优秀的、实现良好的libs，但这是我减少对供应商依赖的首选方法，也是在子集构建逻辑变得更复杂时更简单、更一致的方法
编辑：相同的es7版本：
const subset = ['color', 'height'].reduce((a, e) => (a[e] = elmo[e], a), {});

编辑：也是一个很好的咖喱例子！有一个“pick”函数返回另一个函数
const pick = (...props) => o => props.reduce((a, e) => ({ ...a, [e]: o[e] }), {});

上述方法与另一种方法非常接近，只是它允许您动态地构建一个“选择器”
pick('color', 'height')(elmo);

这种方法特别巧妙的地方在于，您可以轻松地将所选的“选择”传递到任何具有函数的对象中，例如数组#map
：
[elmo, grover, bigBird].map(pick('color', 'height'));
// [
//   { color: 'red', height: 'short' },
//   { color: 'blue', height: 'medium' },
//   { color: 'yellow', height: 'tall' },
// ]

虽然有点冗长，但您可以通过使用来完成其他人在2年前推荐的下划线/lodash
这种方法从另一个方面解决了这个问题：与其获取一个对象并将属性名传递给它进行提取，不如获取一个属性名数组并将其缩减为一个新对象
虽然在最简单的情况下更为详细，但这里的回调非常方便，因为您可以轻松满足一些常见要求，例如，将新对象的“color”属性更改为“color”，展平数组，等等——从一个服务/库接收对象并在某处构建所需的新对象时需要执行的任何操作，例如虽然下划线/lodash是优秀的、实现良好的libs，但这是我减少对供应商依赖的首选方法，也是在子集构建逻辑变得更复杂时更简单、更一致的方法
编辑：相同的es7版本：
const subset = ['color', 'height'].reduce((a, e) => (a[e] = elmo[e], a), {});

编辑：也是一个很好的咖喱例子！有一个“pick”函数返回另一个函数
const pick = (...props) => o => props.reduce((a, e) => ({ ...a, [e]: o[e] }), {});

上述方法与另一种方法非常接近，只是它允许您动态地构建一个“选择器”
pick('color', 'height')(elmo);

这种方法特别巧妙的地方在于，您可以轻松地将所选的“选择”传递到任何具有函数的对象中，例如数组#map
：
[elmo, grover, bigBird].map(pick('color', 'height'));
// [
//   { color: 'red', height: 'short' },
//   { color: 'blue', height: 'medium' },
//   { color: 'yellow', height: 'tall' },
// ]

使用对象分解和属性速记

const object={a:5，b:6，c:7}；
常量picked=（{a，c}）=>（{a，c}））（对象）；
console.log（picked）；//{a:5，c:7}
使用对象解构和属性速记

const object={a:5，b:6，c:7}；
常量picked=（{a，c}）=>（{a，c}））（对象）；
console.log（已拾取）；//{a:5，c:7}
将参数转换为数组
使用Array.forEach（）
拾取属性
Object.prototype.pick = function(...args) {
   var obj = {};
   args.forEach(k => obj[k] = this[k])
   return obj
}
var a = {0:"a",1:"b",2:"c"}
var b = a.pick('1','2')  //output will be {1: "b", 2: "c"}


将参数转换为数组
使用Array.forEach（）
拾取属性
Object.prototype.pick = function(...args) {
   var obj = {};
   args.forEach(k => obj[k] = this[k])
   return obj
}
var a = {0:"a",1:"b",2:"c"}
var b = a.pick('1','2')  //output will be {1: "b", 2: "c"}


具有动态特性的分解赋值
此解决方案不仅适用于您的具体示例，而且更普遍适用于：

constsubset2=（x，y）=>（{[x]：a[y]：b}）=>（{[x]：a[y]：b}）；
常量subset3=（x，y，z）=>（{[x]：a[y]：b[z]：c}）=>（{[x]：a[y]：b[z]：c}）；
//常数第4分节…等。
常数o={a:1，b:2，c:3，d:4，e:5}；
常量pickBD=子类2（“b”，“d
var obj = { 'a': 1, 'b': '2', 'c': 3 };

_.pick(object, ['a', 'c']);

// => { 'a': 1, 'c': 3 }

['color', 'height'].reduce((a,b) => (a[b]=elmo[b],a), {})

const elmo={color:"red",annoying:!0,height:"unknown",meta:{one:"1",two:"2"}};

const {color, height} = elmo; newObject = ({color, height});

console.log(newObject); //{ color: 'red', height: 'unknown' }

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

{ foo: 1, bar: 2 }

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

let subset = (({ foo, bar, baz }) => ({ foo, bar, baz }))(obj);

let { foo, bar, baz } = obj;
let subset = { foo, bar, baz };

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

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

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

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

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

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

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

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

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

const object = { a: 5, b: 6, c: 7, d: 8, aa: 5, bb: 6, cc: 7, dd: 8, aaa: 5, bbb: 6, ccc: 7, ddd: 8, ab: 5, bc: 6, cd: 7, de: 8  };
const picked = (({ a, aa, aaa, ab, c, cc, ccc, cd }) => ({ a, aa, aaa, ab, c, cc, ccc, cd }))(object);

console.log(picked);

const slice = (k, o) => eval(`(${k} => ${k})(o)`);


const object    = { a: 5, b: 6, c: 7, d: 8, aa: 5, bb: 6, cc: 7, dd: 8, aaa: 5, bbb: 6, ccc: 7, ddd: 8, ab: 5, bc: 6, cd: 7, de: 8  };
const sliceKeys = '({ a, aa, aaa, ab, c, cc, ccc, cd })';

console.log( slice(sliceKeys, object) );

Object.fromEntries(
  Object.entries(obj)
  .filter(([key]) => ['whitelisted', 'keys'].includes(key))
);

Object.entries(obj)
.filter(([key]) => ['whitelisted', 'keys'].includes(key))
.reduce((obj, [key, val]) => Object.assign(obj, { [key]: val }), {});

Object.keys(obj)
.filter((key) => ['whitelisted', 'keys'].indexOf(key) >= 0)
.reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})

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

Object.entries(obj)
.filter(([key]) => !['blacklisted', 'keys'].includes(key))
.reduce((obj, [key, val]) => Object.assign(obj, { [key]: val }), {});

Object.keys(obj)
.filter((key) => ['blacklisted', 'keys'].indexOf(key) < 0)
.reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})

var obj = {a: 1, b:2, c:3}
var newobj = {a,c}=obj && {a,c}
// {a: 1, c:3}

const aListOfObjects = [{
    prop1: 50,
    prop2: "Nothing",
    prop3: "hello",
    prop4: "What's up",
  },
  {
    prop1: 88,
    prop2: "Whatever",
    prop3: "world",
    prop4: "You get it",
  },
]

const sections = aListOfObjects.map(({prop1, prop2}) => ({prop1, prop2}));

pick(obj, keys){
    return  Object.assign({}, ...keys.map(key => ({ [key]: obj[key] })))
}

pick(obj, keys){
    return  Object.assign({}, ...keys.map(key => ({ [key]: obj[key] })))
}
const obj = {a:1, b:2, c:3, d:4}
const keys = ['a', 'c', 'f']
const picked = pick(obj,keys)
console.log(picked)