Benchmark: Temp123 - MeasureThat.net

Script Preparation code:

window.FOO = [
    'Detached House',
    'Detached Property',
    'Semi-Detached House',
    'Semi-Detached Property',
    'End Terrace House',
    'End Terrace Property',
    'Mid Terrace House',
    'Mid Terrace Property',
    'Terrace Property',
    'Terraced',
    'Converted Flat',
    'Flat/Maisonette',
    'Purpose Built Flat',
    'Bungalow Property',
    'Detached Bungalow',
    'End Terrace Bungalow',
    'Mid Terrace Bungalow',
    'Semi-Detached Bungalow',
    'Terraced Bungalow',
    'barn_conversion',
    'cottage',
    'country_house',
    'detached',
    'farmhouse',
    'link_detached',
    'lodge',
    'semi_detached',
    'end_terrace',
    'mews',
    'terraced',
    'town_house',
    'flat',
    'maisonette',
    'studio',
    'detached_bungalow',
    'semi_detached_bungalow',
    'terraced_bungalow',
    'bungalow'
];

Tests:

.includes
const isTemp = (foo) => { typeof foo === 'string' && FOO.includes(foo); }; isTemp('maisonette');
.includes new array
const isTemp = (foo) => { const BAR = [...FOO]; typeof foo === 'string' && BAR.includes(foo); }; isTemp('maisonette');
.some
const isTemp = (foo) => { typeof foo === 'string' && FOO.some((bar) => bar === foo); }; isTemp('maisonette');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
.includes
.includes new array
.some

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark that tests three different approaches for determining whether a string is present in an array. The benchmark is designed to measure the performance difference between using the `includes()` method, creating a new array and searching for the value, and using the `some()` method.

**Test Cases**

There are three individual test cases:

1. **`.includes`**: This test case uses the built-in `includes()` method to search for the string `'maisonette'` in the `FOO` array.
2. **`.includes new array`**: This test case creates a new array `BAR` by spreading the `FOO` array, and then uses the `includes()` method on `BAR` to search for the string `'maisonette'`.
3. **`.some`**: This test case uses the `some()` method to check if any element in the `FOO` array is equal to the string `'maisonette'`.

**Options Compared**

The benchmark compares three different approaches:

* **`.includes()`**: This approach uses the built-in `includes()` method, which creates a new array with the elements that match the search value.
* **`.includes new array`**: This approach creates a new array by spreading the original array and then uses the `includes()` method on the new array. This approach avoids creating a new array with the matching elements, but still creates an intermediate array.
* **`.some()`**: This approach uses the `some()` method, which checks if any element in the array meets the condition.

**Pros and Cons of Each Approach**

1. **`.includes()`**:
	* Pros: Short and concise code, easy to understand and maintain.
	* Cons: Creates a new array with the matching elements, which can be memory-intensive for large arrays.
2. **`.includes new array`**:
	* Pros: Avoids creating a new array with the matching elements, reduces memory usage.
	* Cons: Requires creating an intermediate array by spreading the original array.
3. **`.some()`**:
	* Pros: Can be more efficient than `includes()` if the array is very large and only contains one element that matches the search value.
	* Cons: May require additional logic to handle cases where no elements match.

**Library Usage**

The benchmark uses the following library:

* `FOO`: An array of strings defined in the `Script Preparation Code`.

**Special JS Feature or Syntax**

There are no special JS features or syntax used in this benchmark. The code is simple and straightforward, using only built-in methods and standard JavaScript syntax.

**Other Alternatives**

If you're looking for alternative approaches to these methods, you can consider:

* Using the `indexOf()` method instead of `includes()`, which returns the index of the first occurrence or -1 if not found.
* Using a custom loop or recursion to iterate through the array and check each element manually.
* Using a library like Lodash that provides optimized implementations of these methods.

However, for most cases, the built-in `includes()` method is sufficient and efficient enough.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
.includes	8984910.0 Ops/sec
.includes new array	584537.2 Ops/sec
.some	7063947.0 Ops/sec

Related benchmarks:

Temp123 (version: 0)

Comparing performance of: .includes vs .includes new array vs .some

Created: one year ago by: Guest

Jump to the latest result

.includes

.includes new array

.some

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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