Benchmark: Test values - MeasureThat.net

Script Preparation code:

function objectValues1(object) {
   	const t = [];
  
   	for(var key in object) {
   		t.push(object[key]);
    }
   	
  	return t;
}

function *objectValues2(object) {
	for(let property of Object.keys(object)) {
		yield object[property]
	}
}

function objectValues3(object) {
 	return Object.keys(object).map(k => object[k]) 
}

Tests:

Test 1
var a = { a: 1, b: 2, c: 3}; var b = Object.values(a); var c = b[0] + b[1] + b[2];
Test 2
var a = { a: 1, b: 2, c: 3}; var b = objectValues1(a); var c = b[0] + b[1] + b[2];
Test 3
var a = { a: 1, b: 2, c: 3}; var b = objectValues2(a); var c = b[0] + b[1] + b[2];
Test 4
var a = { a: 1, b: 2, c: 3}; var b = objectValues3(a); var c = b[0] + b[1] + b[2];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Test 1
Test 2
Test 3
Test 4

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 dive into the world of MeasureThat.net and explore what's being tested in this benchmark.

**Benchmark Definition JSON**

The provided JSON represents a JavaScript microbenchmark, which consists of two main parts:

1. **Script Preparation Code**: This section contains three functions that take an object as input and return its values:
	* `objectValues1`: A recursive function that uses a for...in loop to iterate over the object's properties and push their values into an array.
	* `objectValues2`: A generator function that yields each property value in the object using Object.keys().
	* `objectValues3`: A function that uses Array.prototype.map() to create a new array with the object's property values.
2. **Html Preparation Code**: This section is empty, which means no HTML code is required for the benchmark.

**Individual Test Cases**

Each test case represents a specific scenario where one of the above functions (`objectValues1`, `objectValues2`, or `objectValues3`) is called to extract the object's values and then performs an arithmetic operation on those values. The test cases are:

1. **Test 1**: Uses `Object.values()` to get the object's property values and then calculates their sum.
2. **Test 2**: Uses `objectValues1` to get the object's property values, which is a custom implementation that uses recursion.
3. **Test 3**: Uses `objectValues2` to get the object's property values using Object.keys().
4. **Test 4**: Uses `objectValues3` to get the object's property values and then calculates their sum.

**Options Compared**

The main options being compared in this benchmark are:

* Using built-in methods (`Object.values()`) vs. custom implementations (`objectValues1`, `objectValues2`, and `objectValues3`)
* Recursion (in `objectValues1`) vs. iteration (in `objectValues2` and `objectValues3`)

**Pros and Cons**

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

* **Built-in methods (`Object.values()`)**:
	+ Pros: Fast, widely supported, and easy to use.
	+ Cons: May not be as efficient as custom implementations in certain situations.
* **Custom implementations (e.g., `objectValues1`)**:
	+ Pros: Can provide better performance or control over the iteration process.
	+ Cons: May be slower due to overhead of recursive function calls, and requires more code.

**Library: Object**

Object is a built-in JavaScript object that provides several useful methods for working with objects. In this benchmark, `Object.values()` is used to get an array of an object's property values.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntaxes mentioned in the provided code snippets.

**Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

* Using other built-in methods (e.g., `Object.keys()` and Array.prototype.forEach()) to extract object property values.
* Implementing custom iteration logic using iterators or closures.
* Optimizing performance using techniques like memoization or caching.

Keep in mind that these alternatives might not provide significant benefits for this specific benchmark, as the focus is on comparing different methods of extracting object property values.

Related benchmarks:

Test values (version: 0)

Test values

Comparing performance of: Test 1 vs Test 2 vs Test 3 vs Test 4

Created: 6 years ago by: Guest

Jump to the latest result

Test 1

Test 2

Test 3

Test 4

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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