Benchmark: Copy array568 - MeasureThat.net

Copy array568 (version: 2)

Comparing performance of: var child = JSON.parse(JSON.stringify(parent)); vs child[i] = parent[i].slice()/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = parent[i].slice(); } vs child[i][j] = parent[i][j]/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = []; for (var j = 0; j < parent[i].length; j += 1) { child[i][j] = parent[i][j]; } } vs var child = JSON.parse(JSON.stringify(sparent)); vs var child = sparent.slice(); vs child[i] = sparent[i]/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = sparent[i]; }

Created: 7 years ago by: Registered User

Jump to the latest result

Script Preparation code:

var parent = [
  [0],
  [1,4,4,5,8,6,4,4],
  [5,4,3,2,4,7,6,8],
  [1,3,2,4,5,1,8,6],
  [4,5,3,2,8,7,1,6],
  [4,3,1,8,6,7,1,3],
  [4,5,3,4,10,4,5,3],
  [6,3,8,9,2,3,4,7],
  [9,2,3,7,2,1,10,8],
  [2,5,5,3,5,1,10,9]
];
var sparent = [
  "0",
  "14458644",
  "54324768",
  "13245186",
  "45328716",
  "43186713",
  "453410453",
  "63892347",
  "923721108",
  "255351109"
]

Tests:

var child = JSON.parse(JSON.stringify(parent));
var child = JSON.parse(JSON.stringify(parent));
child[i] = parent[i].slice()/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = parent[i].slice(); }
var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = parent[i].slice(); }
child[i][j] = parent[i][j]/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = []; for (var j = 0; j < parent[i].length; j += 1) { child[i][j] = parent[i][j]; } }
var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = []; for (var j = 0; j < parent[i].length; j += 1) { child[i][j] = parent[i][j]; } }
var child = JSON.parse(JSON.stringify(sparent));
var child = JSON.parse(JSON.stringify(sparent));
var child = sparent.slice();
var child = sparent.slice();
child[i] = sparent[i]/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = sparent[i]; }
var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = sparent[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
var child = JSON.parse(JSON.stringify(parent));
child[i] = parent[i].slice()/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = parent[i].slice(); }
child[i][j] = parent[i][j]/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = []; for (var j = 0; j < parent[i].length; j += 1) { child[i][j] = parent[i][j]; } }
var child = JSON.parse(JSON.stringify(sparent));
var child = sparent.slice();
child[i] = sparent[i]/// var child = []; for (var i = 0; i < parent.length; i += 1) { child[i] = sparent[i]; }

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark measures the performance of creating an array copy from a given input `parent` array. The input is converted to a string representation `sparent`, which is then used for comparison with different methods.

**Test Cases**

There are four test cases, each comparing two methods:

1. **Method 1**: `var child = sparent.slice();`
2. **Method 2**: `child[i] = sparent[i];` (with a loop)
3. **Method 3**: `child[i] = parent[i].slice();` (using the `slice()` method on the original array)
4. **Method 4**: `var child = JSON.parse(JSON.stringify(sparent));`

**Library and Syntax**

* In Method 2, the library used is JavaScript's built-in array methods (`[]`, `push`, etc.). The syntax is simple and widely supported.
* In Method 3, the same library is used, but with a specific method call (`slice()`) on the original array.
* In Method 4, the library is JSON.parse, which is used to create a deep copy of an object. This method is not directly applicable to arrays, but it can be used as a workaround by converting the array to an object and then parsing it.

**Performance Comparison**

The benchmark results show that:

1. `var child = sparent.slice();` (Method 1) is the fastest execution method, with approximately 560 million executions per second.
2. `child[i] = sparent[i];` (with a loop) (Method 2) is slower than Method 1, but faster than Methods 3 and 4.
3. `child[i] = parent[i].slice();` (using the `slice()` method on the original array) (Method 3) is slower than Method 2.
4. `var child = JSON.parse(JSON.stringify(sparent));` (Method 4) is the slowest execution method, with approximately 82 million executions per second.

**Conclusion**

The benchmark results show that creating an array copy using `sparent.slice()` (Method 1) is the most efficient approach, followed by a loop-based method (Method 2). The use of `slice()` on the original array (Method 3) and `JSON.parse` (Method 4) are less efficient. This suggests that for performance-critical applications, using native JavaScript methods like `slice()` may be preferable to workarounds involving JSON parsing or object manipulation.

Related benchmarks: