Benchmark: mybenchmark12331313111233243213

Script Preparation code:

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

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition JSON**

The benchmark definition JSON contains several functions that are designed to test different methods of checking if a specific value (theTarget) is present in an array, set, object, or map. These functions are:

* `isTargetThereFor(arr, target)`: A recursive function that searches for the target value in the array from start to end.
* `isTargetThereForReverse(arr, target)`: A recursive function that searches for the target value in the array from end to start.
* `isTargetThereIncludes(arr, target)`: A built-in JavaScript method that checks if an element is present in the array using the includes() method.
* The set-related functions:
	+ `isTargetThereSet(numberSet, target)`: Checks if the target value is present in the set using the has() method.
	+ `isTargetThereHasOwnProperty(obj, target)`: A function that checks if an object property exists using the.hasOwnProperty() method.
	+ `isTargetThereIn(obj, target)`: A function that checks if a key is present in an object using the 'in' operator.
	+ `isTargetThereSelectKey(obj, target)`: A function that accesses an object property by its key using the square bracket notation.
* The map-related function:
	+ `isTargetThereMap(numberMap, target)`: Checks if the target value is present in the map using the has() method.

**Test Cases**

The test cases are individual benchmark tests that exercise one of the functions mentioned above. Each test case consists of a "Benchmark Definition" JSON string and a "Test Name". The Benchmark Definition contains only the function to be tested, while the Test Name provides context for the execution results.

**Options Compared**

The test cases compare the performance of different methods for checking if a value is present in an array, set, object, or map. These options include:

* Recursive functions (e.g., `isTargetThereFor`, `isTargetThereHasOwnProperty`)
* Built-in JavaScript methods (e.g., `includes()`, `has()`, `in` operator)
* Property access using the square bracket notation (e.g., `obj[key]`)

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

* Recursive functions:
	+ Pros: Can be efficient for large datasets, easy to implement.
	+ Cons: May have high overhead due to function calls, can lead to stack overflow for very large arrays.
* Built-in JavaScript methods:
	+ Pros: Typically optimized for performance, easy to use.
	+ Cons: May not work as expected for certain data types or edge cases.
* Property access using the square bracket notation:
	+ Pros: Fast and efficient, works well with objects and maps.
	+ Cons: Requires knowledge of property names, may lead to errors if property names are incorrect.

**Other Considerations**

When interpreting the benchmark results, consider the following:

* The test data and dataset size may impact performance.
* Other factors like CPU, memory, and garbage collection can affect execution times.
* The benchmark runner's optimizations and limitations may influence results.

By analyzing these factors, you can better understand which methods perform well in different scenarios and make informed decisions about optimizing your code.

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	4895623.0 Ops/sec
set.has	4973181.5 Ops/sec
obj.hasownproperty	4871212.0 Ops/sec
in obj	4840246.0 Ops/sec
obj[key]	4904170.5 Ops/sec
map.set	5045685.0 Ops/sec

Related benchmarks:

mybenchmark12331313111233243213 (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):