Run results for: multi-order consolidateCartItems lodash vs Map

Test name	Executions per second
✓ Map (for...of)	4,431,074 Ops/sec
Map (reduce)	4,025,243 Ops/sec
lodash	1,468,710 Ops/sec
lodash (chain)	538,737 Ops/sec

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)