Benchmark: booger - MeasureThat.net

Script Preparation code:

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

Tests:

string.indexOf
string.indexOf('Hello') > 1
includes
string.includes('Hello')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
string.indexOf
includes

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/97.0.4692.71 Safari/537.36

Browser/OS: Chrome 97 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
string.indexOf	11494342.0 Ops/sec
includes	8583372.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark on MeasureThat.net. The benchmark tests two built-in JavaScript methods: `string.indexOf` and `string.includes`.

**Options compared:**

In this case, there are two options being compared:

1. **`string.indexOf`**: This method returns the index of the first occurrence of a specified value in a string. If the value is not found, it returns -1.
2. **`string.includes`**: This method checks if a string includes another string as a substring. It returns `true` if the substring is found and `false` otherwise.

**Pros and Cons:**

*   **`string.indexOf`**:
    *   Pros:
        *   Faster (on average) for searching exact matches
        *   More accurate for determining the starting position of an exact match
    *   Cons:
        *   Returns -1 if the value is not found, which may be misleading in some cases
*   **`string.includes`**:
    *   Pros:
        *   Returns `true` or `false`, making it more intuitive and easier to use for simple checks
        *   More suitable for searching a substring within a larger string
    *   Cons:
        *   Generally slower than `indexOf` due to its substring search approach

**Library usage:**

In the provided benchmark, there is no explicit library mentioned. However, it's essential to note that some JavaScript strings may include non-ASCII characters or special Unicode values.

**Special JS feature/syntax:**

There are no specific JavaScript features or syntaxes being tested in this example.

**Benchmark preparation code:**

The script preparation code sets up a test string and regex pattern for the `string.indexOf` method:
```javascript
var string = "Hello world!";
var regex = /Hello/;
```
This ensures that both methods have access to the same test data when executed.

Now, let's look at some alternatives to these built-in JavaScript methods:

*   For exact matching without using `indexOf`, you can use a regular expression with the `^` and `$` anchors:
    ```javascript
var regex = /^Hello/;
```
    This will match only the literal string "Hello" at the start of the input.
*   For substring searches, you may consider using a library like [js-subs-regex](https://github.com/paulotruong/js-subs-regex), which provides a more efficient approach to searching substrings within strings.

Keep in mind that when choosing between `indexOf` and `includes`, consider the specific use case and performance requirements. If you need exact matches or precise starting positions, `indexOf` might be a better choice. For substring searches or simple checks, `includes` is often sufficient.

Related benchmarks:

booger (version: 0)

test

Comparing performance of: string.indexOf vs includes

Created: 2 years ago by: Guest

Jump to the latest result

string.indexOf

includes

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