Benchmark: mybenchmark123313131112332432130112

Script Preparation code:

var theArr = Array.from({ length: 30 }, (_, 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 = 27



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

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark definition is an object with several properties:

* `Name`: A unique identifier for the benchmark (in this case, "mybenchmark123313131112332432130112").
* `Description`: None.
* `Script Preparation Code`: This section of code initializes several variables:
	+ `theArr` is a JavaScript array created using `Array.from`.
	+ `theSet` is a Set created from `theArr`.
	+ `theObject` is an object created by assigning properties to each element in `theArr` using `Object.assign`.
	+ `theMap` is a Map created from `theArr` using the spread operator.
	+ `theTarget` is set to 27.
* `Html Preparation Code`: None.

The script preparation code defines six functions:

1. `isTargetThereFor(arr, target)`: Searches for the target value in the array from left to right.
2. `isTargetThereForReverse(arr, target)`: Searches for the target value in the array from right to left.
3. `isTargetThereIncludes(arr, target)`: Returns whether the array includes the target value using the `includes` method.
4. Five functions are defined for different data structures: Set (`has`), Object (`hasOwnProperty`, `in`, and `selectKey`), and Map (`set`). These functions test various ways to check if a value is present in each data structure.

**Test Cases**

The benchmark consists of six individual test cases, each with its own `Benchmark Definition` string that references one of the defined functions. The test names are:

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

**Options Compared**

The benchmark compares six different options for checking if a value is present in an array, Set, Object, and Map:

1. Array: using the `includes` method
2. Set: using the `has` method
3. Object:
	* Using the `hasOwnProperty` property
	* Using the `in` operator
	* Using object key access (`selectKey`)
4. Map: using the `set` method

**Pros and Cons**

Each option has its pros and cons:

1. Array: `includes` is generally fast and efficient, but can be slow for large arrays.
2. Set: `has` is usually the fastest way to check if a value is present in a Set.
3. Object:
	* `hasOwnProperty` is reliable but might not work as expected with inherited properties or prototypes.
	* `in` operator is slower than `hasOwnProperty`.
	* `selectKey` is generally slower than other options.
4. Map: `set` is not a standard method for checking if a value is present in a Map; it's primarily used for adding elements.

**Other Considerations**

The benchmark also includes the browser and device information, which can affect performance due to factors like caching, hardware acceleration, and page loading time.

Keep in mind that this benchmark focuses on the JavaScript engine and data structure operations, not on other aspects like network latency or user interaction.

Latest run results:

Run details: (Test run date: one year 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	5212498.5 Ops/sec
set.has	5267181.0 Ops/sec
obj.hasownproperty	5140730.0 Ops/sec
in obj	5278378.5 Ops/sec
obj[key]	5256087.5 Ops/sec
map.set	5419878.0 Ops/sec

Related benchmarks:

mybenchmark123313131112332432130112 (version: 0)

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

Created: one year 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>

Experimental features:

Fastest: N/A

Slowest: N/A

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