Question

假设我有一个包含3个这样的对象的数组：

[
  {
    a: 4, 
    b: 5,
    c: 4
  },
  {
    a: 3, 
    b: 5,
    c: 6
  },
  {
    a: 2, 
    b: 3,
    c: 3
  }
]

我想返回一个包含共享属性b的公共值的对象的数组数组。因此，结果数组只包含一个包含2个对象的数组，如下所示：

[

  [  
    {
      a: 4, 
      b: 5,
      c: 4
    },
    {
      a: 3, 
      b: 5,
      c: 6
    }
  ]

]

我该怎么做？

Answer 1

您可以使用map和filter

执行此操作

＆＃13;

var data = [{"a":4,"b":5,"c":4},{"a":3,"b":5,"c":6},{"a":2,"b":3,"c":3}];

var check = data.map(e => {return e.b});
var result = [data.filter(e => { return check.indexOf(e.b) != check.lastIndexOf(e.b)})];

console.log(result)

＆＃13;

要将具有相同b值的单独数组中的多个对象分组，您可以使用map和forEach

＆＃13;

var data = [{"a":4,"b":5,"c":4},{"a":3,"b":5,"c":6},{"a":2,"b":3,"c":3}, {"a":3,"b":7,"c":6},{"a":2,"b":7,"c":3}], result = [];

var check = data.map(e => {return e.b});
data.forEach(function(e) { 
 if(check.indexOf(e.b) != check.lastIndexOf(e.b) && !this[e.b]) {
   this[e.b] = [];
    result.push(this[e.b]);
 }
 (this[e.b] || []).push(e);
}, {});

console.log(result)

＆＃13;

Answer 2

此提案使用包含Array#forEach但没有Array#indexOf的单个循环。

＆＃13;

var array = [{ a: 4, b: 5, c: 4 }, { a: 3, b: 5, c: 6 }, { a: 2, b: 3, c: 3 }],
    grouped = [];

array.forEach(function (a) {
    this[a.b] = this[a.b] || [];
    this[a.b].push(a);
    this[a.b].length === 2 && grouped.push(this[a.b]);
}, Object.create(null));

console.log(grouped);

＆＃13;

Answer 3

您可以创建一个接受履行标准的函数，并返回与传递的规则一样多的嵌套数组。

我们假设您有一组对象arr。

var arr = [{a: 1, b: 2}, {a: 3, b: 2}, {a: 3, b: 4}, {a: 1, b: 1}]

并且您希望返回一个包含满足特定要求的嵌套数组的数组，假设您想要具有a:1和b:2的对象。

您可以创建一个循环规则的函数，并使用满足每个规则的对象创建一个嵌套数组。

例如：

＆＃13;

var arr = [{a: 1, b: 2}, {a: 3, b: 2}, {a: 3, b: 4}, {a: 1, b: 1}]
    
function makeNestedArrays() {
  var rules = [].slice.call(arguments);
    
  return rules.reduce(function(acc, fn) {
    var nestedArr = [];

    arr.forEach(function(obj) {
      if (fn(obj)) {
        nestedArr.push(obj);
      }
    });
    
    // only push nested array
    // if there are matches
    if (nestedArr.length) {
      acc.push(nestedArr);
    }
        
    return acc;
  }, []);
}
    
var result = makeNestedArrays(
  function(obj) { return obj.a === 1; },
  function(obj) { return obj.b === 2; }
);

console.log(result);

＆＃13;

这允许您传递尽可能多的＆＃34;规则＆＃34;如你所愿，只要至少有一个匹配，就会为每个规则创建一个嵌套数组。

Answer 4

您可以使用Map对它们进行分组，这应该适用于任何类型的值（只需确保相等规则检出）：

var arr = [{
  a: 4,
  b: 5,
  c: 4

}, {
  a: 3,
  b: 5,
  c: 6
}, {
  a: 2,
  b: 3,
  c: 3
}];

var result = arr.reduce(function(m, o){
  var value = o.b;
  if(m.has(value)){
    m.get(value).push(o);
  } else {
    m.set(value, [o]);
  }
  return m;
}, new Map());

console.log(...(result.values()));

如果你需要过滤掉1：

的组

var arr = [{
  a: 4,
  b: 5,
  c: 4

}, {
  a: 3,
  b: 5,
  c: 6
}, {
  a: 2,
  b: 3,
  c: 3
}];

var result = arr.reduce(function(m, o){
  var value = o.b;
  if(m.has(value)){
    m.get(value).push(o);
  } else {
    m.set(value, [o]);
  }
  return m;
}, new Map());

result = [...result.values()].filter(a => a.length > 1);
console.log(result);

返回包含在属性中共享公共值的对象的数组数组

4 个答案: