Benchmark: Move To First 2 - MeasureThat.net

Script Preparation code:

var wallets = [
  {
    currency: {
      id: "USD"
    }
  },
  {
    currency: {
      id: "IDR"
    }
  },
  {
    currency: {
      id: "SGD"
    }
  },
]

Tests:

Old Code
const moveCurrencyToFirst = (wallets, currencyId) => { const currencyIdx = wallets.findIndex( (wallet) => wallet.currency.id === currencyId ); const tempWallets = [...wallets]; if (currencyIdx !== -1) { const currWallet = wallets[currencyIdx]; tempWallets.splice(currencyIdx); tempWallets.unshift(currWallet); } return tempWallets; }; console.log(moveCurrencyToFirst(wallets, "SGD"))
New Code
const moveCurrencyToFirst = (wallets, currencyId) => { if(!wallets.length) return []; return wallets.reduce((result, wallet) => { if(wallet.currency.id === currencyId) { return [wallet, ...result] } return [...result, wallet] }, []) }; console.log(moveCurrencyToFirst(wallets, "SGD"))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Old Code
New Code

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Old Code	287450.4 Ops/sec
New Code	282583.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the benchmark.

**Benchmark Definition**

The provided JSON represents a benchmark for measuring the performance difference between two JavaScript functions, specifically designed to move a specific currency to the first position in an array of wallets.

The `Script Preparation Code` section contains a JavaScript code snippet that initializes an array of wallet objects with three currencies (USD, IDR, and SGD). This code is used as input for both benchmark test cases.

**Test Cases**

There are two individual test cases:

1. **Old Code**: The first test case uses the original implementation, which finds the index of the target currency in the `wallets` array, creates a temporary copy of the array, and then moves the target wallet to the first position using `splice`. This approach is generally straightforward but may involve unnecessary copies of the original data.
2. **New Code**: The second test case uses a different implementation that leverages the `reduce()` method to achieve the same result. This approach is more concise and avoids explicit indexing, but it also relies on the iterative nature of the `reduce()` method.

**Pros and Cons**

Here's a brief analysis of each approach:

* **Old Code**:
	+ Pros: Easy to understand, straightforward implementation.
	+ Cons: May involve unnecessary copies of data, potentially leading to performance issues with large arrays.
* **New Code**:
	+ Pros: More concise, avoids explicit indexing, and can be more efficient for large arrays.
	+ Cons: May be less intuitive for developers unfamiliar with the `reduce()` method.

**Library**

There is no explicitly mentioned library in the provided benchmark definition. However, it's worth noting that some of the modern JavaScript features used here, such as template literals (`\r\n`) and destructuring assignments (`const { id } = currency`), are part of the ECMAScript standard and are not typically considered "libraries."

**Special JS Features or Syntax**

The benchmark definition uses the following special JavaScript features:

* **Template Literals**: Used to create multi-line strings with backslashes (`\r\n`) escaping the newline characters.
* **Destructuring Assignments**: Used to extract the `id` property from the `currency` object in a concise manner.

**Other Alternatives**

For benchmarking similar scenarios, you might consider using other approaches or tools:

1. **Use a testing framework**: Consider using a testing framework like Jest or Mocha, which can provide additional features for writing and running tests.
2. **Experiment with different data sizes**: Vary the size of the `wallets` array to test performance under different loads.
3. **Compare against existing solutions**: Look up existing libraries or implementations that achieve similar results, such as a currency management library.

Keep in mind that these alternatives might not be directly applicable to this specific benchmark definition, but they can provide additional insights and ideas for optimizing your own JavaScript performance testing workflows.

Related benchmarks:

Move To First 2 (version: 0)

Comparing performance of: Old Code vs New Code

Created: 2 years ago by: Guest

Jump to the latest result

Old Code

New Code

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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