Benchmark: convert and lookup 10k times

Script Preparation code:

var objList= [
  { name: "Lorem" },
  { name: "ipsum" },
  { name: "dolor" },
  { name: "sit" },
  { name: "amet" },
  { name: "consectetur" },
  { name: "adipisicing" },
  { name: "elit." },
  { name: "Ullam" },
  { name: "nesciunt" },
  { name: "debitis," },
  { name: "facilis" },
  { name: "qui" },
  { name: "possimus" },
  { name: "minus" },
  { name: "rerum" },
  { name: "velit" },
  { name: "saepe" },
  { name: "magnam," },
  { name: "voluptatum" },
  { name: "quos" },
  { name: "eveniet" },
  { name: "ducimus" },
  { name: "facere" },
  { name: "harum" },
  { name: "itaque" },
  { name: "atque" },
  { name: "assumenda" },
  { name: "reiciendis" },
  { name: "exercitationem" }
]

Tests:

Object lookup
var object = objList.reduce((acc, team) => { acc[team.name] = team return acc; }, {}); var b = object["consectetur"]
Map lookup
var map = objList.reduce((acc, team) => { acc.set(team.name, team); return acc; }, new Map()); for(let i = 0; i < 100000; i++) var b = map.has("consectetur")
Set lookup
var set = objList.reduce((acc, team) => { acc.add(team.name); return acc; }, new Set()); for(let i = 0; i < 100000; i++) var b = set.has("consectetur")
Obj array lookup
for(let i = 0; i < 100000; i++) var b = objList.some(o=>o.name == "consectetur")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object lookup
Map lookup
Set lookup
Obj array lookup

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object lookup	1635299.2 Ops/sec
Map lookup	36647.3 Ops/sec
Set lookup	36601.9 Ops/sec
Obj array lookup	1750.7 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark presented in the JSON focuses on various methods of looking up a value within a structured list of objects. Specifically, it compares the performance of different JavaScript data structures and lookup techniques using a consistently defined object list containing 10,000 items.

### Options Compared:

1. **Object Lookup:**
   - **Method**: An object is created using `Array.prototype.reduce`, mapping each object's `name` property to the object itself for efficient lookup. The test retrieves an object using the `name` key.
   - **Pros**: 
     - Fast lookups due to the inherent implementation of JavaScript objects using hash tables.
     - Simple syntax and widely used.
   - **Cons**:
     - Can lead to performance issues if there are many properties or deep nesting, but for flat data structures, it remains efficient.

2. **Map Lookup:**
   - **Method**: Uses the JavaScript `Map` object, which is designed for key-value pairs, to store the objects using their `name` property.
   - **Pros**: 
     - Maintains the insertion order of keys.
     - Can hold keys of any type (not just strings).
     - Generally better performance when handling large datasets.
   - **Cons**: 
     - Slightly higher memory overhead compared to plain objects.
     - Some overhead in terms of syntax and operations compared to objects.

3. **Set Lookup:**
   - **Method**: A `Set` is created to store unique `name` values. The test checks for existence of a specific `name` in the set.
   - **Pros**: 
     - Ensures uniqueness of values.
     - Fast `has()` method for checking if an item exists.
   - **Cons**: 
     - Not suitable for storing complete objects or values associated with keys.
     - Only checks for existence, meaning additional data associated with those names would require a different data structure.

4. **Object Array Lookup:**
   - **Method**: Uses the method `Array.prototype.some` to iterate over the array checking if any object's `name` matches the search term.
   - **Pros**: 
     - Simple and understandable.
     - Works without extra data structures.
   - **Cons**: 
     - Inefficient for large datasets, as it requires iterating through the entire array.
     - Performance degrades significantly as the size of the list increases.

### Performance Results:

From the benchmark results:
- **Object Lookup**: 1,635,299 executions per second (most efficient).
- **Map Lookup**: 36,647 executions per second.
- **Set Lookup**: 36,601 executions per second.
- **Object Array Lookup**: 1,750 executions per second (least efficient).

### Considerations:

When choosing a data structure for lookups, the choice often depends on the requirements for performance, memory usage, and whether the order of items matters (as with `Map`). Using objects remains the most straightforward and efficient choice for many scenarios, especially when keys are simple strings.

### Alternatives:

Other alternatives could include:
- **Typed Arrays**: Useful for numeric data but not directly comparable in context as above.
- **WeakMap and WeakSet**: Provide similar functionality to `Map` and `Set`, but with memory management benefits for garbage collection when keys or values are no longer referenced.
- External libraries: Libraries like Lodash or Immutable.js provide various utilities for data manipulation which might offer additional performance benefits, but would come at the cost of loading additional code into the application.

Overall, each method has strengths and weaknesses, and the optimal choice depends on specific use cases and performance requirements. For an application needing high-frequency lookups, opting for `Map` or traditional objects is advisable, while arrays might be more suitable for smaller or infrequency-use cases.

Related benchmarks:

convert and lookup 10k times (version: 1)

Comparing performance of: Object lookup vs Map lookup vs Set lookup vs Obj array lookup

Created: one month ago by: Guest

Jump to the latest result

Object lookup

Map lookup

Set lookup

Obj array lookup

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):