Benchmark: object to array with lodash

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.5/lodash.min.js"></script>

Script Preparation code:

var object = {
  'a': {
    'key': 'a',
    'foo': 123123,
    'bar': 123,
    'fobar': 456
  },
  'b': {
    'key': 'b',
    'foo': 67563,
    'bar': 6345,
    'fobar': 3425
  },
  'c': {
    'key': 'c',
    'foo': 34532,
    'bar': 123412,
    'fobar': 534532
  },
  'd': {
    'key': 'd',
    'foo': 1234321,
    'bar': 435234,
    'fobar': 346457
  },
  'e': {
    'key': 'e',
    'foo': 23523,
    'bar': 124325,
    'fobar': 2134235
  },
  'f': {
    'key': 'f',
    'foo': 1235213,
    'bar': 346346,
    'fobar': 213423
  }
};

Tests:

Array.prototype.reduce()
Object.keys(object).reduce(function(acc, cur) { acc.push(object[cur]); return acc; }, []);
_.reduce()
_.reduce(object, function(acc, cur) { acc.push(cur); return acc; }, []);
_.values()
_.values(object);
_.toArray()
_.toArray(object);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.reduce()
_.reduce()
_.values()
_.toArray()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36

Browser/OS: Chrome 64 on Mac OS X 10.13.3

View result in a separate tab

Test name	Executions per second
Array.prototype.reduce()	733959.4 Ops/sec
_.reduce()	1213602.4 Ops/sec
_.values()	1662732.1 Ops/sec
_.toArray()	1557529.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested in each benchmark.

**Benchmark Definition**

The `benchmark` object defines the test case, which includes:

*   **Name**: A unique identifier for the benchmark (in this case, "object to array with lodash").
*   **Description**: An optional description of the benchmark. In this example, it's null.
*   **Script Preparation Code**: The code used to prepare the input data for the test case. This is a JavaScript object representing an nested structure (`object`).
*   **Html Preparation Code**: The HTML code used to include the required library (Lodash) in the benchmark.

**Individual Test Cases**

The `testCases` array contains four individual test cases, each with:

*   **Benchmark Definition**: A string defining the actual benchmark function to be tested. This is a JavaScript function that converts the nested object into an array using Lodash functions.
*   **Test Name**: The name of the test case.

Now, let's analyze each test case and explain what's being compared:

1.  `Array.prototype.reduce()`: This test case uses the built-in `reduce()` method of the Array prototype to convert the nested object into an array. Lodash provides a similar function called `_reduce()` that achieves the same result.
2.  `_.reduce(object, function(acc, cur) {\r\n  acc.push(cur);\r\n  return acc;\r\n}, [])`: This test case uses the Lodash function `_reduce()` to convert the nested object into an array. The difference between this and the built-in `reduce()` method is that `_reduce()` takes a callback function as its second argument, which allows for more flexibility in how elements are added to the accumulator.
3.  `_.values(object)`: This test case uses Lodash's `_values()` function to convert the nested object into an array of its values. However, this approach does not preserve the original structure of the object and may lead to unexpected results if the nested objects contain arrays or other complex data types.
4.  `_.toArray(object)`: This test case uses Lodash's `_toArray()` function to convert the nested object into an array. Similar to `_values()`, this approach may not preserve the original structure of the object.

**Pros and Cons**

Here are some pros and cons for each approach:

*   **Built-in `reduce()` method**: Pros:
    *   Native JavaScript implementation, so it's likely to be optimized for performance.
    *   Simple and easy to understand.
    Cons:
    *   Limited flexibility in how elements are added to the accumulator.
*   Lodash's `_reduce()` function: Pros:
    *   More flexible than the built-in `reduce()` method.
    *   Allows for more control over how elements are added to the accumulator.
    Cons:
    *   Requires an additional library (Lodash).
    *   May introduce overhead due to the need to load and initialize Lodash.
*   Lodash's `_values()` function: Pros:
    *   Simple and easy to use.
    Cons:
    *   Does not preserve the original structure of the object, which may lead to unexpected results.
    *   Limited control over how values are extracted from the object.
*   Lodash's `_toArray()` function: Pros:
    *   Similar to `_values()`, but with more control over the resulting array.
    Cons:
    *   May not preserve the original structure of the object, similar to `_values()`.

**Other Considerations**

When choosing an approach for benchmarking, consider the following factors:

*   **Performance**: If performance is a critical concern, use the built-in `reduce()` method or Lodash's `_reduce()` function.
*   **Flexibility**: If you need more control over how elements are added to the accumulator, choose Lodash's `_reduce()` function.
*   **Preserving structure**: If preserving the original structure of the object is important, consider using Lodash's `_values()` or `_toArray()` functions.

**Alternatives**

If you're not interested in using JavaScript libraries like Lodash, you can implement your own custom solution for converting nested objects to arrays. Some alternative approaches include:

*   Using a recursive function to iterate over the nested object and add elements to an array.
*   Utilizing a queue-based data structure to traverse the nested object and collect its values.

Keep in mind that implementing a custom solution may require more development time and effort, but it can provide greater control over the conversion process.

Related benchmarks:

object to array with lodash (version: 0)

Comparing performance of: Array.prototype.reduce() vs _.reduce() vs _.values() vs _.toArray()

Created: 6 years ago by: Guest

Jump to the latest result

Array.prototype.reduce()

_.reduce()

_.values()

_.toArray()

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):