Benchmark: string match in list: switch case vs array.includes

Tests:

switch case
((v) => { switch (v) { case 'asdpopqnf': case 'zbvxcvuud': case 'qwtewoiru': case 'pojfopdgd': case 'tuunreiro': return true; } return false; })('tuunreiro')
array.includes
((v) => { return [ 'asdpopqnf', 'zbvxcvuud', 'qwtewoiru', 'pojfopdgd', 'tuunreiro' ].includes(v); })('tuunreiro')

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 23 runs

switch case

135.5M/s

array.includes

68.1M/s

Fastest: switch case (2.0x faster)

View exact numbers

✓ switch case: 135,523,328 ops/sec
• array.includes: 68,073,520 ops/sec

Firefox 6 runs

switch case

1369.0M/s

array.includes

33.5M/s

Fastest: switch case (40.9x faster)

View exact numbers

✓ switch case: 1,368,993,280 ops/sec
• array.includes: 33,451,556 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
switch case
array.includes

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 months ago)

User agent: Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Fedora

View result in a separate tab

switch case

2210.0M/s

array.includes

50.8M/s

View exact numbers

Test name	Executions per second
✓ switch case	2,209,950,208 Ops/sec
array.includes	50,757,328 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and its test cases to explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The MeasureThat.net website provides a platform for users to create and run JavaScript microbenchmarks. The provided benchmark is designed to compare two approaches: `switch case` and `array.includes` for checking if a string exists in an array.

**Test Cases**

There are two test cases:

1. **`switch case`**:
```javascript
((v) => {
  switch (v) {
    case 'asdpopqnf':
    case 'zbvxcvuud':
    case 'qwtewoiru':
    case 'pojfopdgd':
    case 'tuunreiro':
      return true;
  }
  return false;
})('tuunreiro')
```
This test case uses a `switch` statement to check if the input string `'tuunreiro'` matches any of the specified cases. The `switch` statement is a traditional approach for pattern matching.

2. **`array.includes`**:
```javascript
((v) => {
  return [
    'asdpopqnf',
    'zbvxcvuud',
    'qwtewoiru',
    'pojfopdgd',
    'tuunreiro'
  ].includes(v);
})('tuunreiro')
```
This test case uses the `array.includes` method to check if the input string `'tuunreiro'` exists in the provided array.

**Comparison**

The benchmark compares the execution times of these two approaches for a specific test case. The goal is to determine which approach is faster and more efficient.

**Pros and Cons**

1. **`switch case`**:
	* Pros:
		+ Can be optimized by the browser's JavaScript engine, reducing overhead.
		+ Can provide better performance for certain types of patterns (e.g., integer comparisons).
	* Cons:
		+ More verbose and less readable than other approaches.
		+ May not work as expected with large or complex arrays.
2. **`array.includes`**:
	* Pros:
		+ Shorter and more readable code.
		+ Works well for small to medium-sized arrays.
	* Cons:
		+ Can be slower due to the overhead of searching through the array.
		+ May not be optimized by the browser's JavaScript engine.

**Library and Special JS Features**

In this benchmark, there are no external libraries being used. However, it does utilize the `includes` method on an array, which is a built-in JavaScript feature introduced in ECMAScript 2015 (ES6).

**Other Alternatives**

If you're looking for alternative approaches to string matching or array searching, consider:

1. **Regular expressions**: A powerful but complex way to match patterns in strings.
2. **Arrays.prototype.some()**: An alternative to `array.includes` that stops iterating as soon as a match is found.
3. **NativeArray.prototype.indexOf()**: A method that searches for the first occurrence of a value in an array.

These alternatives may offer better performance or more flexibility, but they also come with additional complexity and potential overhead.

Keep in mind that the best approach depends on your specific use case, performance requirements, and code readability considerations.

string match in list: switch case vs array.includes (version: 0)

Comparing performance of: `switch case vs array.includes`

Created: 2 years ago by: Guest

Go to the latest result

switch case

array.includes

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 23 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

string match in list: switch case vs array.includes (version: 0)

Comparing performance of: switch case vs array.includes

Created: 2 years ago by: Guest

Go to the latest result

switch case

array.includes

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 23 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `switch case vs array.includes`