API tools faq
paste
Pauan

Array performance comparison 1

Pauan
Nov 13th, 2014
412
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.10 KB | None | 0 0
raw download clone embed print report
  1. Get from an array with 1 element:
  2.  
  3. js x 40,975,531 ops/sec ±0.70% (98 runs sampled)
  4. cons x 37,826,131 ops/sec ±1.59% (93 runs sampled)
  5. avl x 12,883,026 ops/sec ±0.75% (95 runs sampled)
  6. immutable-js x 23,315,346 ops/sec ±0.69% (94 runs sampled)
  7. mori (vector) x 17,178,793 ops/sec ±0.90% (96 runs sampled)
  8.  
  9. Add 1 element into an empty array (at whatever spot is most efficient):
  10.  
  11. js x 15,458,651 ops/sec ±0.49% (98 runs sampled)
  12. cons x 30,741,625 ops/sec ±1.15% (92 runs sampled)
  13. avl x 8,168,315 ops/sec ±0.47% (98 runs sampled)
  14. immutable-js x 1,592,227 ops/sec ±0.76% (97 runs sampled)
  15. mori (vector) x 1,791,837 ops/sec ±0.68% (101 runs sampled)
  16.  
  17. Push 1 element into an empty array:
  18.  
  19. js x 14,314,606 ops/sec ±0.47% (98 runs sampled)
  20. cons x 26,743,631 ops/sec ±0.54% (97 runs sampled)
  21. avl x 8,191,843 ops/sec ±0.47% (97 runs sampled)
  22. immutable-js x 1,641,563 ops/sec ±1.56% (94 runs sampled)
  23. mori (vector) x 1,628,557 ops/sec ±0.98% (99 runs sampled)
  24.  
  25. Unshift 1 element into an empty array:
  26.  
  27. js x 12,098,245 ops/sec ±1.06% (99 runs sampled)
  28. cons x 29,760,238 ops/sec ±0.65% (95 runs sampled)
  29. avl x 8,377,137 ops/sec ±1.47% (91 runs sampled)
  30. immutable-js x 1,115,087 ops/sec ±1.87% (99 runs sampled)
  31.  
  32. Add 1 element into an empty array, and then pop 1 element:
  33.  
  34. js x 11,465,925 ops/sec ±1.81% (97 runs sampled)
  35. cons x 20,386,316 ops/sec ±1.36% (93 runs sampled)
  36. avl x 4,921,670 ops/sec ±0.83% (96 runs sampled)
  37. immutable-js x 1,476,503 ops/sec ±2.13% (95 runs sampled)
  38. mori (vector) x 1,646,172 ops/sec ±0.87% (100 runs sampled)
  39.  
  40. Add 1 element into an empty array, and then shift 1 element:
  41.  
  42. js x 8,970,667 ops/sec ±0.61% (98 runs sampled)
  43. cons x 20,681,311 ops/sec ±0.52% (96 runs sampled)
  44. avl x 4,823,489 ops/sec ±1.11% (92 runs sampled)
  45. immutable-js x 1,575,563 ops/sec ±0.81% (93 runs sampled)
  46.  
  47. Insert 1 element at a random index:
  48.  
  49. js x 8,564,146 ops/sec ±0.38% (98 runs sampled)
  50. cons x 21,115,359 ops/sec ±1.78% (98 runs sampled)
  51. avl x 7,566,058 ops/sec ±1.01% (99 runs sampled)
  52. immutable-js x 72,847 ops/sec ±2.02% (86 runs sampled)
  53.  
  54. Add 1 element into an empty array, and then remove 1 element at a random index:
  55.  
  56. js x 6,265,226 ops/sec ±1.23% (99 runs sampled)
  57. cons x 17,736,942 ops/sec ±0.53% (94 runs sampled)
  58. avl x 4,597,770 ops/sec ±0.57% (97 runs sampled)
  59. immutable-js x 93,688 ops/sec ±2.86% (80 runs sampled)
  60.  
  61. Concatenate two arrays which both have 1 element each:
  62.  
  63. js x 12,143,209 ops/sec ±0.62% (98 runs sampled)
  64. cons x 26,829,300 ops/sec ±1.49% (93 runs sampled)
  65. avl x 3,537,823 ops/sec ±0.25% (99 runs sampled)
  66. immutable-js x 86,687 ops/sec ±2.84% (80 runs sampled)
  67.  
  68. ----
  69.  
  70. Get from an array with 10 elements:
  71.  
  72. js x 44,894,778 ops/sec ±0.55% (99 runs sampled)
  73. cons x 24,128,462 ops/sec ±0.97% (91 runs sampled)
  74. avl x 11,029,128 ops/sec ±0.64% (99 runs sampled)
  75. immutable-js x 25,797,098 ops/sec ±0.65% (97 runs sampled)
  76. mori (vector) x 17,600,080 ops/sec ±0.82% (98 runs sampled)
  77.  
  78. Add 10 elements into an empty array (at whatever spot is most efficient):
  79.  
  80. js x 10,538,311 ops/sec ±0.68% (97 runs sampled)
  81. cons x 7,027,357 ops/sec ±0.39% (99 runs sampled)
  82. avl x 425,000 ops/sec ±0.90% (93 runs sampled)
  83. immutable-js x 95,712 ops/sec ±0.80% (98 runs sampled)
  84. mori (vector) x 608,460 ops/sec ±0.84% (97 runs sampled)
  85.  
  86. Push 10 elements into an empty array:
  87.  
  88. js x 5,500,007 ops/sec ±0.76% (95 runs sampled)
  89. cons x 1,115,652 ops/sec ±0.36% (101 runs sampled)
  90. avl x 414,473 ops/sec ±2.24% (91 runs sampled)
  91. immutable-js x 100,657 ops/sec ±1.63% (98 runs sampled)
  92. mori (vector) x 627,684 ops/sec ±0.78% (99 runs sampled)
  93.  
  94. Unshift 10 elements into an empty array:
  95.  
  96. js x 2,197,770 ops/sec ±1.47% (99 runs sampled)
  97. cons x 6,464,041 ops/sec ±0.95% (98 runs sampled)
  98. avl x 433,278 ops/sec ±0.49% (98 runs sampled)
  99. immutable-js x 122,080 ops/sec ±0.52% (101 runs sampled)
  100.  
  101. Add 10 elements into an empty array, and then pop 10 elements:
  102.  
  103. js x 3,480,491 ops/sec ±0.29% (100 runs sampled)
  104. cons x 1,109,843 ops/sec ±0.13% (102 runs sampled)
  105. avl x 252,390 ops/sec ±0.52% (99 runs sampled)
  106. immutable-js x 74,415 ops/sec ±0.62% (100 runs sampled)
  107. mori (vector) x 399,951 ops/sec ±0.47% (98 runs sampled)
  108.  
  109. Add 10 elements into an empty array, and then shift 10 elements:
  110.  
  111. js x 1,931,558 ops/sec ±0.14% (101 runs sampled)
  112. cons x 4,249,770 ops/sec ±0.49% (97 runs sampled)
  113. avl x 250,759 ops/sec ±0.62% (101 runs sampled)
  114. immutable-js x 71,774 ops/sec ±0.47% (95 runs sampled)
  115.  
  116. Insert 10 elements at a random index:
  117.  
  118. js x 1,188,679 ops/sec ±0.14% (102 runs sampled)
  119. cons x 1,500,484 ops/sec ±0.98% (94 runs sampled)
  120. avl x 369,011 ops/sec ±1.04% (97 runs sampled)
  121. immutable-js x 5,973 ops/sec ±3.65% (76 runs sampled)
  122.  
  123. Add 10 elements into an empty array, and then remove 10 elements at a random index:
  124.  
  125. js x 833,288 ops/sec ±1.23% (97 runs sampled)
  126. cons x 1,252,592 ops/sec ±1.25% (96 runs sampled)
  127. avl x 164,866 ops/sec ±1.14% (95 runs sampled)
  128. immutable-js x 5,723 ops/sec ±3.18% (80 runs sampled)
  129.  
  130. Concatenate two arrays which both have 10 elements each:
  131.  
  132. js x 10,382,980 ops/sec ±1.32% (98 runs sampled)
  133. cons x 5,507,096 ops/sec ±0.72% (99 runs sampled)
  134. avl x 524,542 ops/sec ±0.40% (99 runs sampled)
  135. immutable-js x 74,890 ops/sec ±2.72% (82 runs sampled)
  136.  
  137. ----
  138.  
  139. Get from an array with 100 elements:
  140.  
  141. js x 45,051,640 ops/sec ±0.48% (96 runs sampled)
  142. cons x 7,638,749 ops/sec ±0.22% (97 runs sampled)
  143. avl x 8,666,954 ops/sec ±0.65% (98 runs sampled)
  144. immutable-js x 21,104,665 ops/sec ±0.51% (93 runs sampled)
  145. mori (vector) x 15,760,142 ops/sec ±0.44% (100 runs sampled)
  146.  
  147. Add 100 elements into an empty array (at whatever spot is most efficient):
  148.  
  149. js x 2,029,959 ops/sec ±0.53% (93 runs sampled)
  150. cons x 408,753 ops/sec ±0.31% (98 runs sampled)
  151. avl x 25,095 ops/sec ±0.57% (99 runs sampled)
  152. immutable-js x 11,576 ops/sec ±0.63% (96 runs sampled)
  153. mori (vector) x 58,599 ops/sec ±0.63% (97 runs sampled)
  154.  
  155. Push 100 elements into an empty array:
  156.  
  157. js x 821,201 ops/sec ±1.20% (96 runs sampled)
  158. cons x 9,379 ops/sec ±0.25% (101 runs sampled)
  159. avl x 25,080 ops/sec ±0.65% (96 runs sampled)
  160. immutable-js x 11,490 ops/sec ±0.83% (98 runs sampled)
  161. mori (vector) x 57,985 ops/sec ±1.02% (100 runs sampled)
  162.  
  163. Unshift 100 elements into an empty array:
  164.  
  165. js x 207,162 ops/sec ±0.38% (101 runs sampled)
  166. cons x 704,809 ops/sec ±0.78% (97 runs sampled)
  167. avl x 24,470 ops/sec ±0.72% (99 runs sampled)
  168. immutable-js x 11,392 ops/sec ±0.67% (99 runs sampled)
  169.  
  170. Add 100 elements into an empty array, and then pop 100 elements:
  171.  
  172. js x 450,477 ops/sec ±0.43% (96 runs sampled)
  173. cons x 9,471 ops/sec ±0.34% (98 runs sampled)
  174. avl x 14,344 ops/sec ±0.59% (101 runs sampled)
  175. immutable-js x 7,680 ops/sec ±0.68% (99 runs sampled)
  176. mori (vector) x 35,627 ops/sec ±0.62% (99 runs sampled)
  177.  
  178. Add 100 elements into an empty array, and then shift 100 elements:
  179.  
  180. js x 219,881 ops/sec ±0.93% (96 runs sampled)
  181. cons x 460,243 ops/sec ±0.54% (99 runs sampled)
  182. avl x 13,918 ops/sec ±0.64% (101 runs sampled)
  183. immutable-js x 6,482 ops/sec ±0.50% (98 runs sampled)
  184.  
  185. Insert 100 elements at a random index:
  186.  
  187. js x 102,973 ops/sec ±1.70% (93 runs sampled)
  188. cons x 18,748 ops/sec ±0.96% (100 runs sampled)
  189. avl x 22,581 ops/sec ±0.87% (97 runs sampled)
  190. immutable-js x 310 ops/sec ±2.53% (82 runs sampled)
  191.  
  192. Add 100 elements into an empty array, and then remove 100 elements at a random index:
  193.  
  194. js x 83,907 ops/sec ±0.25% (99 runs sampled)
  195. cons x 18,604 ops/sec ±0.50% (98 runs sampled)
  196. avl x 8,599 ops/sec ±0.51% (99 runs sampled)
  197. immutable-js x 306 ops/sec ±2.41% (84 runs sampled)
  198.  
  199. Concatenate two arrays which both have 100 elements each:
  200.  
  201. js x 3,990,297 ops/sec ±0.60% (99 runs sampled)
  202. cons x 435,394 ops/sec ±0.56% (95 runs sampled)
  203. avl x 233,925 ops/sec ±0.56% (98 runs sampled)
  204. immutable-js x 17,886 ops/sec ±1.56% (97 runs sampled)
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!