Lodash vs. Underscore (benchmarks)

gistfile1.txt

Chrome 36.0.1985.67 on OS X 10.9.3

Sit back and relax, this may take a while.

`_(...)` with a number:
lodash.min x 148,659,845 ops/sec ±1.16% (83 runs sampled)
underscore-min x 21,250,737 ops/sec ±0.71% (89 runs sampled)
lodash.min is 596% faster.

`_(...)` with an array:
lodash.min x 36,828,038 ops/sec ±4.43% (60 runs sampled)
underscore-min x 17,687,134 ops/sec ±1.91% (87 runs sampled)
lodash.min is 103% faster.

`_(...)` with an object:
lodash.min x 11,407,961 ops/sec ±1.91% (86 runs sampled)
underscore-min x 17,520,456 ops/sec ±2.04% (81 runs sampled)
underscore-min is 53% faster.

`_(...).tap(...)`:
lodash.min x 3,627,917 ops/sec ±0.90% (86 runs sampled)
underscore-min x 3,187,347 ops/sec ±2.48% (86 runs sampled)
lodash.min is 16% faster.

`_.bind`:
lodash.min x 718,070 ops/sec ±0.70% (83 runs sampled)
underscore-min x 500,533 ops/sec ±3.31% (81 runs sampled)
lodash.min is 47% faster.

bound call with arguments:
lodash.min x 7,698,836 ops/sec ±1.72% (89 runs sampled)
underscore-min x 4,219,958 ops/sec ±2.82% (84 runs sampled)
lodash.min is 84% faster.

bound and partially applied call with arguments:
lodash.min x 3,154,085 ops/sec ±1.96% (87 runs sampled)
underscore-min x 3,468,460 ops/sec ±2.08% (84 runs sampled)
underscore-min is 10% faster.

bound multiple times:
lodash.min x 5,983,261 ops/sec ±2.07% (87 runs sampled)
underscore-min x 3,993,998 ops/sec ±2.38% (84 runs sampled)
lodash.min is 50% faster.

`_.bindAll` iterating arguments:
lodash.min x 13,613 ops/sec ±3.51% (59 runs sampled)
underscore-min x 9,581 ops/sec ±5.41% (55 runs sampled)
lodash.min is 45% faster.

`_.bindAll` iterating the `object`:
lodash.min x 12,500 ops/sec ±3.14% (62 runs sampled)
underscore-min: 
There was a problem, skipping...

`_.clone` with an object:
lodash.min x 108,049 ops/sec ±0.69% (90 runs sampled)
underscore-min x 88,651 ops/sec ±1.56% (90 runs sampled)
lodash.min is 23% faster.

`_.compact`:
lodash.min x 7,932,072 ops/sec ±2.18% (85 runs sampled)
underscore-min x 586,927 ops/sec ±3.75% (82 runs sampled)
lodash.min is 1,272% faster.

`_.contains` iterating an array:
lodash.min x 14,699,347 ops/sec ±0.67% (88 runs sampled)
underscore-min x 8,795,839 ops/sec ±2.04% (85 runs sampled)
lodash.min is 69% faster.

`_.contains` iterating an object:
lodash.min x 523,956 ops/sec ±0.89% (88 runs sampled)
underscore-min x 416,315 ops/sec ±2.41% (89 runs sampled)
lodash.min is 28% faster.

`_.countBy` with `callback` iterating an array:
lodash.min x 370,503 ops/sec ±1.60% (86 runs sampled)
underscore-min x 246,898 ops/sec ±0.92% (84 runs sampled)
lodash.min is 49% faster.

`_.countBy` with `property` name iterating an array:
lodash.min x 359,513 ops/sec ±1.41% (85 runs sampled)
underscore-min x 229,394 ops/sec ±1.38% (81 runs sampled)
lodash.min is 57% faster.

`_.countBy` with `callback` iterating an object:
lodash.min x 122,416 ops/sec ±1.65% (84 runs sampled)
underscore-min x 97,139 ops/sec ±1.35% (81 runs sampled)
lodash.min is 26% faster.

`_.defaults`:
lodash.min x 82,699 ops/sec ±1.47% (86 runs sampled)
underscore-min x 67,431 ops/sec ±0.98% (86 runs sampled)
lodash.min is 22% faster.

`_.difference`:
lodash.min x 798,405 ops/sec ±0.71% (87 runs sampled)
underscore-min x 195,139 ops/sec ±3.87% (80 runs sampled)
lodash.min is 322% faster.

`_.difference` iterating 75 elements:
lodash.min x 41,059 ops/sec ±1.32% (83 runs sampled)
underscore-min x 28,328 ops/sec ±0.99% (83 runs sampled)
lodash.min is 44% faster.

`_.difference` iterating 200 elements:
lodash.min x 24,019 ops/sec ±2.01% (71 runs sampled)
underscore-min x 6,820 ops/sec ±1.35% (84 runs sampled)
lodash.min is 250% faster.

`_.difference` iterating 20 and 40 elements:
lodash.min x 185,348 ops/sec ±1.56% (84 runs sampled)
underscore-min x 106,459 ops/sec ±0.51% (82 runs sampled)
lodash.min is 72% faster.

`_.each` iterating an array:
lodash.min x 1,703,374 ops/sec ±6.77% (76 runs sampled)
underscore-min x 700,394 ops/sec ±2.90% (79 runs sampled)
lodash.min is 134% faster.

`_.each` iterating an array with `thisArg` (slow path):
lodash.min x 371,477 ops/sec ±2.35% (83 runs sampled)
underscore-min x 332,045 ops/sec ±0.70% (88 runs sampled)
lodash.min is 10% faster.

`_.each` iterating an object:
lodash.min x 480,446 ops/sec ±2.98% (84 runs sampled)
underscore-min x 441,418 ops/sec ±2.70% (84 runs sampled)
lodash.min is 9% faster.

`_.every` iterating an array:
lodash.min x 2,745,408 ops/sec ±0.78% (85 runs sampled)
underscore-min x 898,224 ops/sec ±1.71% (80 runs sampled)
lodash.min is 208% faster.

`_.every` iterating an object:
lodash.min x 446,865 ops/sec ±2.86% (80 runs sampled)
underscore-min x 411,770 ops/sec ±1.29% (84 runs sampled)
lodash.min is 7% faster.

`_.extend`:
lodash.min x 111,051 ops/sec ±2.23% (86 runs sampled)
underscore-min x 84,836 ops/sec ±2.36% (88 runs sampled)
lodash.min is 31% faster.

`_.filter` iterating an array:
lodash.min x 2,343,605 ops/sec ±0.89% (85 runs sampled)
underscore-min x 570,027 ops/sec ±4.12% (82 runs sampled)
lodash.min is 324% faster.

`_.filter` iterating an array with `thisArg` (slow path):
lodash.min x 379,179 ops/sec ±2.96% (84 runs sampled)
underscore-min x 286,705 ops/sec ±2.66% (87 runs sampled)
lodash.min is 32% faster.

`_.filter` iterating an object:
lodash.min x 464,217 ops/sec ±3.01% (84 runs sampled)
underscore-min x 407,848 ops/sec ±1.43% (84 runs sampled)
lodash.min is 12% faster.

`_.find` iterating an array:
lodash.min x 2,924,404 ops/sec ±0.65% (88 runs sampled)
underscore-min x 722,757 ops/sec ±2.03% (83 runs sampled)
lodash.min is 310% faster.

`_.find` iterating an object:
lodash.min x 317,551 ops/sec ±3.05% (83 runs sampled)
underscore-min x 279,230 ops/sec ±0.70% (88 runs sampled)
lodash.min is 11% faster.

`_.find` with `properties`:
lodash.min x 1,432,840 ops/sec ±1.78% (82 runs sampled)
underscore-min x 708,040 ops/sec ±1.68% (82 runs sampled)
lodash.min is 102% faster.

`_.flatten`:
lodash.min x 463,252 ops/sec ±0.63% (85 runs sampled)
underscore-min x 463,864 ops/sec ±1.20% (83 runs sampled)
It's too close to call.

`_.flatten` with objects:
lodash.min x 413,319 ops/sec ±1.56% (81 runs sampled)
underscore-min x 434,326 ops/sec ±1.06% (79 runs sampled)
underscore-min is 6% faster.

`_.flatten` with `shallow`:
lodash.min x 1,055,662 ops/sec ±3.45% (81 runs sampled)
underscore-min x 1,047,386 ops/sec ±0.94% (84 runs sampled)
underscore-min is 2% faster.

`_.functions`:
lodash.min x 12,860 ops/sec ±1.97% (75 runs sampled)
underscore-min x 12,008 ops/sec ±2.61% (67 runs sampled)
lodash.min is 8% faster.

`_.groupBy` with `callback` iterating an array:
lodash.min x 304,224 ops/sec ±3.57% (67 runs sampled)
underscore-min x 191,318 ops/sec ±2.22% (82 runs sampled)
lodash.min is 57% faster.

`_.groupBy` with `property` name iterating an array:
lodash.min x 238,493 ops/sec ±1.11% (89 runs sampled)
underscore-min x 163,768 ops/sec ±1.84% (86 runs sampled)
lodash.min is 47% faster.

`_.groupBy` with `callback` iterating an object:
lodash.min x 72,381 ops/sec ±0.94% (86 runs sampled)
underscore-min x 58,825 ops/sec ±2.38% (81 runs sampled)
lodash.min is 25% faster.

`_.indexBy` with `callback` iterating an array:
lodash.min x 1,052,291 ops/sec ±5.17% (77 runs sampled)
underscore-min x 490,041 ops/sec ±1.94% (81 runs sampled)
lodash.min is 108% faster.

`_.indexBy` with `property` name iterating an array:
lodash.min x 1,313,356 ops/sec ±2.38% (80 runs sampled)
underscore-min x 479,426 ops/sec ±0.48% (87 runs sampled)
lodash.min is 169% faster.

`_.indexBy` with `callback` iterating an object:
lodash.min x 248,304 ops/sec ±2.64% (88 runs sampled)
underscore-min x 204,032 ops/sec ±2.60% (80 runs sampled)
lodash.min is 22% faster.

`_.indexOf`:
lodash.min x 889,038 ops/sec ±1.38% (84 runs sampled)
underscore-min x 1,042,917 ops/sec ±1.42% (84 runs sampled)
underscore-min is 17% faster.

`_.intersection`:
lodash.min x 386,225 ops/sec ±3.69% (84 runs sampled)
underscore-min x 99,873 ops/sec ±3.02% (85 runs sampled)
lodash.min is 284% faster.

`_.intersection` iterating 75 elements:
lodash.min x 21,718 ops/sec ±2.46% (83 runs sampled)
underscore-min x 12,811 ops/sec ±1.87% (87 runs sampled)
lodash.min is 69% faster.

`_.intersection` iterating 200 elements:
lodash.min x 13,830 ops/sec ±1.89% (86 runs sampled)
underscore-min x 3,036 ops/sec ±1.34% (86 runs sampled)
lodash.min is 353% faster.

`_.invert`:
lodash.min x 470,103 ops/sec ±2.98% (85 runs sampled)
underscore-min x 459,013 ops/sec ±2.48% (84 runs sampled)
lodash.min is 2% faster.

`_.invoke` iterating an array:
lodash.min x 105,264 ops/sec ±1.65% (81 runs sampled)
underscore-min x 87,058 ops/sec ±1.95% (81 runs sampled)
lodash.min is 21% faster.

`_.invoke` with a function for `methodName` iterating an array:
lodash.min x 229,319 ops/sec ±2.40% (82 runs sampled)
underscore-min x 150,657 ops/sec ±2.39% (84 runs sampled)
lodash.min is 52% faster.

`_.invoke` iterating an object:
lodash.min x 88,795 ops/sec ±2.00% (84 runs sampled)
underscore-min x 73,267 ops/sec ±2.39% (83 runs sampled)
lodash.min is 22% faster.

`_.isEqual` comparing primitives and objects (edge case):
lodash.min x 179,688 ops/sec ±2.03% (86 runs sampled)
underscore-min x 246,183 ops/sec ±4.05% (53 runs sampled)
underscore-min is 34% faster.

`_.isEqual` comparing arrays:
lodash.min x 254,188 ops/sec ±2.14% (86 runs sampled)
underscore-min x 489,464 ops/sec ±3.46% (80 runs sampled)
underscore-min is 90% faster.

`_.isEqual` comparing nested arrays:
lodash.min x 87,317 ops/sec ±2.05% (80 runs sampled)
underscore-min x 148,440 ops/sec ±1.45% (84 runs sampled)
underscore-min is 71% faster.

`_.isEqual` comparing arrays of objects:
lodash.min x 18,640 ops/sec ±1.07% (83 runs sampled)
underscore-min x 39,479 ops/sec ±3.86% (79 runs sampled)
underscore-min is 106% faster.

`_.isEqual` comparing objects:
lodash.min x 60,012 ops/sec ±2.31% (84 runs sampled)
underscore-min x 72,018 ops/sec ±1.53% (86 runs sampled)
underscore-min is 21% faster.

`_.isArguments`, `_.isDate`, `_.isFunction`, `_.isNumber`, `_.isObject`, `_.isRegExp`:
lodash.min x 867,644 ops/sec ±2.34% (83 runs sampled)
underscore-min x 394,301 ops/sec ±5.50% (73 runs sampled)
lodash.min is 127% faster.

`_.keys` (uses native `Object.keys` if available):
lodash.min x 661,407 ops/sec ±4.93% (76 runs sampled)
underscore-min x 817,286 ops/sec ±2.56% (84 runs sampled)
underscore-min is 26% faster.

`_.lastIndexOf`:
lodash.min x 30,117,608 ops/sec ±0.53% (88 runs sampled)
underscore-min x 19,965,981 ops/sec ±0.52% (86 runs sampled)
lodash.min is 51% faster.

`_.map` iterating an array:
lodash.min x 1,811,192 ops/sec ±5.62% (83 runs sampled)
underscore-min x 552,331 ops/sec ±3.81% (82 runs sampled)
lodash.min is 222% faster.

`_.map` with `thisArg` iterating an array (slow path):
lodash.min x 358,424 ops/sec ±2.01% (89 runs sampled)
underscore-min x 262,782 ops/sec ±2.30% (87 runs sampled)
lodash.min is 37% faster.

`_.map` iterating an object:
lodash.min x 366,992 ops/sec ±2.61% (86 runs sampled)
underscore-min x 300,949 ops/sec ±3.71% (77 runs sampled)
lodash.min is 23% faster.

`_.max`:
lodash.min x 10,513,440 ops/sec ±3.07% (83 runs sampled)
underscore-min x 4,587,893 ops/sec ±2.32% (85 runs sampled)
lodash.min is 127% faster.

`_.min`:
lodash.min x 9,765,095 ops/sec ±3.08% (76 runs sampled)
underscore-min x 4,258,046 ops/sec ±1.93% (82 runs sampled)
lodash.min is 127% faster.

`_.omit` iterating 20 properties, omitting 2 keys:
lodash.min x 79,717 ops/sec ±2.22% (86 runs sampled)
underscore-min x 66,185 ops/sec ±2.10% (81 runs sampled)
lodash.min is 20% faster.

`_.omit` iterating 40 properties, omitting 20 keys:
lodash.min x 90,421 ops/sec ±2.72% (77 runs sampled)
underscore-min x 72,739 ops/sec ±1.73% (82 runs sampled)
lodash.min is 23% faster.

`_.pairs`:
lodash.min x 482,155 ops/sec ±3.39% (81 runs sampled)
underscore-min x 464,266 ops/sec ±3.53% (80 runs sampled)
lodash.min is 4% faster.

`_.partial`:
lodash.min x 514,077 ops/sec ±1.19% (83 runs sampled)
underscore-min x 1,038,234 ops/sec ±3.21% (74 runs sampled)
underscore-min is 98% faster.

partially applied call with arguments:
lodash.min x 2,587,250 ops/sec ±3.56% (77 runs sampled)
underscore-min x 2,030,517 ops/sec ±2.35% (86 runs sampled)
lodash.min is 26% faster.

`_.pick`:
lodash.min x 834,836 ops/sec ±2.37% (84 runs sampled)
underscore-min x 349,586 ops/sec ±1.92% (85 runs sampled)
lodash.min is 138% faster.

`_.pluck`:
lodash.min x 1,806,378 ops/sec ±1.20% (83 runs sampled)
underscore-min x 484,938 ops/sec ±4.19% (76 runs sampled)
lodash.min is 283% faster.

`_.reduce` iterating an array:
lodash.min x 883,287 ops/sec ±2.50% (82 runs sampled)
underscore-min x 505,713 ops/sec ±1.80% (84 runs sampled)
lodash.min is 73% faster.

`_.reduce` iterating an object:
lodash.min x 294,387 ops/sec ±0.72% (87 runs sampled)
underscore-min x 255,158 ops/sec ±3.36% (84 runs sampled)
lodash.min is 18% faster.

`_.reduceRight` iterating an array:
lodash.min x 832,697 ops/sec ±4.38% (82 runs sampled)
underscore-min x 494,512 ops/sec ±3.81% (41 runs sampled)
lodash.min is 67% faster.

`_.reduceRight` iterating an object:
lodash.min x 128,680 ops/sec ±4.70% (59 runs sampled)
underscore-min x 122,608 ops/sec ±5.05% (81 runs sampled)
lodash.min is 5% faster.

`_.reject` iterating an array:
lodash.min x 616,580 ops/sec ±13.25% (20 runs sampled)
underscore-min x 315,006 ops/sec ±6.91% (34 runs sampled)
lodash.min is 85% faster.

`_.reject` iterating an array with `thisArg` (slow path):
lodash.min x 231,589 ops/sec ±1.60% (89 runs sampled)
underscore-min x 163,905 ops/sec ±1.84% (87 runs sampled)
lodash.min is 42% faster.

`_.reject` iterating an object:
lodash.min x 210,901 ops/sec ±3.42% (72 runs sampled)
underscore-min x 216,710 ops/sec ±0.73% (89 runs sampled)
It's too close to call.

`_.sample` with an `n`:
lodash.min x 446,326 ops/sec ±0.88% (80 runs sampled)
underscore-min x 245,391 ops/sec ±3.74% (80 runs sampled)
lodash.min is 87% faster.

`_.shuffle`:
lodash.min x 482,947 ops/sec ±3.28% (84 runs sampled)
underscore-min x 271,410 ops/sec ±1.80% (89 runs sampled)
lodash.min is 75% faster.

`_.size` with an object:
lodash.min x 508,425 ops/sec ±4.33% (58 runs sampled)
underscore-min x 487,774 ops/sec ±6.32% (64 runs sampled)
lodash.min is 6% faster.

`_.some` iterating an array:
lodash.min x 1,844,086 ops/sec ±6.93% (36 runs sampled)
underscore-min x 585,013 ops/sec ±2.42% (52 runs sampled)
lodash.min is 202% faster.

`_.some` with `thisArg` iterating an array (slow path):
lodash.min x 258,151 ops/sec ±4.46% (53 runs sampled)
underscore-min x 222,598 ops/sec ±2.96% (83 runs sampled)
lodash.min is 14% faster.

`_.some` iterating an object:
lodash.min x 301,798 ops/sec ±3.87% (82 runs sampled)
underscore-min x 279,412 ops/sec ±1.18% (87 runs sampled)
lodash.min is 5% faster.

`_.sortBy` with `callback`:
lodash.min x 50,772 ops/sec ±2.71% (84 runs sampled)
underscore-min x 86,156 ops/sec ±0.54% (87 runs sampled)
underscore-min is 73% faster.

`_.sortBy` with `callback` and `thisArg` (slow path):
lodash.min x 44,934 ops/sec ±4.42% (79 runs sampled)
underscore-min x 77,378 ops/sec ±0.85% (85 runs sampled)
underscore-min is 78% faster.

`_.sortBy` with `property` name:
lodash.min x 58,088 ops/sec ±6.92% (81 runs sampled)
underscore-min x 95,695 ops/sec ±5.94% (75 runs sampled)
underscore-min is 66% faster.

`_.sortedIndex` with `callback`:
lodash.min x 3,669,045 ops/sec ±4.20% (82 runs sampled)
underscore-min x 4,881,279 ops/sec ±3.15% (85 runs sampled)
underscore-min is 34% faster.

`_.template` (slow path):
lodash.min x 15,227 ops/sec ±1.93% (86 runs sampled)
underscore-min x 16,769 ops/sec ±2.98% (84 runs sampled)
underscore-min is 9% faster.

compiled template:
lodash.min x 44,638 ops/sec ±1.40% (85 runs sampled)
underscore-min x 43,720 ops/sec ±1.74% (86 runs sampled)
lodash.min is 2% faster.

compiled template without a with-statement:
lodash.min x 990,348 ops/sec ±2.67% (81 runs sampled)
underscore-min x 901,093 ops/sec ±2.79% (77 runs sampled)
lodash.min is 10% faster.

`_.times`:
lodash.min x 1,253,029 ops/sec ±3.56% (83 runs sampled)
underscore-min x 1,126,433 ops/sec ±5.49% (80 runs sampled)
lodash.min is 13% faster.

`_.times` with `thisArg`:
lodash.min x 434,386 ops/sec ±4.48% (82 runs sampled)
underscore-min x 692,115 ops/sec ±3.42% (83 runs sampled)
underscore-min is 61% faster.

`_.toArray` with an array (edge case):
lodash.min x 5,590,315 ops/sec ±3.29% (83 runs sampled)
underscore-min x 2,270,596 ops/sec ±2.46% (87 runs sampled)
lodash.min is 144% faster.

`_.toArray` with an object:
lodash.min x 407,476 ops/sec ±2.52% (83 runs sampled)
underscore-min x 429,878 ops/sec ±2.63% (88 runs sampled)
underscore-min is 5% faster.

`_.union`:
lodash.min x 213,751 ops/sec ±2.46% (86 runs sampled)
underscore-min x 86,540 ops/sec ±1.57% (84 runs sampled)
lodash.min is 145% faster.

`_.union` iterating an array of 75 elements:
lodash.min x 19,870 ops/sec ±1.73% (81 runs sampled)
underscore-min x 19,008 ops/sec ±5.14% (37 runs sampled)
It's too close to call.

`_.union` iterating an array of 200 elements:
lodash.min x 11,921 ops/sec ±5.47% (79 runs sampled)
underscore-min x 6,146 ops/sec ±5.37% (80 runs sampled)
lodash.min is 94% faster.

`_.uniq`:
lodash.min x 390,244 ops/sec ±0.49% (87 runs sampled)
underscore-min x 89,843 ops/sec ±2.09% (88 runs sampled)
lodash.min is 341% faster.

`_.uniq` with `callback`:
lodash.min x 459,492 ops/sec ±0.84% (85 runs sampled)
underscore-min x 99,681 ops/sec ±0.80% (86 runs sampled)
lodash.min is 361% faster.

`_.uniq` iterating an array of 75 elements:
lodash.min x 21,158 ops/sec ±1.21% (84 runs sampled)
underscore-min x 18,164 ops/sec ±3.99% (74 runs sampled)
lodash.min is 20% faster.

`_.uniq` iterating an array of 200 elements:
lodash.min x 14,478 ops/sec ±2.13% (84 runs sampled)
underscore-min x 6,313 ops/sec ±3.97% (49 runs sampled)
lodash.min is 133% faster.

`_.values`:
lodash.min x 422,069 ops/sec ±6.87% (50 runs sampled)
underscore-min x 426,199 ops/sec ±8.64% (37 runs sampled)
It's too close to call.

`_.where`:
lodash.min x 624,647 ops/sec ±6.45% (37 runs sampled)
underscore-min x 284,796 ops/sec ±5.73% (66 runs sampled)
lodash.min is 118% faster.

`_.without`:
lodash.min x 993,880 ops/sec ±10.08% (21 runs sampled)
underscore-min x 122,306 ops/sec ±4.18% (82 runs sampled)
lodash.min is 669% faster.

`_.wrap` result called:
lodash.min x 970,697 ops/sec ±3.26% (85 runs sampled)
underscore-min x 1,118,287 ops/sec ±4.40% (67 runs sampled)
underscore-min is 14% faster.

`_.zip`:
lodash.min x 492,429 ops/sec ±7.49% (20 runs sampled)
underscore-min x 194,804 ops/sec ±3.96% (71 runs sampled)
lodash.min is 144% faster.

lodash.min is 49% (1.49x) faster than underscore-min.