Benchmark: mybenchmark123313131112332432

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 = 6500



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	4968939.5 Ops/sec
set.has	4956718.5 Ops/sec
obj.hasownproperty	4906502.5 Ops/sec
in obj	5062245.0 Ops/sec
obj[key]	4965298.0 Ops/sec
map.set	5155986.0 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 its different test cases.

**Benchmark Definition JSON**

The benchmark definition json provides the basic setup for the tests, including the script preparation code, which creates an array, set, object, map, and a target value of 6500. It also defines six functions:

* `isTargetThereFor` and `isTargetThereForReverse`: searches for the target in the array from both ends
* `isTargetThereIncludes`, `isTargetThereSet`, `isTargetThereHasOwnProperty`, and `isTargetThereIn`: uses various methods to check if an element is present in the set, object, and map
* `isTargetThereMap` and `isTargetThereSelectKey`: checks if a key exists in the map

These functions are used as test cases in the individual test cases.

**Individual Test Cases**

The benchmark consists of six individual test cases:

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

These test cases use different methods to check if the target value (6500) is present in the array, set, object, and map.

**Options Compared**

The six test cases compare the performance of different methods for checking presence:

1. Array: `includes` method
2. Set: `has` method
3. Object: `hasOwnProperty`, `in`, and `[key]` properties
4. Map: `has` and `set` methods

**Pros and Cons of Different Approaches**

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

1. Array: `includes`
	* Pros: Simple, widely supported, fast.
	* Cons: May be slow for large arrays due to iteration.
2. Set: `has`
	* Pros: Fast, efficient for set operations.
	* Cons: Not suitable for objects or arrays without a set implementation.
3. Object:
	* `hasOwnProperty`: Pros: Fast, reliable, but only works on object properties.
	* Cons: Limited scope, may not work on all types of objects.
	* `in`: Pros: Works on any type of object, fast. Cons: May be slower than `hasOwnProperty` due to the check for the property's existence.
	* `[key]`: Pros: Fast, reliable, and works on any type of object. Cons: May not work as expected if the key is not a string or if it's a non-enumerable property.
4. Map:
	* `has`: Pros: Fast, efficient for map operations.
	* Cons: Not suitable for objects or arrays without a map implementation.

**Other Considerations**

When writing benchmarks like this, consider the following factors:

1. **Scalability**: Test cases should be designed to scale well with increasing data sizes and complexity.
2. **Consistency**: Ensure that test cases are executed consistently, with minimal variation between runs.
3. **Representative data**: Use representative data that covers a range of possible scenarios.
4. **Benchmarking tool selection**: Choose a suitable benchmarking tool that can handle the test cases' requirements.

By considering these factors and understanding the trade-offs between different approaches, you can write informative benchmarks that provide valuable insights into performance differences between various methods.

Related benchmarks:

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