Benchmark: mybenchmark1233131311123324320

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 = 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	4996446.5 Ops/sec
set.has	4843208.5 Ops/sec
obj.hasownproperty	4793990.5 Ops/sec
in obj	4962883.5 Ops/sec
obj[key]	4954665.0 Ops/sec
map.set	4929125.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and analyze the provided benchmark.

**Benchmark Definition JSON**

The benchmark definition represents a JavaScript function that checks if an element exists in various data structures (array, set, object, map). The script preparation code creates these data structures with 100,000 elements, each assigned a value. The target value is set to 6500.

**Options Compared**

The benchmark compares the performance of six functions:

1. `isTargetThereIncludes(arr, target)`: Uses the `.includes()` method on an array.
2. `isTargetThereSet(numberSet, target)`: Uses the `has()` method on a set.
3. `isTargetThereHasOwnProperty(obj, target)`: Uses the `hasOwnProperty()` method on an object.
4. `isTargetThereIn(obj, target)`: Uses the `in` operator on an object.
5. `isTargetThereSelectKey(obj, target)`: Accesses an object property using bracket notation (`obj[target]`).
6. `isTargetThereMap(numberMap, target)`: Uses the `.has()` method on a map.

**Pros and Cons of Each Approach**

1. `.includes()` (Array):
	* Pros: Widely supported, simple to implement.
	* Cons: Can be slower for large arrays due to the need to search through the entire array.
2. `has()` (Set):
	* Pros: Fast lookup times, ideal for sets with unique elements.
	* Cons: May not work well for sets with duplicate elements or non-unique elements.
3. `hasOwnProperty()` (Object):
	* Pros: Fast and efficient, ideal for objects with properties that are often accessed directly.
	* Cons: May not work well for objects with dynamic properties or inheritance.
4. `in` operator (Object):
	* Pros: Simple and fast, ideal for objects with a limited number of properties.
	* Cons: May not work well for objects with many properties or complex property access patterns.
5. Bracket notation (`obj[target]`) (Object):
	* Pros: Fast and efficient, ideal for accessing object properties by key.
	* Cons: May not work well for objects with dynamic properties or inheritance.
6. `.has()` (Map):
	* Pros: Fast lookup times, ideal for maps with unique keys.
	* Cons: May not work well for maps with duplicate keys.

**Other Considerations**

* The benchmark uses a relatively small target value (6500) and large data structures (100,000 elements), which may not be representative of real-world use cases.
* The script preparation code creates multiple data structures, which can affect the overall performance of the benchmark.
* The benchmark does not account for potential caching or optimization techniques that might improve performance in practice.

**Alternatives**

Other alternatives to these functions could include:

* Using `Array.prototype.find()` instead of `.includes()`
* Using a library like Lodash's `some()` function instead of `hasOwnProperty()` and `in` operator
* Using a library like Google's Closure Library's `goog.object.hasKey()` function instead of bracket notation

Keep in mind that these alternatives may have different performance characteristics, and the best choice will depend on the specific use case and requirements.

Related benchmarks:

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