如何根据深度嵌套在数组和对象的某种组合中的日期找到最新的对象？

Question

I have a particularly challenging data structure (that I don't control) where I need to find the latest object based on a combination of nested arrays and objects, while some of the properties along the way are optional. So far, I've managed to filter away where the optional properties definitely exist, but convincing javascript to pull the dates up so I can compare them to find the latest is proving challenging.

Here's the data structure:

const data = {
  "objects": [
    {
      "id": "id1",
      "code": "code1",
      "props": [
        {
          "foos": [
            {
              "itemId": "theItem",
              "fooDate": "2018-03-01T10:00:00.000Z"
            }
          ]
        }
      ]
    },
    {
      "id": "id2",
      "code": "code2",
      "props": [
        {
          "bar": {
            "itemId": "theItem",
            "barDate": "2018-03-06T22:00:00.000Z"
          }
        }
      ]
    },
    {
      "id": "id3",
      "code": "code3",
      "props": [
        {
          "foos": [
            {
              "itemId": "someOtherItem",
              "fooDate": "2018-01-23T06:00:00.000Z"
            },
            {
              "itemId": "theItem",
              "fooDate": "2018-03-04T18:00:00.000Z"
            }
          ]
        }
      ]
    }
  ]
}

const searchItem = "theItem";

const foosOnly = data.objects.filter(obj => obj.props.find(prop => prop.foos && prop.foos.find(foo => foo.itemId === searchItem)));

What I'm trying to find is the object with the most recent fooDate for "theItem" so that I can operate on some of the top-level properties of the object like id or code . In this example, I expect "id3" to be the most recent despite also having "someOtherItem" with an older fooDate .

I've managed to remove objects that do not contain a foo with filter and find, but I struggle to act on fooDate in comparison between the foos so I can find the latest foo .

Answer 1

The format of fooDate means you can compare it lexicographically. Looking for fooDate just means doing a lot of guards and loops:

let latest = null;
let latestDate = null;
for (const item of data.objects) {
    if (Array.isArray(item.props)) {
        for (const prop of item.props) {
            if (prop.foo) {
                for (const {fooDate} of prop.foo) {
                    if (fooDate && (!latestDate || fooDate > latestDate)) {
                        latest = item;
                        latestDate = fooDate;
                    }
                }
            }
        }
    }
}

Live Example:

 const data = { "objects": [ { "id": "id1", "code": "code1", "props": [ { "foo": [ { "itemId": "theItem", "fooDate": "2018-03-01T10:00:00.000Z" } ] } ] }, { "id": "id2", "code": "code2", "props": [ { "bar": [ { "itemId": "theItem", "barDate": "2018-03-06T22:00:00.000Z" } ] } ] }, { "id": "id3", "code": "code3", "props": [ { "foo": [ { "itemId": "someOtherItem", "fooDate": "2018-01-23T06:00:00.000Z" }, { "itemId": "theItem", "fooDate": "2018-03-04T18:00:00.000Z" } ] } ] } ] }; let latest = null; let latestDate = null; for (const item of data.objects) { if (Array.isArray(item.props)) { for (const prop of item.props) { if (prop.foo) { for (const {fooDate} of prop.foo) { if (fooDate && (!latestDate || fooDate > latestDate)) { latest = item; latestDate = fooDate; } } } } } } console.log(latest);

Answer 2

I started going down the route of navigating the object hierarchy, but there seemed like too many unknowns. So, if you're only curious about a property called fooDate , here's a solution that loops through the objects, stringify's each one, and uses regex to get the date:

let latest = null;
data.objects.forEach(obj => {
    const json = JSON.stringify(obj);
    const regex = new RegExp(/^.+"fooDate":"(.+)".+$/);
    const match = json.match(regex);
    if (match && match.length > 1) {
        const [first, ...results] = match;
        results.forEach(result => {
            const timestamp = new Date(result).valueOf();
            if (!latest || latest.timestamp < timestamp) {
                latest = { obj, timestamp };
            }
        });
    }
});

Answer 3

Below code should help you achieve the desired object. If it works, I 'll add comments too.

 const data={"objects":[{"id":"id1","code":"code1","props":[{"foos":[{"itemId":"theItem","fooDate":"2018-03-01T10:00:00.000Z"}]}]},{"id":"id2","code":"code2","props":[{"bar":{"itemId":"theItem","barDate":"2018-03-06T22:00:00.000Z"}}]},{"id":"id3","code":"code3","props":[{"foos":[{"itemId":"someOtherItem","fooDate":"2018-01-23T06:00:00.000Z"},{"itemId":"theItem","fooDate":"2018-03-04T18:00:00.000Z"}]}]}]}; const list = data.objects; const desiredObject = list.sort((itemA, itemB) => { let itemAFoo = itemA.props.reduce((list, prop) => {return list.concat(prop.foos || [])}, []).sort((a, b) => a.fooDate - b.fooDate).pop() || {fooDate: 0}; let itemBFoo = itemA.props.reduce((list, prop) => {return list.concat(prop.foos || [])}, []).sort((a, b) => a.fooDate - b.fooDate).pop() || {fooDate: 0}; return itemAFoo.fooDate - itemBFoo.fooDate; }).pop(); desiredItemId = desiredObject.props.reduce((list, prop) => {return list.concat(prop.foos || [])}, []).pop().itemId; console.log('desiredObject:', desiredObject); console.log('desiredItemId:', desiredItemId);

Answer 4

Here's some code for what I think would fix your issue. The objective of this method would be to create a new data structure of type

{
  id: string;
  itemId: string;
  date: Date;
}

after which you can simply filter/sort and search. So let's see how we can create above data.

Something along the lines of

const intermediateData = [];

function findItemIdAndDateRecursively(id, object) {
  Object.keys(object).forEach((key) => {
    if(key === 'itemId') {
      let date;
      for(let i in object) {
        if (isUTCString(object[i])) {
          date = object[i];
        }
      }
      intermediateData.push({id: id, itemId: object.itemId, date: date})
    } else if (typeof object[key] === 'object' || typeof object[key] === 'array') {
      findItemIdAndDateRecursively(id, object[key]);
    }
  })
}

array.forEach(item => {
  findItemIdAndDateRecursively(item.id, item);
})

where isUTCString is supposed to find if a string is a date string. You might have to write that utility function depending on the type of data you get.

Answer 5

You could wirte a function that receives the object end returns you the fooDate each time. This function could do something like breadth-first-search to find this key in the object.

When you have this function you can iterate over the array ob objects and save the latest one you found.