Benchmark: map-values - MeasureThat.net

map-values (version: 13)

Comparing performance of: Reduce + spread vs Loop (for...in) with .keys() vs Loop (for...in) with .entries() vs Reduce + mutate vs Reduce + mutate with entries() vs Map with fromEntries vs Loop (for...in) with mutate vs Loop (for...in) with mutate (Object.assign) vs Loop (for...in) with mutate (save object[key]) vs Loop (for...in) with unsafe mutate vs Object.fromEntries with map

Created: one year ago by: Registered User

Jump to the latest result

Script Preparation code:

fn = (val, key) => val.toString()
obj = Object.fromEntries([...Array(10000)].map((v, i) => ([i+1, i+1])))

Tests:

Reduce + spread
const keys = Object.keys(obj); return keys.reduce((carry, key) => ({ ...carry, [key]: fn(obj[key], key) }), {});
Loop (for...in) with .keys()
const keys = Object.keys(obj); let result = {}; for (let key of keys) { result[key] = fn(obj[key], key); } return result;
Loop (for...in) with .entries()
const entries = Object.entries(obj); let result = {}; for (let [key, value] of entries) { result[key] = fn(value, key); } return result;
Reduce + mutate
const keys = Object.keys(obj); return keys.reduce((carry, key) => (carry[key] = fn(obj[key], key)), {});
Reduce + mutate with entries()
const entries = Object.entries(obj); return entries.reduce((carry, [key, value]) => (carry[key] = fn(value, key)), {});
Map with fromEntries
Object.fromEntries( Object.entries(obj).map(([key, value]) => [key, fn(value, key)]) )
Loop (for...in) with mutate
const result = { ...obj }; for (const key in result) { if (result[key]) { result[key] = fn(result[key], key); } }
Loop (for...in) with mutate (Object.assign)
const result = Object.assign({}, obj); for (const key in result) { if (result[key]) { result[key] = fn(result[key], key); } }
Loop (for...in) with mutate (save object[key])
const result = { ...obj }; for (const key in result) { const value = result[key] if (result[key]) { result[key] = fn(result[key], key); } }
Loop (for...in) with unsafe mutate
for (const key in obj) { if (obj[key]) { obj[key] = fn(obj[key], key); } }
Object.fromEntries with map
Object.fromEntries(Object.entries(obj).map(([key, value]) => { return [key, fn(value, key)]; }));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce + spread
Loop (for...in) with .keys()
Loop (for...in) with .entries()
Reduce + mutate
Reduce + mutate with entries()
Map with fromEntries
Loop (for...in) with mutate
Loop (for...in) with mutate (Object.assign)
Loop (for...in) with mutate (save object[key])
Loop (for...in) with unsafe mutate
Object.fromEntries with map

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

To analyze the data, I'll focus on the test results.

**Summary**

The dataset appears to be from tests related to JavaScript loops and array methods. It provides information about browser versions, operating systems, device platforms, and execution frequencies per second for various tests.

**Key Observations**

1. **Browser**: The majority of tests are run on Chrome 112, with a few tests also running on earlier versions.
2. **Device Platform**: Most tests are run on Desktop (Windows) devices.
3. **Operating System**: Windows is the dominant operating system used in these tests.
4. **Execution Frequencies**: The execution frequencies per second vary widely across different tests, ranging from around 50 to over 700.

**Test Results**

To get a better understanding of the test results, I can try to extract more information about each test. For example:

* Which specific array methods or loops are being tested?
* Are there any notable differences in execution frequencies between Chrome versions or other browsers?

However, without more context or specific details about each test, it's challenging to provide a deeper analysis.

**Questions**

If you'd like me to dig deeper into the data or explore specific aspects of these tests, please let me know! Some potential questions I can help with include:

* How do different browser versions and operating systems affect execution frequencies?
* Are there any correlations between test results and array method/loop complexity?
* Can we identify any trends or patterns in the execution frequencies across different tests?

Feel free to provide more context, and I'll be happy to assist!

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36

Browser/OS: Chrome 112 on Windows

View result in a separate tab

Test name	Executions per second
Reduce + spread	65.5 Ops/sec
Loop (for...in) with .keys()	393.1 Ops/sec
Loop (for...in) with .entries()	672.3 Ops/sec
Reduce + mutate	231.9 Ops/sec
Reduce + mutate with entries()	291.8 Ops/sec
Map with fromEntries	536.7 Ops/sec
Loop (for...in) with mutate	874.4 Ops/sec
Loop (for...in) with mutate (Object.assign)	411.2 Ops/sec
Loop (for...in) with mutate (save object[key])	874.6 Ops/sec
Loop (for...in) with unsafe mutate	278.5 Ops/sec
Object.fromEntries with map	529.6 Ops/sec

Related benchmarks:

map-values (version: 13)

Created: one year ago by: Registered User

Jump to the latest result

Reduce + spread

Loop (for...in) with .keys()

Loop (for...in) with .entries()

Reduce + mutate

Reduce + mutate with entries()

Map with fromEntries

Loop (for...in) with mutate

Loop (for...in) with mutate (Object.assign)

Loop (for...in) with mutate (save object[key])

Loop (for...in) with unsafe mutate

Object.fromEntries with map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):