Question

我有这个数组

const array = [1, 3, 6];

和这个物体

const obj = {
   1: {id: 1, foo: 'a', ...},
   2: {id: 2, foo: 'b', ...}
   3: {id: 3, foo: 'c', ...},
   4: {id: 4, foo: 'd', ...},
   5: {...},
   6: {...}
   ... // up to 1000 key/value paris
};

我想知道如何用obj中的键过滤array。一种方法是

obj.filter(elem => elem.id...);

但是，尽管obj中只有三个元素，但这仍然会遍历array中的所有元素。最好是遍历array，但是

array.filter(elem => elem === obj.id ...);

然后仅返回array（即1, 3, 6）中的元素。我需要的是一个看起来像

的数组

const result  = ['s', 'b', 'c', 'd'];

最好的方法是什么？

Answer 1

您可以映射到数组并从对象内部返回键foo

const res = array.map(elem => obj[elem].foo);

如果对象中不存在所有元素，则可以添加过滤条件以删除未定义的值

const res = array.map(elem => obj[elem] &&obj[elem].foo).filter(Boolean);

Answer 2

如果您将id作为键，则可以通过过滤键以仅获取已知键来映射所需的值，然后映射该值。

const
    array = [1, 3, 6],
    object = { 1: { id: 1, foo: 'bar' }, 2: {}, 3: { id: 3, foo: 'foo' }, 4: {}, 5: {} },
    result = array 
        .filter(Object.hasOwnProperty.bind(object))
        .map(id => object[id].foo);

console.log(result);

Answer 3

如果array中的所有值都存在于obj中，则使用Array.map；否则，如果obj中缺少条目，则可以使用Array.reduce

const array = [1, 3, 6];
const obj = {1: {id: 1, foo: 'bar'},2: {id: 2, foo: 'foo'}};
 
const result = array.reduce((a,c) => obj[c] ? a.concat(obj[c].foo) : a, []);;
console.log(result);

Answer 4

您不需要迭代所有只需要检查键是否存在的对象，如果键存在，则将foo值推送到结果数组这是代码：

const array = [1, 3, 6];

const obj = {
    1: {id: 1, foo: 'bar'},
    2: {id: 2, foo: 'foo'},
    3: {},
    4: {},
    5: {},
    6: {}
};

let result = [];

array.forEach((el) => {
    if(obj.hasOwnProperty(el)){
        result.push(obj[el].foo)
    }
});

console.log(result);

用数组中的键过滤对象

4 个答案: