Run results for: Array element assignment

Replace the content of one array with the content of another array. Assume that: • alternative approaches are not a choice: • reusing the second array; • cloning the second array; • the arrays are not the same, are not sparse and are of the same length; • content order must be kept; • the difference between +0 and -0 and the differences between NaNs are irrelevant: • we can use === or Object.is() to avoid assignments; • otherwise, elements are opaque; The tests with literals, constants and variables serve as baselines for performance comparison.

Run details:

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: Chrome 131

Operating system: Windows

Device Platform: Desktop

Date tested: one year ago

Variable binding to literal

62.9M/s

Constant binding to literal

57.7M/s

Do nothing (leave at the end, hardware is warmed up)

57.7M/s

Do nothing (leave at the beginning, hardware warm up)

57.5M/s

Object-destructuring variable binding with numbers

49.8M/s

Object-destructuring reverse constant binding with strings

49.8M/s

Object-destructuring constant binding with strings

49.7M/s

Object-destructuring reverse variable binding with strings

49.1M/s

Object-destructuring reverse variable binding with numbers

48.9M/s

Object-destructuring variable binding with strings

45.7M/s

Constant binding to variable

44.9M/s

Variable binding to constant

44.7M/s

Variable binding to variable

44.5M/s

Object-destructuring reverse constant binding with numbers

44.1M/s

Array-destructuring constant binding

43.4M/s

Array-destructuring variable binding

42.3M/s

Object-destructuring constant binding with numbers

39.5M/s

Variable binding to array

38.9M/s

Constant binding to array

38.8M/s

Constant binding to constant

38.4M/s

Constant reverse binding to array

38.0M/s

Variable reverse binding to array

37.5M/s

Conditional array assignment to literal !==

33.3M/s

Conditional variable assignment to literal !==

33.2M/s

Conditional array reverse assignment to literal !==

30.8M/s

Array assignment to literal

29.4M/s

Conditional array assignment to variable !==

28.5M/s

Conditional variable assignment to variable !==

28.4M/s

Conditional variable assignment to array !==

28.1M/s

Conditional variable assignment to constant !==

28.1M/s

Conditional variable reverse assignment to array !==

28.0M/s

Array reverse assignment to literal

28.0M/s

Array assignment to constant

24.6M/s

Conditional array reverse assignment to variable !==

24.1M/s

Array reverse assignment to constant

24.0M/s

Object-destructuring reverse element assignment with numbers

23.3M/s

Conditional array reverse assignment to constant !==

23.3M/s

Object-destructuring element assignment with numbers

22.8M/s

Object-destructuring reverse element assignment with strings

22.8M/s

Object-destructuring element assignment with strings

22.8M/s

Conditional array assignment to array !==

22.6M/s

Conditional array assignment to literal Object.is()

22.2M/s

Array reverse assignment to variable

22.0M/s

Array assignment to variable

21.8M/s

Conditional array reverse assignment to literal Object.is()

21.6M/s

Loop of second

21.6M/s

Conditional array reverse assignment to array !==

21.4M/s

Conditional array reverse assignment to variable Object.is()

21.4M/s

Conditional variable assignment to literal Object.is()

21.2M/s

Conditional array reverse assignment to constant Object.is()

21.2M/s

Conditional variable assignment to variable Object.is()

21.1M/s

Conditional array assignment to variable Object.is()

21.1M/s

Conditional array assignment to constant Object.is()

21.0M/s

Conditional array assignment to constant !==

21.0M/s

Conditional variable assignment to constant Object.is()

20.5M/s

Conditional variable assignment to array Object.is()

20.1M/s

Loop from end with constant length

19.7M/s

Loop from start with literal length

19.6M/s

Array reverse assignment to array

19.4M/s

Loop from start with constant length

19.4M/s

Conditional array reverse assignment to array Object.is()

19.3M/s

Conditional array assignment to array Object.is()

18.9M/s

Conditional variable reverse assignment to array Object.is()

18.8M/s

Array assignment to array

18.8M/s

Loop from end with literal length

18.5M/s

Loop of first

18.0M/s

Array-destructuring element assignment

17.1M/s

Loop from end with constant first length

17.1M/s

Loop from end evaluating second length

17.0M/s

Loop from end evaluating first length

16.5M/s

Loop from end with variable first length

16.4M/s

Loop from start with constant first length

16.1M/s

Loop from end with variable second length

16.0M/s

Loop from start with variable second length

15.9M/s

Loop from end with constant second length

15.8M/s

Loop from start with variable first length

15.6M/s

.forEach() on first closure

15.4M/s

Loop from start with constant second length

15.2M/s

.forEach() on second closure

14.7M/s

Loop from start re-evaluating first length

14.7M/s

Loop from start re-evaluating second length

13.9M/s

.forEach() on second

7.5M/s

.forEach() on first

6.5M/s

Array-destructuring rest assignment

2.7M/s

Loop in first

2.0M/s

Loop in second

1.9M/s

Object-destructuring reverse variable assignment with strings

1.4M/s

Object-destructuring reverse variable assignment with numbers

1.4M/s

Object-destructuring variable assignment with strings

1.4M/s

Object-destructuring variable assignment with numbers

1.4M/s

Variable assignment to variable

1.3M/s

Variable assignment to array

1.3M/s

Variable reverse assignment to array

1.2M/s

Variable assignment to constant

1.2M/s

Variable assignment to literal

1.2M/s

Array-destructuring variable assignment

1.1M/s

Object-destructuring rest assignment

350K/s

View exact numbers

Test name	Executions per second
✓ Variable binding to literal	62,922,236 Ops/sec
Constant binding to literal	57,676,348 Ops/sec
Do nothing (leave at the end, hardware is warmed up)	57,665,884 Ops/sec
Do nothing (leave at the beginning, hardware warm up)	57,478,832 Ops/sec
Object-destructuring variable binding with numbers	49,794,924 Ops/sec
Object-destructuring reverse constant binding with strings	49,764,324 Ops/sec
Object-destructuring constant binding with strings	49,664,060 Ops/sec
Object-destructuring reverse variable binding with strings	49,085,320 Ops/sec
Object-destructuring reverse variable binding with numbers	48,931,360 Ops/sec
Object-destructuring variable binding with strings	45,665,976 Ops/sec
Constant binding to variable	44,917,524 Ops/sec
Variable binding to constant	44,701,200 Ops/sec
Variable binding to variable	44,472,068 Ops/sec
Object-destructuring reverse constant binding with numbers	44,117,768 Ops/sec
Array-destructuring constant binding	43,363,372 Ops/sec
Array-destructuring variable binding	42,272,040 Ops/sec
Object-destructuring constant binding with numbers	39,534,520 Ops/sec
Variable binding to array	38,883,008 Ops/sec
Constant binding to array	38,813,616 Ops/sec
Constant binding to constant	38,365,084 Ops/sec
Constant reverse binding to array	37,950,436 Ops/sec
Variable reverse binding to array	37,504,864 Ops/sec
Conditional array assignment to literal !==	33,255,812 Ops/sec
Conditional variable assignment to literal !==	33,192,938 Ops/sec
Conditional array reverse assignment to literal !==	30,802,484 Ops/sec
Array assignment to literal	29,425,548 Ops/sec
Conditional array assignment to variable !==	28,490,798 Ops/sec
Conditional variable assignment to variable !==	28,372,002 Ops/sec
Conditional variable assignment to array !==	28,110,302 Ops/sec
Conditional variable assignment to constant !==	28,093,182 Ops/sec
Conditional variable reverse assignment to array !==	28,025,650 Ops/sec
Array reverse assignment to literal	27,969,364 Ops/sec
Array assignment to constant	24,637,108 Ops/sec
Conditional array reverse assignment to variable !==	24,140,354 Ops/sec
Array reverse assignment to constant	23,982,702 Ops/sec
Object-destructuring reverse element assignment with numbers	23,307,198 Ops/sec
Conditional array reverse assignment to constant !==	23,299,324 Ops/sec
Object-destructuring element assignment with numbers	22,839,016 Ops/sec
Object-destructuring reverse element assignment with strings	22,832,166 Ops/sec
Object-destructuring element assignment with strings	22,813,556 Ops/sec
Conditional array assignment to array !==	22,638,614 Ops/sec
Conditional array assignment to literal Object.is()	22,211,558 Ops/sec
Array reverse assignment to variable	21,984,274 Ops/sec
Array assignment to variable	21,835,088 Ops/sec
Conditional array reverse assignment to literal Object.is()	21,639,946 Ops/sec
Loop of second	21,630,276 Ops/sec
Conditional array reverse assignment to array !==	21,415,974 Ops/sec
Conditional array reverse assignment to variable Object.is()	21,350,422 Ops/sec
Conditional variable assignment to literal Object.is()	21,240,844 Ops/sec
Conditional array reverse assignment to constant Object.is()	21,210,166 Ops/sec
Conditional variable assignment to variable Object.is()	21,149,526 Ops/sec
Conditional array assignment to variable Object.is()	21,095,758 Ops/sec
Conditional array assignment to constant Object.is()	21,027,210 Ops/sec
Conditional array assignment to constant !==	21,015,598 Ops/sec
Conditional variable assignment to constant Object.is()	20,533,852 Ops/sec
Conditional variable assignment to array Object.is()	20,102,334 Ops/sec
Loop from end with constant length	19,740,880 Ops/sec
Loop from start with literal length	19,614,166 Ops/sec
Array reverse assignment to array	19,444,828 Ops/sec
Loop from start with constant length	19,443,376 Ops/sec
Conditional array reverse assignment to array Object.is()	19,282,466 Ops/sec
Conditional array assignment to array Object.is()	18,899,040 Ops/sec
Conditional variable reverse assignment to array Object.is()	18,845,834 Ops/sec
Array assignment to array	18,808,360 Ops/sec
Loop from end with literal length	18,465,244 Ops/sec
Loop of first	17,988,788 Ops/sec
Array-destructuring element assignment	17,102,096 Ops/sec
Loop from end with constant first length	17,078,096 Ops/sec
Loop from end evaluating second length	16,971,996 Ops/sec
Loop from end evaluating first length	16,547,016 Ops/sec
Loop from end with variable first length	16,379,137 Ops/sec
Loop from start with constant first length	16,050,165 Ops/sec
Loop from end with variable second length	15,960,315 Ops/sec
Loop from start with variable second length	15,854,480 Ops/sec
Loop from end with constant second length	15,773,020 Ops/sec
Loop from start with variable first length	15,583,005 Ops/sec
.forEach() on first closure	15,407,853 Ops/sec
Loop from start with constant second length	15,191,005 Ops/sec
.forEach() on second closure	14,721,358 Ops/sec
Loop from start re-evaluating first length	14,691,269 Ops/sec
Loop from start re-evaluating second length	13,889,201 Ops/sec
.forEach() on second	7,516,918 Ops/sec
.forEach() on first	6,480,734 Ops/sec
Array-destructuring rest assignment	2,698,267 Ops/sec
Loop in first	1,989,614 Ops/sec
Loop in second	1,932,138 Ops/sec
Object-destructuring reverse variable assignment with strings	1,414,204 Ops/sec
Object-destructuring reverse variable assignment with numbers	1,414,132 Ops/sec
Object-destructuring variable assignment with strings	1,387,436 Ops/sec
Object-destructuring variable assignment with numbers	1,385,889 Ops/sec
Variable assignment to variable	1,300,063 Ops/sec
Variable assignment to array	1,270,750 Ops/sec
Variable reverse assignment to array	1,244,739 Ops/sec
Variable assignment to constant	1,226,941 Ops/sec
Variable assignment to literal	1,200,615 Ops/sec
Array-destructuring variable assignment	1,078,004 Ops/sec
Object-destructuring rest assignment	350,345 Ops/sec

Script Preparation code:

const X = "x", Y = "y", Z = "z", W = "d";
let   a = "a", b = "b", c = "c", d = "d";
let   x = "x", y = "y", z = "z", w = "d";
const firstArray  = [ "a", "b", "c", "d" ];
let   firstArray2 = [ "a", "b", "c", "d" ]; // for destructuring rest assignment tests
const secondArray = [ "x", "y", "z", "d" ];

Tests:

Do nothing at the beginning, cold hardware
;
Constant binding to literal
const first0 = "x"; const first1 = "y"; const first2 = "z"; const first3 = "d";
Constant binding to constant
const first0 = X; const first1 = Y; const first2 = Z; const first3 = W;
Constant binding to variable
const first0 = x; const first1 = y; const first2 = z; const first3 = w;
Constant binding to array
const first0 = secondArray[0]; const first1 = secondArray[1]; const first2 = secondArray[2]; const first3 = secondArray[3];
Constant reverse binding to array
const first3 = secondArray[3]; const first2 = secondArray[2]; const first1 = secondArray[1]; const first0 = secondArray[0];
Variable binding to literal
let first0 = "x"; let first1 = "y"; let first2 = "z"; let first3 = "d";
Variable binding to constant
let first0 = X; let first1 = Y; let first2 = Z; let first3 = W;
Variable binding to variable
let first0 = x; let first1 = y; let first2 = z; let first3 = w;
Variable binding to array
let first0 = secondArray[0]; let first1 = secondArray[1]; let first2 = secondArray[2]; let first3 = secondArray[3];
Variable reverse binding to array
let first3 = secondArray[3]; let first2 = secondArray[2]; let first1 = secondArray[1]; let first0 = secondArray[0];
Variable assignment to literal
a = "x"; b = "y"; c = "z"; d = "d";
Variable assignment to constant
a = X; b = Y; c = Z; d = W;
Variable assignment to variable
a = x; b = y; c = z; d = w;
Variable assignment to array
a = secondArray[0]; b = secondArray[1]; c = secondArray[2]; d = secondArray[3];
Variable reverse assignment to array
d = secondArray[3]; c = secondArray[2]; b = secondArray[1]; a = secondArray[0];
Array assignment to literal
firstArray[0] = "x"; firstArray[1] = "y"; firstArray[2] = "z"; firstArray[3] = "d";
Array reverse assignment to literal
firstArray[3] = "d"; firstArray[2] = "z"; firstArray[1] = "y"; firstArray[0] = "x";
Array assignment to constant
firstArray[0] = X; firstArray[1] = Y; firstArray[2] = Z; firstArray[3] = W;
Array reverse assignment to constant
firstArray[3] = W; firstArray[2] = Z; firstArray[1] = Y; firstArray[0] = X;
Array assignment to variable
firstArray[0] = x; firstArray[1] = y; firstArray[2] = z; firstArray[3] = w;
Array reverse assignment to variable
firstArray[3] = w; firstArray[2] = z; firstArray[1] = y; firstArray[0] = x;
Array assignment to array
firstArray[0] = secondArray[0]; firstArray[1] = secondArray[1]; firstArray[2] = secondArray[2]; firstArray[3] = secondArray[3];
Array reverse assignment to array
firstArray[3] = secondArray[3]; firstArray[2] = secondArray[2]; firstArray[1] = secondArray[1]; firstArray[0] = secondArray[0];
Conditional variable assignment to literal !==
if (a !== "x") a = "x"; if (b !== "y") b = "y"; if (c !== "z") c = "z"; if (d !== "d") d = "d";
Conditional variable assignment to constant !==
if (a !== X) a = X; if (b !== Y) b = Y; if (c !== Z) c = Z; if (d !== W) d = W;
Conditional variable assignment to variable !==
if (a !== x) a = x; if (b !== y) b = y; if (c !== z) c = z; if (d !== w) d = w;
Conditional variable assignment to array !==
const second0 = secondArray[0]; const second1 = secondArray[1]; const second2 = secondArray[2]; const second3 = secondArray[3]; if (a !== second0) a = second0; if (b !== second1) b = second1; if (c !== second2) c = second2; if (d !== second3) d = second3;
Conditional variable reverse assignment to array !==
const second3 = secondArray[3]; const second2 = secondArray[2]; const second1 = secondArray[1]; const second0 = secondArray[0]; if (d !== second3) d = second3; if (c !== second2) c = second2; if (b !== second1) b = second1; if (a !== second0) a = second0;
Conditional array assignment to literal !==
if (firstArray[0] !== "x") firstArray[0] = "x"; if (firstArray[1] !== "y") firstArray[1] = "y"; if (firstArray[2] !== "z") firstArray[2] = "z"; if (firstArray[3] !== "d") firstArray[3] = "d";
Conditional array reverse assignment to literal !==
if (firstArray[3] !== "d") firstArray[3] = "d"; if (firstArray[2] !== "z") firstArray[2] = "z"; if (firstArray[1] !== "y") firstArray[1] = "y"; if (firstArray[0] !== "x") firstArray[0] = "x";
Conditional array assignment to constant !==
if (firstArray[0] !== X) firstArray[0] = X; if (firstArray[1] !== Y) firstArray[1] = Y; if (firstArray[2] !== Z) firstArray[2] = Z; if (firstArray[3] !== W) firstArray[3] = W;
Conditional array reverse assignment to constant !==
if (firstArray[3] !== W) firstArray[3] = W; if (firstArray[2] !== Z) firstArray[2] = Z; if (firstArray[1] !== Y) firstArray[1] = Y; if (firstArray[0] !== X) firstArray[0] = X;
Conditional array assignment to variable !==
if (firstArray[0] !== x) firstArray[0] = x; if (firstArray[1] !== y) firstArray[1] = y; if (firstArray[2] !== z) firstArray[2] = z; if (firstArray[3] !== w) firstArray[3] = w;
Conditional array reverse assignment to variable !==
if (firstArray[3] !== w) firstArray[3] = w; if (firstArray[2] !== z) firstArray[2] = z; if (firstArray[1] !== y) firstArray[1] = y; if (firstArray[0] !== x) firstArray[0] = x;
Conditional array assignment to array !==
const second0 = secondArray[0]; const second1 = secondArray[1]; const second2 = secondArray[2]; const second3 = secondArray[3]; if (firstArray[0] !== second0) firstArray[0] = second0; if (firstArray[1] !== second1) firstArray[1] = second1; if (firstArray[2] !== second2) firstArray[2] = second2; if (firstArray[3] !== second3) firstArray[3] = second3;
Conditional array reverse assignment to array !==
const second3 = secondArray[3]; const second2 = secondArray[2]; const second1 = secondArray[1]; const second0 = secondArray[0]; if (firstArray[3] !== second3) firstArray[3] = second3; if (firstArray[2] !== second2) firstArray[2] = second2; if (firstArray[1] !== second1) firstArray[1] = second1; if (firstArray[0] !== second0) firstArray[0] = second0;
Conditional variable assignment to literal Object.is()
if (!Object.is(a, "x")) a = "x"; if (!Object.is(b, "y")) b = "y"; if (!Object.is(c, "z")) c = "z"; if (!Object.is(d, "d")) d = "d";
Conditional variable assignment to constant Object.is()
if (!Object.is(a, X)) a = X; if (!Object.is(b, Y)) b = Y; if (!Object.is(c, Z)) c = Z; if (!Object.is(d, W)) d = W;
Conditional variable assignment to variable Object.is()
if (!Object.is(a, x)) a = x; if (!Object.is(b, y)) b = y; if (!Object.is(c, z)) c = z; if (!Object.is(d, w)) d = w;
Conditional variable assignment to array Object.is()
const second0 = secondArray[0]; const second1 = secondArray[1]; const second2 = secondArray[2]; const second3 = secondArray[3]; if (!Object.is(a, second0)) a = second0; if (!Object.is(b, second1)) b = second1; if (!Object.is(c, second2)) c = second2; if (!Object.is(d, second3)) d = second3;
Conditional variable reverse assignment to array Object.is()
const second3 = secondArray[3]; const second2 = secondArray[2]; const second1 = secondArray[1]; const second0 = secondArray[0]; if (!Object.is(d, second3)) d = second3; if (!Object.is(c, second2)) c = second2; if (!Object.is(b, second1)) b = second1; if (!Object.is(a, second0)) a = second0;
Conditional array assignment to literal Object.is()
if (!Object.is(firstArray[0], "x")) firstArray[0] = "x"; if (!Object.is(firstArray[1], "y")) firstArray[1] = "y"; if (!Object.is(firstArray[2], "z")) firstArray[2] = "z"; if (!Object.is(firstArray[3], "d")) firstArray[3] = "d";
Conditional array reverse assignment to literal Object.is()
if (!Object.is(firstArray[3], "d")) firstArray[3] = "d"; if (!Object.is(firstArray[2], "z")) firstArray[2] = "z"; if (!Object.is(firstArray[1], "y")) firstArray[1] = "y"; if (!Object.is(firstArray[0], "x")) firstArray[0] = "x";
Conditional array assignment to constant Object.is()
if (!Object.is(firstArray[0], X)) firstArray[0] = X; if (!Object.is(firstArray[1], Y)) firstArray[1] = Y; if (!Object.is(firstArray[2], Z)) firstArray[2] = Z; if (!Object.is(firstArray[3], W)) firstArray[3] = W;
Conditional array reverse assignment to constant Object.is()
if (!Object.is(firstArray[3], W)) firstArray[3] = W; if (!Object.is(firstArray[2], Z)) firstArray[2] = Z; if (!Object.is(firstArray[1], Y)) firstArray[1] = Y; if (!Object.is(firstArray[0], X)) firstArray[0] = X;
Conditional array assignment to variable Object.is()
if (!Object.is(firstArray[0], x)) firstArray[0] = x; if (!Object.is(firstArray[1], y)) firstArray[1] = y; if (!Object.is(firstArray[2], z)) firstArray[2] = z; if (!Object.is(firstArray[3], w)) firstArray[3] = w;
Conditional array reverse assignment to variable Object.is()
if (!Object.is(firstArray[3], w)) firstArray[3] = w; if (!Object.is(firstArray[2], z)) firstArray[2] = z; if (!Object.is(firstArray[1], y)) firstArray[1] = y; if (!Object.is(firstArray[0], x)) firstArray[0] = x;
Conditional array assignment to array Object.is()
const second0 = secondArray[0]; const second1 = secondArray[1]; const second2 = secondArray[2]; const second3 = secondArray[3]; if (!Object.is(firstArray[0], second0)) firstArray[0] = second0; if (!Object.is(firstArray[1], second1)) firstArray[1] = second1; if (!Object.is(firstArray[2], second2)) firstArray[2] = second2; if (!Object.is(firstArray[3], second3)) firstArray[3] = second3;
Conditional array reverse assignment to array Object.is()
const second3 = secondArray[3]; const second2 = secondArray[2]; const second1 = secondArray[1]; const second0 = secondArray[0]; if (!Object.is(firstArray[3], second3)) firstArray[3] = second3; if (!Object.is(firstArray[2], second2)) firstArray[2] = second2; if (!Object.is(firstArray[1], second1)) firstArray[1] = second1; if (!Object.is(firstArray[0], second0)) firstArray[0] = second0;
Loop from start with literal length
for (let i = 0; i < 4; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end with literal length
for (let i = 4 - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop from start with constant length
const length = 4; for (let i = 0; i < 4; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end with constant length
const length = 4; for (let i = length - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop from start with constant first length
const length = firstArray.length; for (let i = 0; i < length; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end with constant first length
const length = firstArray.length; for (let i = length - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop from start with constant second length
const length = secondArray.length; for (let i = 0; i < length; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end with constant second length
const length = secondArray.length; for (let i = length - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop from start with variable first length
let length = firstArray.length; for (let i = 0; i < length; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end with variable first length
let length = firstArray.length; for (let i = length - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop from start with variable second length
let length = secondArray.length; for (let i = 0; i < length; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end with variable second length
let length = secondArray.length; for (let i = length - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop from start re-evaluating first length
for (let i = 0; i < firstArray.length; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end evaluating first length
for (let i = firstArray.length - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop from start re-evaluating second length
for (let i = 0; i < secondArray.length; i += 1) { firstArray[i] = secondArray[i]; }
Loop from end evaluating second length
for (let i = secondArray.length - 1; i >= 0; i -= 1) { firstArray[i] = secondArray[i]; }
Loop in first
for (const i in firstArray) { firstArray[i] = secondArray[i]; }
Loop in second
for (const i in secondArray) { firstArray[i] = secondArray[i]; }
Loop of first
let i = 0; for (const _ of firstArray) { firstArray[i] = secondArray[i]; i += 1; }
Loop of second
let i = 0; for (const e of secondArray) { firstArray[i] = e; i += 1; }
.forEach() on first
firstArray.forEach(function (_, i, a) { a[i] = this[i]; }, secondArray);
.forEach() on first closure
firstArray.forEach(function (_, i, a) { a[i] = secondArray[i]; });
.forEach() on second
secondArray.forEach(function (e, i, _) { this[i] = e; }, firstArray);
.forEach() on second closure
secondArray.forEach(function (e, i, _) { firstArray[i] = e; });
Array-destructuring constant binding
const [ first0, first1, first2, first3 ] = secondArray;
Array-destructuring variable binding
let [ first0, first1, first2, first3 ] = secondArray;
Array-destructuring variable assignment
[ a, b, c, d ] = secondArray;
Array-destructuring element assignment
([ firstArray[0], firstArray[1], firstArray[2], firstArray[3] ] = secondArray);
Array-destructuring rest assignment
// cannot use firstArray, it's const ([ ...firstArray2 ] = secondArray);
Object-destructuring constant binding with numbers
const { 0: first0, 1: first1, 2: first2, 3: first3 } = secondArray;
Object-destructuring reverse constant binding with numbers
const { 3: first3, 2: first2, 1: first1, 0: first0 } = secondArray;
Object-destructuring variable binding with numbers
let { 0: first0, 1: first1, 2: first2, 3: first3 } = secondArray;
Object-destructuring reverse variable binding with numbers
let { 3: first3, 2: first2, 1: first1, 0: first0 } = secondArray;
Object-destructuring variable assignment with numbers
({ 0: a, 1: b, 2: c, 3: d } = secondArray);
Object-destructuring reverse variable assignment with numbers
({ 3: d, 2: c, 1: b, 0: a } = secondArray);
Object-destructuring element assignment with numbers
({ 0: firstArray[0], 1: firstArray[1], 2: firstArray[2], 3: firstArray[3] } = secondArray);
Object-destructuring reverse element assignment with numbers
({ 3: firstArray[3], 2: firstArray[2], 1: firstArray[1], 0: firstArray[0] } = secondArray);
Object-destructuring constant binding with strings
const { "0": first0, "1": first1, "2": first2, "3": first3 } = secondArray;
Object-destructuring reverse constant binding with strings
const { "3": first3, "2": first2, "1": first1, "0": first0 } = secondArray;
Object-destructuring variable binding with strings
let { "0": first0, "1": first1, "2": first2, "3": first3 } = secondArray;
Object-destructuring reverse variable binding with strings
let { "3": first3, "2": first2, "1": first1, "0": first0 } = secondArray;
Object-destructuring variable assignment with strings
({ "0": a, "1": b, "2": c, "3": d } = secondArray);
Object-destructuring reverse variable assignment with strings
({ "3": d, "2": c, "1": b, "0": a } = secondArray);
Object-destructuring element assignment with strings
({ "0": firstArray[0], "1": firstArray[1], "2": firstArray[2], "3": firstArray[3] } = secondArray);
Object-destructuring reverse element assignment with strings
({ "3": firstArray[3], "2": firstArray[2], "1": firstArray[1], "0": firstArray[0] } = secondArray);
Object-destructuring rest assignment
// cannot use firstArray, it's const ({ ...firstArray2 } = secondArray);
Object.assign()
Object.assign(firstArray, secondArray);
Do nothing at the end, warm hardware
;