Benchmark: Exclude keywords

Script Preparation code:

var arr = ['my', 'key', 'word']
var str = 'my key word'
var regex = /^(my|key|word)$/

Tests:

array includes
arr.includes('word')
string includes
str.includes('word')
regex test
regex.test('word')
switch case
switch('word') { case 'my': case 'key': case 'word': break default: break }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array includes
string includes
regex test
switch case

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 benchmark is designed to test the performance of various JavaScript operations on different data types: arrays, strings, and regular expressions.

**Test Cases**

There are four individual test cases:

1. **Array Includes**: This test case measures the performance of the `includes()` method on an array.
2. **String Includes**: This test case measures the performance of the `includes()` method on a string.
3. **Regex Test**: This test case measures the performance of the `test()` method with a regular expression.
4. **Switch Case**: This test case measures the performance of a switch statement.

**Options Compared**

The options being compared are the different ways to perform these operations:

* Array includes: Using the `includes()` method versus using the `indexOf()` method (not shown in this benchmark).
* String includes: Using the `includes()` method versus using the `indexOf()` method.
* Regex test: Using the `test()` method with a simple regular expression versus a more complex one.
* Switch case: The order of cases and whether to use `break` statements.

**Pros and Cons**

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

* **Array Includes**: Using `includes()` is generally faster and more readable than using `indexOf()`. However, if the array is large, `indexOf()` might be faster due to caching.
* **String Includes**: Similar to array includes, using `includes()` is usually faster and more efficient. If you need to search for multiple strings, consider using a different data structure like a Set or an array of indices.
* **Regex Test**: Using simple regular expressions can lead to slower performance than more complex ones. This is because the regex engine has to compile the expression, which can be time-consuming. However, if the regular expression is simple and fixed, it might be faster than using `test()` with a new regex object each time.
* **Switch Case**: The order of cases can significantly impact performance. If the cases are in the wrong order, the interpreter might have to traverse the entire switch statement, leading to slower performance. Using `break` statements can help optimize the switch case.

**Library and Special Features**

No libraries or special JavaScript features are used in this benchmark other than the standard ECMAScript features.

**Other Considerations**

Some additional considerations when running benchmarks:

* Make sure to warm up the browser by loading a few pages before starting the benchmark.
* Run multiple iterations of each test case to ensure accurate results.
* Avoid using caching or memoization, as they can affect the outcome of the benchmark.
* Consider running the benchmark on different devices and browsers to get a more comprehensive picture of performance.

**Alternatives**

If you want to explore alternative approaches for similar benchmarks, consider:

* Using a framework like Benchmark.js or JSDoc's benchmarking tool to simplify the process.
* Creating custom microbenchmarks using a library like micro-benchmark or benchmark-extended.
* Writing benchmarks for specific use cases, such as performance comparison of different algorithms or data structures.

Keep in mind that each alternative has its own strengths and weaknesses, and some might be more suitable for your needs than others.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.55 Safari/537.36 Edg/96.0.1054.43

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
array includes	8065943.0 Ops/sec
string includes	6129047.0 Ops/sec
regex test	6202559.0 Ops/sec
switch case	1524952320.0 Ops/sec

Related benchmarks:

Exclude keywords (version: 1)

array includes, string includes, regex test, switch case

Comparing performance of: array includes vs string includes vs regex test vs switch case

Created: 2 years ago by: Registered User

Jump to the latest result

array includes

string includes

regex test

switch case

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