Benchmark: mybenchmark123313131112332432130

Script Preparation code:

var theArr = Array.from({ length: 100000 }, (_, el) => el)
var theSet = new Set(theArr)
var theObject = Object.assign({}, ...theArr.map(num => ({ [num]: true })))
var theMap = new Map(theArr.map(num => [num, true]))
var theTarget = 9000



function isTargetThereFor(arr, target) {
  const len = arr.length
  for (let i = 0; i < len; i++) {
    if (arr[i] === target) {
      return true
    }
  }
  return false
}
function isTargetThereForReverse(arr, target) {
  const len = arr.length
  for (let i = len; i > 0; i--) {
    if (arr[i] === target) {
      return true
    }
  }
  return false
}

function isTargetThereIncludes(arr, target) {
  return arr.includes(target)
}

// Set

function isTargetThereSet(numberSet, target) {
  return numberSet.has(target)
}

// Object 

function isTargetThereHasOwnProperty(obj, target) {
  return obj.hasOwnProperty(target)
}
function isTargetThereIn(obj, target) {
  return target in obj
}
function isTargetThereSelectKey(obj, target) {
  return obj[target]
}

// Map

function isTargetThereMap(numberMap, target) {
  return numberMap.has(target)
}

Tests:

array.includes
isTargetThereIncludes(theArr, theTarget);
set.has
isTargetThereSet(theSet, theTarget);
obj.hasownproperty
isTargetThereHasOwnProperty(theObject, theTarget);
in obj
isTargetThereIn(theObject, theTarget);
obj[key]
isTargetThereSelectKey(theObject, theTarget)
map.set
isTargetThereMap(theMap, theTarget)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array.includes
set.has
obj.hasownproperty
in obj
obj[key]
map.set

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
array.includes	4903960.5 Ops/sec
set.has	5045461.5 Ops/sec
obj.hasownproperty	4916128.0 Ops/sec
in obj	5000469.0 Ops/sec
obj[key]	4970508.5 Ops/sec
map.set	5129566.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and their pros/cons.

**Benchmark Definition JSON**

The benchmark defines a script that creates various data structures (arrays, sets, objects, maps) and tests if a specific value is present in each of them. The script also includes two custom functions: `isTargetThereFor`, `isTargetThereForReverse`, which are used as a baseline for the other test cases.

**Test Cases**

The benchmark consists of six test cases:

1. **array.includes**: Tests if the value `theTarget` is present in an array (`theArr`).
2. **set.has**: Tests if the value `theTarget` is present in a set (`theSet`).
3. **obj.hasOwnProperty**: Tests if the value `theTarget` has a property with the key `theTarget` on an object (`theObject`).
4. **in obj**: Tests if the value `theTarget` is present as a property key in an object (`theObject`).
5. **obj[key]**: Tests if the value `theTarget` can be accessed using bracket notation on an object (`theObject`).
6. **map.set**: Tests if the value `theTarget` has been set as a key-value pair in a map (`theMap`).

**Comparison of Options**

The benchmark compares the performance of six different approaches:

1. **array.includes**
2. **set.has**
3. **obj.hasOwnProperty**
4. **in obj**
5. **obj[key]**
6. **map.set**

Each option has its pros and cons:

* **array.includes**: Fast and efficient, but may have poor performance for large arrays or specific values.
* **set.has**: Fast and efficient, especially for sets with a small number of elements.
* **obj.hasOwnProperty**: Slow due to the need to iterate through object properties. May be useful for testing property existence in objects.
* **in obj**: Fast, but may not work as expected if the object has a large number of own enumerable properties.
* **obj[key]**: Similar to `in obj`, but more explicit and faster for most cases.
* **map.set**: Fast and efficient for maps with a small number of key-value pairs.

**Library/Functionality**

The benchmark uses several built-in JavaScript functions and operators:

* `Array.from()`: Creates an array from an iterable.
* `Set()`: Creates a set from an iterable.
* `Object.assign()`: Copies values from one or more source objects to a target object.
* `Map()`: Creates a map from an iterable.
* `includes()` and `has()`: Test for presence of a value in an array, set, and object, respectively.

**Special JS Feature/Syntax**

None of the benchmark test cases use any special JavaScript features or syntax beyond what's built into the standard library.

Related benchmarks:

mybenchmark123313131112332432130 (version: 0)

Comparing performance of: array.includes vs set.has vs obj.hasownproperty vs in obj vs obj[key] vs map.set

Created: 2 years ago by: Guest

Jump to the latest result

array.includes

set.has

obj.hasownproperty

in obj

obj[key]

map.set

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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