Benchmark: Object.keys vs for-in

Script Preparation code:

var obj = {
    'a': 1,
    'b': 2,
    'c': 3,
    'd': 4,
    'e': 5,
    'f': 6,
    'g': 7,
    'h': 8,
    'i': 9,
    'j': 10,
    'k': 11,
    'l': 12,
    'm': 13,
    'n': 14,
    'o': 15,
    'p': 16,
    'q': 17,
    'r': 18,
    's': 19,
    't': 20,
    'u': 21,
    'v': 22,
    'w': 23,
    'x': 24,
    'y': 25,
    'z': 26
};

AخA
 
var obj = {    'a': 1,    'b': 2,    'c': 3,    'd': 4,    'e': 5,    'f': 6,    'g': 7,    'h': 8,    'i': 9,    'j': 10,    'k': 11,    'l': 12,    'm': 13,    'n': 14,    'o': 15,    'p': 16,    'q': 17,    'r': 18,    's': 19,    't': 20,    'u': 21,    'v': 22,    'w': 23,    'x': 24,    'y': 25,    'z': 26};

Tests:

Object.keys
for (var i = 0; i < 1000; i++) { Object.keys(obj).forEach(key => console.log(key)); }
for (var i = 0; i < 1000; i++) {
Object.keys(obj).forEach(key => console.log(key));
}

for-in with var

for (var i = 0; i < 1000; i++) {
  for (var key in obj) {
      console.log(key); 
  }
}

 
for (var i = 0; i < 1000; i++) {  for (var key in obj) {      console.log(key);   }}

for-in with let

for (let i = 0; i < 1000; i++) {
  for (let key in obj) {
      console.log(key); 
  }
}

 
for (let i = 0; i < 1000; i++) {  for (let key in obj) {      console.log(key);   }}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Object.keys
for-in with var
for-in with let

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.4

View result in a separate tab

Test name	Executions per second
Object.keys	44.2 Ops/sec
for-in with var	52.0 Ops/sec
for-in with let	52.1 Ops/sec

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

Let's break down the provided benchmarking test cases.

Benchmark Definition

The benchmark compares three approaches to iterate over an object's keys:

Object.keys(): This method returns an array of a given object's own enumerable property names.
for-in with var: This is an older way of iterating over an object's properties using the for...in loop. The variable declared in this context has limited scope and can lead to unexpected behavior if used outside the loop.
for-in with let: Similar to the previous approach, but uses a block-scoped variable.

Library and Special JS Features

In this benchmark, there is no specific library being tested or special JavaScript features like async/await or modern syntax (e.g., arrow functions).

Options Compared

The three options are compared in terms of their execution speed. The test case measures the number of executions per second for each approach.

Pros and Cons of Each Approach

Object.keys():
- Pros: Efficient, modern, and widely supported.
- Cons: May not be as performant on older browsers or versions.
for-in with var:
- Pros: Widely available in older browsers, but may lead to issues if used outside the loop.
- Cons: Less efficient, more prone to errors due to variable scope limitations.
for-in with let:
- Pros: Same efficiency as Object.keys(), with better variable scoping control.
- Cons: Requires modern browsers and JavaScript versions.

Considerations

When choosing an approach, consider the following:

Modernity: Use Object.keys() or for-in with let for new projects to ensure compatibility with future browsers and JavaScript versions.
Browser support: If you need to support older browsers, use for-in with var, but be aware of potential issues.
Performance: In most cases, Object.keys() is the fastest option.

Other Alternatives

If none of these options appeal to you or if you're interested in alternative approaches:

forEach(): Similar to Object.keys(), but more suitable for array iteration.
**Array.prototype.entries()`: Returns an array-like object with key-value pairs, suitable for iterating over objects and arrays.

Keep in mind that these alternatives may not be specifically designed for iterating over objects' keys or might have different performance characteristics compared to the options tested here.

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking test cases.

**Benchmark Definition**

The benchmark compares three approaches to iterate over an object's keys:

1. `Object.keys()`: This method returns an array of a given object's own enumerable property names.
2. `for-in` with `var`: This is an older way of iterating over an object's properties using the `for...in` loop. The variable declared in this context has limited scope and can lead to unexpected behavior if used outside the loop.
3. `for-in` with `let`: Similar to the previous approach, but uses a block-scoped variable.

**Library and Special JS Features**

In this benchmark, there is no specific library being tested or special JavaScript features like async/await or modern syntax (e.g., arrow functions).

**Options Compared**

The three options are compared in terms of their execution speed. The test case measures the number of executions per second for each approach.

**Pros and Cons of Each Approach**

1. **`Object.keys()`**:
	* Pros: Efficient, modern, and widely supported.
	* Cons: May not be as performant on older browsers or versions.
2. **`for-in` with `var`**:
	* Pros: Widely available in older browsers, but may lead to issues if used outside the loop.
	* Cons: Less efficient, more prone to errors due to variable scope limitations.
3. **`for-in` with `let`**:
	* Pros: Same efficiency as `Object.keys()`, with better variable scoping control.
	* Cons: Requires modern browsers and JavaScript versions.

**Considerations**

When choosing an approach, consider the following:

* Modernity: Use `Object.keys()` or `for-in` with `let` for new projects to ensure compatibility with future browsers and JavaScript versions.
* Browser support: If you need to support older browsers, use `for-in` with `var`, but be aware of potential issues.
* Performance: In most cases, `Object.keys()` is the fastest option.

**Other Alternatives**

If none of these options appeal to you or if you're interested in alternative approaches:

1. **`forEach()`**: Similar to `Object.keys()`, but more suitable for array iteration.
2. **Array.prototype.entries()`: Returns an array-like object with key-value pairs, suitable for iterating over objects and arrays.

Keep in mind that these alternatives may not be specifically designed for iterating over objects' keys or might have different performance characteristics compared to the options tested here.

Related benchmarks:

Object.keys vs for-in (version: 0)

Comparing performance of: Object.keys vs for-in with var vs for-in with let

Created: 3 years ago by: Guest

Jump to the latest result

Object.keys