Benchmark: bench hubble .startsWith() vs .test() vs .match() vs .indexOf()

Script Preparation code:

var fullMessage = "Temos um convite especial pra você!  Seu perfil foi notado por nossa empresa e por esse motivo te convidamos a fazer um teste. link. Dica da Catho: 1. Fazer o teste não é obrigatório, mas pode te colocar na frente de vários candidatos no seu processo. Se você não curtir sua nota, poderá deixá-la oculta e cabe ao recrutador entender se segue ou não com o teu processo mesmo assim, ok? 2. Aguarde o contato do recrutador até que saia o resultado do seu teste. Boa sorte!";

Tests:

regexp .test()
/^Temos um convite especial pra você\! Seu perfil foi notado por nossa empresa, e por esse motivo te convidamos a fazer um teste/.test(fullMessage)
string .match()
!!fullMessage.match(/^Temos um convite especial pra você\! Seu perfil foi notado por nossa empresa, e por esse motivo te convidamos a fazer um teste/)
indexOf === 0
fullMessage.indexOf('Temos um convite especial pra você! Seu perfil foi notado por nossa empresa, e por esse motivo te convidamos a fazer um teste') === 0
string .startsWith()
fullMessage.startsWith('Temos um convite especial pra você! Seu perfil foi notado por nossa empresa, e por esse motivo te convidamos a fazer um teste')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regexp .test()
string .match()
indexOf === 0
string .startsWith()

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**What is being tested?**

On MeasureThat.net, the provided benchmark tests the performance of different string manipulation methods in JavaScript: `startsWith()`, `.test()`, `.match()`, and `.indexOf()`.

These methods are used to search for specific patterns or substrings within a given string. The test creates a large sample string (`fullMessage`) containing a predefined pattern and then measures how quickly each method can identify the presence of that pattern.

**Options compared:**

1. `startsWith()`: Returns `true` if the string starts with the specified value.
2. `.test(regexp)`: Tests whether the string matches the regular expression provided.
3. `.match(pattern)`: Returns an array of matches for a pattern in a string.
4. `indexOf(substring)`: Returns the index of the first occurrence of the specified substring, or -1 if not found.

**Pros and Cons:**

*   **Performance:**
    *   `.test(regexp)` is generally faster because it avoids creating a new regular expression object each time, as required for `.startsWith()`.
    *   `indexOf(substring)` can be slower due to its use of a linear search algorithm.
*   **Readability and maintainability:**
    *   Using `.test(regexp)` ensures the pattern is treated exactly as intended, making it easier to debug complex patterns.
    *   With `.startsWith()`, the value being searched for must start with the specified string; any partial matches are ignored.
*   **Flexibility:**
    *   `match(pattern)`, while more flexible, can return multiple matches and may be slower due to the overhead of creating a regular expression object.

**Library usage (if applicable):**

None of the methods tested in this benchmark rely on external libraries. However, if using modern JavaScript features like Unicode support or advanced pattern matching (e.g., `^` at the start of the string), consider libraries like `unicode-matcher` for enhanced regex performance or ` match-sort-find` for advanced string matching.

**Special JS feature/syntax:**

This benchmark does not explicitly use any special JavaScript features, such as async/await, callbacks, Promises, or Generators. If used, these would likely be present in the actual test code but not affecting the interpretation of the methods being compared.

**Alternatives and best practices:**

*   Consider using a library like `regex-micro-benchmark` for more advanced and accurate measurements.
*   Use `.test(regexp)` when working with complex patterns or requiring precise matching.
*   For simple, partial matches, consider using `.startsWith()` or similar methods based on the specific use case.

In conclusion, understanding the differences between these string manipulation methods can help developers choose the best approach for their specific use cases.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Linux

View result in a separate tab

Test name	Executions per second
regexp .test()	14876831.0 Ops/sec
string .match()	14746307.0 Ops/sec
indexOf === 0	22525748.0 Ops/sec
string .startsWith()	8118990.5 Ops/sec

Related benchmarks:

bench hubble .startsWith() vs .test() vs .match() vs .indexOf() (version: 0)

Comparing performance of: regexp .test() vs string .match() vs indexOf === 0 vs string .startsWith()

Created: one year ago by: Registered User

Jump to the latest result

regexp .test()

string .match()

indexOf === 0

string .startsWith()

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