Benchmark: Object to Arrayss3

Script Preparation code:

function obj2Array2(obj, prefix) {
    var arr = [];

    _.forIn(obj, function (value, key) {
      if (_.isObject(value) && !_.isEmpty(value)) {
        arr = _.concat(arr, obj2Array2(value, key));
      }
      else {
        arr.push(key);
        try {
          arr.push(JSON.stringify(value));
        }
        catch (e) {
          arr.push(value);
        }
      }

    });


    if (_.isString(prefix) && !_.isEmpty(prefix)) {
      return _.map(arr, function (arg, index) {
        if (index % 2 === 0) { return `${prefix}.${arg}`; }
        return arg;
      });
    }

    return arr;
  }

function obj2Array (object, prefix) {
    var arr = [];
	
  	Object.keys(object).forEach(function (key) {
		const value = object[key];
		
		if (typeof value === 'object' && Object.keys(value).length !== 0) {
            let prefixedKey = (prefix && `${prefix}.${key}`) || key,
                
                returnedArray = obj2Array(value, prefixedKey);

            arr = arr.concat(returnedArray);

            return;
        }

        arr.push((prefix && `${prefix}.${key}`) || key);
        arr.push(JSON.stringify(value));

	});

    return arr;
}

function obj2Array3(obj, prefix, arr = []) {
    if (!obj) { return arr; }


    const usePrefix = prefix && typeof prefix === 'string';


    usePrefix && (prefix += '.');


    Object.keys(obj).forEach(function (key) {
      const value = obj[key];

      usePrefix && (key = prefix + key);

      if (typeof value === 'object' && Object.keys(value).length !== 0) {
        obj2Array3(value, key, arr);
      }

      else {
        arr.push(key, JSON.stringify(value));
      }
    });


    return arr;

  }

    var objToTest = {
      user: {
        id: 123,
        data: {
            username: 'marvin',
            email: 'marvin@heartofgold.ship'
        },
        tags: ['robot', 'depressed', 'brain the size of a planet']
      }
    }

Tests:

Current Method
obj2Array2(objToTest);
My Method (added empty check)
obj2Array(objToTest);
Yashish Method (added empty check)
obj2Array3(objToTest);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Current Method
My Method (added empty check)
Yashish Method (added empty check)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1.1 Safari/605.1.15

Browser/OS: Safari 13 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
Current Method	51203.2 Ops/sec
My Method (added empty check)	123277.4 Ops/sec
Yashish Method (added empty check)	105001.2 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is designed to measure the performance of different approaches for converting an object to an array in JavaScript. The benchmark uses three different functions: `obj2Array2`, `obj2Array`, and `obj2Array3`.

**What are we testing?**

We're comparing the execution speed (in executions per second) of these three functions when running the following code:

`obj2Array(objToTest);`

This code converts an object `objToTest` to an array.

The benchmark is testing the performance of each function by executing it repeatedly and measuring how many times it can execute within a second.

**Options compared**

Here's what we're comparing in the three functions:

1.  **`obj2Array2(objToTest)`**
    *   This function uses Lodash, a popular utility library for JavaScript.
    *   It recursively traverses the object and checks if each value is an object or not. If it's an object, it calls itself with that object as its argument and the current key as the prefix.
    *   If the value is not an object, it adds the key-value pair to the array.
2.  **`obj2Array(objToTest)`**
    *   This function does not use any libraries (no external dependencies).
    *   It iterates over the keys of the object and checks if each value is an object or not.
    *   If it's an object, it calls itself with that object as its argument and adds the prefixed key to the array.
    *   If it's not an object, it adds the key-value pair to the array without prefixing it
3.  **`obj2Array3(objToTest)`**
    *   This function does not use any libraries (no external dependencies).
    *   It iterates over the keys of the object and checks if each value is an object or not.
    *   If it's an object, it calls itself with that object as its argument and adds the prefixed key to the array.
    *   If it's not an object, it adds the key-value pair to the array without prefixing it.

**Pros and Cons of different approaches**

*   **`obj2Array2(objToTest)`**: This function uses Lodash for recursive operations. While this makes the code more concise and easier to maintain, it might introduce overhead due to the library dependency.
    *   Pros: More readable, less prone to errors
    *   Cons: Adds external dependency (Lodash)
*   **`obj2Array(objToTest)`**: This function does not use any libraries. It's a more lightweight approach without any dependencies but can become verbose and harder to read.
    *   Pros: Lightweight, no external dependencies
    *   Cons: Can be harder to maintain, prone to errors
*   **`obj2Array3(objToTest)`**: This function does not use any libraries. It's similar to `obj2Array`, but uses a different approach for prefixing keys.
    *   Pros: Lightweight, no external dependencies
    *   Cons: Can be harder to maintain, prone to errors

**Library**

The Lodash library is used in the `obj2Array2` function.

*   Purpose: Utility functions for functional programming, array manipulation, and more.
*   Benefits: Concise code, easier maintenance, less prone to errors
*   Drawbacks: Adds external dependency

**Best Practice**

When dealing with performance-critical code or when working on large-scale projects, it's essential to consider the trade-offs between readability, maintainability, and execution speed. In this case, if you're concerned about performance, `obj2Array3` might be a better choice due to its lightweight nature. However, if you prioritize readability and ease of maintenance, `obj2Array2` with Lodash is a viable option.

**Device Platform**

The benchmark is run on a Desktop platform (Mac OS X 10.15.4).

*   Pros: Well-suited for desktop applications
*   Cons: May not be optimized for mobile or web applications

**Best Practice**

When working on cross-platform projects, ensure that your code is compatible with the target platforms and optimizes their performance.

**Conclusion**

The benchmark compares three approaches for converting an object to an array in JavaScript. Each function has its pros and cons, including library dependencies and execution speed. The best approach depends on your specific use case, priorities, and requirements.

Related benchmarks:

Object to Arrayss3 (version: 0)

Converts object to array.

Comparing performance of: Current Method vs My Method (added empty check) vs Yashish Method (added empty check)

Created: 4 years ago by: Guest

Jump to the latest result

Current Method

My Method (added empty check)

Yashish Method (added empty check)

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