Benchmark: set main methods SYMBOL/OBJ/STRING?NUMBER

Script Preparation code:

var arr = Array.from({length: 1000}).map((_, i) => i);
var arrNum = arr.map(v => Number(v));
var arrStr = arr.map(String);
var arrObj = arr.map(v =>{return {[v]: v}})
var arrSymb = arr.map(Symbol)

function func(a, b) {  
  return 0.5 - Math.random();
}  
const arrMix = arr.toSorted(func);
var arrRandom = [...arrNum.slice(0, 250), ...arrStr.slice(250, 500), ...arrObj.slice(500, 750), ...arrMix.slice(750, 1000).map(v => Symbol(v))].toSorted(func)


var numberSet = new Set();
var stringSet = new Set();
var objSet = new Set();
var symbolSet = new Set();
var mixedSet = new Set();

Tests:

SET number
arrNum.forEach(v => stringSet.add(v)) arrNum.forEach(v => stringSet.has(v)) arrNum.forEach(v => stringSet.size) arrNum.forEach(v => stringSet.delete(v))
SET string
arrStr.forEach(v => numberSet.add(v)) arrStr.forEach(v => numberSet.has(v)) arrStr.forEach(v => numberSet.size) arrStr.forEach(v => numberSet.delete(v))
SET obj
arrObj.forEach(v => objSet.add(v)) arrObj.forEach(v => objSet.has(v)) arrObj.forEach(v => objSet.size) arrObj.forEach(v => objSet.delete(v))
SET symbol
arrSymb.forEach(v => symbolSet.add(v)) arrSymb.forEach(v => symbolSet.has(v)) arrSymb.forEach(v => symbolSet.size) arrSymb.forEach(v => symbolSet.delete(v))
SET mixed
arrRandom.forEach(r => mixedSet.add(r)) arrRandom.forEach(r => mixedSet.has(r)) arrRandom.forEach(r => mixedSet.size) arrRandom.forEach(r => mixedSet.delete(r))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
SET number
SET string
SET obj
SET symbol
SET mixed

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
SET number	4796.5 Ops/sec
SET string	5857.3 Ops/sec
SET obj	4911.1 Ops/sec
SET symbol	4826.1 Ops/sec
SET mixed	4787.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in the provided benchmark.

**Benchmark Overview**

The benchmark tests various data structures (sets) created from different types of arrays:

1. `numberSet` - set created from an array of numbers (`arrNum`)
2. `stringSet` - set created from an array of strings (`arrStr`)
3. `objSet` - set created from an array of objects (`arrObj`)
4. `symbolSet` - set created from an array of symbols (`arrSymb`)
5. `mixedSet` - set created from a mixed array containing all types (numbers, strings, objects, and symbols) (`arrRandom`)

**Options Compared**

The benchmark compares the performance of sets created using different methods:

1. Using arrays (`numberArray`, `stringArray`, `objectArray`, `symbolArray`)
2. Mixing arrays with other data structures (`mixedSet`)

**Pros and Cons**

1. **Arrays**: Pros:
	* Most widely supported and understood.
	* Simple to implement.
	* Can be used for various operations.
Cons:
	* May require additional memory allocations.
	* Insertion and deletion can lead to linear time complexity.
2. **Sets with objects**: Pros:
	+ No need to iterate over the entire array when inserting or deleting elements.
	+ Good performance for insertion, deletion, and lookup operations.
Cons:
	+ Requires JavaScript engine support for object-based sets.
	+ May require additional memory allocations due to object creation.
3. **Sets with symbols**: Pros:
	+ Fast and efficient for insertion, deletion, and lookup operations.
	+ No need to iterate over the entire array when inserting or deleting elements.
Cons:
	+ Requires JavaScript engine support for symbol-based sets.
	+ Limited availability (JavaScript engines may not support symbols).
4. **Mixed arrays**: Pros:
	+ Offers a balance between performance and simplicity.
Cons:
	+ May require more complex logic due to mixed data types.

**Library Usage**

The benchmark uses the following libraries:

1. `Array.from()`: creates an array from an iterable.
2. `Set()`: creates a set from an array or other iterable.
3. `String()`: converts values to strings.
4. `Symbol()`: creates symbols.

**Special JavaScript Features**

No special JavaScript features are mentioned in the benchmark, but some might be implicitly used due to library functions (e.g., `Array.from()`). If any special features were explicitly used, they would be mentioned here.

**Alternatives**

Other alternatives for creating sets could include:

1. **Native array methods**: using built-in methods like `filter()`, `map()`, or `reduce()` to create a set.
2. **Third-party libraries**: using specialized libraries for set operations, such as [Lodash](https://lodash.com/).
3. **Data structure implementations**: implementing custom data structures from scratch.

Keep in mind that the benchmark's focus is on comparing different methods for creating sets, rather than evaluating alternative approaches for set operations.

Related benchmarks:

set main methods SYMBOL/OBJ/STRING?NUMBER (version: 3)

Comparing performance of: SET number vs SET string vs SET obj vs SET symbol vs SET mixed

Created: one year ago by: Registered User

Jump to the latest result

SET number

SET string

SET obj

SET symbol

SET mixed

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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