Benchmark: Array.from vs Object.assign

Tests:

Array.from
var fooSet = new Set(); for(var i=0;i<100;i++) { fooSet.add(i); } var other = Array.from(fooSet);
Object.assign
var fooSet = new Set(); for(var i=0;i<100;i++) { fooSet.add(i); } var other = Object.assign([],fooSet);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.from
Object.assign

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition and Options**

The benchmark is defined in two test cases: `Array.from` and `Object.assign`. Both options aim to create an array from a set of unique values. However, they differ in their implementation:

*   **`Array.from`**: This method creates a new array by taking elements from another iterable (in this case, the `Set` object) and adding them to the end of an existing array.
*   **`Object.assign`**: In this approach, we use `Object.assign()` with an empty array (`[]`) as its first argument. We then pass the set (`fooSet`) as the second argument.

**Pros and Cons**

### Array.from

Pros:

*   Faster: Creating a new array using `Array.from` is generally faster than using `Object.assign()`.
*   More readable: It's more straightforward to read, especially when dealing with larger datasets.
*   Built-in method: `Array.from()` is a built-in JavaScript method, so it doesn't require any additional libraries.

Cons:

*   Only works on arrays: If the underlying data structure isn't an array (like in our case with sets), this method won't work as intended.
*   May not be cache-friendly: When dealing with large datasets, `Array.from()` might not be cache-friendly due to its dynamic nature.

### Object.assign

Pros:

*   Flexible: It works with any iterable data structure, including arrays and even other objects.
*   Cache-friendly: Using `Object.assign()` can take advantage of the browser's caching mechanisms, which may improve performance in certain scenarios.

Cons:

*   Slower: Creating an array using `Object.assign()` is generally slower than using `Array.from()`.
*   Less readable: It requires more code to achieve the same result.
*   Requires additional library calls: You're essentially calling a method on another object (the target array), which can add overhead.

**Library and Special JS Features**

Neither of these options relies on external libraries or special JavaScript features beyond what's available in modern browsers. However, if you need to support older browsers that don't support `Set` objects or `Object.assign()` with an empty array as its first argument, additional workarounds might be necessary.

**Other Alternatives**

If you're looking for alternative methods to create arrays from sets, consider the following:

*   **Spread operator (`...`) + `Array.from()`:**
    ```javascript
const other = [...fooSet];
```
    This approach takes advantage of the spread operator's support in modern browsers.
*   **`Array.prototype.slice()` with a closure:**
    ```javascript
function createArray(set) {
  return function() {
    var array = [];
    for (var i = 0; i < set.size; i++) {
      array.push(set.values().next().value);
    }
    return array;
  };
}

const other = createArray(fooSet)();
```
    This approach uses a closure to capture the size of the set and then iterates over it, adding values to an array.
*   **`reduce()` + `Array.from()`:**
    ```javascript
const other = Array.from(fooSet.reduce((acc, value) => [...acc, value], []));
```
    This approach uses `reduce()` to build an array from the set's values.

While these alternatives can provide different performance characteristics and trade-offs, they're worth considering when dealing with specific use cases or browser support requirements.

Related benchmarks:

Array.from vs Object.assign (version: 0)

Comparing performance of: Array.from vs Object.assign

Created: 7 years ago by: Guest

Jump to the latest result

Array.from

Object.assign

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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