Benchmark: test vs include vs indexOf no match

Script Preparation code:

var badWords = ['xxx',
    'vaffanculo',
    'merda',
    'cazzo',
    'figa',
    'culo',
    'dio',
    'porco',
    'porca',
    'coglione',
    'pirla',
    'deficente',
    'bastardo',
    'stronzo',
    'puttana',
    'troia',
    'frocio',
    'cacca',
    'zoccola',
    'bagascia',
    'cane',
    'madre',
    'padre',
    'porco dio',
    'procodio',
    'porca madonna',
    'madonna puttana',
    'cristo',
    'gesu',
    'berlusconi',
    'obama',
    'trump',
    'paperino',
    'pippo',
    'pluto',
    'paperone',
    'tizio',
    'caio',
    'sempronio',
    'cip',
    'ciop',
    'totti',
    'del piero',
    'ronaldo',
    'paperon',
    'paperoni',
    'disney',
    'pinco',
    'pallino',
    'zio',
    'zia',
    'ciao',
    'cane',
    'topo',
    'test',
    'prova',
    'proviamo',
    'nome',
    'cognome',]
var badWordsRegex = new RegExp(`(${badWords.map(s => `\\b${s}\\b`).join('|')})`, 'i')

Tests:

test
badWordsRegex.test("hello")
include
badWords.includes("hello")
indexof
badWords.indexOf("hello") > -1

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
test
include
indexof

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark definition json represents a test that compares three different approaches to check if a word is in an array or string:

1. **Using `includes()`**: This method checks if a value exists in an array or string.
2. **Using `indexOf()` with a negative index**: This method returns the index of the first occurrence of a value in an array or string, or -1 if not found.
3. **Using a regular expression (`badWordsRegex.test()`)**: This method tests if a value matches a specific pattern in a string.

Now, let's discuss the pros and cons of each approach:

**Includes()**

Pros:

* Easy to read and maintain
* Fast and efficient for large arrays or strings

Cons:

* Can lead to slower performance when dealing with very large datasets due to the need to iterate through the entire array/string.
* May not be suitable for cases where exact matching is required.

**IndexOf() with a negative index**

Pros:

* Fast and efficient, especially when dealing with large arrays or strings.
* Can return the index of the first occurrence of a value, which can be useful in certain scenarios.

Cons:

* Requires manual handling of the -1 case to indicate no match.
* May not be suitable for cases where exact matching is required.
* Can lead to unexpected results if the array/string is empty or contains only one element.

**Regular Expression (`badWordsRegex.test()`)**

Pros:

* Flexible and powerful for complex pattern matching.
* Can be used for both exact matching and regular expressions with variables.

Cons:

* Slower performance compared to `includes()` and `indexOf()`.
* Requires manual handling of the regex pattern, which can add complexity.

In this specific benchmark, we have three test cases that compare these approaches. The results show that `includes()` is faster than `test()` and `indexOf()`, indicating that it's a good choice for large datasets or performance-critical code.

On the other hand, `indexOf()` outperforms both `includes()` and `test()`, suggesting that it might be suitable for cases where exact matching is required. However, its performance comes at the cost of requiring manual handling of the -1 case.

**Other Considerations**

* When dealing with very large datasets or performance-critical code, consider using optimized data structures like `Set` or `Map` instead of arrays or strings.
* For complex pattern matching, consider using regular expressions (like `badWordsRegex.test()`).
* Always profile and benchmark your code to determine the most efficient approach for a specific use case.

**Alternatives**

Other alternatives to these approaches include:

* Using `includes()` with a custom implementation for exact matching
* Using `indexOf()` with a custom implementation for exact matching
* Using a different data structure, like `Set` or `Map`, instead of an array or string
* Using a library like Lodash or Ramda for functional programming and optimization

I hope this explanation helps software engineers understand the trade-offs involved in choosing the right approach for their JavaScript benchmarks!

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.80 Safari/537.36

Browser/OS: Chrome 98 on Linux

View result in a separate tab

Test name	Executions per second
test	7702734.5 Ops/sec
include	15666356.0 Ops/sec
indexof	6765454.5 Ops/sec

Related benchmarks:

test vs include vs indexOf no match (version: 0)

Comparing performance of: test vs include vs indexof

Created: 2 years ago by: Guest

Jump to the latest result

test

include

indexof

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):