如何筛选基于内数组属性的滤波阵列？

Question

我有以下对象数组：

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

我想要做在哪里可以返回一个第二阵列是a的副本，但仅包括其b阵列包含至少一个元素大于10更大，并且对于每一个这样的元素中的元素的最简单的操作中，有b仅包含元件（ S）比10更大。所以我想输出是：

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

我知道我能做到这一点天真与循环或使用filter()多个步骤，但我不知道是否有一个高效的在线解决方案。有小费吗？

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

您可以使用减少和过滤器

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


let op = a.reduce((out,{b,c})=>{
  let temp = b.filter(e => e > 10);
  if(temp.length){
    out.push( { b : temp,c })
  } 
  return out
},[])

console.log(op)

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

UPDATE还有一堆在这里伟大的答案（我upvoted所有至今）的。下面是我最终想出了，但：

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”。所以在这一点上，你会过滤掉的“一”，因为它没有在它的“B”是> 10.任何元素你现在有这个第三个元素：

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

接下来，您映射新的阵列，即。对于每个元素返回在于具有“c”的相同的值的新的数组的新元素，除了过滤以仅包括是> 10。因此你结束了这些元素“B”的相同值：

[
    {
        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);