Benchmark: array includes vs object key тест

Script Preparation code:

var obj = (new Array(10000)).fill(null).reduce((prev, newVal) => {prev[Math.random() + ''] = Math.random() + ''; return prev; }, { sausage: 'tst' });
var array = Object.keys(obj);

Tests:

Includes
array.includes('sausage')
Object[key]
obj['sausage']

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Includes
Object[key]

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Purpose:**
The purpose of this benchmark is to compare the performance of two methods for checking if an array contains a specific value:

1. `array.includes(value)`
2. `obj[key]` (using bracket notation to access object properties)

**Options Compared:**

*   **Method 1: `array.includes(value)`**: This method uses the `includes()` function to check if the array contains the specified value.
*   **Method 2: `obj[key]`**: This method uses bracket notation (`obj['key']`) to access a property on an object. Since the property is not defined on the object, it will return undefined. To make this comparison meaningful, we need to modify Method 2 so that it returns true when the property exists.

**Pros and Cons:**

*   **`array.includes(value)`**: This method has the following pros:
    *   Efficient use of memory (no additional objects are created)
    *   Simple syntax
*   However, there's a con:
    *   May be slower for very large arrays because it needs to traverse the entire array to find the value.

*   **`obj[key]`**: This method has the following pros:
    *   Can handle large amounts of data (since it doesn't need to search an array)
*   However, there are some cons:
    *   Requires access to object properties
    *   May be slower due to the overhead of property lookup and potential cache misses

**Library and Purpose:**
There is no external library being used in this benchmark. The `Object.keys()` method is a built-in JavaScript method that returns an array of a given object's own enumerable property names.

**Special JS Features/Syntax:**

*   None are explicitly mentioned, but the use of bracket notation (`obj['key']`) is a common way to access properties on objects in JavaScript.
*   `includes()` function was introduced in ECMAScript 2015 (ES6) as part of the Array prototype.

**Other Considerations:**

*   The size of the array and object used in this benchmark can impact performance. Larger data sets may favor one method over the other due to caching effects or memory access patterns.
*   If you were comparing `obj[key]` against a different method (like `in` operator), the results might be different because `in` is a part of the object itself, whereas bracket notation is more specific and might behave differently depending on object inheritance.

**Alternatives:**

If you wanted to compare other methods for finding values in arrays or accessing properties on objects, some alternatives could include:

*   Using `for...of` loop with array iteration
*   Using `for...in` loop with object iteration
*   Implementing a custom algorithm using bitwise operations (e.g., checking if a value is present in an array by iterating through the array and performing bitwise AND operations)
*   Comparing different caching strategies for optimizing performance

Related benchmarks:

array includes vs object key тест (version: 0)

performance comparison of ways to find if an array contains a value

Comparing performance of: Includes vs Object[key]

Created: 4 years ago by: Guest

Jump to the latest result

Includes

Object[key]

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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