Benchmark: Performance of Object.values(obj) vs_.values() vs for...in to extract values from an object with 1000 entries-3

Performance of Object.values(obj) vs_.values() vs for...in to extract values from an object with 1000 entries-3 (version: 0)

Compare performance between the native Object.values(obj) function vs the lodash _.values() option and a function that extracts the values of an object using a for...in loop.

Comparing performance of: Object.values(obj) vs _.values(obj) vs for...in vs Object.keys(obj).map(key => obj[key])

Created: 4 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.core.js"></script>

AخA
 
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.core.js"></script>

Script Preparation code:

function extractValues(obj) {
   const t = [];
   for(var key in obj) { t.push(obj[key]); }
   return t;
}

 
function extractValues(obj) {   const t = [];   for(var key in obj) { t.push(obj[key]); }   return t;}

Tests:

Object.values(obj)
var i; var a = {}; for (i = 0; i < 1000; i++) { a[i + ""] = i + "text"; } Object.values(a);
x

var i;
var a = {};

for (i = 0; i < 1000; i++) {
a[i + ""] = i + "text";
}

Object.values(a);

_.values(obj)

var i;
var a = {};

for (i = 0; i < 1000; i++) {
  a[i + ""] = i + "text";
}

_.values(a);

 
var i;var a = {};​for (i = 0; i < 1000; i++) {  a[i + ""] = i + "text";}​_.values(a);

for...in

var i;
var a = {};

for (i = 0; i < 1000; i++) {
  a[i + ""] = i + "text";
}

extractValues(a);

 
var i;var a = {};​for (i = 0; i < 1000; i++) {  a[i + ""] = i + "text";}​extractValues(a);

Object.keys(obj).map(key => obj[key])
var i; var a = {}; for (i = 0; i < 1000; i++) { a[i + ""] = i + "text"; } Object.keys(a).map(key => a[key]);
var i;
var a = {};

for (i = 0; i < 1000; i++) {
a[i + ""] = i + "text";
}

Object.keys(a).map(key => a[key]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Object.values(obj)
_.values(obj)
for...in
Object.keys(obj).map(key => obj[key])

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/84.0.4147.135 Safari/537.36

Browser/OS: Chrome 84 on Windows

View result in a separate tab

Test name	Executions per second
Object.values(obj)	21060.3 Ops/sec
_.values(obj)	12955.6 Ops/sec
for...in	11866.5 Ops/sec
Object.keys(obj).map(key => obj[key])	13446.3 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 4 months ago):

Let's break down the provided benchmark and its components.

Benchmark Overview

The benchmark compares the performance of three different approaches to extract values from an object with 1000 entries:

Object.values(obj)
_values(obj) (using the Lodash library)
A custom function using a for...in loop (extractValues(a))
Another approach that uses Object.keys(obj).map(key => obj[key])

Options Compared

The benchmark compares the performance of:

Two built-in JavaScript functions: Object.values() and Object.keys().map()
A third-party library function: _values() from Lodash
A custom implementation using a for...in loop

Pros and Cons of Each Approach

Object.values(obj): This is the most straightforward approach, as it's a native JavaScript method that directly returns an array of object values.
- Pros: Simple, efficient, and widely supported.
- Cons: May not be suitable for all use cases (e.g., when iterating over objects with non-enumerable properties).
_values() from Lodash: This approach uses a third-party library to provide an alternative implementation of the value extraction process.
- Pros: Can handle edge cases more robustly than the native Object.values() method.
- Cons: Adds dependencies and potential performance overhead due to the use of a library.
Custom extractValues(a): This approach uses a manual implementation of the value extraction process using a for...in loop.
- Pros: Allows for fine-grained control over the iteration process, which can be beneficial in certain scenarios.
- Cons: May be less efficient than the native Object.values() method and introduces additional complexity.

Other Considerations

The benchmark uses a large number of iterations (1000 entries) to ensure that performance differences are visible.
The test cases cover different use cases, including iterating over an object with non-enumerable properties using Object.keys().map().
The benchmark results provide insight into the relative performance of each approach on modern hardware.

Library and Syntax

The benchmark uses the Lodash library to provide the _values() function. Lodash is a popular utility library that provides a wide range of functions for common tasks, such as array manipulation, object modification, and more.

There are no special JavaScript features or syntax used in this benchmark beyond what's already discussed.

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its components.

**Benchmark Overview**

The benchmark compares the performance of three different approaches to extract values from an object with 1000 entries:

1. `Object.values(obj)`
2. `_values(obj)` (using the Lodash library)
3. A custom function using a `for...in` loop (`extractValues(a)`)
4. Another approach that uses `Object.keys(obj).map(key => obj[key])`

**Options Compared**

The benchmark compares the performance of:

* Two built-in JavaScript functions: `Object.values()` and `Object.keys().map()`
* A third-party library function: `_values()` from Lodash
* A custom implementation using a `for...in` loop

**Pros and Cons of Each Approach**

1. **`Object.values(obj)`**: This is the most straightforward approach, as it's a native JavaScript method that directly returns an array of object values.
	* Pros: Simple, efficient, and widely supported.
	* Cons: May not be suitable for all use cases (e.g., when iterating over objects with non-enumerable properties).
2. **`_values() from Lodash`**: This approach uses a third-party library to provide an alternative implementation of the value extraction process.
	* Pros: Can handle edge cases more robustly than the native `Object.values()` method.
	* Cons: Adds dependencies and potential performance overhead due to the use of a library.
3. **Custom `extractValues(a)`**: This approach uses a manual implementation of the value extraction process using a `for...in` loop.
	* Pros: Allows for fine-grained control over the iteration process, which can be beneficial in certain scenarios.
	* Cons: May be less efficient than the native `Object.values()` method and introduces additional complexity.

**Other Considerations**

* The benchmark uses a large number of iterations (1000 entries) to ensure that performance differences are visible.
* The test cases cover different use cases, including iterating over an object with non-enumerable properties using `Object.keys().map()`.
* The benchmark results provide insight into the relative performance of each approach on modern hardware.

**Library and Syntax**

The benchmark uses the Lodash library to provide the `_values()` function. Lodash is a popular utility library that provides a wide range of functions for common tasks, such as array manipulation, object modification, and more.

There are no special JavaScript features or syntax used in this benchmark beyond what's already discussed.

Related benchmarks: