Benchmark: Set vs POJO - MeasureThat.net

Script Preparation code:

red = (r, y) => {r[y] = true; return r;}
clone = s => Object.keys(s).reduce(red, {})
set1 = {a: true, b: true, c: true, d: true, e: true};
add1 = x => s => {
  if (s[x]) return s;
  var t = clone(s);
  t[x] = true; 
  return t;
}

set2 = new Set(['a','b','c','d','e'])
add2 = x => s => {
    if (s.has(x)) return s;
    var t = new Set(s);
    t.add(x);
    return t;
}

Tests:

POJO
r1 = add1('aloha')(set1)
Set
r2 = add2('aloha')(set2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
POJO
Set

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition JSON**

The provided JSON defines a benchmark that compares two approaches: POJO (Plain Old Java Object) and Set data structures for adding elements to an array-like object. The script preparation code defines:

1. A function `red` that sets a property value in an object.
2. A function `clone` that creates a shallow copy of an object using `Object.keys` and the `reduce` method with `red`.
3. Two test arrays, `set1` (a POJO) and `set2` (a Set), each containing five elements: 'a', 'b', 'c', 'd', and 'e'.
4. Functions `add1` and `add2`, which add an element to the corresponding array-like object.

The HTML preparation code is empty, indicating that no additional setup is required for the benchmark.

**Options Compared**

The two options being compared are:

1. **POJO (Plain Old Java Object)**: An object with properties, where each property value can be a boolean.
2. **Set**: A collection of unique values, implemented using a hash table.

**Pros and Cons**

**POJO**

Pros:

* Easy to understand and work with for developers familiar with JavaScript objects.
* May be more efficient for small arrays or specific use cases.

Cons:

* Less memory-efficient than Sets due to the overhead of property storage.
* May incur slower performance due to property lookup and iteration.

**Set**

Pros:

* More memory-efficient, as elements are stored in a hash table without additional overhead.
* Faster performance for large datasets or frequent additions.

Cons:

* Less intuitive to work with for developers unfamiliar with Sets.
* May have higher overhead due to the creation of a new Set object on each addition.

**Library and Purpose**

In this benchmark, `Object.keys` is used as a library function to get an array of property names from an object. It's not explicitly mentioned in the script preparation code, but it's likely included by MeasureThat.net's environment.

The purpose of `Object.keys` is to provide a way to iterate over the properties of an object and perform operations on them.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this benchmark. The focus is on comparing two approaches for adding elements to an array-like object, using standard JavaScript functions and data structures.

**Other Alternatives**

If you were interested in exploring alternative approaches, some options could be:

* Using `Map` instead of POJO: A `Map` is a data structure that stores key-value pairs, which could provide faster lookups than property access.
* Using `Array.prototype.forEach` or `Array.prototype.reduce` for additions: These methods are more efficient than the custom implementations provided by `add1` and `add2`.
* Exploring other data structures, such as `WeakSet` or `IndexedSet`, for set-like operations.

These alternatives might provide different performance characteristics, so it's essential to evaluate them in your specific use case.

Latest run results:

Run details: (Test run date: 6 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36

Browser/OS: Chrome 69 on Windows

View result in a separate tab

Test name	Executions per second
POJO	515457.3 Ops/sec
Set	562047.6 Ops/sec

Related benchmarks:

Set vs POJO (version: 0)

Comparing performance of: POJO vs Set

Created: 6 years ago by: Guest

Jump to the latest result

POJO

Set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):