Benchmark: 2 string map vs. for search with sharded array small N

Script Preparation code:

globalThis.map = []
globalThis.objArr = []

for (let i = 0; i < 20; i++) {
    const shardKey = String(i).slice(0,2)
  	if (!map[`thing-${shardKey}`]) map[`thing-${shardKey}`] = []
    map[`thing-${shardKey}`][String(i)] = { i }
    objArr.push({ i })
}

Tests:

string map
const v = map['thing-5']['5'] console.log(v) delete map['thing-5']['5']
find
for (let i = objArr.length - 1; i >= 0; i--) { const v = objArr[i] if (v.i === 5) { objArr.splice(i, 1) console.log(v) return v } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
string map
find

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 benchmark and explain what's being tested, compared, and their pros and cons.

**What's being tested:**

The benchmark is comparing two approaches for searching an array:

1. **String Map**: The benchmark defines an object `map` with string keys and values that are arrays of objects containing a single property `i`. The search query uses the bracket notation to access a specific value in the array.
2. **For loop with Array Splice**: The benchmark defines an array `objArr` and performs a for loop iteration from the end to find a specific element based on its index.

**Options compared:**

The two options being compared are:

* String Map (using bracket notation)
* For loop with Array Splice

**Pros and Cons of each approach:**

1. **String Map:**
	* Pros:
		+ Fast lookups, as the browser can directly access the array using the key.
		+ Efficient use of memory, as the data is stored in a compact object structure.
	* Cons:
		+ Limited to arrays with string keys, which might not be suitable for all scenarios.
		+ Can lead to slower performance due to object creation and lookup overhead.
2. **For loop with Array Splice:**
	* Pros:
		+ More flexible, as it can work with arrays of any type.
		+ Allows for more control over the iteration process.
	* Cons:
		+ Generally slower than the String Map approach due to array manipulation and loop overhead.

**Library used:**

The benchmark uses a JavaScript object `map` which is not part of the standard library. It's likely that this object is a custom implementation or a polyfill for a specific use case.

**Special JS feature/syntax:**

There are no special features or syntaxes being tested in this benchmark.

**Other alternatives:**

Other approaches to search arrays could include:

* Using `Array.prototype.indexOf()` and `Array.prototype.splice()`
* Using `Map` objects (if the browser supports them)
* Using native methods like `Object.keys()`, `JSON.parse()`, and `Array.from()`
* Using third-party libraries or frameworks that provide optimized array searching algorithms.

It's worth noting that the performance difference between these approaches can be significant, especially for large arrays. The String Map approach is generally faster due to its optimized data structure and direct access to elements.

Related benchmarks:

2 string map vs. for search with sharded array small N (version: 0)

Comparing performance of: string map vs find

Created: 3 years ago by: Guest

Jump to the latest result

string map

find

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):