Benchmark: chain of or equals vs includes

Script Preparation code:

var stringToMatch = 'hello';

Tests:

Array.includes
['banana', 'map', 'cloth', 'hello', 'person'].includes(stringToMatch)
Or chain
stringToMatch === 'banana' || stringToMatch === 'map' || stringToMatch === 'cloth' || stringToMatch === 'hello' || stringToMatch === 'person'

Historical Performance Data aggregated from 136 community runs

Desktop Results:

Chrome 116 runs

Array.includes

20.9M/s

Or chain

7.4M/s

Fastest: Array.includes (2.8x faster)

View exact numbers

✓ Array.includes: 20,940,800 ops/sec
• Or chain: 7,358,225 ops/sec

Firefox 15 runs

Or chain

778.4M/s

Array.includes

36.5M/s

Fastest: Or chain (21.3x faster)

View exact numbers

✓ Or chain: 778,441,920 ops/sec
• Array.includes: 36,547,700 ops/sec

Mobile Results:

Chrome 5 runs

Array.includes

13.0M/s

Or chain

4.2M/s

Fastest: Array.includes (3.1x faster)

View exact numbers

✓ Array.includes: 13,025,050 ops/sec
• Or chain: 4,249,731 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
Array.includes
Or chain

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 140 on Mac OS X 10.15.7

View result in a separate tab

Or chain

161.8M/s

Array.includes

93.4M/s

View exact numbers

Test name	Executions per second
✓ Or chain	161,847,120 Ops/sec
Array.includes	93,358,184 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is tested in the provided JSON benchmark.

**Benchmark Overview**

The benchmark compares the performance of using `Array.includes` versus manually writing a chain of logical ORs to check if a string matches a specific value within an array. The test aims to measure the overhead of using `Array.includes` compared to traditional OR chaining.

**Options Compared**

There are two options being tested:

1. **Array.includes**: This is a built-in JavaScript method that checks if a specified element is present in an array. It returns true if the element is found, and false otherwise.
2. **Or chain (manual approach)**: This involves manually writing a chain of logical ORs to check if a string matches a specific value within an array.

**Pros and Cons**

**Array.includes:**

Pros:

* Concise and expressive code
* Easy to read and maintain
* Optimized for performance by the JavaScript engine

Cons:

* May have overhead due to the additional function call and possible overhead of traversing the array internally
* Might not be as efficient as manual OR chaining in some cases, depending on the specific implementation

**Or chain (manual approach):**

Pros:

* Can be more efficient than using `Array.includes` because it avoids the overhead of an additional function call and potentially traversing an array
* Gives developers more control over the performance-critical part of the code

Cons:

* More verbose and harder to read than using `Array.includes`
* Requires explicit loop or recursive logic, which can be error-prone

**Library Used**

In this benchmark, the `stringToMatch` variable is initialized with a string value `'hello'`. No specific library is used in this test case.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this benchmark.

**Other Alternatives**

If you were to implement your own OR chain manually, you could use loops, recursive functions, or even bitwise operations (though that would be a stretch!). Some alternatives to using `Array.includes` include:

* Using the `indexOf()` method, which returns the index of the first occurrence of the specified element, and then checking if the index is -1
* Using the `forEach()` method to iterate over the array and check each element manually
* Using bitwise operations to compare individual bytes or characters of the string

Keep in mind that these alternatives would likely be less efficient than using `Array.includes`, which is optimized for performance by the JavaScript engine.

In conclusion, this benchmark provides a simple yet informative way to measure the overhead of using `Array.includes` versus manual OR chaining. By understanding the pros and cons of each approach, developers can make informed decisions about how to optimize their code for performance.

chain of or equals vs includes (version: 0)

how much of a performance deficit you can expect from using Array.includes instead of manually writing a chain of logical ORs

Comparing performance of: `Array.includes vs Or chain`

Created: 4 years ago by: Guest

Go to the latest result

Array.includes

Or chain

Historical Performance Data aggregated from 136 community runs

Desktop Results:

Chrome 116 runs

Firefox 15 runs

Mobile Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

chain of or equals vs includes (version: 0)

how much of a performance deficit you can expect from using Array.includes instead of manually writing a chain of logical ORs

Comparing performance of: Array.includes vs Or chain

Created: 4 years ago by: Guest

Go to the latest result

Array.includes

Or chain

Historical Performance Data aggregated from 136 community runs

Desktop Results:

Chrome 116 runs

Firefox 15 runs

Mobile Results:

Chrome 5 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: `Array.includes vs Or chain`