Benchmark: Object.keys partial assign vs Spread Operator

Object.keys partial assign vs Spread Operator (version: 0)

Verify if is worth using object keys to get keys of a given object, that have some properties of another one, to assign to another object or just use spread operator modify the object partially.

Comparing performance of: Using Object keys and modifying the original object vs Using spread to merge objects vs Manually editing every single property (Wanna have this to prove why sometimes there is a manual assign for each property required)

Created: 3 years ago by: Guest

Jump to the latest result

Script Preparation code:

var voucher = {
    "single": false,
    "applyOverTaxes": false,
    "discountType": "1",
    "value": 100,
    "minimumAmount": 0,
    "quantity": 1,
    "suffixLength": 8,
    "code": "IF5R0AFX",
    "vertical": [],
    "allowedPaymentMethods": [],
    "allowedBanks": [],
    "types": [],
    "partners": [],
    "startDate": "2020-10-21T00:00:00.000Z",
    "endDate": "2020-10-21T00:00:00.000Z",
    "applyed": false
}

var voucherQuantityAndPriceUpdated = {
    value: 120,
    quantity: 10
}

Tests:

Using Object keys and modifying the original object
const keysOfObjectWithUpdatedData = Object.keys(voucherQuantityAndPriceUpdated) for (key of keysOfObjectWithUpdatedData) { const updatedPropertyValue = voucher[key] = voucherQuantityAndPriceUpdated[key] }
Using spread to merge objects
const voucherUpdated = { ...voucher, ...voucherQuantityAndPriceUpdated }
Manually editing every single property (Wanna have this to prove why sometimes there is a manual assign for each property required)
voucher.value = voucherQuantityAndPriceUpdated.value voucher.quantity = voucherQuantityAndPriceUpdated.quantity

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using Object keys and modifying the original object
Using spread to merge objects
Manually editing every single property (Wanna have this to prove why sometimes there is a manual assign for each property required)

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 break down the provided benchmark.

**Benchmark Description**

The benchmark is designed to compare three approaches for partially assigning properties from one object to another:

1. Using `Object.keys()` to get keys of an object and then iterating over those keys to assign values.
2. Using the spread operator (`...`) to merge two objects.
3. Manually editing every single property.

**What is being tested?**

The benchmark tests which approach is faster, assuming that the size of the `voucher` and `voucherQuantityAndPriceUpdated` objects are fixed.

**Options Compared**

1. **Using `Object.keys()`**: This method iterates over the keys of the `voucher` object using a `for...of` loop and then assigns values from `voucherQuantityAndPriceUpdated` to each key in the original object.
2. **Using spread operator (`...`)**: This method creates a new object that is a copy of `voucher`, and then merges `voucherQuantityAndPriceUpdated` into this new object using the spread operator.
3. **Manually editing every single property**: This approach involves assigning individual properties from `voucherQuantityAndPriceUpdated` to corresponding keys in `voucher`.

**Pros and Cons**

1. **Using `Object.keys()`**:
	* Pros: Simple and easy to understand, can be used for arbitrary objects.
	* Cons: May be slower than other approaches due to the overhead of iterating over keys.
2. **Using spread operator (`...`)**:
	* Pros: Concise and efficient, creates a new object that is a copy of `voucher`.
	* Cons: May not work as expected if `voucher` has complex properties or if the order of properties matters.
3. **Manually editing every single property**:
	* Pros: Can be faster for small objects, allows for direct assignment.
	* Cons: Requires explicit loops and assignments, can lead to errors if not done correctly.

**Library/Functionality**

None mentioned in this benchmark definition. The benchmark focuses on comparing different approaches rather than utilizing external libraries or functions.

**Special JS Feature/Syntax**

No special JavaScript features or syntax are used in this benchmark. All code is standard JavaScript.

**Other Considerations**

* The benchmark assumes that the size of the `voucher` and `voucherQuantityAndPriceUpdated` objects is fixed, which may not be the case in all scenarios.
* The benchmark only compares three approaches, so other optimizations or techniques may not be tested.

**Alternatives**

* Other methods for partially assigning properties from one object to another might include using `Object.assign()`, creating a new object with `Object.create()` and then assigning values, or using a library like Lodash.
* Additional optimization techniques might involve caching results, memoizing expensive operations, or optimizing data structures used in the benchmark.

Related benchmarks: