API tools faq
paste
Advertisement
Guest User

lodash vs underscore benchmarks

a guest
Oct 18th, 2013
433
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.78 KB | None | 0 0
raw download clone embed print report
  1. Chrome 30.0.1599.69 32-bit on Windows 8 64-bit
  2. Sit back and relax, this may take a while.
  3. `_(...)` with a number:
  4. lodash.min x 19,429,863 ops/sec ±12.08% (42 runs sampled)
  5. underscore-min x 6,863,277 ops/sec ±3.91% (43 runs sampled)
  6. lodash.min is 162% faster.
  7. `_(...)` with an array:
  8. lodash.min x 19,409,938 ops/sec ±5.52% (34 runs sampled)
  9. underscore-min x 5,776,348 ops/sec ±2.41% (40 runs sampled)
  10. lodash.min is 226% faster.
  11. `_(...)` with an object:
  12. lodash.min x 8,991,089 ops/sec ±0.98% (69 runs sampled)
  13. underscore-min x 9,008,323 ops/sec ±2.67% (71 runs sampled)
  14. lodash.min is 1% faster.
  15. `_(...).tap(...)`:
  16. lodash.min x 5,758,037 ops/sec ±0.73% (73 runs sampled)
  17. underscore-min x 2,721,296 ops/sec ±4.97% (81 runs sampled)
  18. lodash.min is 120% faster.
  19. `_.bind` (uses native `Function#bind` if available and inferred fast):
  20. lodash.min x 261,401 ops/sec ±0.38% (85 runs sampled)
  21. underscore-min x 300,159 ops/sec ±6.90% (62 runs sampled)
  22. underscore-min is 8% faster.
  23. bound call:
  24. lodash.min x 4,651,377 ops/sec ±11.60% (87 runs sampled)
  25. underscore-min x 2,945,161 ops/sec ±3.59% (82 runs sampled)
  26. lodash.min is 47% faster.
  27. bound call with arguments:
  28. lodash.min x 6,144,270 ops/sec ±4.57% (77 runs sampled)
  29. underscore-min x 3,015,896 ops/sec ±3.86% (78 runs sampled)
  30. lodash.min is 102% faster.
  31. bound and partially applied call (uses native `Function#bind` if available):
  32. lodash.min x 3,465,675 ops/sec ±3.73% (85 runs sampled)
  33. underscore-min x 3,414,194 ops/sec ±3.56% (84 runs sampled)
  34. lodash.min is 1% faster.
  35. bound and partially applied call with arguments (uses native `Function#bind` if available):
  36. lodash.min x 2,307,459 ops/sec ±3.51% (87 runs sampled)
  37. underscore-min x 2,326,928 ops/sec ±4.37% (87 runs sampled)
  38. underscore-min is 0.02% faster.
  39. bound multiple times:
  40. lodash.min x 5,032,507 ops/sec ±0.87% (65 runs sampled)
  41. underscore-min x 2,915,750 ops/sec ±3.84% (81 runs sampled)
  42. lodash.min is 78% faster.
  43. `_.bindAll` iterating arguments:
  44. lodash.min x 2,770 ops/sec ±7.91% (18 runs sampled)
  45. underscore-min x 3,447 ops/sec ±3.78% (20 runs sampled)
  46. underscore-min is 29% faster.
  47. `_.bindAll` iterating the `object`:
  48. lodash.min x 2,642 ops/sec ±8.64% (17 runs sampled)
  49. underscore-min:
  50. There was a problem, skipping...
  51. `_.clone` with an object:
  52. lodash.min x 93,237 ops/sec ±2.94% (82 runs sampled)
  53. underscore-min x 76,064 ops/sec ±3.04% (83 runs sampled)
  54. lodash.min is 23% faster.
  55. `_.compact`:
  56. lodash.min x 3,721,117 ops/sec ±4.18% (79 runs sampled)
  57. underscore-min x 405,848 ops/sec ±6.98% (68 runs sampled)
  58. lodash.min is 842% faster.
  59. `_.contains` iterating an array:
  60. lodash.min x 10,261,007 ops/sec ±6.14% (77 runs sampled)
  61. underscore-min x 7,011,500 ops/sec ±3.63% (83 runs sampled)
  62. lodash.min is 43% faster.
  63. `_.contains` iterating an object:
  64. lodash.min x 365,630 ops/sec ±0.78% (85 runs sampled)
  65. underscore-min x 286,577 ops/sec ±3.29% (85 runs sampled)
  66. lodash.min is 31% faster.
  67. `_.countBy` with `callback` iterating an array:
  68. lodash.min x 279,754 ops/sec ±2.60% (78 runs sampled)
  69. underscore-min x 177,901 ops/sec ±2.30% (85 runs sampled)
  70. lodash.min is 57% faster.
  71. `_.countBy` with `property` name iterating an array:
  72. lodash.min x 284,432 ops/sec ±1.34% (84 runs sampled)
  73. underscore-min x 167,719 ops/sec ±2.61% (80 runs sampled)
  74. lodash.min is 72% faster.
  75. `_.countBy` with `callback` iterating an object:
  76. lodash.min x 94,542 ops/sec ±3.10% (79 runs sampled)
  77. underscore-min x 84,895 ops/sec ±0.94% (85 runs sampled)
  78. lodash.min is 9% faster.
  79. `_.defaults`:
  80. lodash.min x 75,217 ops/sec ±3.03% (88 runs sampled)
  81. underscore-min x 56,788 ops/sec ±3.83% (74 runs sampled)
  82. lodash.min is 33% faster.
  83. `_.difference`:
  84. lodash.min x 641,448 ops/sec ±4.45% (78 runs sampled)
  85. underscore-min x 138,930 ops/sec ±6.58% (74 runs sampled)
  86. lodash.min is 371% faster.
  87. `_.difference` iterating 75 elements:
  88. lodash.min x 34,061 ops/sec ±3.17% (87 runs sampled)
  89. underscore-min x 22,379 ops/sec ±3.45% (76 runs sampled)
  90. lodash.min is 53% faster.
  91. `_.difference` iterating 200 elements:
  92. lodash.min x 22,664 ops/sec ±3.04% (84 runs sampled)
  93. underscore-min x 5,706 ops/sec ±1.31% (33 runs sampled)
  94. lodash.min is 291% faster.
  95. `_.difference` iterating 20 and 40 elements:
  96. lodash.min x 152,653 ops/sec ±1.90% (77 runs sampled)
  97. underscore-min x 82,250 ops/sec ±4.49% (79 runs sampled)
  98. lodash.min is 90% faster.
  99. `_.each` iterating an array:
  100. lodash.min x 1,597,019 ops/sec ±3.51% (78 runs sampled)
  101. underscore-min x 586,644 ops/sec ±2.56% (83 runs sampled)
  102. lodash.min is 170% faster.
  103. `_.each` iterating an array with `thisArg` (slow path):
  104. lodash.min x 179,043 ops/sec ±1.01% (83 runs sampled)
  105. underscore-min x 177,586 ops/sec ±3.30% (84 runs sampled)
  106. lodash.min is 3% faster.
  107. `_.each` iterating an object:
  108. lodash.min x 323,876 ops/sec ±4.47% (65 runs sampled)
  109. underscore-min x 320,733 ops/sec ±3.30% (87 runs sampled)
  110. underscore-min is 0.15% faster.
  111. `_.every` iterating an array:
  112. lodash.min x 1,655,087 ops/sec ±4.08% (81 runs sampled)
  113. underscore-min x 639,511 ops/sec ±1.48% (71 runs sampled)
  114. lodash.min is 152% faster.
  115. `_.every` iterating an object:
  116. lodash.min x 303,387 ops/sec ±3.94% (83 runs sampled)
  117. underscore-min x 282,976 ops/sec ±4.18% (83 runs sampled)
  118. lodash.min is 7% faster.
  119. `_.extend`:
  120. lodash.min x 105,701 ops/sec ±4.18% (86 runs sampled)
  121. underscore-min x 77,554 ops/sec ±0.98% (76 runs sampled)
  122. lodash.min is 32% faster.
  123. `_.filter` iterating an array:
  124. lodash.min x 1,677,967 ops/sec ±4.00% (85 runs sampled)
  125. underscore-min x 387,284 ops/sec ±6.72% (68 runs sampled)
  126. lodash.min is 345% faster.
  127. `_.filter` iterating an array with `thisArg` (slow path):
  128. lodash.min x 179,000 ops/sec ±3.30% (79 runs sampled)
  129. underscore-min x 155,908 ops/sec ±5.43% (75 runs sampled)
  130. lodash.min is 17% faster.
  131. `_.filter` iterating an object:
  132. lodash.min x 298,390 ops/sec ±3.76% (83 runs sampled)
  133. underscore-min x 283,531 ops/sec ±3.55% (83 runs sampled)
  134. lodash.min is 5% faster.
  135. `_.find` iterating an array:
  136. lodash.min x 2,082,364 ops/sec ±3.57% (86 runs sampled)
  137. underscore-min x 500,356 ops/sec ±3.35% (80 runs sampled)
  138. lodash.min is 315% faster.
  139. `_.find` iterating an object:
  140. lodash.min x 218,692 ops/sec ±0.93% (86 runs sampled)
  141. underscore-min x 181,881 ops/sec ±3.91% (79 runs sampled)
  142. lodash.min is 24% faster.
  143. `_.find` with `properties`:
  144. lodash.min x 1,319,550 ops/sec ±4.50% (70 runs sampled)
  145. underscore-min x 496,666 ops/sec ±4.03% (76 runs sampled)
  146. lodash.min is 164% faster.
  147. `_.flatten`:
  148. lodash.min x 868,255 ops/sec ±6.61% (68 runs sampled)
  149. underscore-min x 386,744 ops/sec ±3.92% (86 runs sampled)
  150. lodash.min is 119% faster.
  151. `_.flatten` with objects:
  152. lodash.min x 883,212 ops/sec ±0.65% (87 runs sampled)
  153. underscore-min x 418,776 ops/sec ±3.82% (83 runs sampled)
  154. lodash.min is 118% faster.
  155. `_.flatten` with `shallow`:
  156. lodash.min x 2,387,820 ops/sec ±4.46% (81 runs sampled)
  157. underscore-min x 764,839 ops/sec ±4.14% (85 runs sampled)
  158. lodash.min is 211% faster.
  159. `_.functions`:
  160. lodash.min x 8,986 ops/sec ±1.56% (86 runs sampled)
  161. underscore-min x 9,155 ops/sec ±2.56% (49 runs sampled)
  162. underscore-min is 0.89% faster.
  163. `_.groupBy` with `callback` iterating an array:
  164. lodash.min x 212,857 ops/sec ±4.34% (79 runs sampled)
  165. underscore-min x 114,350 ops/sec ±6.43% (65 runs sampled)
  166. lodash.min is 90% faster.
  167. `_.groupBy` with `property` name iterating an array:
  168. lodash.min x 164,655 ops/sec ±4.03% (30 runs sampled)
  169. underscore-min x 101,476 ops/sec ±6.86% (41 runs sampled)
  170. lodash.min is 67% faster.
  171. `_.groupBy` with `callback` iterating an object:
  172. lodash.min x 45,701 ops/sec ±9.66% (57 runs sampled)
  173. underscore-min x 43,844 ops/sec ±11.25% (35 runs sampled)
  174. lodash.min is 6% faster.
  175. `_.indexBy` with `callback` iterating an array:
  176. lodash.min x 571,135 ops/sec ±14.40% (48 runs sampled)
  177. underscore-min x 394,320 ops/sec ±3.03% (77 runs sampled)
  178. lodash.min is 30% faster.
  179. `_.indexBy` with `property` name iterating an array:
  180. lodash.min x 1,053,293 ops/sec ±2.85% (56 runs sampled)
  181. underscore-min x 316,700 ops/sec ±6.70% (45 runs sampled)
  182. lodash.min is 245% faster.
  183. `_.indexBy` with `callback` iterating an object:
  184. lodash.min x 190,245 ops/sec ±2.32% (51 runs sampled)
  185. underscore-min x 152,135 ops/sec ±2.69% (65 runs sampled)
  186. lodash.min is 26% faster.
  187. `_.indexOf`:
  188. lodash.min x 509,265 ops/sec ±5.81% (32 runs sampled)
  189. underscore-min x 503,274 ops/sec ±4.27% (65 runs sampled)
  190. It's too close to call.
  191. `_.intersection`:
  192. lodash.min x 305,548 ops/sec ±4.50% (40 runs sampled)
  193. underscore-min x 45,993 ops/sec ±8.34% (23 runs sampled)
  194. lodash.min is 589% faster.
  195. `_.intersection` iterating 75 elements:
  196. lodash.min x 14,082 ops/sec ±2.58% (65 runs sampled)
  197. underscore-min x 8,686 ops/sec ±4.51% (44 runs sampled)
  198. lodash.min is 65% faster.
  199. `_.intersection` iterating 200 elements:
  200. lodash.min x 10,276 ops/sec ±2.46% (50 runs sampled)
  201. underscore-min x 2,562 ops/sec ±1.20% (17 runs sampled)
  202. lodash.min is 296% faster.
  203. `_.invert`:
  204. lodash.min x 297,057 ops/sec ±4.99% (18 runs sampled)
  205. underscore-min x 287,347 ops/sec ±5.11% (42 runs sampled)
  206. It's too close to call.
  207. `_.invoke` iterating an array:
  208. lodash.min x 59,806 ops/sec ±3.79% (55 runs sampled)
  209. underscore-min x 49,603 ops/sec ±5.64% (14 runs sampled)
  210. lodash.min is 23% faster.
  211. `_.invoke` with a function for `methodName` iterating an array:
  212. lodash.min x 98,818 ops/sec ±3.39% (59 runs sampled)
  213. underscore-min x 86,683 ops/sec ±3.40% (42 runs sampled)
  214. lodash.min is 14% faster.
  215. `_.invoke` iterating an object:
  216. lodash.min x 54,224 ops/sec ±4.33% (64 runs sampled)
  217. underscore-min x 42,434 ops/sec ±3.07% (68 runs sampled)
  218. lodash.min is 26% faster.
  219. `_.isEqual` comparing primitives and objects (edge case):
  220. lodash.min x 101,962 ops/sec ±4.81% (47 runs sampled)
  221. underscore-min x 151,299 ops/sec ±7.47% (25 runs sampled)
  222. underscore-min is 45% faster.
  223. `_.isEqual` comparing arrays:
  224. lodash.min x 213,275 ops/sec ±4.68% (50 runs sampled)
  225. underscore-min x 250,840 ops/sec ±3.27% (31 runs sampled)
  226. underscore-min is 19% faster.
  227. `_.isEqual` comparing nested arrays:
  228. lodash.min x 95,491 ops/sec ±3.54% (57 runs sampled)
  229. underscore-min x 103,017 ops/sec ±3.68% (48 runs sampled)
  230. underscore-min is 8% faster.
  231. `_.isEqual` comparing arrays of objects:
  232. lodash.min x 14,424 ops/sec ±3.91% (66 runs sampled)
  233. underscore-min x 24,519 ops/sec ±4.56% (41 runs sampled)
  234. underscore-min is 69% faster.
  235. `_.isEqual` comparing objects:
  236. lodash.min x 18,542 ops/sec ±5.15% (37 runs sampled)
  237. underscore-min x 20,844 ops/sec ±6.19% (24 runs sampled)
  238. underscore-min is 11% faster.
  239. `_.isArguments`, `_.isDate`, `_.isFunction`, `_.isNumber`, `_.isObject`, `_.isRegExp`:
  240. lodash.min x 828,106 ops/sec ±3.00% (87 runs sampled)
  241. underscore-min x 438,585 ops/sec ±4.74% (79 runs sampled)
  242. lodash.min is 92% faster.
  243. `_.keys` (uses native `Object.keys` if available):
  244. lodash.min x 506,855 ops/sec ±6.90% (78 runs sampled)
  245. underscore-min x 564,438 ops/sec ±3.15% (59 runs sampled)
  246. underscore-min is 15% faster.
  247. `_.lastIndexOf`:
  248. lodash.min x 7,556,772 ops/sec ±7.22% (32 runs sampled)
  249. underscore-min x 6,185,594 ops/sec ±8.90% (43 runs sampled)
  250. lodash.min is 24% faster.
  251. `_.map` iterating an array:
  252. lodash.min x 1,445,036 ops/sec ±3.93% (76 runs sampled)
  253. underscore-min x 380,369 ops/sec ±9.80% (38 runs sampled)
  254. lodash.min is 301% faster.
  255. `_.map` with `thisArg` iterating an array (slow path):
  256. lodash.min x 161,623 ops/sec ±4.71% (57 runs sampled)
  257. underscore-min x 136,586 ops/sec ±4.19% (54 runs sampled)
  258. lodash.min is 18% faster.
  259. `_.map` iterating an object:
  260. lodash.min x 232,040 ops/sec ±4.87% (31 runs sampled)
  261. underscore-min x 231,284 ops/sec ±3.22% (57 runs sampled)
  262. It's too close to call.
  263. `_.max`:
  264. lodash.min x 5,729,423 ops/sec ±4.34% (19 runs sampled)
  265. underscore-min x 2,087,713 ops/sec ±4.68% (52 runs sampled)
  266. lodash.min is 175% faster.
  267. `_.min`:
  268. lodash.min x 7,330,413 ops/sec ±4.89% (76 runs sampled)
  269. underscore-min x 2,659,881 ops/sec ±3.58% (74 runs sampled)
  270. lodash.min is 172% faster.
  271. `_.omit` iterating 20 properties, omitting 2 keys:
  272. lodash.min x 72,429 ops/sec ±3.72% (82 runs sampled)
  273. underscore-min x 62,472 ops/sec ±2.85% (85 runs sampled)
  274. lodash.min is 15% faster.
  275. `_.omit` iterating 40 properties, omitting 20 keys:
  276. lodash.min x 58,546 ops/sec ±2.77% (69 runs sampled)
  277. underscore-min x 54,265 ops/sec ±2.54% (84 runs sampled)
  278. lodash.min is 8% faster.
  279. `_.pairs`:
  280. lodash.min x 396,228 ops/sec ±5.76% (81 runs sampled)
  281. underscore-min x 419,151 ops/sec ±3.71% (86 runs sampled)
  282. underscore-min is 8% faster.
  283. `_.pick`:
  284. lodash.min x 790,443 ops/sec ±3.52% (80 runs sampled)
  285. underscore-min x 264,778 ops/sec ±2.30% (84 runs sampled)
  286. lodash.min is 195% faster.
  287. `_.pluck`:
  288. lodash.min x 5,240,328 ops/sec ±3.20% (67 runs sampled)
  289. underscore-min x 381,831 ops/sec ±5.49% (62 runs sampled)
  290. lodash.min is 1,303% faster.
  291. `_.reduce` iterating an array:
  292. lodash.min x 789,649 ops/sec ±5.20% (74 runs sampled)
  293. underscore-min x 459,921 ops/sec ±3.65% (80 runs sampled)
  294. lodash.min is 69% faster.
  295. `_.reduce` iterating an object:
  296. lodash.min x 237,679 ops/sec ±4.12% (76 runs sampled)
  297. underscore-min x 208,663 ops/sec ±3.38% (83 runs sampled)
  298. lodash.min is 13% faster.
  299. `_.reduceRight` iterating an array:
  300. lodash.min x 795,041 ops/sec ±4.87% (77 runs sampled)
  301. underscore-min x 307,906 ops/sec ±7.80% (64 runs sampled)
  302. lodash.min is 165% faster.
  303. `_.reduceRight` iterating an object:
  304. lodash.min x 85,011 ops/sec ±11.21% (51 runs sampled)
  305. underscore-min x 113,145 ops/sec ±4.28% (67 runs sampled)
  306. underscore-min is 42% faster.
  307. `_.reject` iterating an array:
  308. lodash.min x 791,293 ops/sec ±10.37% (20 runs sampled)
  309. underscore-min x 293,171 ops/sec ±4.85% (51 runs sampled)
  310. lodash.min is 156% faster.
  311. `_.reject` iterating an array with `thisArg` (slow path):
  312. lodash.min x 175,262 ops/sec ±3.34% (82 runs sampled)
  313. underscore-min x 140,326 ops/sec ±4.71% (78 runs sampled)
  314. lodash.min is 27% faster.
  315. `_.reject` iterating an object:
  316. lodash.min x 284,376 ops/sec ±2.43% (84 runs sampled)
  317. underscore-min x 222,121 ops/sec ±4.40% (80 runs sampled)
  318. lodash.min is 30% faster.
  319. `_.sample` with an `n`:
  320. lodash.min x 330,460 ops/sec ±2.27% (84 runs sampled)
  321. underscore-min x 359,716 ops/sec ±2.26% (84 runs sampled)
  322. underscore-min is 9% faster.
  323. `_.shuffle`:
  324. lodash.min x 224,348 ops/sec ±5.71% (41 runs sampled)
  325. underscore-min x 350,532 ops/sec ±2.72% (78 runs sampled)
  326. underscore-min is 61% faster.
  327. `_.size` with an object:
  328. lodash.min x 553,916 ops/sec ±4.12% (87 runs sampled)
  329. underscore-min x 550,663 ops/sec ±4.28% (88 runs sampled)
  330. It's too close to call.
  331. `_.some` iterating an array:
  332. lodash.min x 2,107,279 ops/sec ±3.66% (87 runs sampled)
  333. underscore-min x 688,182 ops/sec ±1.79% (82 runs sampled)
  334. lodash.min is 201% faster.
  335. `_.some` with `thisArg` iterating an array (slow path):
  336. lodash.min x 209,086 ops/sec ±3.03% (79 runs sampled)
  337. underscore-min x 199,646 ops/sec ±1.81% (87 runs sampled)
  338. lodash.min is 3% faster.
  339. `_.some` iterating an object:
  340. lodash.min x 333,065 ops/sec ±3.11% (89 runs sampled)
  341. underscore-min x 268,790 ops/sec ±3.89% (82 runs sampled)
  342. lodash.min is 25% faster.
  343. `_.sortBy` with `callback`:
  344. lodash.min x 255,897 ops/sec ±3.41% (82 runs sampled)
  345. underscore-min x 72,967 ops/sec ±8.79% (52 runs sampled)
  346. lodash.min is 269% faster.
  347. `_.sortBy` with `callback` and `thisArg` (slow path):
  348. lodash.min x 136,983 ops/sec ±4.31% (74 runs sampled)
  349. underscore-min x 57,375 ops/sec ±6.39% (81 runs sampled)
  350. lodash.min is 143% faster.
  351. `_.sortBy` with `property` name:
  352. lodash.min x 141,418 ops/sec ±2.31% (72 runs sampled)
  353. underscore-min x 60,633 ops/sec ±6.23% (75 runs sampled)
  354. lodash.min is 142% faster.
  355. `_.sortedIndex` with `callback`:
  356. lodash.min x 4,708,765 ops/sec ±4.51% (77 runs sampled)
  357. underscore-min x 5,155,684 ops/sec ±3.31% (81 runs sampled)
  358. underscore-min is 11% faster.
  359. `_.template` (slow path):
  360. lodash.min x 14,622 ops/sec ±3.36% (75 runs sampled)
  361. underscore-min x 16,787 ops/sec ±3.12% (84 runs sampled)
  362. underscore-min is 15% faster.
  363. compiled template:
  364. lodash.min x 41,208 ops/sec ±1.67% (86 runs sampled)
  365. underscore-min x 42,059 ops/sec ±1.55% (86 runs sampled)
  366. underscore-min is 2% faster.
  367. compiled template without a with-statement:
  368. lodash.min x 1,801,535 ops/sec ±5.52% (74 runs sampled)
  369. underscore-min x 1,816,110 ops/sec ±3.61% (77 runs sampled)
  370. underscore-min is 3% faster.
  371. `_.times`:
  372. lodash.min x 1,595,453 ops/sec ±5.27% (84 runs sampled)
  373. underscore-min x 1,380,988 ops/sec ±3.79% (74 runs sampled)
  374. lodash.min is 14% faster.
  375. `_.times` with `thisArg`:
  376. lodash.min x 608,190 ops/sec ±3.09% (63 runs sampled)
  377. underscore-min x 793,088 ops/sec ±4.35% (79 runs sampled)
  378. underscore-min is 29% faster.
  379. `_.toArray` with an array (edge case):
  380. lodash.min x 6,649,957 ops/sec ±3.75% (79 runs sampled)
  381. underscore-min x 3,524,087 ops/sec ±4.33% (86 runs sampled)
  382. lodash.min is 90% faster.
  383. `_.toArray` with an object:
  384. lodash.min x 419,922 ops/sec ±2.82% (83 runs sampled)
  385. underscore-min x 433,614 ops/sec ±3.11% (84 runs sampled)
  386. underscore-min is 3% faster.
  387. `_.union`:
  388. lodash.min x 335,142 ops/sec ±3.24% (85 runs sampled)
  389. underscore-min x 142,456 ops/sec ±3.15% (74 runs sampled)
  390. lodash.min is 135% faster.
  391. `_.union` iterating an array of 75 elements:
  392. lodash.min x 28,813 ops/sec ±3.52% (76 runs sampled)
  393. underscore-min x 32,259 ops/sec ±2.56% (84 runs sampled)
  394. underscore-min is 13% faster.
  395. `_.union` iterating an array of 200 elements:
  396. lodash.min x 14,261 ops/sec ±2.62% (73 runs sampled)
  397. underscore-min x 8,969 ops/sec ±1.93% (49 runs sampled)
  398. lodash.min is 58% faster.
  399. `_.uniq`:
  400. lodash.min x 290,184 ops/sec ±2.49% (77 runs sampled)
  401. underscore-min x 165,480 ops/sec ±4.40% (77 runs sampled)
  402. lodash.min is 79% faster.
  403. `_.uniq` with `callback`:
  404. lodash.min x 665,956 ops/sec ±2.59% (84 runs sampled)
  405. underscore-min x 133,059 ops/sec ±6.33% (81 runs sampled)
  406. lodash.min is 419% faster.
  407. `_.uniq` iterating an array of 75 elements:
  408. lodash.min x 29,417 ops/sec ±2.98% (81 runs sampled)
  409. underscore-min x 33,369 ops/sec ±1.90% (85 runs sampled)
  410. underscore-min is 15% faster.
  411. `_.uniq` iterating an array of 200 elements:
  412. lodash.min x 17,501 ops/sec ±2.75% (86 runs sampled)
  413. underscore-min x 9,041 ops/sec ±2.62% (48 runs sampled)
  414. lodash.min is 93% faster.
  415. `_.values`:
  416. lodash.min x 432,444 ops/sec ±3.12% (85 runs sampled)
  417. underscore-min x 431,454 ops/sec ±3.51% (85 runs sampled)
  418. lodash.min is 0.61% faster.
  419. `_.where`:
  420. lodash.min x 814,616 ops/sec ±4.83% (76 runs sampled)
  421. underscore-min x 275,665 ops/sec ±5.53% (71 runs sampled)
  422. lodash.min is 197% faster.
  423. `_.without`:
  424. lodash.min x 342,738 ops/sec ±3.21% (83 runs sampled)
  425. underscore-min x 128,151 ops/sec ±5.32% (82 runs sampled)
  426. lodash.min is 173% faster.
  427. `_.zip`:
  428. lodash.min x 435,808 ops/sec ±2.16% (87 runs sampled)
  429. underscore-min x 225,106 ops/sec ±3.69% (86 runs sampled)
  430. lodash.min is 96% faster.
  431. lodash.min is 60% (1.60x) faster than underscore-min.
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!