Benchmark: keys vs values - MeasureThat.net

Script Preparation code:

var testObj = {}
for (let i = 0; i < 10000; i++) {
  const randomString = Math.random().toString(36).substr(2, 5);
  testObj[randomString] = randomString;
}

Tests:

keys
console.log(Object.keys(testObj));
values
console.log(Object.values(testObj));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
keys
values

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and considered.

**Benchmark Definition**

The benchmark is defined in two parts:

1. **Script Preparation Code**: This code creates an object `testObj` with 10,000 properties, each containing a random string as its value.
2. **Html Preparation Code**: There is no HTML preparation code provided for this benchmark, which means that the browser doesn't need to render any HTML content before running the test.

**Test Cases**

There are two individual test cases:

1. **"keys"`**:
This test case measures how long it takes to get an array of keys (i.e., property names) from the `testObj` object using `Object.keys()`.
2. **"values"`**:
This test case measures how long it takes to get an array of values from the `testObj` object using `Object.values()`.

**Comparison**

The benchmark compares two approaches:

1. **Using keys**: This approach uses `Object.keys()` to retrieve the array of keys.
2. **Using values**: This approach uses `Object.values()` to retrieve the array of values.

**Options Compared**

These options are compared in terms of execution time, which is measured in executions per second (i.e., how many times the test can be repeated in one second).

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **Using keys (`Object.keys()`)**
	+ Pros: More efficient when dealing with sparse objects or objects that contain fewer properties.
	+ Cons: May be slower for dense objects (i.e., objects with many properties).
* **Using values (`Object.values()`)**
	+ Pros: Faster for dense objects, as it doesn't require iterating over the object's keys to retrieve its properties.
	+ Cons: May be slower for sparse objects or objects that contain fewer properties.

**Library and Special JS Features**

In this benchmark:

* No libraries are used explicitly. However, the `Object` and `Array` constructors are implicitly used in the test cases.
* No special JavaScript features (e.g., async/await, promise) are used in the test code.

**Other Alternatives**

If you wanted to modify this benchmark, here are some alternative approaches you could consider:

1. Compare using other array methods, such as `Object.keys()` with a `for...of` loop or `Array.from(Object.keys(testObj))`.
2. Use a different data structure, like an array of objects, and compare the performance of getting keys or values from it.
3. Measure the performance of getting keys or values using different JavaScript engines or Node.js versions.

Keep in mind that the performance differences between these approaches may vary depending on your specific use case and JavaScript environment.

Latest run results:

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

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

Browser/OS: Chrome 102 on Windows

View result in a separate tab

Test name	Executions per second
keys	208.1 Ops/sec
values	127.8 Ops/sec

Related benchmarks:

keys vs values (version: 0)

Comparing performance of: keys vs values

Created: 3 years ago by: Guest

Jump to the latest result

keys

values

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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