Benchmark: HashMapLoop - MeasureThat.net

Script Preparation code:

var a = {
    1: {
        id: 1
    },
    2: {
        id: 2
    },
    3: {
        id: 3
    }
};

function extractValues(obj) {
    const t = [];
    for (var key in obj) {
        t.push(obj[key]);
    }
    return t;
}

function extractAndFilter(obj) {
    const t = [];
    for (var key in obj) {
        if (obj[key].id > 1) {
            t.push(obj[key].name);
        }
    }
    return t;
}

Tests:

Object.values
Object.values(a).filter(model => model.id > 1).map(model => model.id)
for in
extractValues(a).filter(model => model.id > 1).map(model => model.id)
Object.entries
Object.entries(a).filter(([, model]) => model.id > 1).map(([key]) => key);
Object.keys
Object.keys(a).filter(id => a[id].id > 1).map(id => a[id].id);
extractAndFilter
extractAndFilter(a);
reduce
Object.values(a).reduce((a, b) => { if(b.id > 1) { a.push(b.name); } return a; }, [])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.values
for in
Object.entries
Object.keys
extractAndFilter
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 83 on Windows

View result in a separate tab

Test name	Executions per second
Object.values	1245204.0 Ops/sec
for in	1085662.0 Ops/sec
Object.entries	784777.8 Ops/sec
Object.keys	660472.2 Ops/sec
extractAndFilter	1225945.4 Ops/sec
reduce	1393295.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark definition for a HashMapLoop test case.

The purpose of this benchmark is to compare the performance of different approaches to extract values from an object in JavaScript. The benchmark uses a predefined object `a` with three keys, each containing an object with an `id` property.

**Test Cases**

There are six individual test cases:

1. **Object.values**: This test case extracts all values from the object `a` using the `Object.values()` method.
2. **for in**: This test case uses a traditional `for...in` loop to iterate over the keys of the object `a` and extract the corresponding values.
3. **Object.entries**: This test case extracts all key-value pairs from the object `a` using the `Object.entries()` method.
4. **Object.keys**: This test case extracts all keys from the object `a` using the `Object.keys()` method.
5. **extractAndFilter**: This test case uses a custom function `extractAndFilter()` to extract values from the object `a` based on a filter condition.
6. **reduce**: This test case uses the `Array.prototype.reduce()` method to accumulate values from the object `a` that meet a certain condition.

**Comparison of Approaches**

The benchmark compares the performance of these different approaches to extract values from an object in JavaScript:

* **Object.values()**: This approach is likely to be the fastest, as it provides direct access to the values of the object without iterating over its keys.
* **for in**: This approach can be slower than `Object.values()` due to the overhead of iterating over the keys using a loop.
* **Object.entries()**: Similar to `Object.values()`, this approach is likely to be faster, as it provides direct access to the key-value pairs of the object.
* **Object.keys()**: This approach can also be slower than `Object.values()` and `Object.entries()`, due to the overhead of iterating over the keys using a loop.
* **extractAndFilter()**: This custom function uses a filter condition to extract values from the object, which may impact performance depending on the complexity of the filter.
* **reduce()**: This approach can be slower than other methods, as it requires accumulating values in an array and then applying a reducer function.

**Pros and Cons**

Here are some pros and cons for each approach:

* **Object.values()**:
	+ Pros: Fast, direct access to object values
	+ Cons: May not work with objects that do not have enumerable properties
* **for in**:
	+ Pros: Works with any object, regardless of its properties
	+ Cons: Can be slower due to iteration overhead
* **Object.entries()**:
	+ Pros: Fast, direct access to key-value pairs
	+ Cons: May require more memory, as it creates a new array of entries
* **Object.keys()**:
	+ Pros: Works with any object, regardless of its properties
	+ Cons: Can be slower due to iteration overhead
* **extractAndFilter()**:
	+ Pros: Customizable filter condition
	+ Cons: May impact performance due to filter complexity
* **reduce()**:
	+ Pros: Accurate accumulation of values
	+ Cons: Can be slower than other methods

**Other Alternatives**

Other approaches that could be used to extract values from an object in JavaScript include:

* Using `Array.prototype.forEach()` or `Array.prototype.map()` with a callback function
* Using a library like Lodash, which provides utility functions for working with objects and arrays
* Using a framework like React or Angular, which provide built-in mechanisms for working with state and props

However, the benchmark provided by MeasureThat.net focuses on the performance of different approaches to extract values from an object in JavaScript, using a predefined object `a`.

Related benchmarks:

HashMapLoop (version: 0)

Comparing performance of: Object.values vs for in vs Object.entries vs Object.keys vs extractAndFilter vs reduce

Created: 4 years ago by: Guest

Jump to the latest result

Object.values

for in

Object.entries

Object.keys

extractAndFilter

reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):