JavaScript - 通过深度嵌套的 object 键从标准数组中过滤 Object？

Question

I have been breaking my head the last few days trying to implement the following functionality:

I have an incoming object, with a nested sub-object that's a list of dates. I would like to filter the original object against a range of dates, and return the modified filtered object, with only the specified dates.

Here is the desired functionality:

let incomingObject = {
    'one': {
        id: "one",
        dates: {
            "2021-05-01": [{ a: "foo", b: "bar" }],
            "2021-05-02": [{ a: "foo", b: "bar" }] } },
    'two': {
        id: "two",
        dates: {
            "2021-05-01": [{ a: "foo", b: "bar" }, { a: "foo2", b: "bar2" }],
            "2021-05-02": [{ a: "baz", b: "far" }] } },
    'three': {
        id: "three",
        dates: {
            "2021-05-03": [{ a: "foo", b: "bar" }],
            "2021-05-02": [{ a: "foo", b: "bar" }] } } };

// Function to get an array between two dates
const getDaysArray = function (s, e) {
    for (var a = [], d = new Date(s); d <= new Date(e); d.setDate(d.getDate() + 1)) {
        a.push(new Date(d));
    }
    let aStrings = a.map((date) => date.toISOString().slice(0, 10));
    return aStrings;
};

I have no idea how to implement this function, that would return the "filtered" object:

filterResults(incomingObject, getDaysArray("2021-05-01", "2021-05-01"));

This is the desired result - all the (sub-)objects that don't pass the filter, are left out:

let desiredResult = {
    'one': {
        id: "one",
        dates: {
            "2021-05-01": [{ a: "foo", b: "bar" }] } },
    'two': {
        id: "two",
        dates: {
            "2021-05-01": [{ a: "foo", b: "bar" }, { a: "foo2", b: "bar2" }] } } };

And my progress so far:

let dateRange = getDaysArray("2021-05-01", "2021-05-01");

// This logs out only the required keys –– however, logging out the whole "parent" object is completely beyond my comprehension at the moment...
const filteredImages = Object.keys(images).forEach((key) => {
    let imgObject = images[key];
    Object.keys(images[key].dates).forEach((key) => {
        if (dateRange.includes(key)) {
            console.log(key);
        }
    });
});

All help or pointers much appreciated!

Answer 1

 const incomingObject={one:{id:"one",dates:{"2021-05-01":[{a:"foo",b:"bar"}],"2021-05-02":[{a:"foo",b:"bar"}]}},two:{id:"two",dates:{"2021-05-01":[{a:"foo",b:"bar"},{a:"foo2",b:"bar2"}],"2021-05-02":[{a:"baz",b:"far"}]}},three:{id:"three",dates:{"2021-05-03":[{a:"foo",b:"bar"}],"2021-05-02":[{a:"foo",b:"bar"}]}}}; const getDaysArray = function(e,t){for(var a=[],n=new Date(e);n<=new Date(t);n.setDate(n.getDate()+1))a.push(new Date(n));return a.map(e=>e.toISOString().slice(0,10))} const filterResults = (data, days) => Object.entries(data).reduce((result, [k, v]) => { const {dates, ...rest} = v const filteredDates = days.reduce((acc, date) => { if(v.dates[date]) acc[date] = v.dates[date] return acc }, {}) if (Object.keys(filteredDates).length) result.push([k, {...rest, dates: filteredDates }]) return result }, []) const res = filterResults( incomingObject, getDaysArray("2021-05-01", "2021-05-01") ) console.log(Object.fromEntries(res))

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

Answer 2

What about this one? I find it very concise and modern:

const filterResults = (data, days) => 
  Object.entries(data).reduce((acc, [n, { id, dates }]) => {
    const ds = Object.entries(dates).filter(([d,]) => days.includes(d))
    return ds.length ? { ...acc, [n]: { id, dates: Object.fromEntries(ds) } } : acc
  }, {})

The nice thing here is to use nested destructuring patterns and spread operator to avoid boilerplate code.

Also, while doing reduce over Object.entries , we can construct an object directly, without need of an intermediary array. In this implementation, everything is done in just one iteration over the original data array, so it performs better.

---

Additional information on the techniques used in the snippet:

• Lambda syntax for anonymous function (arrow function => ) ;

   const filterResults = (data, days) =>

• Object.entries() function ;

• Array.reduce() , using empty object {} as initial accumulator ;

• Array and Object nested argument destructuring [a, { b, c }] ;

   Object.entries(data).reduce((acc, [n, { id, dates }]) => {

• Array.filter function ;

• Array.includes function ;

• Ignoring some values with Array destructuring [d,] ;

   const ds = Object.entries(dates).filter(([d,]) => days.includes(d))

• Conditional ternary operator ?: ;

• Spread operator for object literals {...acc } ;

• Computed property name [n] ;

• Object.fromEntries function :

   return ds.length? {...acc, [n]: { id, dates: Object.fromEntries(ds) } }: acc

Answer 3

You can use the array methods filter()

In your case it could look something like this:

 const incoming = [ { nested: { date: '2021-05-01' } }, { nested: { date: '2021-03-16' } }, { nested: { date: '2021-02-05' } }, { nested: { date: '2021-01-20' } }, ] let someRange = ['2021-02-05', '2021-03-24'] const result = incoming.filter((item) => { return item.nested.date >= someRange[0] && item.nested.date <= someRange[1] }) console.log(result)

You need to transform your object into an array with Object.values(yourArray) to use the filter() method.

EDIT:

Just read your post again. You can use the Object.keys() to retrieve the keys from your object like so:

 const dates = { "2021-05-01": [{ a: "foo", b: "bar", }, { a: "foo2", b: "bar2", }, ], "2021-05-02": [{ a: "baz", b: "far", }, ], } const dateKeys = Object.keys(dates) console.log(`Keys from date object: ${dateKeys}`) const result = dateKeys.filter((item) => { return item >= '2021-05-02' }) console.log(result)