Benchmark: Number matching - MeasureThat.net

HTML Preparation code:

<div></div>

Script Preparation code:

const text = 'hello1hello2hello3hello4hello5hello6hello78hello9_0'

Tests:

String.prototype.match
const numbers = [...text.match(/\d+/g)].map(n => +n)
String.prototype.split filter
const numbers = text.split('').map(n => +n).filter(Number)
String.prototype.matchAll
const numbers = [...text.matchAll(/\d+/g)].map(n => +n)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.prototype.match
String.prototype.split filter
String.prototype.matchAll

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0

Browser/OS: Firefox 133 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
String.prototype.match	3393988.2 Ops/sec
String.prototype.split filter	1194901.1 Ops/sec
String.prototype.matchAll	625083.4 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined above is focused on evaluating the performance of different methods for extracting numbers from a string in JavaScript. The primary goal is to compare various approaches in terms of how efficiently they can match numerical values within a given string.

### Benchmark Options Compared

1. **String.prototype.match**:
   - **Implementation**: `const numbers = [...text.match(/\\d+/g)].map(n => +n)`
   - **Description**: This method uses a regular expression to match all occurrences of one or more digits (`\d+`) in the input string, returning them as an array. The array is then transformed into numbers using `.map(n => +n)`.

2. **String.prototype.split filter**:
   - **Implementation**: `const numbers = text.split('').map(n => +n).filter(Number)`
   - **Description**: This approach splits the string into individual characters, converts each character to a number, and then filters out the non-numeric values. The filtering is done using `Number()`, which evaluates to `0` for non-numeric characters.

3. **String.prototype.matchAll**:
   - **Implementation**: `const numbers = [...text.matchAll(/\\d+/g)].map(n => +n)`
   - **Description**: Similar to `String.prototype.match`, this method also utilizes a regex to find all numeric matches. However, `matchAll` returns an iterator of matches, which allows for handling more complex patterns and multiple capturing groups, though in this case, it is used in a similar manner to `match`.

### Pros and Cons of Each Approach

- **String.prototype.match**
  - **Pros**:
    - Clear and concise implementation.
    - Directly retrieves all numbers in one step.
  - **Cons**:
    - May be less intuitive for those unfamiliar with regex.
  
- **String.prototype.split filter**
  - **Pros**:
    - If the user is less comfortable with regex, this method might be more understandable as it breaks the problem down into simpler steps (splitting, mapping, and filtering).
    - Potentially more flexible for minor modifications.
  - **Cons**:
    - Less efficient because it processes each character individually, leading to overhead that can significantly slow down performance.
  
- **String.prototype.matchAll**
  - **Pros**:
    - Excellent for handling complex matching scenarios, especially if you need to work with capturing groups.
  - **Cons**:
    - Overhead associated with creating an iterator; it might not provide significant benefits for simple number extraction like in this benchmark.
    - Complexity in readability for those unfamiliar with its usage.

### Considerations
Performance is a critical factor when choosing the right method for extracting data, especially in applications dealing with large datasets or strings that require frequent manipulation. Depending on the use case, choosing a more efficient method can lead to improved performance and better user experience.

### Alternatives to These Approaches
Other than the methods tested, there are several alternatives to extracting numbers from a string in JavaScript:

1. **Using a for loop with condition checks**:
   - Manually iterate through the string, checking each character and building an array of numbers directly.
   
2. **Using `Array.from()`**:
   - Similar to splitting, but allowing for additional transformation and filtering in a single pass.

3. **Third-party libraries**:
   - Libraries like Lodash or Ramda could provide utility functions for parsing strings or numbers, often with better performance or abstractions.

In summary, this benchmark is a straightforward yet essential demonstration of how different JavaScript string manipulation methods perform in extracting numeric values, providing useful insights for developers on the efficiency and readability of their code in various scenarios.

Related benchmarks:

Number matching (version: 1)

Take a string and match only the numbers

Comparing performance of: String.prototype.match vs String.prototype.split filter vs String.prototype.matchAll

Created: 3 months ago by: Registered User

Jump to the latest result

String.prototype.match

String.prototype.split filter

String.prototype.matchAll

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):