Benchmark: lodash groupBy vs Array.reduce 100k fair3

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var max2 = 100000;

var data = [];
for (var i = 0; i <= max2; i++) { data.push({ id: i }); }





function groupByReduce(arr, iteratee) {
    return arr.reduce((acc, v) => {
      const k = iteratee(v);
      (acc[k] || (acc[k] = [])).push(v)
      return acc;
  }, {})
}

function groupByReduceBetter(arr, iteratee) {
    return arr.reduce((acc, v) => {
      const k = iteratee(v);
      if(acc[k]) {
        acc[k].push(v);
      } else {
        acc[k] = [v];
      }
      return acc;
  }, {})
}

function groupByHasOwnProperty(arr, iteratee) {
    return arr.reduce((acc, v) => {
      const k = iteratee(v);
      if(acc.hasOwnProperty(k)) {
        acc[k].push(v);
      } else {
        acc[k] = [v];
      }
      return acc;
  }, {})
}


function groupByHasOwnPropertyCall(arr, iteratee) {
    return arr.reduce((acc, v) => {
      const k = iteratee(v);
      if(hasOwnProperty.call(acc, k)) {
        acc[k].push(v);
      } else {
        acc[k] = [v];
      }
      return acc;
  }, {})
}

function groupByMap(arr, iteratee) {
  const m = new Map();

  for (const v of arr) {
      const k = iteratee(v);
      const temp = m.get(k) ?? [];
      temp.push(v);
      m.set(k, temp)
  }
  return m;
}

function groupByMapBetter(arr, iteratee) {
  const m = new Map();

  for (let length = arr.length, i = 0; i < length; ++i) {
      const k = iteratee(arr[i]);
      let temp = m.get(k);
      if (temp) {
        temp.push(arr[i]);
      } else {
        temp = [arr[i]]
      }
      m.set(k, temp)
  }
  return m;
}

var iteratee = ({ id }) => id

Tests:

Lodash
_.groupBy(data, iteratee)
Native
data.reduce((acc, item) => { if(acc[item.id]) { acc[item.id].push(item); } else { acc[item.id] = [item]; } return acc; }, {})
groupByReduce
groupByReduce(data, iteratee)
groupByReduceBetter
groupByReduceBetter(data, iteratee)
groupByHasOwnProperty
groupByHasOwnProperty(data, iteratee)
groupByMapBetter
groupByMapBetter(data, iteratee)
native direct
data.reduce((acc, v) => { const k = v.id; if(acc[k]) { acc[k].push(v); } else { acc[k] = [v]; } return acc; }, {})
native direct no copy
data.reduce((acc, v) => { if(acc[v.id]) { acc[v.id].push(v); } else { acc[v.id] = [v]; } return acc; }, {})
groupByHasOwnPropertyCall
groupByHasOwnProperty(data, iteratee)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Native
groupByReduce
groupByReduceBetter
groupByHasOwnProperty
groupByMapBetter
native direct
native direct no copy
groupByHasOwnPropertyCall

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark results.

The tests are comparing different methods of grouping data using Lodash, including `groupBy`, `groupByHasOwnProperty`, and others.

Here's a brief summary of the top-performing tests:

1. **Native**: Chrome 109 on Desktop with Windows OS executes approximately 278 times per second.
2. **native direct no copy**: Chrome 109 on Desktop with Windows OS executes around 266 times per second.
3. **groupByReduceBetter**: Chrome 109 on Desktop with Windows OS executes around 260 times per second.

These results suggest that the `native` method is the fastest, followed closely by the `native direct no copy` variant. The `groupByReduceBetter` test is slightly slower but still relatively fast.

**Notable mentions:**

* **Lodash**: Chrome 109 on Desktop with Windows OS executes around 174 times per second.
* **groupByMapBetter**: Chrome 109 on Desktop with Windows OS executes around 104 times per second.

The results indicate that the Lodash implementation is not optimized for this specific test, and the native methods are significantly faster. The `groupByMapBetter` test is also relatively slow compared to the others.

**Conclusion:**

For grouping data using Lodash, it appears that the native methods (without Lodash) are generally faster than the Lodash implementation. However, the actual performance difference may vary depending on the specific use case and requirements of your project.

Related benchmarks:

lodash groupBy vs Array.reduce 100k fair3 (version: 0)

lodash groupBy vs Array.reduce 100k fair3 smol

Comparing performance of: Lodash vs Native vs groupByReduce vs groupByReduceBetter vs groupByHasOwnProperty vs groupByMapBetter vs native direct vs native direct no copy vs groupByHasOwnPropertyCall

Created: 3 years ago by: Guest

Jump to the latest result

Lodash

Native

groupByReduce

groupByReduceBetter

groupByHasOwnProperty

groupByMapBetter

native direct

native direct no copy

groupByHasOwnPropertyCall

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):