Benchmark: global function or function in function

Script Preparation code:

const globalFunctionIn = (arg) => {
    return arg * arg;
}
const globalFunctionOut = () => {
    return globalFunctionIn(parseInt("131"));
}

const funcInFunc = () => {
    const func = (arg) => {
        return arg * arg;
    };

    return func(parseInt("131"));
}

function f1() {
  return globalFunctionOut();
}

function f2() {
  return funcInFunc();
}

Tests:

globalFunc
f1();
funcInFunc
f2();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
globalFunc
funcInFunc

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/124.0.0.0 Safari/537.36 Edg/124.0.0.0

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
globalFunc	10793361.0 Ops/sec
funcInFunc	10749744.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain what's being tested in this JavaScript microbenchmark.

**Benchmark Definition**

The benchmark definition provides two types of functions:

1. `globalFunctionIn`: This is a global function that takes an argument, multiplies it by itself, and returns the result. It also defines another global function `globalFunctionOut` that calls `globalFunctionIn` with the string "131" as an argument.
2. `funcInFunc`: This is a nested function definition inside another function. The outer function `f1` calls `globalFunctionOut`, which in turn calls `globalFunctionIn` with the same string "131".

**Options Compared**

The benchmark compares two approaches:

1. **Global Function Call**: `f1()`
2. **Nested Function Call**: `f2()`

**Pros and Cons of Each Approach**

**Global Function Call (f1())**

Pros:

* Simplistic and easy to understand
* Can be more efficient in terms of function lookup and call overhead

Cons:

* Requires a global scope, which can lead to namespace pollution
* May have slower performance due to the need to resolve the global variable

**Nested Function Call (f2())**

Pros:

* Encapsulates the inner function within a local scope, reducing namespace pollution
* Can be more efficient since the inner function is only accessible within its outer context

Cons:

* More complex and harder to understand due to the nested scope
* May have slower performance due to the need to resolve the inner function's scope

**Library Usage**

The benchmark uses two library functions: `parseInt()` and the built-in `Math` object (specifically, the `*` operator). These libraries are widely supported in modern browsers and provide a convenient way to perform arithmetic operations.

**Special JS Feature or Syntax**

None mentioned explicitly. However, it's worth noting that the use of template literals (`\r\n`) is not specific to JavaScript and is commonly used in various programming languages for string formatting.

**Other Considerations**

* The benchmark uses Chrome 124 as the test browser, which may not be representative of other browsers' performance.
* The `DevicePlatform` and `OperatingSystem` fields suggest that the benchmark was run on a desktop device with macOS.
* The `ExecutionsPerSecond` value indicates the number of function calls performed per second by the test browser.

**Alternatives**

If you're looking for alternative benchmarks or testing tools, some options include:

1. **JSPerf**: A popular online tool for comparing JavaScript performance across different browsers and versions.
2. **Benchmark.js**: An open-source benchmarking library that provides a simple way to write and run microbenchmarks.
3. **WebPageTest**: A comprehensive tool for measuring web page performance, including JavaScript execution time.

Keep in mind that each of these alternatives has its own strengths and weaknesses, and may be more suitable depending on your specific use case and requirements.

Related benchmarks:

global function or function in function (version: 0)

Comparing performance of: globalFunc vs funcInFunc

Created: 2 years ago by: Guest

Jump to the latest result

globalFunc

funcInFunc

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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