Benchmark: String parse - MeasureThat.net

Script Preparation code:

function modelCheckOrig(target, ...args) {
    const rgx = /[-_.]/g;
    const processedArgs = [];
    while (args.length) {
        const item = args.pop();
        if (Array.isArray(item)) for (const x of item) args.push(x);
        else processedArgs.push(item.replace(rgx, '[-_.]*'));
    }
    return new RegExp(`\\b(?:${processedArgs.join('|')})\\b`, 'g').test(target);
}

const modelCheckCache = new Map();
function modelCheck(target, ...args) {
    const cacheKey = args.toString();
    let pattern = modelCheckCache.get(cacheKey);
    if (!pattern) {
        let list;
        while (args.length) {
            const item = args.pop();
            if (Array.isArray(item)) for (const x of item) args.push(x);
            else list += !list ? item : `|${item}`;
        }
        pattern = new RegExp(`\\b(?:${list.replace(/[_.-]+/g, '[_.-]*')})\\b`);
        modelCheckCache.set(cacheKey, pattern);
    }
    return pattern.test(target);
}

const modelStrTestCACHE = new Map();

function modelStrTest(target, ...args) {
    const cacheKey = args.toString();
    let pattern = modelStrTestCACHE.get(cacheKey);
    if (!pattern) {
        let list = '';
        while (args.length) {
            const item = args.pop();
            if (Array.isArray(item)) for (const x of item) args.push(x);
            else list += list === '' ? item : `|${item}`;
        }
        pattern = new RegExp(`\\b(?:${list.replace(/[_.-]+/g, '[_.-]*')})\\b`);
        modelStrTestCACHE.set(cacheKey, pattern);
    }
    return pattern.test(target);
}

Tests:

modelCheck
modelCheck('gpt-4o', 'o1', 'o3', '4o');
modelStrTest
modelStrTest('gpt-4o', 'o1', 'o3', '4o');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
modelCheck
modelStrTest

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
modelCheck	3758829.0 Ops/sec
modelStrTest	3709890.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark evaluates the performance of two string matching functions written in JavaScript: `modelStrTest` and `modelCheck2`. Both functions use regular expressions to test if a specific target string contains any of the provided patterns, but they optimize performance through caching.

### Function Descriptions and Purpose:
1. **`modelStrTest(target, ...args)`**:
   - Builds a regular expression from the provided `args` patterns and caches it for future use to avoid repetitive computation. It replaces any occurrences of the characters `-.` in the list of patterns with a regex that matches any sequence of `-` or `_` or `.` using the regex `/[-_.]/g` which substitutes them with `[-_.]*`.
   - Utilizes a Map (`modelStrTestCache`) to store previously generated regex patterns based on the input arguments.

2. **`modelCheck2(target, ...args)`**:
   - Similar to `modelStrTest`, it constructs a regular expression from the provided patterns but does not apply the same character replacement for `[-_.]` and instead directly includes the args in the regex pattern.
   - This function also maintains its own cache (`modelCheck2Cache`) to optimize speed for repeat queries.

### Benchmark Test Cases:
- **Test Case 1**: `modelStrTest('gpt-4o', 'o1', 'o3', '4o');` 
  - Tests the performance of `modelStrTest` function using the string `'gpt-4o'` against the patterns `'o1'`, `'o3'`, and `'4o'`.

- **Test Case 2**: `modelCheck2('gpt-4o', 'o1', 'o3', '4o');`
  - Tests the performance of `modelCheck2` function using the same target string and patterns.

### Performance Results:
The benchmark results printed show that `modelStrTest` has a higher execution rate (3725436.25 executions per second) compared to `modelCheck2` (3544464.5 executions per second), indicating that the caching and string manipulation in `modelStrTest` may be a more effective optimization for this specific input set, which leads to faster execution overall.

### Pros and Cons of the Approaches:
**Pros of `modelStrTest`**:
- Caches regex patterns, minimizing the need to recreate them on subsequent calls with the same parameters, improving performance.
- Handles a wider range of input formats due to the pattern transformation (`[-_.]*`), making it potentially more flexible in matching variants of the strings.

**Cons of `modelStrTest`**:
- Slightly more processing overhead involved with replacing characters and constructing the regex.
- The cache may consume more memory with a high number of unique argument sets.

**Pros of `modelCheck2`**:
- Simpler implementation without the character replacement may lead to faster single requests when the input set is small and known.
- Potentially less memory usage since it doesn't manipulate patterns extensively.

**Cons of `modelCheck2`**:
- Does not handle variations of input strings (`-`, `_`, and `.`) which may limit its usability in broader cases.
- All calls need to rebuild the regex from scratch, leading to slower performance on repeat calls with identical parameters.

### Other Considerations:
Both methods rely on JavaScript's `RegExp` object for string matching. They are immediately applicable in use cases involving pattern matching in text processing, validation checks, or filtering operations.

### Alternatives:
- **Direct String Comparison**: For a small number of comparisons, simple string checks (e.g., `target.includes(pattern)`) are quicker and less complex but don't have regex capabilities.
- **Advanced Libraries**: Utilization of libraries like **Lodash** or **Underscore** can provide utilities for deep comparisons, though they may not directly relate to regex performance.
- **Web Assembly (Wasm)**: For heavy computational regex tasks, implementing regex in a lower-level language that compiles to WebAssembly may provide performance improvements as it can leverage optimized algorithms and execute more quickly than JavaScript in some situations.

In conclusion, the choice between these two functions will depend on the specific use case, the expected input patterns, and the performance requirements of the application. Each method has its respective strengths and trade-offs that software engineers should consider.

Related benchmarks:

String parse (version: 46)

Comparing performance of: modelCheck vs modelStrTest

Created: 2 months ago by: Registered User

Jump to the latest result

modelCheck

modelStrTest

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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