Benchmark: Map Values Array.from vs Spread

Tests:

Array.from
var fooSet = new Map(); for(var i=0;i<100;i++) { fooSet.set(i, i); } var other = Array.from(fooSet.values());
Spread
var fooSet = new Map(); for(var i=0;i<100;i++) { fooSet.set(i, i); } var other = [...fooSet.values()];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.from
Spread

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.

The provided benchmark measures the performance difference between using `Array.from()` and the spread operator (`...`) to extract values from a `Map` object.

**What is tested?**

In this benchmark, we create an empty `Map` object called `fooSet`. We then populate it with 100 key-value pairs using the `set()` method. The goal is to measure which approach (either `Array.from()` or the spread operator) is faster when extracting all values from the map.

**Options compared**

There are two options being compared:

1. **`Array.from(fooSet.values())`**: This method creates a new array by iterating over the values of the `Map` object using its iterator.
2. **`[...fooSet.values()]`**: This is the spread operator (also known as array destructuring) applied to the map's values.

**Pros and Cons**

*   **`Array.from()`**:
    *   Pros: More explicit, readable code; no ambiguity about what it does.
    *   Cons: May incur a performance overhead due to the iterator creation.
*   **Spread Operator (`[...fooSet.values()]`)**:
    *   Pros: Efficient and fast; modern syntax that's widely used in JavaScript development.
    *   Cons: Less explicit code, might be harder to understand for less experienced developers.

**Library**

Neither of these options requires any external libraries. The `Map` object is a built-in JavaScript data structure, which makes this benchmark particularly focused on the language itself.

**Special JS feature or syntax**

The spread operator (`[...fooSet.values()]`) is a modern JavaScript feature introduced in ECMAScript 2015 (ES6). It's used extensively in modern web development but might not be familiar to all developers, especially those with less experience in JavaScript.

Now that we've explained the benchmark, let's look at the alternatives:

*   For measuring the performance of different approaches in JavaScript, MeasureThat.net provides a wide range of benchmarks covering various aspects of the language, such as:
    *   Array and DOM manipulation
    *   Loops (e.g., `for`, `while`)
    *   String manipulation
    *   Object creation and iteration
*   If you're interested in exploring other benchmarking tools or websites, some popular alternatives include:
    *   jsperf.com
    *   jsbench.net
    *   js-bench.org

Keep in mind that the choice of benchmarking tool depends on your specific needs and requirements. MeasureThat.net is excellent for JavaScript microbenchmarks, but it might not cover all aspects or be suitable for other programming languages.

Related benchmarks:

Map Values Array.from vs Spread (version: 0)

Comparing performance of: Array.from vs Spread

Created: 3 years ago by: Guest

Jump to the latest result

Array.from

Spread

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