Benchmark: Using a Set vs. Object vs Array for small number of elements

Using a Set vs. Object vs Array for small number of elements (version: 0)

For a small number of elements (5) test whether creating and looking and deleting elements in a set vs object vs array are faster

Comparing performance of: Objects: Create and lookup vs Objects: Create lookup and delete vs Sets: Create and lookup vs Sets: Create, lookup and delete vs Arrays: Create and lookup vs Arrays: Create, lookup and delete

Created: 4 years ago by: Registered User

Jump to the latest result

Tests:

Objects: Create and lookup
let ELEMENTS = ["one", "two", "three", "four", "five"]; let obj = {}; for(let key of ELEMENTS) { obj[key] = 1; } let a = 0; for(let key of ELEMENTS) { if (key in obj) { a++; } }
Objects: Create lookup and delete
let ELEMENTS = ["one", "two", "three", "four", "five"]; let obj = {}; for(let key of ELEMENTS) { obj[key] = 1; } let a = 0; for(let key of ELEMENTS) { if (key in obj) { a++; } } for(let key of ELEMENTS) { delete obj[key]; }
Sets: Create and lookup
let ELEMENTS = ["one", "two", "three", "four", "five"]; let set = new Set(); for(let key of ELEMENTS) { set.add(key); } let a = 0; for(let key of ELEMENTS) { if (set.has(key)) { a++; } }
Sets: Create, lookup and delete
let ELEMENTS = ["one", "two", "three", "four", "five"]; let set = new Set(); for(let key of ELEMENTS) { set.add(key); } let a = 0; for(let key of ELEMENTS) { if (set.has(key)) { a++; } } for(let key of ELEMENTS) { set.delete(key); }
Arrays: Create and lookup
let ELEMENTS = ["one", "two", "three", "four", "five"]; let arr = []; for(let key of ELEMENTS) { if (arr.indexOf(key) === -1) { arr.push(key); } } let a = 0; for(let key of ELEMENTS) { if (arr.indexOf(key) !== -1) { a++; } } // reverse for delete test. arr.reverse();
Arrays: Create, lookup and delete
let ELEMENTS = ["one", "two", "three", "four", "five"]; let arr = []; for(let key of ELEMENTS) { if (arr.indexOf(key) === -1) { arr.push(key); } } let a = 0; for(let key of ELEMENTS) { if (arr.indexOf(key) !== -1) { a++; } } // reverse for delete test to hit worst case arr.reverse(); for(let key of ELEMENTS) { let i = arr.indexOf(key); if (i !== -1) { arr[i] = arr[arr.length-1]; arr.length -= 1; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Objects: Create and lookup
Objects: Create lookup and delete
Sets: Create and lookup
Sets: Create, lookup and delete
Arrays: Create and lookup
Arrays: Create, lookup and delete

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.

Let's break down the benchmark and its various test cases.

**Benchmark Overview**

The benchmark measures the performance of creating, looking up, and deleting elements in different data structures: Sets, Objects, and Arrays. The focus is on small numbers of elements (5).

**Data Structures Compared**

1. **Objects**: An empty object (`{}`) is created, populated with keys from an array (`ELEMENTS`), and then iterated over to look up values using the `in` operator. Later, elements are deleted from the object.
2. **Arrays**: An empty array (`[]`) is created, populated with keys from an array (`ELEMENTS`), and then iterated over to look up values using the `indexOf()` method. Later, elements are deleted from the array by reversing it and assigning a value at the end index.
3. **Sets**: A new Set instance is created, added with keys from an array (`ELEMENTS`), and then iterated over to look up values using the `has()` method. Later, elements are deleted from the set.

**Pros and Cons of Each Approach**

* **Objects**:
	+ Pros: Easy to implement, flexible data structure.
	+ Cons: Iterating over object keys can be slow due to hash table lookups.
	+ Performance: Moderate (2nd fastest).
* **Arrays**:
	+ Pros: Fast iteration using `indexOf()`, easy element access.
	+ Cons: Deleting elements by reversing the array is inefficient, leading to O(n) time complexity.
	+ Performance: Slowest.
* **Sets**:
	+ Pros: Fast lookups with `has()` method, efficient set operations.
	+ Cons: Creating a new Set instance can be slower than initializing an empty object or array.
	+ Performance: Moderate (fastest for "Create and lookup" tests).

**Why the Results?**

The benchmark results show that Sets are generally faster for creating and looking up elements, while Arrays perform poorly due to their deletion approach. Objects fall in between. The variations in performance across different test cases might be attributed to factors like:

* Cache locality: Set operations tend to access memory more efficiently than Array or Object iterations.
* Browser-specific optimizations: Firefox 95 might have optimized its implementation for Sets and Objects, leading to better performance.

Keep in mind that these results are specific to this particular benchmark and browser version. Other browsers, versions, or data structures might exhibit different performance characteristics.

Related benchmarks: