Benchmark: Object values vs _.values vs polyfill vs map polyfill

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.core.js"></script>
<script>
const reduce = Function.bind.call(Function.call, Array.prototype.reduce);
const isEnumerable = Function.bind.call(Function.call, Object.prototype.propertyIsEnumerable);
const concat = Function.bind.call(Function.call, Array.prototype.concat);
const keys = Reflect.ownKeys;
  
if (!Object.valuess) {
	Object.valuess = function values(O) {
		return reduce(keys(O), (v, k) => concat(v, typeof k === 'string' && isEnumerable(O, k) ? [O[k]] : []), []);
	};
}
if (!Object.valuesmap) {
	Object.valuesmap = function(obj) {return Object.keys(obj).map(function(e) {return obj[e];});};
}
</script>

Script Preparation code:

var a = { a: 1, b: 2, c: 3};

Tests:

_.values
_.values(a);
Object values
Object.values(a);
proposal-object-values-entries/polyfill.js
Object.valuess(a);
polyfill with map
Object.valuesmap(a);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.values
Object values
proposal-object-values-entries/polyfill.js
polyfill with map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark measures the performance of different approaches to retrieve object values. There are four test cases:

1. `_.values(a)`
2. `Object.values(a)`
3. `Object.valuess(a)` (a polyfill for the proposed "object-values-entries" feature)
4. `Object.valuesmap(a)` (a polyfill with the addition of map functionality)

**Options Compared**

Each test case uses a different approach to retrieve object values:

1. **_.values(a)**: Uses Lodash's `_values` function, which is a utility function that returns an array of values from an object.
2. **Object.values(a)**: Uses the built-in `Object.values()` method (introduced in ECMAScript 2019), which returns an array of values from an object.
3. **Object.valuess(a)**: A polyfill implementation, which uses a recursive function to traverse the object's prototype chain and retrieve values.
4. **Object.valuesmap(a)**: Another polyfill implementation that not only retrieves values but also adds map functionality.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **_.values(a)**:
	* Pros: Simple, efficient, and well-tested in Lodash.
	* Cons: Requires Lodash library to be included, which may add overhead.
2. **Object.values(a)**:
	* Pros: Built-in method, no external dependencies required.
	* Cons: Introduced in ECMAScript 2019, may not support older browsers or environments.
3. **Object.valuess(a)**:
	* Pros: Polyfill implementation that supports older browsers and environments.
	* Cons: Recursive function can be slower than native methods.
4. **Object.valuesmap(a)**:
	* Pros: Adds map functionality to the polyfill, making it more versatile.
	* Cons: Additional complexity and potential performance impact.

**Library and Syntax**

The benchmark uses Lodash (version 4.17.5) as a utility library for the `_values` function. There is no specific JavaScript feature or syntax used in this benchmark. However, it's worth noting that `Object.values()` was introduced in ECMAScript 2019, which may be supported in newer browsers and environments.

**Other Alternatives**

If you need to implement an object values retrieval mechanism without using a library like Lodash, you could consider the following alternatives:

1. **Using `for...in` loop**: Iterate over the object's properties using a `for...in` loop and store the values in an array.
2. **Using `Object.keys()` and indexing**: Use `Object.keys()` to get an array of property names, then use indexing to access and retrieve the corresponding values.
3. **Implementing a custom recursive function**: Write a custom recursive function that traverses the object's prototype chain and retrieves values.

These alternatives may have different performance characteristics and trade-offs compared to using a library like Lodash or built-in methods like `Object.values()`.

Latest run results:

Run details: (Test run date: 16 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Windows

View result in a separate tab

Test name	Executions per second
_.values	5100062.0 Ops/sec
Object values	23584350.0 Ops/sec
proposal-object-values-entries/polyfill.js	1486865.0 Ops/sec
polyfill with map	12231240.0 Ops/sec

Related benchmarks:

Object values vs _.values vs polyfill vs map polyfill (version: 0)

Comparing performance of: _.values vs Object values vs proposal-object-values-entries/polyfill.js vs polyfill with map

Created: 16 days ago by: Guest

Jump to the latest result

_.values

Object values

proposal-object-values-entries/polyfill.js

polyfill with map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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