Benchmark: regex vs string functions

Script Preparation code:


function domain1(x, wild = 'n', subs = 'o') { 
    return x.length < 256 && new RegExp(
        `^(?=(` + // capture
        (wild === 'o' && '(?:\\*\\.)?' || wild === 'r' && '(?:\\*\\.)' || '') + // start with *. if allowed/required
        `(?:[a-z\\d](?:[-a-z\\d]{0,61}[a-z\\d])?\\.)` + // [a-z0-9-] up to 63 chars, can't start or end w/ dash
        (subs === 'o' && '+' || subs === 'r' && '{2,}' || '') + // subdomains or not
        `(?!\\d+$)` + // tld can't be all digits
        `(?:[a-z\\d][-a-z\\d]{0,22}[a-z\\d])` + // tld up to 24 chars
        `))\\1$` // end capture
    , 'i').test(x);
}

function domain2(dom) {
    if(dom.indexOf('..')>0) return false;
    if(dom.indexOf('-.')>0) return false;
    if(dom.indexOf('.-')>0) return false;
    if(dom[0] === '-' || dom[dom.length - 1] === '-') return false;
    const parts = dom.split('.');
    const last = parts.pop();
    if(last.length > 22 || /^\d+$/.test(last)) {
        return false;
    }
    const valid = /^[a-z0-9\-]+$/i;
    return parts.every(p => {
        return p.length < 63 && valid.test(p);
    });
}

Tests:

domain 1
domain1('eefsdsdfsdfsdfs.fdsfsddfsdfsdfs.dfsdfsdfsfdsdfs.sdffdsdfssdfdffdssdfdf.dsdfsfsddfsx.com..33')
domain 2
domain2('eefsdsdfsdfsdfs.fdsfsddfsdfsdfs.dfsdfsdfsfdsdfs.sdffdsdfssdfdffdssdfdf.dsdfsfsddfsx.com..33')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
domain 1
domain 2

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON for MeasureThat.net, explaining what's being tested and the pros and cons of different approaches.

**Benchmark Definition**

The benchmark is testing two JavaScript functions: `domain1` and `domain2`, which appear to validate domain names. The goal is to determine which function is faster when given a specific input string.

**Function domain1**

`domain1` uses a regular expression (regex) to validate the domain name. The regex pattern captures various parts of the domain name, including:

*   Start with `*` if allowed/required
*   Followed by `[a-z\0-9]` up to 63 characters
*   Subdomains or not
*   Top-level domain (TLD) cannot be all digits

Pros:

*   More flexible and able to handle edge cases
*   Can validate TLDs with varying lengths

Cons:

*   Slower due to regex engine overhead
*   May have performance issues when dealing with very long domain names

**Function domain2**

`domain2` uses a combination of string methods to validate the domain name, including:

*   `indexOf()` to check for invalid characters like `.`, `-`, and `..`
*   `split()` to separate the domain name into parts
*   `every()` to iterate over each part and validate it

Pros:

*   Faster since it avoids regex engine overhead
*   Simple and easy to understand

Cons:

*   Less flexible and may not handle edge cases correctly
*   Requires more manual validation, which can be prone to errors

**Library and Special Features**

Neither function uses any external libraries. There are no special JavaScript features or syntax mentioned in the benchmark.

**Alternatives**

If you were to rewrite these functions or choose alternative approaches for a similar task:

1.  **Use a library:** If you need more flexibility and support for complex domain name validation, consider using a dedicated library like `domain-name-validator` (Node.js) or `tldextract` (JavaScript).
2.  **Use a different string method:** Instead of `indexOf()` and `split()`, you could use regular expressions to validate the domain name. This would eliminate the need for `every()` and provide more flexibility.
3.  **Use a different approach:** Consider using a more advanced algorithm, like the Punycode algorithm used in DNS lookups, to validate domain names.

**Benchmark Results**

The latest benchmark results show that:

*   `domain2` is faster than `domain1`, with an average of 12 million executions per second.
*   The browser and device platform used for the test are Chrome 118 on a Windows desktop.

Keep in mind that these results may vary depending on the specific input strings, browsers, and devices used in future benchmark runs.

Related benchmarks:

regex vs string functions (version: 0)

Comparing performance of: domain 1 vs domain 2

Created: 2 years ago by: Guest

Jump to the latest result

domain 1

domain 2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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