Benchmark: localeIncludesLowercase vs escape+test vs escape+match vs findMatchGroups

Script Preparation code:

var a = 'abcdefghijklmnopqrstuvwxyz';
var b = 'NOP';

var locale = 'en-US'

/////////////////////////////////////////////////////////////////////////////////////

var BACKSLASH = '\\';
var escapeMap = new Map(
  [
    '\\',
    '^',
    '$',
    '*',
    '+',
    '?',
    '(',
    ')',
    '[',
    ']',
    '{',
    '}',
    '=',
    ':',
    '!',
    '|',
  ].map(char => [char, `${BACKSLASH}${char}`])
);

var escapeRegExp = (searchPhrase) =>
  [...searchPhrase]
    .map(character => escapeMap.get(character) || character)
    .join('');

var findMatchGroups = (
  searchPhrase,
  valueToSearchOn
) => {
  const safeSearchPhrase = escapeRegExp(searchPhrase);
  const searchPhraseRegExp = new RegExp(`(.+)?(${safeSearchPhrase})(.+)?`, 'i');
  const match = valueToSearchOn.match(searchPhraseRegExp);
  if (match) {
    const [, preFind = '', find = '', postFind = ''] = match;
    return [preFind, find, postFind];
  }
  return [valueToSearchOn, '', ''];
};

/////////////////////////////////////////////////////////////////////////////////////

Tests:

localeIncludesLowercase
a.toLocaleLowerCase(locale).includes(b.toLocaleLowerCase(locale));
escape+test
new RegExp(escapeRegExp(b), 'gi').test(a)
escape+match
a.toLocaleLowerCase(locale).match(escapeRegExp(b).toLocaleLowerCase(locale))
findMatchGroups
findMatchGroups(b, a)[1] !== ''

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
localeIncludesLowercase
escape+test
escape+match
findMatchGroups

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
localeIncludesLowercase	5894777.5 Ops/sec
escape+test	2189721.0 Ops/sec
escape+match	1698813.0 Ops/sec
findMatchGroups	1568162.9 Ops/sec

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 data for you.

**Benchmark Definition**

The benchmark measures the performance of different approaches to search for a substring in a string, specifically focusing on case-insensitive searches and handling locale-specific characters.

**Options Compared**

There are four options compared:

1. `localeIncludesLowercase`: Uses the `toLocaleLowerCase` method to convert both strings to lowercase before comparing.
2. `escape+test`: Escapes special characters in the search phrase using a custom map, then uses the `test` method to check if the search phrase is present in the string.
3. `escape+match`: Escapes special characters in the search phrase and uses the `match` method with a regular expression to find all occurrences of the search phrase in the string.
4. `findMatchGroups`: Uses a custom function `findMatchGroups` to find all occurrences of the search phrase in the string, returning the matched groups.

**Pros and Cons of Each Approach**

1. **localeIncludesLowercase**:
	* Pros: Simple and efficient, as it only involves two method calls.
	* Cons: May not work correctly with locale-specific characters or non-ASCII strings.
2. **escape+test**:
	* Pros: Can handle locale-specific characters and non-ASCII strings, as the escape map provides a way to convert special characters to their escaped equivalents.
	* Cons: More complex and slower than the other approaches, due to the need to create an escape map and use the `test` method.
3. **escape+match**:
	* Pros: Can handle locale-specific characters and non-ASCII strings, as the regular expression supports Unicode properties.
	* Cons: Slower than `localeIncludesLowercase`, as it involves creating a regular expression object and using the `match` method with an i flag for case-insensitive matching.
4. **findMatchGroups**:
	* Pros: Can handle locale-specific characters and non-ASCII strings, as the custom function can be designed to work with Unicode properties.
	* Cons: Most complex and slower than the other approaches, due to the need to create a custom function and implement its logic.

**Library Used**

In this benchmark, the following libraries are used:

1. `Intl`: This library provides functions for working with internationalization and localization, including `toLocaleLowerCase`.
2. `RegExp`: This library provides functions for working with regular expressions, including creating regular expression objects and using the `test` and `match` methods.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax used in this benchmark that requires specific knowledge to understand.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

1. Using a different locale-specific character conversion method (e.g., `charCodeAt` and `String.fromCharCode`).
2. Implementing a custom string matching algorithm using techniques like Knuth-Morris-Pratt or Boyer-Moore.
3. Using a dedicated library for string matching, such as `string-match`.

Keep in mind that each alternative may offer trade-offs in terms of performance, complexity, and compatibility with different environments.

Related benchmarks:

localeIncludesLowercase vs escape+test vs escape+match vs findMatchGroups (version: 0)

Comparing performance of: localeIncludesLowercase vs escape+test vs escape+match vs findMatchGroups

Created: one year ago by: Registered User

Jump to the latest result

localeIncludesLowercase

escape+test

escape+match

findMatchGroups

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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