Benchmark: Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.find vs Map.has

Script Preparation code:

  var object = {},
      array = [],
      i, test = 1000;
	var map = new Map();
  
  for (i = 0; i < 1000; i++) {
   object['something' + i] = true;
   array.push({id: 'something' + i});
    map.set('something' + i, true);
  }

Tests:

Object.hasOwnProperty
object.hasOwnProperty('something' + test)
Object in
('something' + test) in object
Array.indexOf
array.indexOf({id:'something' + test}) !== -1
direct
object['something' + test] === true
Array find
array.find(e => e.id === 'something' + test)
Map has
map.has('something' + test)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.hasOwnProperty
Object in
Array.indexOf
direct
Array find
Map has

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0

Browser/OS: Firefox 123 on Linux

View result in a separate tab

Test name	Executions per second
Object.hasOwnProperty	945507648.0 Ops/sec
Object in	891083392.0 Ops/sec
Array.indexOf	8324755.5 Ops/sec
direct	941446272.0 Ops/sec
Array find	45489.6 Ops/sec
Map has	790937088.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested on the provided JSON?**

The provided JSON represents a JavaScript microbenchmark that tests six different approaches to check if an object or array has a specific property with a certain value. The test cases are:

1. `object.hasOwnProperty('something' + test)`: checks if the object `object` has a property named `'something' + test`.
2. `('something' + test) in object`: uses the "in" operator to check if the string `'something' + test` is a property of the object `object`.
3. `array.indexOf({id: 'something' + test}) !== -1`: checks if the array `array` contains an element with the property `id` equal to `'something' + test`.
4. `object['something' + test] === true`: directly accesses the property `object['something' + test]` and checks if its value is `true`.
5. `array.find(e => e.id === 'something' + test)`: uses the `find()` method to search for an element in the array `array` that has the property `id` equal to `'something' + test`.
6. `map.has('something' + test)`: checks if the Map `map` has a key with the value `'something' + test`.

**Options compared**

The six options are being compared to measure their performance in terms of execution speed. The performance will be measured by calculating the number of executions per second (ExecutionsPerSecond) for each test case.

**Pros and Cons of different approaches**

1. **`object.hasOwnProperty('something' + test')`:**
	* Pros: simple, efficient, and widely supported.
	* Cons: may not work as expected if the property is inherited from a prototype chain or if the object has multiple properties with the same name.
2. **`('something' + test) in object':** (using "in" operator)
	* Pros: works even if the property is inherited from a prototype chain, but can be slower than `hasOwnProperty`.
	* Cons: may not work as expected if the property is hidden behind another property, and can be slower than `hasOwnProperty` for most cases.
3. **`array.indexOf({id: 'something' + test}) !== -1':** (using `indexOf()` method)
	* Pros: works even if the array contains other elements with the same property value, but can be slower than directly accessing the property.
	* Cons: may not work as expected if the array is large and the `indexOf()` method needs to search through it, which can lead to performance issues.
4. **`object['something' + test] === true':** (directly accessing the property)
	* Pros: simple, efficient, and works well even if the property is inherited from a prototype chain or has multiple properties with the same name.
	* Cons: requires knowing the exact property name at compile-time.
5. **`array.find(e => e.id === 'something' + test)':** (using `find()` method)
	* Pros: works well even if the array contains other elements, but can be slower than directly accessing the property and may not work as expected if the element is not found.
	* Cons: requires an arrow function or a callback function, which can make the code more complex.
6. **`map.has('something' + test)`:**
	* Pros: works well even if the map contains other keys with the same value, but can be slower than directly accessing the property due to the Map's underlying data structure.
	* Cons: may not work as expected if the key is hidden behind another key.

**Special JS features or syntax**

The `find()` method and arrow functions are used in some of the test cases. These features are part of modern JavaScript, but they may not be supported by older browsers or versions of Internet Explorer.

In summary, each approach has its strengths and weaknesses, and the choice of which one to use depends on the specific requirements of the project and the desired level of complexity and maintainability.

Related benchmarks:

Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.find vs Map.has (version: 0)

Comparing performance of: Object.hasOwnProperty vs Object in vs Array.indexOf vs direct vs Array find vs Map has

Created: 3 years ago by: Guest

Jump to the latest result

Object.hasOwnProperty

Object in

Array.indexOf

direct

Array find

Map has

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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