Benchmark: multi-order consolidateCartItems lodash vs Map

HTML Preparation code:

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

Script Preparation code:

var body = {
      items: [
        {
          goodsCode: 'A',
          quantity: 1,
          options: [
            {
              goodsCode: 'X',
              quantity: 1,
              options: [
                {
                  goodsCode: 'Z',
                  quantity: 2,
                },
              ],
            },
          ],
        },
        {
          goodsCode: 'A',
          quantity: 2,
          options: [
            {
              goodsCode: 'X',
              quantity: 2,
              options: [
                {
                  goodsCode: 'Z',
                  quantity: 3,
                },
              ],
            },
          ],
        },
      ],
    }

Tests:

Map (reduce)
function consolidateCartItems({ items }) { const uniqItemsMap = items.reduce((acc, item) => { const prevItem = acc.get(item.goodsCode); if (prevItem) { const options = (prevItem.options ?? []).concat(item?.options ?? []); const hasOptions = options.length > 0; const newItem = { ...prevItem, quantity: prevItem.quantity + item.quantity, }; if (hasOptions) { newItem.options = consolidateCartItems({ items: options }); } acc.set(item.goodsCode, newItem); } else { acc.set(item.goodsCode, item); } return acc; }, new Map()); return [...uniqItemsMap.values()]; } consolidateCartItems(body)
Map (for...of)
function consolidateCartItems({ items }) { const map = new Map(); for (const item of items) { const key = item.goodsCode; const existing = map.get(key); if (existing) { existing.quantity += item.quantity; const mergedOptions = (existing.options ?? []).concat(item.options ?? []); if (mergedOptions.length > 0) { existing.options = consolidateCartItems({ items: mergedOptions }); } } else { map.set(key, { ...item }); } } return [...map.values()]; } consolidateCartItems(body)
lodash
function consolidateCartItems({ items }) { const grouped = _.groupBy(items, 'goodsCode'); return Object.entries(grouped).map(([goodsCode, group]) => { const totalQuantity = _.sumBy(group, 'quantity'); const allOptions = group.flatMap((item) => item.options ?? []); const mergedOptions = allOptions.length > 0 ? consolidateCartItems({ items: allOptions }) : undefined; const result = { goodsCode, quantity: totalQuantity }; if (mergedOptions?.length) result.options = mergedOptions; return result; }); } consolidateCartItems(body)
lodash (chain)
function consolidateCartItems({ items }) { return ( _.chain(items) .groupBy('goodsCode') .map((group, goodsCode) => { const quantity = _.sumBy(group, 'quantity'); const mergedOptions = _.chain(group) .flatMap('options') .filter(Boolean) .thru((opts) => opts.length > 0 ? consolidateCartItems({ items: opts }) : undefined, ) .value(); return { goodsCode, quantity, ...(mergedOptions ? { options: mergedOptions } : {}), }; }) .value() ); } consolidateCartItems(body)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map (reduce)
Map (for...of)
lodash
lodash (chain)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Map (reduce)	4025243.2 Ops/sec
Map (for...of)	4431074.0 Ops/sec
lodash	1468709.8 Ops/sec
lodash (chain)	538737.3 Ops/sec

Related benchmarks:

multi-order consolidateCartItems lodash vs Map (version: 1)

Comparing performance of: Map (reduce) vs Map (for...of) vs lodash vs lodash (chain)

Created: one year ago by: Registered User

Jump to the latest result

Map (reduce)

Map (for...of)

lodash

lodash (chain)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A