1

This is an attempt to further a previous question.. I feel like this is just different enough to warrant another topic in hopes to help anyone who is trying to solve the same problem.

If I have a dataset of key-value pairs, let's say I want to accomplish 3 things:

  1. Find the first occurrence of a value of an inner key-value pair.
  2. Copy that value into a Map
  3. Utilize the value of another key-value pair as the key for the Map.

So, for example, let's say I have the following dataset:

[
  {"date":"2019-01-01", "temp":"cold", "season":"winter", "precip":"snow"},
  {"date":"2019-02-01", "temp":"cold", "season":"winter", "precip":"none"},
  {"date":"2019-03-01", "temp":"mild", "season":"spring", "precip":"rain"},
  {"date":"2019-04-01", "temp":"mild", "season":"spring", "precip":"none"},
  {"date":"2019-05-01", "temp":"warm", "season":"spring", "precip":"rain"},
  {"date":"2019-06-01", "temp":"warm", "season":"summer", "precip":"hail"},
  {"date":"2019-07-01", "temp":"hot", "season":"summer", "precip":"none"}
]

I would like to end up with the following Map object:

[
  "2019-01-01" => "snow",
  "2019-02-01" => "none",
  "2019-03-01" => "rain",
  "2019-06-01" => "hail"
]

As a last challenge, how could I do this in a function where my result can be dynamic? So in the above example, I chose 'precip' as the desired value in the final Map. But what if I wanted 'season'? Is there a way to do that dynamically, where I can pass the 'key' name as an argument of a function?

Also, is there a name for this operation? I had trouble coming up with a title. If someone has a better idea, I'd gladly rename it. I feel like this is an elegant problem that many may run into.

Improve this question
4
  • What is "2019-06-01" => "hail"? Commented Jul 31, 2019 at 14:18
  • @ChrisLi key which is "2019-06-01" and it is associated with the value "hail". Commented Jul 31, 2019 at 14:20
  • How do you define the first occurrence? The first one that shows up in the array even if it might contain dates in non-chronological order or the first in terms of chronology? Commented Jul 31, 2019 at 14:25
  • Sorry for not getting back to you quickly. First occurrence would simply be the one with the lowest numerical index (first to show up in an iteration of the array). Commented Jul 31, 2019 at 15:35

5 Answers 5

Reset to default
6

You can use

  1. Array#filter to remove any entries that will end up producing duplicate values
  2. Array#map over your data to produce key-value pairs
  3. Just collect into a Map via the constructor

To have that dynamic, you simply need to supply what the names of the properties you use for your key and value:

const data = [
  {"date":"2019-01-01", "temp":"cold", "season":"winter", "precip":"snow"},
  {"date":"2019-02-01", "temp":"cold", "season":"winter", "precip":"none"},
  {"date":"2019-03-01", "temp":"mild", "season":"spring", "precip":"rain"},
  {"date":"2019-04-01", "temp":"mild", "season":"spring", "precip":"none"},
  {"date":"2019-05-01", "temp":"warm", "season":"spring", "precip":"rain"},
  {"date":"2019-06-01", "temp":"warm", "season":"summer", "precip":"hail"},
  {"date":"2019-07-01", "temp":"hot", "season":"summer", "precip":"none"}
];

function transform(keyProp, valueProp, arr) {
  const keyValuePairs = arr
    .filter(function(obj) {
      const value = obj[valueProp];
      //only keep the value if it hasn't been encountered before
      const keep = !this.has(value);

      //add the value, so future repeats are removed
      this.add(value)

      return keep;
    }, new Set()) // <-- pass a Set to use as `this` in the callback
    .map(obj => [obj[keyProp], obj[valueProp]]);
  
  return new Map(keyValuePairs);
}

const map = transform("date", "precip", data);

//Stack Snippets don't print the Map content
//via console.log(map), so doing it manually
for (let [key, value] of map) {
  console.log(`${key} -> ${value}`);
}

Note that this uses the second argument to .filter - it sets the this context of the callback. By setting it to a Set, it ensures that is only used for the .filter operation - you don't need to keep an extra variable in scope of the entire function. Also, since it sets the this context, you need a normal function as opposed to an arrow function as the this value cannot be changed for the latter.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

This is a beautifully elegant solution, but it's only for half of the problem. This solution does do the job of creating the map. The other half of the problem is that I only want the results that provide the first occurrence of valueProp. Using date and precip would return a map of size 4 (see the description above).
@jasonmclose apologies, I completely missed that you wanted the unique values. I'll re-work this.
Well done. Thank you very much for responding. This was a cool problem to run into, and it was great to have so many people respond. Your solution did the trick.
4

This is a good scenario for Array.prototype.reduce

const invertMap = map => {
  const entires = Array.from(map.entries());
  const reversedKeyValues = entires.map(([key, value]) => [value, key]);
  return new Map(reversedKeyValues);
};

const weatherLogs = [
      {"date":"2019-01-01", "temp":"cold", "season":"winter", "precip":"snow"},
      {"date":"2019-02-01", "temp":"cold", "season":"winter", "precip":"none"},
      {"date":"2019-03-01", "temp":"mild", "season":"spring", "precip":"rain"},
      {"date":"2019-04-01", "temp":"mild", "season":"spring", "precip":"none"},
      {"date":"2019-05-01", "temp":"warm", "season":"spring", "precip":"rain"},
      {"date":"2019-06-01", "temp":"warm", "season":"summer", "precip":"hail"},
      {"date":"2019-07-01", "temp":"hot", "season":"summer", "precip":"none"}
    ];

const firstPrecipToDate = weatherLogs.reduce((acc, log) => {
  const { date, precip } = log;
  
  if (!acc.has(precip)) {
    // only add precip to the `precip->date` map if we don't have it yet
    acc.set(precip, date);
  }

  return acc;
}, new Map());

// Now invert map to be date -> precip
const dateToPrecip = invertMap(firstPrecipToDate);

console.log(dateToPrecip);
console.log('-- It shows as empty object in stackoverflow, view browser console');

Explanation

weatherLogs.reduce takes 2 arguments. The first argument is a callback and the second argument is the initial value (of the accumulator).

The callback is executed on each element in the array in order and can take the following arguments.

  • accumulator (acc in the example)
    • This is the previously returned value from the last item
  • currentValue (log in the example)
    • This is the current element being processed in the array
  • index (not used in example)
    • This is the index of the current element
  • array (not used in example)
    • The original array that reduce was called on

Read more about Array.prototype.reduce here - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce

Improve this answer

2 Comments

Realized this doesn't fully answer the question. I will try to update accordingly
Thank you very much for contributing. This accomplished the task. They only reason I didn't check it as the solution is that the other solution by @VLAZ added the dynamic option of being able to be able to pass column names. But I want to commend your code, as I would have never come up with anything close.
1

You actually have a few questions there. I'll answer one by one.

Question 1: Make it dynamic

All you need to do is accept a few more arguments as shown below.

This way, not only that you can make value of your result dynamic, you can also make the key of your result dynamic.

Due to the dynamic nature, you'd want more verbose checking most of the time. So you'll see a lot of conditional throws below. Take it out as you see fit.

const data = [
  {"date":"2019-01-01", "temp":"cold", "season":"winter", "precip":"snow"},
  {"date":"2019-02-01", "temp":"cold", "season":"winter", "precip":"none"},
  {"date":"2019-03-01", "temp":"mild", "season":"spring", "precip":"rain"},
  {"date":"2019-04-01", "temp":"mild", "season":"spring", "precip":"none"},
  {"date":"2019-05-01", "temp":"warm", "season":"spring", "precip":"rain"},
  {"date":"2019-06-01", "temp":"warm", "season":"summer", "precip":"hail"},
  {"date":"2019-07-01", "temp":"hot", "season":"summer", "precip":"none"}
];


let result;

result = firstOccurance(data, 'date', 'precip');
console.log('date => precip');
log(result);

result = firstOccurance(data, 'date', 'season');
console.log('date => season');
log(result);

result = firstOccurance(data, 'temp', 'precip');
console.log('temp => precip');
log(result);


/**
 * All you need to do is accept a few more arguments:
 *   1. keyPropName
 *   2. valuePropName
 *
 * This not only make value dynamic, the key can also be dynamic.
 */
function firstOccurance(data, keyPropName, valuePropName){
  if (keyPropName === valuePropName)
    throw new TypeError('`keyPropName` and `valuePropName` cannot be the same.');

  const ret = new Map();

  for (const obj of data){
    if (!hasOwnProperty(obj, keyPropName) || !hasOwnProperty(obj, valuePropName))
      throw new ReferenceError(`Property ${keyPropName} is not found in the dataset.`);

    const key = obj[keyPropName]
    const value = obj[valuePropName];

    // Check if `value` already exist in Map.
    if ([...ret.values()].includes(value))
      continue;

    ret.set(key, value);
  }

  return ret;
}

function hasOwnProperty(obj, name){
  return Object.prototype.hasOwnProperty.call(obj, name);
}

function log(iterable){
  for (const [key, val] of iterable){
    console.log(key, '=>', val);
  }
  console.log('\n');
}

You can go ahead and change the keyPropName and valuePropName to something else, and it will work just fine and as expected.

Question 2: Is there a name for this operation?

No.

Improve this answer

1 Comment

Thank you very much for responding. It's awesome to see so many different angles of attack on this problem.
0

Use reduceRight, map, and sort.

const arr = [{"date":"2019-01-01", "temp":"cold", "season":"winter", "precip":"snow"},{"date":"2019-02-01", "temp":"cold", "season":"winter", "precip":"none"},{"date":"2019-03-01", "temp":"mild", "season":"spring", "precip":"rain"},{"date":"2019-04-01", "temp":"mild", "season":"spring", "precip":"none"},{"date":"2019-05-01", "temp":"warm", "season":"spring", "precip":"rain"},{"date":"2019-06-01", "temp":"warm", "season":"summer", "precip":"hail"},{"date":"2019-07-01", "temp":"hot", "season":"summer", "precip":"none"}];

const key = "precip";

const res = new Map(Object.entries(arr.reduceRight((a, { date, [key]: c }) => (a[c] = date, a), {})).map(e => e.reverse()).sort(([a], [b]) => new Date(a) - new Date(b)));

console.log(res);
Improve this answer

Comments

0

Try this approach:

const data = [
  {"date":"2019-01-01", "temp":"cold", "season":"winter", "precip":"snow"},
  {"date":"2019-02-01", "temp":"cold", "season":"winter", "precip":"none"},
  {"date":"2019-03-01", "temp":"mild", "season":"spring", "precip":"rain"},
  {"date":"2019-04-01", "temp":"mild", "season":"spring", "precip":"none"},
  {"date":"2019-05-01", "temp":"warm", "season":"spring", "precip":"rain"},
  {"date":"2019-06-01", "temp":"warm", "season":"summer", "precip":"hail"},
  {"date":"2019-07-01", "temp":"hot", "season":"summer", "precip":"none"}
]

function getFirstOccurenceMap(key, value) {
    const myMap = new Map();
    for (let i=0; i<data.length; i++) {
        if (data[i][value] && !myMap.has(data[i][value])) {
            myMap.set(data[i][value], data[i][key]);
        }
    }
    result = new Map();
    if (myMap) {
        for (var [key, value] of myMap) {
            if (!result.has(value)) {
                result.set(value, key);
            }
        }
    }
    return result;
}

console.log(getFirstOccurenceMap("date", "temp"));
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.