Benchmark: String equality vs includes

Script Preparation code:

var string = "Hello world!";
var regex = /Hello/;

Tests:

Includes
string.includes("Hello world")
equals
string === "Hello world"
obviously wrong equality
string === "x"

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Includes
equals
obviously wrong equality

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Includes	27348232.0 Ops/sec
equals	27306234.0 Ops/sec
obviously wrong equality	27306078.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case on MeasureThat.net. The benchmark tests the performance of string equality and includes operations in JavaScript.

**Options Being Compared**

There are three options being compared:

1. `string.includes("Hello world")`
2. `string === "Hello world"`
3. `string === "x"` (the "obviously wrong equality" test)

The first two options are the standard ways to check if a string contains or is equal to another string, respectively. The third option is an intentionally incorrect comparison, designed to highlight potential pitfalls in JavaScript's equality checking.

**Pros and Cons of Each Approach**

1. `string.includes("Hello world")`:
	* Pros: This method is generally faster and more efficient than the other two options because it uses a built-in, optimized implementation.
	* Cons: It returns `true` if any part of the string matches the search pattern, which may not be what the developer intended. For example, in "Hello world!", the first three characters match the pattern, so this method would return true even if only "world" is expected.
2. `string === "Hello world"`:
	* Pros: This method provides a clear and unambiguous way to check for exact string equality.
	* Cons: It can be slower than the includes method because it uses a more complex algorithm to compare strings.
3. `string === "x"` (obviously wrong equality):
	* Pros: This test case is useful for highlighting potential issues with JavaScript's equality checking, such as comparing non-numeric values using `===` or using a loose comparison (`<=`, `>=`) instead of strict comparison (`===`, `!==`).
	* Cons: It serves no practical purpose in performance testing and may even slow down the benchmark if not optimized correctly.

**Library Used**

None. This benchmark uses native JavaScript methods and does not rely on any external libraries.

**Special JS Feature or Syntax**

The benchmark tests the behavior of JavaScript's string comparison operators, specifically `includes`, `===` (strict equality), and loose comparisons (`<=`, `>=`). The "obviously wrong equality" test case highlights potential issues with these operators when used incorrectly.

Related benchmarks:

String equality vs includes (version: 0)

Comparing performance of: Includes vs equals vs obviously wrong equality

Created: 2 years ago by: Guest

Jump to the latest result

Includes

equals

obviously wrong equality

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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