Benchmark: Testing findMode

Script Preparation code:

// Purposely global
numbers = Array.from({length: 1e6}, () => Math.floor(Math.random() * 1e5))

function findMode(numbers) {
    let counted = numbers.reduce((acc, curr) => { 
        if (curr in acc) {
            acc[curr]++;
        } else {
            acc[curr] = 1;
        }

        return acc;
    }, {});

    let mode = Object.keys(counted).reduce((a, b) => counted[a] > counted[b] ? a : b);

    return mode;
}

function mostCommonNumber(numbers) {
    let map = new Map()
    for (let num of numbers) {
        map.set(num, (map.get(num) || 0) + 1)
    }

    let mostCommonNumber = NaN
    let maxCount = -1
    for (let [num, count] of map.entries()) {
        if (count > maxCount) {
            maxCount = count
            mostCommonNumber = num
        }
    }

    return mostCommonNumber
}

​x
 
// Purposely globalnumbers = Array.from({length: 1e6}, () => Math.floor(Math.random() * 1e5))​function findMode(numbers) {    let counted = numbers.reduce((acc, curr) => {         if (curr in acc) {            acc[curr]++;        } else {            acc[curr] = 1;        }​        return acc;    }, {});​    let mode = Object.keys(counted).reduce((a, b) => counted[a] > counted[b] ? a : b);​    return mode;}​function mostCommonNumber(numbers) {    let map = new Map()    for (let num of numbers) {        map.set(num, (map.get(num) || 0) + 1)    }​    let mostCommonNumber = NaN    let maxCount = -1    for (let [num, count] of map.entries()) {        if (count > maxCount) {            maxCount = count            mostCommonNumber = num        }    }​    return mostCommonNumber}​​

Tests:

findMode
findMode(numbers)
findMode(numbers)
mostCommonNumber
mostCommonNumber(numbers)
mostCommonNumber(numbers)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
findMode
mostCommonNumber

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36

Browser/OS: Chrome 61 on Windows

View result in a separate tab

Test name	Executions per second
findMode	12.0 Ops/sec
mostCommonNumber	7.1 Ops/sec

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

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

Benchmark Definition

The JSON represents two JavaScript microbenchmarks: findMode and mostCommonNumber. Both functions take an array of numbers as input and return the most frequently occurring number in the array.

Options Compared

For each benchmark, two options are compared:

Using a Map: The first option uses a Map object to count the occurrences of each number in the array. This approach is implemented in the findMode function.
Without Using a Map: The second option does not use a Map object and instead uses an object literal to store the counts. This approach is implemented in the mostCommonNumber function.

Pros and Cons

Using a Map (findMode)

Pros:

More concise and expressive code
Easier to understand and maintain, especially for large datasets
Faster lookup times compared to object literals

Cons:

May have higher memory overhead due to the additional data structure
Can be slower if the map is not properly optimized for lookup

Without Using a Map (mostCommonNumber)

Pros:

Lower memory overhead
May be faster in some cases, especially for small datasets

Cons:

More verbose and less expressive code
Slower lookup times compared to maps

In general, using a Map object is a good choice when working with large datasets or performance-critical applications. However, it may come at the cost of higher memory usage.

Library

The Array.from() method is used in both benchmarks to create an array of random numbers. This method is a part of the ECMAScript standard and is supported by most modern JavaScript engines.

Special JS Feature/Syntax

None of the tested code uses any special JavaScript features or syntax that would make it non-standard or non-portable.

Alternatives

If you need to optimize these benchmarks further, here are some alternative approaches:

Using a Set object instead of a Map object for counting occurrences.
Implementing a custom hash function for faster lookup times.
Using a just-in-time (JIT) compiler or a JavaScript engine with optimized performance.

Keep in mind that optimization should always be done carefully and with a clear understanding of the trade-offs involved.

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The JSON represents two JavaScript microbenchmarks: `findMode` and `mostCommonNumber`. Both functions take an array of numbers as input and return the most frequently occurring number in the array.

**Options Compared**

For each benchmark, two options are compared:

1. **Using a Map**: The first option uses a `Map` object to count the occurrences of each number in the array. This approach is implemented in the `findMode` function.
2. **Without Using a Map**: The second option does not use a `Map` object and instead uses an object literal to store the counts. This approach is implemented in the `mostCommonNumber` function.

**Pros and Cons**

**Using a Map (findMode)**

Pros:

* More concise and expressive code
* Easier to understand and maintain, especially for large datasets
* Faster lookup times compared to object literals

Cons:

* May have higher memory overhead due to the additional data structure
* Can be slower if the map is not properly optimized for lookup

**Without Using a Map (mostCommonNumber)**

Pros:

* Lower memory overhead
* May be faster in some cases, especially for small datasets

Cons:

* More verbose and less expressive code
* Slower lookup times compared to maps

In general, using a `Map` object is a good choice when working with large datasets or performance-critical applications. However, it may come at the cost of higher memory usage.

**Library**

The `Array.from()` method is used in both benchmarks to create an array of random numbers. This method is a part of the ECMAScript standard and is supported by most modern JavaScript engines.

**Special JS Feature/Syntax**

None of the tested code uses any special JavaScript features or syntax that would make it non-standard or non-portable.

**Alternatives**

If you need to optimize these benchmarks further, here are some alternative approaches:

* Using a `Set` object instead of a `Map` object for counting occurrences.
* Implementing a custom hash function for faster lookup times.
* Using a just-in-time (JIT) compiler or a JavaScript engine with optimized performance.

Keep in mind that optimization should always be done carefully and with a clear understanding of the trade-offs involved.

Related benchmarks:

Testing findMode (version: 0)

Comparing performance of: findMode vs mostCommonNumber

Created: 7 years ago by: Registered User

Jump to the latest result

findMode

mostCommonNumber

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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