Benchmark: func vs array - MeasureThat.net

Script Preparation code:

const actG = {}
let row = null
let type = null
const test1 = (params) => {
  console.log(params);
}

Tests:

func
const result = [] result.push({ id: 'A1', test: 'Test1', cls: 'asd dd da', act: (ev) => { actG.a1({ r: row, t: type }, ev) } }) result.push({ id: 'A2', test: 'Test2', cls: 'asd dd da2', act: (ev) => { actG.a2({ r: row, t: type }, ev) } }) result.push({ id: 'A3', test: 'Test3', cls: 'asd dd da3', act: (ev) => { actG.a3({ r: row, t: type }, ev) } })
array
const result = [] result.push({ id: 'A1', test: 'Test1', cls: 'asd dd da', act: ['a1', { r: row, t: type }] }) result.push({ id: 'A2', test: 'Test2', cls: 'asd dd da2', act: ['a2', { r: row, t: type }] }) result.push({ id: 'A3', test: 'Test3', cls: 'asd dd da3', act: ['a3', { r: row, t: type }] })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
func
array

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
func	58058596.0 Ops/sec
array	27177082.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON compares two approaches for function invocation in JavaScript: invoking functions directly versus invoking functions through an array reference. The benchmark consists of two test cases, labeled "func" and "array".

### Test Cases Overview

1. **Test Case: "func"**
   - **Definition**: The functions (`actG.a1`, `actG.a2`, `actG.a3`) are called directly within the `act` property of the test cases.
   - **Execution**: Each function is executed immediately when the test case is called, passing predefined parameters (`{ r: row, t: type }`).

2. **Test Case: "array"**
   - **Definition**: The functions are referenced in the `act` property using an array format. In this case, the array contains the function name as a string and the parameters as an object.
   - **Execution**: The actual function needs to be invoked later, which introduces a level of indirection.

### Performance Results
- **"func" Test**: 58,058,596 executions per second.
- **"array" Test**: 27,177,082 executions per second.

### Comparative Analysis of Approach

#### Pros and Cons:

- **Direct Function Invocation (func)**
  - **Pros**:
    - Faster execution as there’s no overhead of creating an array reference.
    - More straightforward, easier to read, and understand.
  - **Cons**:
    - Less flexible if you need to dynamically decide which function to call at runtime.

- **Array Reference Invocation (array)**
  - **Pros**:
    - More flexible, allowing for dynamic function calls and evaluation.
    - Easier to modify and handle if the context of the function to call is determined at runtime.
  - **Cons**:
    - Introduces additional overhead from the array handling, leading to slower execution times.
    - May be less clear for someone reviewing the code, as it separates function names from their invocation.

### Additional Considerations
- **Potential Libraries**: In this benchmark, there is no specific library used for testing. The functions invoked are part of the acting groups (`actG`), which are expected to be defined elsewhere in the code. Libraries often used in conjunction with performance testing could include benchmarking libraries like **Benchmark.js** or utility libraries for functional programming, but they aren't present in this case.

- **JavaScript Features**: There is no particular advanced JavaScript feature or syntax that is specially tested or highlighted in this benchmark. The benchmark focuses on basic JavaScript function invocation techniques.

### Alternatives
- Other options for similar benchmarking may include:
  - **Using Higher-Order Functions**: These can encapsulate the method invocation process, though performance might differ based on how they're implemented.
  - **Leveraging Modern Features**: Such as the spread operator (`...`) or rest parameters can only somewhat affect the performance overhead depending on their usage.
  - **Utilizing JavaScript Proxies**: Proxies can be employed for dynamic method invocation but typically involve additional overhead.
  - **Functional Libraries**: Libraries like lodash or Ramda introduce alternatives to handling functions in a more functional paradigm which can mix performance and flexibility trade-offs.

In summary, this benchmark effectively demonstrates the performance implications between directly calling functions and leveraging an array for indirect calls. Through this analysis, software engineers can make informed decisions on the best method to use based on their specific use case scenarios.

Related benchmarks:

func vs array (version: 1)

Comparing performance of: func vs array

Created: one year ago by: Guest

Jump to the latest result

func

array

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):