Run results for: Lazy array chains: no benefit for simple non-stupid ops

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:134.0) Gecko/20100101 Firefox/134.0

Browser: Firefox 134

Operating system: Mac OS X 10.15

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
array method chain (1000 items)	11413.1 Ops/sec
lazy chain (1000 items)	11226.6 Ops/sec
array method chain (10000 items)	1068.6 Ops/sec
lazy chain (10000 items)	1067.4 Ops/sec
array method chain (100000 items)	58.6 Ops/sec
lazy chain (100000 items)	52.8 Ops/sec
array method chain with 2 filters - stupid! (1000 items)	16150.1 Ops/sec
lazy chain with 2 filters (1000 items)	17254.6 Ops/sec
array method chain with 2 filters - stupid! (10000 items)	1695.3 Ops/sec
lazy chain with 2 filters (10000 items)	1723.0 Ops/sec

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
<script src='https://cdn.jsdelivr.net/g/lodash@4(lodash.min.js+lodash.fp.min.js)'></script><!--your preparation HTML code goes here-->

Script Preparation code:

const LCG = (s) => () => (s = (48271 * s) % 2147483647) / 2147483647;
const rand = LCG(123);
const dataS = Array.from({length: 1000}, () => ({ a: rand() > 0.5 ? 'abcd' : 'abcdefg', b: 50 * rand(), c: ['an', 'array'] }));
const dataM = Array.from({length: 10000}, () => ({ a: rand() > 0.5 ? 'abcd' : 'abcdefg', b: 50 * rand(), c: ['an', 'array'] }));
const dataL = Array.from({length: 100000}, () => ({ a: rand() > 0.5 ? 'abcd' : 'abcdefg', b: 50 * rand(), c: ['an', 'array'] }));

const filterFn = data => data.a === 'abcdefg';
const filterFn2 = data => data.b < 25;
const mapFn = data => ({...data, d: [...data.c, data.b.toString()]});

Tests:

array method chain (1000 items)
const mapped = dataS.filter(filterFn).map(mapFn);
lazy chain (1000 items)
const mapped = _.chain(dataS).filter(filterFn).map(mapFn).value();
array method chain (10000 items)
const mapped = dataM.filter(filterFn).map(mapFn);
lazy chain (10000 items)
const mapped = _.chain(dataM).filter(filterFn).map(mapFn).value();
array method chain (100000 items)
const mapped = dataL.filter(filterFn).map(mapFn);
lazy chain (100000 items)
const mapped = _.chain(dataL).filter(filterFn).map(mapFn).value();
array method chain with 2 filters - stupid! (1000 items)
const mapped = dataS.filter(filterFn).filter(filterFn2).map(mapFn);
lazy chain with 2 filters (1000 items)
const mapped = _.chain(dataS).filter(filterFn).filter(filterFn2).map(mapFn).value();
array method chain with 2 filters - stupid! (10000 items)
const mapped = dataM.filter(filterFn).filter(filterFn2).map(mapFn);
lazy chain with 2 filters (10000 items)
const mapped = _.chain(dataM).filter(filterFn).filter(filterFn2).map(mapFn).value();

Run results for: Lazy array chains: no benefit for simple non-stupid ops

array method chain (1000 items)

lazy chain (1000 items)

array method chain (10000 items)

lazy chain (10000 items)

array method chain (100000 items)

lazy chain (100000 items)

array method chain with 2 filters - stupid! (1000 items)

lazy chain with 2 filters (1000 items)

array method chain with 2 filters - stupid! (10000 items)

lazy chain with 2 filters (10000 items)