This implementation is designed to be a lightweight alternative to the standard JavaScript Array class, with a focus on performance and ease of use. It is particularly useful in scenarios where frequent shift operations are required, such as in data processing, event handling, and other applications where performance is critical. This drop-in replacement for the JavaScript Array class provides fast (approximate O(1)) shift() operations, and in some cases similar O(1)unshift() operations.
use
npminstallfast-shift-array
performance comparison
Comparision of the FastShiftArray.shift() and Array.shift() function. Each table represents a comparisons of various
array sizes, for which half the array elements where shifted out of the array, through repeated calls to the shift()
function. Each row of each table represents 10 runs for the specified array size and number of shifts. The values are
the average number of milliseconds it took to complete all the shifts, followed by ± one standard-deviation.
The first table uses a compacting size of 105. This means that after 105 shifts, the first
105 elements are dropped using an Array.splice() function. The next table uses a compacting size of
104, and then the next table uses a compacting size of 1,000, and then 100.
FastShiftArray compacts when head = 100,000
Array Size
Num Shifts
FastShiftArray (ms)
Array (ms)
Speed-up
10,000
5,000
0.19 ± 0.11
0.33 ± 0.21
1.76 ± 0.16
50,000
25,000
0.76 ± 0.10
146.66 ± 2.32
196.21 ± 18.51
100,000
50,000
1.45 ± 0.02
581.62 ± 9.62
400.07 ± 4.05
200,000
100,000
2.93 ± 0.04
2,309.18 ± 19.80
787.30 ± 14.19
300,000
150,000
4.88 ± 0.21
5,202.80 ± 54.74
1,067.76 ± 39.13
400,000
200,000
7.19 ± 1.42
12,521.91 ± 5,009.20
1,682.12 ± 326.29
500,000
250,000
9.83 ± 1.35
25,242.45 ± 8,692.55
2,491.91 ± 583.89
600,000
300,000
10.54 ± 0.84
23,641.16 ± 8,428.45
2,205.86 ± 531.73
700,000
350,000
12.77 ± 1.29
28,522.37 ± 648.12
2,252.48 ± 181.72
800,000
400,000
14.89 ± 1.29
37,223.47 ± 782.26
2,519.99 ± 236.51
900,000
450,000
16.81 ± 1.57
60,779.80 ± 27,139.28
3,558.00 ± 1,315.03
1,000,000
500,000
19.32 ± 1.15
81,686.76 ± 34,683.43
4,194.94 ± 1,660.87
Figure 1. FastShiftArray.shift() performance versus JavaScript Array.shift() performance. Each data point is calculated for an array size and then calling the shift() function half as many times as the array size. For example, when the array size is 100,000, then the shift() function is called 50,000 times. Each data point shows the mean-value for 10 runs, and the error bars represent plus/minus one standard deviation. In this run, the compacting-size is 100k, which means that after 100k calls to the FastShiftArray.shift(), the shifted memory is reclaimed using the splice() function.
Figure 2. FastShiftArray.shift() performance versus JavaScript Array.shift() performance. This figure is the same as Figure 1, except that the y-axis is shown as a logarithmic scale. Each data point is calculated for an array size and then calling the shift() function half as many times as the array size. For example, when the array size is 100,000, then the shift() function is called 50,000 times. Each data point shows the mean-value for 10 runs, and the error bars represent plus/minus one standard deviation. In this run, the compacting-size is 100k, which means that after 100k calls to the FastShiftArray.shift(), the shifted memory is reclaimed using the splice() function.
Figure 3. Shows the number of times that the FastShiftArray.shift() is faster than the JavaScript Array.shift(). Each data point is calculated for an array size and then calling the shift() function half as many times as the array size. For example, when the array size is 100,000, then the shift() function is called 50,000 times. Each data point shows the mean-value for 10 runs, and the error bars represent plus/minus one standard deviation. In this run, the compacting-size is 100k, which means that after 100k calls to the FastShiftArray.shift(), the shifted memory is reclaimed using the splice() function.
