Benchmark: Object merging with spread operator

Script Preparation code:

function standard(oCol = {}) {
	return validate(oCol, 1, 2);
}        


function validate(oCol = {}, one, two) {
            const obj = {
              one: one,
			  two: two
            };
            return { ...oCol, ...obj };
        }

Tests:

empty obj
const empty = {}; const mergable = { one: 1, two: 2 }; const merged = { ...empty, ...mergable };
non empty obj
const nonEmpty = { zero: 0 }; const mergable = { one: 1, two: 2 }; const merged = { ...nonEmpty, ...mergable };
test 1
const obj = { zero: 0, ...standard() }
test 2
const obj = standard({ zero: 0 })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
empty obj
non empty obj
test 1
test 2

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 world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark measures how efficient different browsers and devices are when performing object merging using the spread operator. Here's a breakdown of what's being tested:

**Benchmark Definition:**

The benchmark definition is a simple JavaScript function `standard` that takes an optional object `oCol` as input. If `oCol` is not provided, it defaults to an empty object `{}`. The function returns the result of merging `oCol` with another object containing two properties (`one` and `two`) using the spread operator (`{ ...oCol, ...obj }`).

**Options being compared:**

There are three test cases that compare different scenarios:

1. **Empty object (`empty obj`):** The benchmark tests how quickly an empty object can be merged with another object.
2. **Non-empty object (`non empty obj`):** This test case merges a non-empty object with another object containing two properties.
3. **Object initialization using `standard()`:** The third test case creates an object by calling the `standard()` function, which returns an object with default values.

**Pros and Cons of different approaches:**

1. **Empty object (`empty obj`):**
	* Pros: Simple and straightforward test case.
	* Cons: May not accurately represent real-world usage, as empty objects are rare.
2. **Non-empty object (`non empty obj`):**
	* Pros: More representative of real-world usage, where objects often contain data.
	* Cons: Requires more complex logic to handle the merging process.
3. **Object initialization using `standard()`:**
	* Pros: Tests object creation and merging in a single step.
	* Cons: May introduce unnecessary overhead due to function call and object creation.

**Library usage:**

The benchmark uses no external libraries, making it a bare-metal JavaScript test.

**Special JS features or syntax:**

There is no special JS feature or syntax used in this benchmark. The code relies on standard JavaScript syntax for object merging using the spread operator.

**Other alternatives:**

MeasureThat.net also provides other benchmarks that compare different JavaScript engines and browsers, such as:

* Array operations (e.g., `push`, `pop`, `splice`)
* String operations (e.g., concatenation, substring extraction)
* Function calls and invocations
* Object property access and iteration

These alternative benchmarks can provide a more comprehensive view of a JavaScript engine's performance characteristics.

Related benchmarks:

Object merging with spread operator (version: 0)

Comparing performance of: empty obj vs non empty obj vs test 1 vs test 2

Created: 6 years ago by: Guest

Jump to the latest result

empty obj

non empty obj

test 1

test 2

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):