Benchmark: Reflect.ownKeys vs object.keys preformence

Script Preparation code:

var dicr = {};
for (var i = 0; i < 1000; i++) {
	var	key1= Math.floor(Math.random() * 1000);
	var	key2= Math.floor(Math.random() * 1000);
    dicr[`${key1}_${key1}`] = key2;
}

Tests:

reflact
for (var i = 0; i < 1000; i++) { const res = Reflect.ownKeys(dicr) }
objectKeys
for (var i = 0; i < 1000; i++) { const res = Object.keys(dicr) }

Historical Performance Data aggregated from 17 community runs

Desktop Results:

Chrome 11 runs

objectKeys

115/s

reflact

52/s

Fastest: objectKeys (2.2x faster)

View exact numbers

✓ objectKeys: 115 ops/sec
• reflact: 52 ops/sec

Firefox 6 runs

objectKeys

584/s

reflact

295/s

Fastest: objectKeys (2.0x faster)

View exact numbers

✓ objectKeys: 584 ops/sec
• reflact: 295 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reflact
objectKeys

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0

Browser/OS: Firefox 150 on Mac OS X 10.15

View result in a separate tab

objectKeys

447K/s

reflact

252/s

View exact numbers

Test name	Executions per second
✓ objectKeys	446,795 Ops/sec
reflact	252 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the provided JSON benchmark and its options.

**Benchmark Definition**

The provided JSON defines two benchmarks:

1. `Reflect.ownKeys vs object.keys performance`
2. Two individual test cases:
	* `reflact` (using `Reflect.ownKeys`)
	* `objectKeys` (using `Object.keys`)

**Options being compared**

In this benchmark, the main difference between the two options is how they are used to retrieve keys from an object:

1. **`Reflect.ownKeys`**: This method returns a new array-like object containing only the own property names (i.e., excluding inherited properties) of the given object.
2. **`Object.keys`**: This method returns an array of a given object's own enumerable property names.

**Pros and Cons**

* **`Reflect.ownKeys`**:
	+ Pros: Can be more efficient when dealing with large objects, as it only returns own properties, excluding inherited ones. Additionally, `Reflect.ownKeys` is a newer method introduced in ECMAScript 2015 (ES6), which might be optimized for performance.
	+ Cons: May not work correctly in older browsers or versions of JavaScript that don't support the Reflect API.
* **`Object.keys`**:
	+ Pros: Widely supported across most modern browsers and JavaScript engines. It's also a more traditional method, making it easier to understand and implement.
	+ Cons: Returns all own properties, including inherited ones, which might be slower for very large objects.

**Library and purpose**

There are no libraries explicitly mentioned in this benchmark. However, `Reflect` is a built-in JavaScript API that provides methods for reflecting on objects, such as `ownKeys`.

**Special JS feature or syntax**

This benchmark does not use any special JavaScript features or syntax beyond the ones mentioned above (e.g., `let`, `const`, `template literals`). If you're interested in exploring other advanced JavaScript features, I can provide explanations for those as well.

**Other alternatives**

If you'd like to test alternative methods for retrieving keys from an object, some options could be:

1. **`for...in` loop**: Iterates over all properties (own and inherited) of an object using a `for...in` loop.
2. **`JSON.keys()`**: An older method that returns an array of property names as a string (not recommended due to limitations).
3. **`Array.from()` with `Object.entries()`**: Can be used to create an array of own property names, but may not be as efficient or memory-friendly as `Reflect.ownKeys`.

Keep in mind that these alternatives might have different performance characteristics and usage scenarios compared to the methods being tested here.

I hope this explanation helps you understand the provided benchmark!

Reflect.ownKeys vs object.keys preformence (version: 0) Benchmark.js

Reflect.ownKeys vs object.keys preformence

Comparing performance of: `reflact vs objectKeys`

Created: 4 years ago by: Registered User

Go to the latest result

reflact

objectKeys

Historical Performance Data aggregated from 17 community runs

Desktop Results:

Chrome 11 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Reflect.ownKeys vs object.keys preformence (version: 0) Benchmark.js

Reflect.ownKeys vs object.keys preformence

Comparing performance of: reflact vs objectKeys

Created: 4 years ago by: Registered User

Go to the latest result

reflact

objectKeys

Historical Performance Data aggregated from 17 community runs

Desktop Results:

Chrome 11 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `reflact vs objectKeys`