How to Insert dates if some of the dates are missing in the original array of objects

Question

Below is my data, which is an array of objects.

const myArray = [
{name: "Dave", date: "2020-07-30T17:30:46.180Z", score: 50, age: 20},
{name: "Dave", date: "2020-06-30T17:30:26.160Z", score: 35, age: 20},
{name: "Cosmo", date: "2020-06-30T17:30:26.160Z", score: 65, age: 22},
{name: "Dave", date: "2020-05-30T15:30:16.160Z", score: 65, age: 20},
{name: "Carlos", date: "2020-07-30T17:30:46.180Z", score: 70, age: 28},
{name: "Carlos", date: "2020-06-30T17:30:26.160Z", score: 53, age: 28},
];

The expected result is to make sure each individual has a score for each date. The score should be null when the date is missing for the individual.

Expected result

[
{name: "Dave", date: "2020-07-30T17:30:46.180Z", score: 50, age: 20},
{name: "Dave", date: "2020-06-30T17:30:26.160Z", score: 35, age: 20},
{name: "Dave", date: "2020-05-30T15:30:16.160Z", score: 65, age: 20},
{name: "Cosmo", date: "2020-06-30T17:30:26.160Z", score: 65, age: 22},
{name: "Cosmo", date: "2020-07-30T17:30:46.180Z", score: null, age: 22},
{name: "Cosmo", date: "2020-05-30T15:30:16.160Z", score: null, age: 22},
{name: "Carlos", date: "2020-07-30T17:30:46.180Z", score: 70, age: 28},
{name: "Carlos", date: "2020-06-30T17:30:26.160Z", score: 53, age: 28},
{name: "Carlos", date: "2020-05-30T15:30:16.160Z", score: null, age: 28}
];

My attempt to solve this problem can be found below. It didn't really work. What changes should I make?

const myArray = [
{name: "Dave", date: "2020-07-30T17:30:46.180Z", score: 50, age: 20},
{name: "Dave", date: "2020-06-30T17:30:26.160Z", score: 35, age: 20},
{name: "Cosmo", date: "2020-06-30T17:30:26.160Z", score: 65, age: 22},
{name: "Dave", date: "2020-05-30T15:30:16.160Z", score: 65, age: 20},
{name: "Carlos", date: "2020-07-30T17:30:46.180Z", score: 70, age: 28},
{name: "Carlos", date: "2020-06-30T17:30:26.160Z", score: 53, age: 28},
];
  
// Get unique dates
const getUniqueDates = (data) => {
    let temp = [];
    data.forEach(el => {

        if (temp.indexOf(el.date) === -1) {
            temp.push(el.date);
        }
    })
    return temp;
}

const myDates = getUniqueDates(myArray);

// Use a nested loop to verify whether date exists or not and insert objects
const getCleanData = () => {
    let temp = [];
    myDates.forEach(el => {

        for (let i = 0; i < myArray.length; i++) {
            let obj = {};
            obj['name'] = myArray[i].name;
            obj['age'] = myArray[i].age;
            if (el === myArray[i].date && typeof myArray[i].date !== 'undefined') {
                obj['score'] = myArray[i].score;
                obj['date'] = myArray[i].date;
                temp.push(obj);
            } else {
                obj['score'] = null;
                obj['date'] = el;
            }
        }

    })
    return temp;
}

console.log(getCleanData());

Is the order of the output records important? Or could they be sorted by name then date or by date then name? — Scott Sauyet, Dec 08 '20 at 20:13

Scott Sauyet · Accepted Answer · 2020-12-08T21:24:13.423

Here's one approach. We calculate the list of unique dates, group the records by name, and then flatMap that result into arrays of elements formed by mapping the dates and choosing the existing match or creating a new one from a simple template based on the first record for that person:

const addMissingDates = (records) => {
  const dates = [... new Set(records .map (r => r.date))]
  const byName = Object .values (records .reduce (
    (a, x) => ({...a, [x.name]: [...(a[x.name] || []), x]}), 
    {}
  ))
  return byName .flatMap (person => {
    const {score, date, ...rest} = person[0] 
    return dates .map (
      d => person .find (({date}) => d == date) || {...rest, date: d, score: null}
    )
  })
}

const myArray = [{name: "Dave", date: "2020-07-30T17:30:46.180Z", score: 50, age: 20}, {name: "Dave", date: "2020-06-30T17:30:26.160Z", score: 35, age: 20}, {name: "Cosmo", date: "2020-06-30T17:30:26.160Z", score: 65, age: 22}, {name: "Dave", date: "2020-05-30T15:30:16.160Z", score: 65, age: 20}, {name: "Carlos", date: "2020-07-30T17:30:46.180Z", score: 70, age: 28}, {name: "Carlos", date: "2020-06-30T17:30:26.160Z", score: 53, age: 28},]

console .log (addMissingDates (myArray))

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

Update: fixed a bug and added a simplification inspired by uke's answer.

Update 2: Another implementation of the same idea, using my preferred expressions-rather-than-statements style:

const addMissingDates = (records, dates = [... new Set(records .map (r => r.date))]) => 
  Object .values (records .reduce (
    (a, x) => ({...a, [x.name]: [...(a[x.name] || []), x]}), 
    {}
  )) .flatMap ((person, _, __, {score, date, ...rest} = person [0]) => dates .map (
    d => person .find (({date}) => d == date) || {...rest, date: d, score: null}
  ))

Nina Scholz · Answer 2 · 2020-12-08T21:33:17.017

You need a cartesian product of names and dates and store the names for getting a tamplate.

const
    data = [{ name: "Dave", date: "2020-07-30T17:30:46.180Z", score: 50, age: 20 }, { name: "Dave", date: "2020-06-30T17:30:26.160Z", score: 35, age: 20 }, { name: "Cosmo", date: "2020-06-30T17:30:26.160Z", score: 65, age: 22 }, { name: "Dave", date: "2020-05-30T15:30:16.160Z", score: 65, age: 20 }, { name: "Carlos", date: "2020-07-30T17:30:46.180Z", score: 70, age: 28 }, { name: "Carlos", date: "2020-06-30T17:30:26.160Z", score: 53, age: 28 }],
    temp = data.reduce((r, o) => {
        r.date[o.date] = true;
        r.name[o.name] = o;
        (r[o.name] ??= {})[o.date] = o;
        return r;
    }, { date: {}, name: {} }),
    result = Object
        .entries(temp.name)
        .flatMap(([name, o]) => Object
            .keys(temp.date)
            .map(date => temp[name]?.[date] || { ...o, date, score: null })
        );

console.log(result);

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

The dates are not correct in your answer. – Damien Dec 08 '20 at 21:30 — Damien, Dec 08 '20 at 21:30
@DamienAsseya, right, sorry. please see edit. – Nina Scholz Dec 08 '20 at 21:33 — Nina Scholz, Dec 08 '20 at 21:33

uke · Answer 3 · 2020-12-09T15:32:36.380

You need to know all possible dates first and the group by name, this will sort your data by name.

const allDates = Array.from(new Set(myArray.map(it=>it.date)))

Then use it in combination with groupBy

Object.entries(groupBy(myArray, (it) => it.name))
    .map(([name,personDates]) =>
        allDates.map(
            (date) =>
                personDates.find((it) => it.date === date) || {
                    name,
                    date,
                    score: null,
                    age: null,
                }
        )
    )
    .flat();

You can use _.groupBY or use this answer to recreate it Most efficient method to groupby on an array of objects

Finally you need to use flat to remove the array of arrays

Please check out [How do I create a runnable stack snippet?](https://meta.stackoverflow.com/questions/358992). Also note that the extra records you generate here don't have the `name` field. — Scott Sauyet, Dec 08 '20 at 20:51

score -1 · Answer 4 · answered Dec 08 '20 at 20:06

-1

To check if a property is in an object, use the in operator. For example:

if (!("date" in el)) {
    // executes if there is no date property.
}

answered Dec 08 '20 at 20:06

sid c

207
1
4

I don't know if this is relevant to the question. If it is, it should be a comment, as this is far from an actual answer to the question. – Scott Sauyet Dec 08 '20 at 21:08

How to Insert dates if some of the dates are missing in the original array of objects

4 Answers4