Benchmark: Performance of Object.values(obj) vs_.values() vs for...in to extract values from an object Andrey

Performance of Object.values(obj) vs_.values() vs for...in to extract values from an object Andrey (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 for...in number

Created: 5 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>

Script Preparation code:

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

Tests:

Object.values(obj)
var a = { 1: 1, 2: 2, 3: 3}; Object.values(a);
_.values(obj)
var a = { 1: 1, 2: 2, 3: 3}; _.values(a);
for...in
var a = { 1: 1, 2: 2, 3: 3}; extractValues(a);
for...in number
var a = { 1: 1, 2: 2, 3: 3}; extractValuesNumver(a);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.values(obj)
_.values(obj)
for...in
for...in number

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 benchmark and its components.

**Benchmark Definition**

The benchmark is designed to compare the performance of three different approaches to extract values from an object:

1. `Object.values(obj)`: A native JavaScript function that returns an array of values from an object.
2. `_values()` (Lodash): A function from the popular utility library Lodash, which provides a more convenient way to achieve the same result as `Object.values()`.
3. `for...in` loop: A traditional approach using a loop to iterate over the keys of the object and push them into an array.

**Options Compared**

The benchmark compares the performance of these three approaches:

* `Object.values(obj)` vs `_values()` (Lodash)
* `Object.values(obj)` vs `for...in`
* `Object.values(obj)` vs `for...in` with numeric values

**Pros and Cons of Each Approach**

1. **Native `Object.values(obj)`**:
	* Pros: Fast, lightweight, and widely supported.
	* Cons: May not be suitable for all use cases (e.g., when the object has a large number of keys or complex data structures).
2. **Lodash `_values()`**:
	* Pros: Convenient, readable code, and well-maintained library with good performance.
	* Cons: Adds an external dependency to the test (in this case, Lodash), which may not be desirable for all users.
3. **`for...in` loop**:
	* Pros: Flexible, can be adapted to specific use cases, and no external dependencies required.
	* Cons: Can be slower than native functions like `Object.values(obj)` due to the overhead of iteration.

**Library Used**

In this benchmark, Lodash is used as a library to provide the `_values()` function. Lodash is a popular utility library that provides many useful functions for tasks such as data manipulation, string manipulation, and more.

**Special JS Features or Syntax**

None mentioned in the provided code snippet, but it's worth noting that the use of `for...in` loop may require special handling for objects with non-enumerable properties (e.g., symbols). However, this is not explicitly handled in the benchmark code.

**Other Alternatives**

If you need to extract values from an object, other alternatives to these approaches include:

* Using `Object.keys()` and `map()` functions: `Object.keys(obj).map(key => obj[key])`
* Using a library like jQuery (which provides similar functionality as Lodash)
* Implementing your own custom solution using recursion or other iteration methods

In summary, this benchmark compares the performance of three approaches to extract values from an object: native JavaScript functions (`Object.values()`), Lodash function (`_values()`), and a traditional `for...in` loop. Each approach has its pros and cons, and understanding these trade-offs can help you choose the best solution for your specific use case.

Related benchmarks: