Benchmark: for in vs foreach

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js'></script>

Script Preparation code:

var allHeaders = {
  'Accept-Encoding': 'gzip,deflate',
  'Accept-Language': 'en-US',
  'Content-Type': 'application/json',
  'User-Agent': `(compatible; Mozilla/5.0; MSIE 9.0; Trident/5.0;})`,
  'Proxy-Connection': 'Keep-Alive',
  Connection: 'Keep-Alive',
  Accept: 'application/hal+json, application/json',
};

function omit(obj, keys) {
  var result = {};
  for (let i in obj) {
    if (keys.indexOf(i) >= 0) continue;
    result[i] = obj[i];
  }
  return result;
}

function forEach(obj, keys) {
  var result = {};
  keys.forEach(k => {
  	if (obj[k]) {
      result[k] = obj[k];
    }
  });
  return result;
}

Tests:

omit for 3 keys
omit(allHeaders, ['Accept-Encoding', 'User-Agent', 'Connection']);
foreach for 3 keys
forEach(allHeaders, ['Accept-Encoding', 'User-Agent', 'Connection']);
omit for 2 keys
omit(allHeaders, ['Accept-Encoding', 'Connection']);
forEach for 2 keys
forEach(allHeaders, ['Accept-Encoding', 'Connection']);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
omit for 3 keys
foreach for 3 keys
omit for 2 keys
forEach for 2 keys

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 14_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 14 on iOS 14.5

View result in a separate tab

Test name	Executions per second
omit for 3 keys	2872288.8 Ops/sec
foreach for 3 keys	4111247.2 Ops/sec
omit for 2 keys	2904259.8 Ops/sec
forEach for 2 keys	4907110.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript loops can be a fascinating topic.

The provided JSON represents two JavaScript functions: `omit` and `forEach`. These functions are used to create test cases for measuring the performance difference between two approaches: iterating over an object using a traditional `for...in` loop versus using the `forEach` method.

**What is tested?**

The tests compare the execution speed of two different methods:

1. **Traditional `for...in` loop**: This approach iterates over the object's properties, checking each key to see if it exists in the `keys` array. If a key matches, its value is added to the result object.
2. **`forEach` method**: This approach uses the `Array.prototype.forEach()` method to iterate over the keys, executing a callback function for each key that exists in the `keys` array.

**Options compared**

The two approaches are:

1. Traditional `for...in` loop
2. `forEach` method

**Pros and Cons:**

* **Traditional `for...in` loop**:
	+ Pros:
		- Can be more efficient for small objects, as it only needs to iterate over the keys.
		- Less memory usage, as no additional arrays are created.
	+ Cons:
		- Can be slower for large objects, due to the overhead of iterating over all properties.
		- May not work well with non-enumerable properties (e.g., those inherited from prototype chains).
* `forEach` method**:
	+ Pros:
		- More concise and expressive code, as it's a built-in method.
		- Can handle non-enumerable properties without issues.
	+ Cons:
		- May be slower due to the overhead of function calls for each iteration.

**Library: Lodash**

The `omit` function uses the `lodash` library. Lodash is a popular utility library that provides a wide range of functions, including those for working with objects, arrays, and more. In this case, `omit` is used to create an object with only specific keys.

**Special JS features: None mentioned**

There are no special JavaScript features or syntaxes used in the provided code snippets.

**Benchmark preparation code explanation**

The `Script Preparation Code` section defines two functions:

1. `allHeaders`: An object representing HTTP headers.
2. `omit(obj, keys)`: A function that takes an object and an array of keys as arguments. It returns a new object with only the specified keys.
3. `forEach(obj, keys)`: A function that takes an object and an array of keys as arguments. It returns a new object with only the specified keys.

The `Html Preparation Code` section includes a script tag referencing Lodash, which is used by the `omit` function.

**Other alternatives**

There are alternative approaches to iterating over objects in JavaScript:

1. Using `Object.keys()` and manual iteration
2. Using `Array.prototype.map()` or `Array.prototype.filter()`
3. Using a library like Underscore.js (similar to Lodash)

Each of these alternatives has its own trade-offs, performance characteristics, and use cases.

Related benchmarks:

for in vs foreach (version: 0)

Comparing performance of: omit for 3 keys vs foreach for 3 keys vs omit for 2 keys vs forEach for 2 keys

Created: 4 years ago by: Guest

Jump to the latest result

omit for 3 keys

foreach for 3 keys

omit for 2 keys

forEach for 2 keys

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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