Benchmark: Passing data to function as parameter list vs other methods (static, new, re-used & global - vars, objects & arrays)

Passing data to function as parameter list vs other methods (static, new, re-used & global - vars, objects & arrays) (version: 0)

Compares performance of a function call with parameter list, against other methods of getting the data into the function

Comparing performance of: Pass raw values vs Pass object vs Pass array vs Pass new object vs Pass new array vs Pass modified object vs Pass modified array vs Global vars vs Global object vs Global array

Created: 2 years ago by: Guest

Jump to the latest result

Script Preparation code:

var a = "Here's a string value";
var b = 5; // and a number
var c = false;

var object = {
  a, b, c
}

var array = [
  a, b, c
];

var passObject = (obj) => {
  return obj.a.length + obj.b * obj.c ? 2 : 1;
}

var passRawValues = (val_a, val_b, val_c) => {
  return val_a.length + val_b * val_c ? 2 : 1;
}

var passArray = (arr) => {
  return arr[0].length + arr[1] * arr[2] ? 2 : 1;
}

var passNothingUseGlobalVars = () => {
  return a + b * c ? 2 : 1;
}

var passNothingUseGlobalObject = () => {
  return object.a.length + object.b * object.c ? 2 : 1;
}

var passNothingUseGlobalArray = () => {
  return array[0].length + array[1] * array[2] ? 2 : 1;
}

var x = 0;

​x
 
var a = "Here's a string value";var b = 5; // and a numbervar c = false;​var object = {  a, b, c}​var array = [  a, b, c];​var passObject = (obj) => {  return obj.a.length + obj.b * obj.c ? 2 : 1;}​var passRawValues = (val_a, val_b, val_c) => {  return val_a.length + val_b * val_c ? 2 : 1;}​var passArray = (arr) => {  return arr[0].length + arr[1] * arr[2] ? 2 : 1;}​var passNothingUseGlobalVars = () => {  return a + b * c ? 2 : 1;}​var passNothingUseGlobalObject = () => {  return object.a.length + object.b * object.c ? 2 : 1;}​var passNothingUseGlobalArray = () => {  return array[0].length + array[1] * array[2] ? 2 : 1;}​var x = 0;

Tests:

Pass raw values
x << 1; x ^= passRawValues(a, b, c);
x << 1;
x ^= passRawValues(a, b, c);
Pass object
x << 1; x ^= passObject(object);
x << 1;
x ^= passObject(object);
Pass array
x << 1; x ^= passArray(array);
x << 1;
x ^= passArray(array);
Pass new object
x << 1; x ^= passObject({a, b, c});
x << 1;
x ^= passObject({a, b, c});
Pass new array
x << 1; x ^= passArray([a,b,c]);
x << 1;
x ^= passArray([a,b,c]);
Pass modified object
object.a = a; object.b = b; object.c = c; x << 1; x ^= passObject(object);
object.a = a;
object.b = b;
object.c = c;
x << 1;
x ^= passObject(object);
Pass modified array
array.a=a; array.b=b; array.c=c; x << 1; x ^= passArray(array);
array.a=a;
array.b=b;
array.c=c;
x << 1;
x ^= passArray(array);
Global vars
x << 1; x ^= passNothingUseGlobalVars();
x << 1;
x ^= passNothingUseGlobalVars();
Global object
x << 1; x ^= passNothingUseGlobalObject();
x << 1;
x ^= passNothingUseGlobalObject();
Global array
x << 1; x ^= passNothingUseGlobalArray();
x << 1;
x ^= passNothingUseGlobalArray();

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
Pass raw values
Pass object
Pass array
Pass new object
Pass new array
Pass modified object
Pass modified array
Global vars
Global object
Global array

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
Pass raw values	2689004.5 Ops/sec
Pass object	3896395.8 Ops/sec
Pass array	3869444.2 Ops/sec
Pass new object	2684526.8 Ops/sec
Pass new array	2673640.5 Ops/sec
Pass modified object	1756238.2 Ops/sec
Pass modified array	1758767.8 Ops/sec
Global vars	2622284.2 Ops/sec
Global object	2706401.8 Ops/sec
Global array	2821887.8 Ops/sec

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

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

Benchmark Overview

The benchmark compares the performance of different ways to pass data to a function in JavaScript. The functions are not explicitly defined, but we can infer their behavior based on the code. There are four main approaches:

Passing by value: Passing variables directly to the function.
Passing by reference (using arrays or objects): Passing references to variables or data structures to the function.
Passing as arguments: Calling the function with explicit arguments.
Using global scope: Using global variables to pass data to the function.

Test Results

The benchmark results show the number of executions per second for each test case, which represents the performance of passing data to the functions. The top three performers are:

Passing by reference (using arrays or objects): 2684526.75 executions/second
Passing as arguments: 2673640.5 executions/second
Passing by value: 2622284.25 executions/second

Key Takeaways

From the results, we can conclude that:

Passing by reference (using arrays or objects) is the fastest way to pass data to a function.
Passing as arguments and passing by value are similar in performance, with passing by value being slightly slower.

This benchmark highlights the importance of understanding how variables are passed to functions in JavaScript. In general, it's recommended to use arrays or objects for passing data to avoid potential issues with variable scope and modification.

The fact that global scope is not the fastest way to pass data may indicate that there are other factors at play, such as caching or optimization techniques used by the JavaScript engine.

Keep in mind that this benchmark is specific to the implementation of JavaScript and may vary depending on the browser, platform, or other factors.

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

1. **Passing by value**: Passing variables directly to the function.
2. **Passing by reference** (using arrays or objects): Passing references to variables or data structures to the function.
3. **Passing as arguments**: Calling the function with explicit arguments.
4. **Using global scope**: Using global variables to pass data to the function.

**Test Results**

The benchmark results show the number of executions per second for each test case, which represents the performance of passing data to the functions. The top three performers are:

1. Passing by reference (using arrays or objects): 2684526.75 executions/second
2. Passing as arguments: 2673640.5 executions/second
3. Passing by value: 2622284.25 executions/second

**Key Takeaways**

From the results, we can conclude that:

* Passing by reference (using arrays or objects) is the fastest way to pass data to a function.
* Passing as arguments and passing by value are similar in performance, with passing by value being slightly slower.

The fact that global scope is not the fastest way to pass data may indicate that there are other factors at play, such as caching or optimization techniques used by the JavaScript engine.

Keep in mind that this benchmark is specific to the implementation of JavaScript and may vary depending on the browser, platform, or other factors.

Related benchmarks: