Question

我有以下对象数组：

let a = [
    {
        b: [1, 11, 12],
        c: "a1"
    },
    {
        b: [2, 56, 1],
        c: "a2"
    },
    {
        b: [1, 2, 3],
        c: "a3"
    }
]

我想做一个最简单的操作，我可以返回一个第二个数组，该数组是a的副本，但仅包含其{{1 }}数组至少包含一个大于b的元素，并且对于每个这样的元素，10仅包含大于b的元素。所以我希望输出为：

我知道我可以使用[ { b: [11, 12], c: "a1" }, { b: [56], c: "a2" } ]通过循环或分多个步骤来幼稚地执行此操作，但是我想知道是否有一种有效的单行解决方案。有提示吗？

Answer 1

您可以像这样使用filter和reduce：

let a = [{b:[1,11,12],c:"a1"},{b:[2,56,1],c:"a2"},{b:[1,2,3],c:"a3"}]

const output = a.reduce((acc, { b, c }) => {
  // filter "b" property
  const filtered = b.filter(n => n > 10);
  
  if (filtered.length)
    acc.push({ b: filtered, c });
    
  return acc;
}, [])

console.log(output)

Answer 2

您可以使用.filter()和.map()获得所需的输出：

let a = [{
    b: [1, 11, 12],
    c: "a1"
}, {
    b: [2, 56, 1],
    c: "a2"
}, {
    b: [1, 2, 3],
    c: "a3"
}];

let b = a.filter(({ b }) => b.some(v => v > 10))
         .map(o => Object.assign({}, o, {b: o.b.filter(v => v > 10)}));

console.log(b);

.as-console-wrapper {max-height: 100% !important; top: 0; }

Answer 3

您可以使用reduce和filter

if @note.save

Answer 4

这也是一种简单的方法。

let a = [
    {
        b: [1, 11, 12],
        c: "a1"
    },
    {
        b: [2, 56, 1],
        c: "a2"
    },
    {
        b: [1, 2, 3],
        c: "a3"
    }
]

var result = [];
a.forEach((item) => {
var subItem = { c:item.c, b: item.b.filter((b)=> b > 10)}
if (subItem.b.length>0)
     result.push(subItem);
});

console.log(result)

Answer 5

let result = a.map((rec)=> {rec.b.filter((bRec)=>bRec>10), rec.c}).filter((rec)=>rec.b.length == 0);

Answer 6

其他很棒的答案。我的看法是：

var ans = a.slice().filter(item => {
    item.b = item.b.filter(s => s > 10)
  return (item.b.length > 0) ? true : false;
})

Answer 7

更新这里有很多不错的答案（到目前为止，我都赞成）。这是我最终想到的：

a.filter(x => x.b.some(y => y>10)).map((z) => {
    return {
        b: z.b.filter(zb => zb>10),
        c: z.c
    }
})

说明：

您采用“ a”，然后对其进行过滤，以仅包括“ b”具有“某些元素y，例如y> 10”的那些元素。因此，此时您将滤除'a'的第三个元素，因为它的'b'中没有任何大于10的元素。您现在有了：

[
    {
        b: [1, 11, 12],
        c: "a1"
    },
    {
        b: [2, 56, 1],
        c: "a2"
    }
]

接下来，您映射该新数组，即。对于每个元素，您将在新数组中返回一个具有相同的“ c”值和一个相同的“ b”值的新元素，但将其过滤掉以仅包括那些大于10的元素。因此，最终得到：

[
    {
        b: [11, 12],
        c: "a1"
    },
    {
        b: [56],
        c: "a2"
    }
]

感谢您的所有贡献！

Answer 8

由于没有人提到它，因此这是一种使用嵌套filters()的方法。

我基于这种方法，条件是如果b数组中的某个元素大于10，则按先前条件对其进行过滤的结果将得到一个non-empty数组。

还请注意，这不会更改原始数组，因为它会更改过滤器接收到的数组的副本。

let a = [
    {b: [1, 11, 12], c: "a1"},
    {b: [2, 56, 1], c: "a2"},
    {b: [1, 2, 3], c: "a3"}
]

let res = a.filter(
    ({b}, i, arr) => (arr[i].b = b.filter(x => x > 10)) && arr[i].b.length > 0
);

console.log(res);

如何基于内部数组属性的过滤来过滤数组？

8 个答案: