Benchmark: String.indexOf vs Map.get vs Object lookup

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

var ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var DIGITS = '0123456789';
var ALL_CHARS = `${DIGITS}${ALPHA}`;
var CHARACTERS = ALL_CHARS.split('');
var CHARMAP = CHARACTERS.reduce((ret, char, idx) => ret.set(char, idx), new Map());
var CHAROBJ = CHARACTERS.reduce((ret, char, idx) => {ret[char] = idx; return ret;}, {});

var LETTER = 'N';
console.log('Prep:', {ALPHA,DIGITS,ALL_CHARS,CHARMAP,CHAROBJ,LETTER});

Tests:

indexOf
var i = ALL_CHARS.indexOf(LETTER);
Map.get
var i = CHARMAP.get(LETTER);
Object Accessor
var i = CHAROBJ[LETTER];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
Map.get
Object Accessor

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 17 days ago)

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

Browser/OS: Chrome 134 on Linux

View result in a separate tab

Test name	Executions per second
indexOf	143533232.0 Ops/sec
Map.get	151962352.0 Ops/sec
Object Accessor	69664960.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 17 days ago):

LLMs can make mistakes. Check important info.

The benchmark you provided compares three different methods for finding the index of a character within a predefined set of characters:

1. **String.indexOf**
2. **Map.get**
3. **Object Accessor**

### Options Compared

1. **String.indexOf**
   - **Method**: This built-in JavaScript method searches for a specified string (or character) within another string and returns the index of its first occurrence.
   - **Usage**: In this case, it is used to find the index of the variable `LETTER` (which is `'N'`) in a string of all characters, `ALL_CHARS`.
   - **Pros**:
     - Simple and concise syntax.
     - Well-supported across all JavaScript environments.
   - **Cons**:
     - Performance can degrade with large strings since it performs a linear search through the string.
     - Returns `-1` if the character is not found, which might require additional handling.

2. **Map.get**
   - **Method**: This method retrieves the value associated with a specified key from a JavaScript `Map`, which is a collection of keyed data items.
   - **Usage**: Here, a `Map` named `CHARMAP` is created where each character maps to its corresponding index, allowing for efficient lookups.
   - **Pros**:
     - Provides average constant-time complexity for lookups (O(1)), making it highly efficient for frequent searches.
     - No need for additional checks for non-existent keys; it can return `undefined` naturally.
   - **Cons**:
     - Slightly more overhead in terms of memory compared to a flat object or string, since you need to initially set up the `Map` structure.

3. **Object Accessor**
   - **Method**: This approach uses a plain JavaScript object (`CHAROBJ`) to get the value associated with the `LETTER` key.
   - **Usage**: Similar to `Map`, it stores the index of each character as object properties.
   - **Pros**:
     - Variable memory footprint since there is less overhead than a `Map`.
     - Straightforward implementation and retrieval.
   - **Cons**:
     - Performance on ES5 and earlier engines might be less optimal with many properties.
     - Property lookups have the potential to conflict with prototype chains unless the object is created without a prototype or checked explicitly.

### Benchmark Results Interpretation

The benchmark results indicate the performance of each method in terms of `ExecutionsPerSecond`:

- **Map.get**: 151,962,352.0 executions/second
- **String.indexOf**: 143,533,232.0 executions/second
- **Object Accessor**: 69,664,960.0 executions/second

### Conclusions and Considerations

From the results, `Map.get` is the fastest method, likely due to its O(1) lookup characteristic, followed closely by `String.indexOf`, and then `Object Accessor` which performs the slowest in this scenario.

- **Choosing the Right Method**: When performance is a critical consideration (especially in cases of frequent character lookups), using a `Map` would be preferable. For simpler cases or where memory overhead matters less, `String.indexOf` or the `Object Accessor` might suffice, especially given their widespread familiarity among developers.

- **Alternatives**:
  - **Array.indexOf** could be considered if using arrays instead of strings.
  - For large datasets or highly repetitive searches, more advanced data structures like tries or hash tables can be employed.
  - In modern JavaScript engines (ES6 and beyond), utilizing features such as Sets and WeakMaps could be beneficial as well, depending on the requirements for unique values and memory management.

Ultimately, the choice between these options will depend on the specific needs for performance, readability, and memory management in a user's application context.

Related benchmarks:

String.indexOf vs Map.get vs Object lookup (version: 1)

Comparing performance of: indexOf vs Map.get vs Object Accessor

Created: 17 days ago by: Guest

Jump to the latest result

indexOf

Map.get

Object Accessor

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 17 days ago):