Benchmark: getListOfPropertyValues Comparation

Script Preparation code:

var arr = [];
for (var i = 0; i < 1000; i++) {
    arr[i] = {
        id: i
    };
}

Tests:

For
const getListOfPropertyValues = (objectsArray, propertyName) => { let mappedList = []; for (const object of objectsArray || []) { if (propertyName in object) mappedList.push(object[propertyName]); } return mappedList; }; getListOfPropertyValues(arr, 'id');
Map, Filter
const getListOfPropertyValues = (array = [], prop) => array.map(item => item[prop]).filter(item => item); getListOfPropertyValues(arr, 'id');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For
Map, Filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
For	186128.5 Ops/sec
Map, Filter	134026.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases to understand what's being tested.

**Benchmark Overview**

The benchmark measures the performance of two approaches for extracting property values from an array of objects. The goal is to compare the execution speed of these two methods.

**Script Preparation Code**

The script preparation code creates an empty array `arr` with 1000 elements, each containing a single property `id`.

```javascript
var arr = [];
for (var i = 0; i < 1000; i++) {
    arr[i] = {
        id: i
    };
}
```

This code is executed before running the test cases to ensure a consistent environment.

**Html Preparation Code**

The html preparation code is empty, indicating that no HTML-related code or setup is required for this benchmark.

**Test Cases**

There are two test cases:

1. **For**
```javascript
const getListOfPropertyValues = (objectsArray, propertyName) => {
    let mappedList = [];
    for (const object of objectsArray || []) {
        if (propertyName in object) mappedList.push(object[propertyName]);
    }
    return mappedList;
};
getListOfPropertyValues(arr, 'id');
```

This implementation uses a traditional `for` loop to iterate over the array and extract the desired property values.

2. **Map, Filter**
```javascript
const getListOfPropertyValues = (array = [], prop) => array.map(item => item[prop]).filter(item => item);
getListOfPropertyValues(arr, 'id');
```

This implementation uses the `map` and `filter` Array methods to extract the desired property values in a more concise way.

**Library Usage**

There is no explicit library usage mentioned in this benchmark. However, it's worth noting that the `map` and `filter` methods are built-in JavaScript methods, not part of any external library.

**Special JS Features/Syntax**

The benchmark uses:

* **Arrow functions**: The test cases use arrow functions (`=>`) to define small, anonymous functions. This is a modern JavaScript feature introduced in ECMAScript 2015.
* **Template literals**: The script preparation code uses template literals (`\r\n` and `'\n'`) for multiline string formatting.

**Pros and Cons of Each Approach**

1. **For**
	* Pros:
		+ Easy to understand and maintain
		+ No overhead from Array methods
	* Cons:
		+ More verbose than using Array methods
		+ Can be slower due to the loop iteration
2. **Map, Filter**
	* Pros:
		+ Concise and expressive code
		+ Built-in performance optimizations
	* Cons:
		+ May have higher overhead due to Array method calls

**Other Alternatives**

If you were looking for alternative approaches, here are a few:

1. **Using `forEach`**: Instead of using `map` and `filter`, you could use the `forEach` method in combination with `push` and `item` variables.
2. **Using a custom loop**: You could implement a custom loop using a variable that increments on each iteration, rather than relying on the built-in `for` loop.

Keep in mind that these alternatives might not provide significant performance improvements over the `map` and `filter` methods used in this benchmark.

Related benchmarks:

getListOfPropertyValues Comparation (version: 1)

Comparing performance of: For vs Map, Filter

Created: 3 years ago by: Registered User

Jump to the latest result

For

Map, Filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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