Lodash vs Underscore Benchmarks

gistfile1.txt

/code Chrome 35.0.1916.153 on OS X 10.9.3

`_(...)` with a number:
lodash.min x 39,094,087 ops/sec ±1.75% (67 runs sampled)
underscore-min x 16,916,505 ops/sec ±1.78% (83 runs sampled)
lodash.min is 131% faster.

`_(...)` with an array:
lodash.min x 51,700,639 ops/sec ±4.95% (82 runs sampled)
underscore-min x 13,862,501 ops/sec ±0.55% (83 runs sampled)
lodash.min is 257% faster.

`_(...)` with an object:
lodash.min x 9,755,544 ops/sec ±0.77% (88 runs sampled)
underscore-min x 13,820,819 ops/sec ±2.86% (82 runs sampled)
underscore-min is 39% faster.

`_(...).tap(...)`:
lodash.min x 4,272,005 ops/sec ±4.11% (82 runs sampled)
underscore-min x 3,243,328 ops/sec ±1.48% (86 runs sampled)
lodash.min is 28% faster.

`_.bind`:
lodash.min x 636,769 ops/sec ±1.69% (86 runs sampled)
underscore-min x 306,142 ops/sec ±3.41% (78 runs sampled)
lodash.min is 112% faster.

bound call with arguments:
lodash.min x 6,491,962 ops/sec ±1.57% (84 runs sampled)
underscore-min x 3,978,938 ops/sec ±1.56% (84 runs sampled)
lodash.min is 63% faster.

bound and partially applied call with arguments:
lodash.min x 2,884,103 ops/sec ±1.16% (87 runs sampled)
underscore-min x 3,218,152 ops/sec ±1.24% (87 runs sampled)
underscore-min is 11% faster.

bound multiple times:
lodash.min x 5,113,545 ops/sec ±1.91% (86 runs sampled)
underscore-min x 3,945,670 ops/sec ±1.23% (85 runs sampled)
lodash.min is 29% faster.

`_.bindAll` iterating arguments:
lodash.min x 11,549 ops/sec ±3.47% (60 runs sampled)
underscore-min x 6,335 ops/sec ±4.03% (63 runs sampled)
lodash.min is 83% faster.

`_.bindAll` iterating the `object`:
lodash.min x 10,585 ops/sec ±1.72% (73 runs sampled)
underscore-min: 
There was a problem, skipping...

`_.clone` with an object:
lodash.min x 99,516 ops/sec ±1.51% (84 runs sampled)
underscore-min x 73,528 ops/sec ±1.15% (85 runs sampled)
lodash.min is 35% faster.

`_.compact`:
lodash.min x 4,257,072 ops/sec ±0.97% (86 runs sampled)
underscore-min x 589,477 ops/sec ±3.80% (77 runs sampled)
lodash.min is 642% faster.

`_.contains` iterating an array:
lodash.min x 11,689,767 ops/sec ±1.39% (85 runs sampled)
underscore-min x 7,169,192 ops/sec ±1.26% (87 runs sampled)
lodash.min is 63% faster.

`_.contains` iterating an object:
lodash.min x 545,409 ops/sec ±0.76% (84 runs sampled)
underscore-min x 412,054 ops/sec ±0.64% (86 runs sampled)
lodash.min is 32% faster.

`_.countBy` with `callback` iterating an array:
lodash.min x 348,900 ops/sec ±0.68% (83 runs sampled)
underscore-min x 215,194 ops/sec ±1.86% (85 runs sampled)
lodash.min is 64% faster.

`_.countBy` with `property` name iterating an array:
lodash.min x 335,921 ops/sec ±0.65% (84 runs sampled)
underscore-min x 220,587 ops/sec ±0.94% (86 runs sampled)
lodash.min is 53% faster.

`_.countBy` with `callback` iterating an object:
lodash.min x 109,602 ops/sec ±2.55% (80 runs sampled)
underscore-min x 96,683 ops/sec ±1.56% (79 runs sampled)
lodash.min is 12% faster.

`_.defaults`:
lodash.min x 83,964 ops/sec ±1.65% (84 runs sampled)
underscore-min x 58,491 ops/sec ±1.62% (86 runs sampled)
lodash.min is 44% faster.

`_.difference`:
lodash.min x 1,043,778 ops/sec ±1.58% (86 runs sampled)
underscore-min x 151,284 ops/sec ±2.19% (85 runs sampled)
lodash.min is 594% faster.

`_.difference` iterating 75 elements:
lodash.min x 43,891 ops/sec ±1.27% (87 runs sampled)
underscore-min x 22,351 ops/sec ±1.13% (84 runs sampled)
lodash.min is 96% faster.

`_.difference` iterating 200 elements:
lodash.min x 30,732 ops/sec ±1.60% (84 runs sampled)
underscore-min x 5,323 ops/sec ±0.84% (86 runs sampled)
lodash.min is 473% faster.

`_.difference` iterating 20 and 40 elements:
lodash.min x 151,855 ops/sec ±1.02% (87 runs sampled)
underscore-min x 82,519 ops/sec ±1.78% (85 runs sampled)
lodash.min is 85% faster.

`_.each` iterating an array:
lodash.min x 2,160,579 ops/sec ±0.89% (86 runs sampled)
underscore-min x 701,956 ops/sec ±1.33% (86 runs sampled)
lodash.min is 209% faster.

`_.each` iterating an array with `thisArg` (slow path):
lodash.min x 330,452 ops/sec ±1.43% (87 runs sampled)
underscore-min x 286,115 ops/sec ±1.44% (85 runs sampled)
lodash.min is 16% faster.

`_.each` iterating an object:
lodash.min x 461,354 ops/sec ±1.71% (82 runs sampled)
underscore-min x 451,114 ops/sec ±1.74% (87 runs sampled)
lodash.min is 2% faster.

`_.every` iterating an array:
lodash.min x 2,603,589 ops/sec ±1.26% (86 runs sampled)
underscore-min x 786,185 ops/sec ±1.25% (80 runs sampled)
lodash.min is 231% faster.

`_.every` iterating an object:
lodash.min x 467,415 ops/sec ±1.57% (86 runs sampled)
underscore-min x 413,657 ops/sec ±1.78% (87 runs sampled)
lodash.min is 13% faster.

`_.extend`:
lodash.min x 116,347 ops/sec ±0.63% (83 runs sampled)
underscore-min x 72,576 ops/sec ±1.47% (84 runs sampled)
lodash.min is 62% faster.

`_.filter` iterating an array:
lodash.min x 2,006,473 ops/sec ±1.35% (88 runs sampled)
underscore-min x 576,172 ops/sec ±3.99% (78 runs sampled)
lodash.min is 257% faster.

`_.filter` iterating an array with `thisArg` (slow path):
lodash.min x 357,194 ops/sec ±0.71% (86 runs sampled)
underscore-min x 275,507 ops/sec ±3.18% (84 runs sampled)
lodash.min is 33% faster.

`_.filter` iterating an object:
lodash.min x 431,636 ops/sec ±3.02% (85 runs sampled)
underscore-min x 392,143 ops/sec ±0.77% (82 runs sampled)
lodash.min is 8% faster.

`_.find` iterating an array:
lodash.min x 2,703,449 ops/sec ±1.67% (86 runs sampled)
underscore-min x 667,403 ops/sec ±0.85% (83 runs sampled)
lodash.min is 302% faster.

`_.find` iterating an object:
lodash.min x 316,391 ops/sec ±0.71% (87 runs sampled)
underscore-min x 237,267 ops/sec ±2.32% (85 runs sampled)
lodash.min is 35% faster.

`_.find` with `properties`:
lodash.min x 1,300,440 ops/sec ±1.44% (85 runs sampled)
underscore-min x 641,876 ops/sec ±0.96% (84 runs sampled)
lodash.min is 102% faster.

`_.flatten`:
lodash.min x 705,012 ops/sec ±4.27% (84 runs sampled)
underscore-min x 410,579 ops/sec ±1.38% (85 runs sampled)
lodash.min is 67% faster.

`_.flatten` with objects:
lodash.min x 719,117 ops/sec ±0.54% (85 runs sampled)
underscore-min x 405,633 ops/sec ±1.24% (86 runs sampled)
lodash.min is 79% faster.

`_.flatten` with `shallow`:
lodash.min x 1,965,506 ops/sec ±1.46% (83 runs sampled)
underscore-min x 872,579 ops/sec ±1.80% (83 runs sampled)
lodash.min is 126% faster.

`_.functions`:
lodash.min x 11,938 ops/sec ±0.69% (86 runs sampled)
underscore-min x 10,614 ops/sec ±2.20% (85 runs sampled)
lodash.min is 14% faster.

`_.groupBy` with `callback` iterating an array:
lodash.min x 210,210 ops/sec ±1.85% (86 runs sampled)
underscore-min x 160,997 ops/sec ±1.16% (84 runs sampled)
lodash.min is 30% faster.

`_.groupBy` with `property` name iterating an array:
lodash.min x 208,677 ops/sec ±2.23% (80 runs sampled)
underscore-min x 162,378 ops/sec ±0.56% (87 runs sampled)
lodash.min is 26% faster.

`_.groupBy` with `callback` iterating an object:
lodash.min x 79,041 ops/sec ±2.57% (86 runs sampled)
underscore-min x 75,851 ops/sec ±0.62% (86 runs sampled)
lodash.min is 2% faster.

`_.indexBy` with `callback` iterating an array:
lodash.min x 1,030,482 ops/sec ±1.72% (84 runs sampled)
underscore-min x 431,096 ops/sec ±1.71% (85 runs sampled)
lodash.min is 139% faster.

`_.indexBy` with `property` name iterating an array:
lodash.min x 884,580 ops/sec ±0.72% (84 runs sampled)
underscore-min x 405,674 ops/sec ±1.83% (86 runs sampled)
lodash.min is 120% faster.

`_.indexBy` with `callback` iterating an object:
lodash.min x 255,920 ops/sec ±1.84% (85 runs sampled)
underscore-min x 211,119 ops/sec ±0.63% (87 runs sampled)
lodash.min is 20% faster.

`_.indexOf`:
lodash.min x 728,572 ops/sec ±1.31% (83 runs sampled)
underscore-min x 686,082 ops/sec ±0.45% (85 runs sampled)
lodash.min is 5% faster.

`_.intersection`:
lodash.min x 397,078 ops/sec ±1.88% (86 runs sampled)
underscore-min x 69,950 ops/sec ±2.22% (83 runs sampled)
lodash.min is 470% faster.

`_.intersection` iterating 75 elements:
lodash.min x 20,417 ops/sec ±0.60% (88 runs sampled)
underscore-min x 10,548 ops/sec ±1.75% (84 runs sampled)
lodash.min is 96% faster.

`_.intersection` iterating 200 elements:
lodash.min x 13,235 ops/sec ±1.59% (88 runs sampled)
underscore-min x 2,528 ops/sec ±0.62% (86 runs sampled)
lodash.min is 419% faster.

`_.invert`:
lodash.min x 529,992 ops/sec ±1.66% (85 runs sampled)
underscore-min x 532,295 ops/sec ±1.70% (82 runs sampled)
It's too close to call.

`_.invoke` iterating an array:
lodash.min x 102,067 ops/sec ±0.84% (84 runs sampled)
underscore-min x 71,480 ops/sec ±1.53% (82 runs sampled)
lodash.min is 44% faster.

`_.invoke` with a function for `methodName` iterating an array:
lodash.min x 241,810 ops/sec ±0.68% (84 runs sampled)
underscore-min x 130,655 ops/sec ±3.18% (84 runs sampled)
lodash.min is 90% faster.

`_.invoke` iterating an object:
lodash.min x 88,873 ops/sec ±1.68% (84 runs sampled)
underscore-min x 70,810 ops/sec ±0.61% (87 runs sampled)
lodash.min is 24% faster.

`_.isEqual` comparing primitives and objects (edge case):
lodash.min x 174,513 ops/sec ±1.75% (84 runs sampled)
underscore-min x 279,249 ops/sec ±1.91% (84 runs sampled)
underscore-min is 60% faster.

`_.isEqual` comparing arrays:
lodash.min x 387,902 ops/sec ±2.77% (81 runs sampled)
underscore-min x 333,847 ops/sec ±2.01% (83 runs sampled)
lodash.min is 15% faster.

`_.isEqual` comparing nested arrays:
lodash.min x 111,238 ops/sec ±1.19% (86 runs sampled)
underscore-min x 117,656 ops/sec ±2.27% (84 runs sampled)
underscore-min is 5% faster.

`_.isEqual` comparing arrays of objects:
lodash.min x 21,849 ops/sec ±0.77% (86 runs sampled)
underscore-min x 32,316 ops/sec ±3.11% (85 runs sampled)
underscore-min is 45% faster.

`_.isEqual` comparing objects:
lodash.min x 58,460 ops/sec ±1.83% (84 runs sampled)
underscore-min x 63,394 ops/sec ±1.40% (82 runs sampled)
underscore-min is 9% faster.

`_.isArguments`, `_.isDate`, `_.isFunction`, `_.isNumber`, `_.isObject`, `_.isRegExp`:
lodash.min x 907,704 ops/sec ±1.16% (86 runs sampled)
underscore-min x 543,189 ops/sec ±1.68% (82 runs sampled)
lodash.min is 68% faster.

`_.keys` (uses native `Object.keys` if available):
lodash.min x 951,604 ops/sec ±1.96% (84 runs sampled)
underscore-min x 948,154 ops/sec ±2.71% (86 runs sampled)
lodash.min is 1% faster.

`_.lastIndexOf`:
lodash.min x 20,578,908 ops/sec ±0.89% (83 runs sampled)
underscore-min x 13,331,435 ops/sec ±0.88% (86 runs sampled)
lodash.min is 54% faster.

`_.map` iterating an array:
lodash.min x 2,144,439 ops/sec ±1.80% (85 runs sampled)
underscore-min x 593,925 ops/sec ±3.90% (78 runs sampled)
lodash.min is 269% faster.

`_.map` with `thisArg` iterating an array (slow path):
lodash.min x 347,562 ops/sec ±0.88% (86 runs sampled)
underscore-min x 281,980 ops/sec ±3.00% (83 runs sampled)
lodash.min is 26% faster.

`_.map` iterating an object:
lodash.min x 443,835 ops/sec ±1.93% (83 runs sampled)
underscore-min x 391,053 ops/sec ±1.22% (81 runs sampled)
lodash.min is 13% faster.

`_.max`:
lodash.min x 8,773,849 ops/sec ±1.14% (87 runs sampled)
underscore-min x 4,077,744 ops/sec ±1.31% (88 runs sampled)
lodash.min is 116% faster.

`_.min`:
lodash.min x 8,606,445 ops/sec ±1.14% (89 runs sampled)
underscore-min x 3,851,257 ops/sec ±1.25% (87 runs sampled)
lodash.min is 124% faster.

`_.omit` iterating 20 properties, omitting 2 keys:
lodash.min x 79,878 ops/sec ±1.39% (83 runs sampled)
underscore-min x 60,815 ops/sec ±1.37% (84 runs sampled)
lodash.min is 31% faster.

`_.omit` iterating 40 properties, omitting 20 keys:
lodash.min x 87,862 ops/sec ±1.08% (84 runs sampled)
underscore-min x 65,519 ops/sec ±1.31% (86 runs sampled)
lodash.min is 34% faster.

`_.pairs`:
lodash.min x 665,376 ops/sec ±0.64% (88 runs sampled)
underscore-min x 673,979 ops/sec ±1.46% (87 runs sampled)
underscore-min is 0.47% faster.

`_.partial`:
lodash.min x 408,524 ops/sec ±1.74% (85 runs sampled)
underscore-min x 1,033,600 ops/sec ±1.52% (85 runs sampled)
underscore-min is 154% faster.

partially applied call with arguments:
lodash.min x 2,627,852 ops/sec ±1.55% (85 runs sampled)
underscore-min x 2,098,855 ops/sec ±1.55% (85 runs sampled)
lodash.min is 25% faster.

`_.pick`:
lodash.min x 874,584 ops/sec ±1.44% (85 runs sampled)
underscore-min x 209,692 ops/sec ±0.66% (84 runs sampled)
lodash.min is 314% faster.

`_.pluck`:
lodash.min x 1,656,746 ops/sec ±1.99% (80 runs sampled)
underscore-min x 541,518 ops/sec ±3.34% (79 runs sampled)
lodash.min is 210% faster.

`_.reduce` iterating an array:
lodash.min x 970,408 ops/sec ±1.57% (85 runs sampled)
underscore-min x 519,291 ops/sec ±1.86% (82 runs sampled)
lodash.min is 87% faster.

`_.reduce` iterating an object:
lodash.min x 344,707 ops/sec ±0.57% (88 runs sampled)
underscore-min x 308,805 ops/sec ±2.63% (82 runs sampled)
lodash.min is 14% faster.

`_.reduceRight` iterating an array:
lodash.min x 972,924 ops/sec ±0.72% (86 runs sampled)
underscore-min x 582,477 ops/sec ±2.02% (84 runs sampled)
lodash.min is 69% faster.

`_.reduceRight` iterating an object:
lodash.min x 209,500 ops/sec ±2.02% (82 runs sampled)
underscore-min x 203,924 ops/sec ±3.83% (79 runs sampled)
It's too close to call.

`_.reject` iterating an array:
lodash.min x 1,186,085 ops/sec ±3.05% (74 runs sampled)
underscore-min x 448,117 ops/sec ±2.59% (72 runs sampled)
lodash.min is 163% faster.

`_.reject` iterating an array with `thisArg` (slow path):
lodash.min x 306,751 ops/sec ±1.58% (83 runs sampled)
underscore-min x 224,170 ops/sec ±3.22% (80 runs sampled)
lodash.min is 39% faster.

`_.reject` iterating an object:
lodash.min x 409,840 ops/sec ±1.23% (85 runs sampled)
underscore-min x 292,497 ops/sec ±1.24% (87 runs sampled)
lodash.min is 40% faster.

`_.sample` with an `n`:
lodash.min x 170,548 ops/sec ±2.82% (80 runs sampled)
underscore-min x 400,373 ops/sec ±2.54% (79 runs sampled)
underscore-min is 135% faster.

`_.shuffle`:
lodash.min x 695,663 ops/sec ±1.07% (84 runs sampled)
underscore-min x 379,904 ops/sec ±1.49% (87 runs sampled)
lodash.min is 84% faster.

`_.size` with an object:
lodash.min x 936,096 ops/sec ±1.48% (86 runs sampled)
underscore-min x 937,036 ops/sec ±1.31% (85 runs sampled)
It's too close to call.

`_.some` iterating an array:
lodash.min x 2,646,847 ops/sec ±2.05% (86 runs sampled)
underscore-min x 810,844 ops/sec ±1.12% (86 runs sampled)
lodash.min is 223% faster.

`_.some` with `thisArg` iterating an array (slow path):
lodash.min x 363,614 ops/sec ±1.33% (83 runs sampled)
underscore-min x 324,085 ops/sec ±1.16% (87 runs sampled)
lodash.min is 12% faster.

`_.some` iterating an object:
lodash.min x 486,797 ops/sec ±1.54% (85 runs sampled)
underscore-min x 353,918 ops/sec ±1.78% (88 runs sampled)
lodash.min is 38% faster.

`_.sortBy` with `callback`:
lodash.min x 154,049 ops/sec ±1.59% (86 runs sampled)
underscore-min x 104,836 ops/sec ±7.55% (69 runs sampled)
lodash.min is 56% faster.

`_.sortBy` with `callback` and `thisArg` (slow path):
lodash.min x 125,884 ops/sec ±1.77% (81 runs sampled)
underscore-min x 62,843 ops/sec ±3.37% (81 runs sampled)
lodash.min is 103% faster.

`_.sortBy` with `property` name:
lodash.min x 159,436 ops/sec ±0.60% (84 runs sampled)
underscore-min x 66,486 ops/sec ±2.94% (84 runs sampled)
lodash.min is 145% faster.

`_.sortedIndex` with `callback`:
lodash.min x 6,553,250 ops/sec ±1.87% (83 runs sampled)
underscore-min x 6,784,322 ops/sec ±1.94% (81 runs sampled)
underscore-min is 3% faster.

`_.template` (slow path):
lodash.min x 18,047 ops/sec ±0.42% (90 runs sampled)
underscore-min x 20,042 ops/sec ±2.08% (84 runs sampled)
underscore-min is 9% faster.

compiled template:
lodash.min x 52,681 ops/sec ±1.33% (84 runs sampled)
underscore-min x 51,909 ops/sec ±1.96% (77 runs sampled)
It's too close to call.

compiled template without a with-statement:
lodash.min x 2,482,047 ops/sec ±1.47% (83 runs sampled)
underscore-min x 2,270,590 ops/sec ±1.74% (81 runs sampled)
lodash.min is 10% faster.

`_.times`:
lodash.min x 2,203,919 ops/sec ±1.59% (86 runs sampled)
underscore-min x 1,852,347 ops/sec ±3.76% (85 runs sampled)
lodash.min is 22% faster.

`_.times` with `thisArg`:
lodash.min x 621,081 ops/sec ±1.24% (87 runs sampled)
underscore-min x 855,328 ops/sec ±1.85% (83 runs sampled)
underscore-min is 37% faster.

`_.toArray` with an array (edge case):
lodash.min x 3,760,972 ops/sec ±1.08% (86 runs sampled)
underscore-min x 4,135,974 ops/sec ±1.33% (83 runs sampled)
underscore-min is 10% faster.

`_.toArray` with an object:
lodash.min x 697,532 ops/sec ±2.10% (81 runs sampled)
underscore-min x 714,720 ops/sec ±2.03% (86 runs sampled)
It's too close to call.

`_.union`:
lodash.min x 328,798 ops/sec ±1.38% (86 runs sampled)
underscore-min x 129,805 ops/sec ±1.34% (88 runs sampled)
lodash.min is 153% faster.

`_.union` iterating an array of 75 elements:
lodash.min x 32,568 ops/sec ±1.38% (87 runs sampled)
underscore-min x 28,208 ops/sec ±1.34% (87 runs sampled)
lodash.min is 15% faster.

`_.union` iterating an array of 200 elements:
lodash.min x 17,720 ops/sec ±1.33% (86 runs sampled)
underscore-min x 8,580 ops/sec ±1.30% (87 runs sampled)
lodash.min is 106% faster.

`_.uniq`:
lodash.min x 419,296 ops/sec ±1.32% (86 runs sampled)
underscore-min x 137,929 ops/sec ±1.26% (83 runs sampled)
lodash.min is 204% faster.

`_.uniq` with `callback`:
lodash.min x 730,292 ops/sec ±1.66% (84 runs sampled)
underscore-min x 155,626 ops/sec ±2.23% (85 runs sampled)
lodash.min is 372% faster.

`_.uniq` iterating an array of 75 elements:
lodash.min x 36,774 ops/sec ±1.79% (83 runs sampled)
underscore-min x 29,683 ops/sec ±0.97% (88 runs sampled)
lodash.min is 23% faster.

`_.uniq` iterating an array of 200 elements:
lodash.min x 20,255 ops/sec ±0.74% (86 runs sampled)
underscore-min x 8,609 ops/sec ±1.39% (84 runs sampled)
lodash.min is 137% faster.

`_.values`:
lodash.min x 756,921 ops/sec ±0.52% (87 runs sampled)
underscore-min x 738,417 ops/sec ±2.63% (85 runs sampled)
It's too close to call.

`_.where`:
lodash.min x 846,097 ops/sec ±2.04% (85 runs sampled)
underscore-min x 370,549 ops/sec ±3.25% (81 runs sampled)
lodash.min is 131% faster.

`_.without`:
lodash.min x 1,285,564 ops/sec ±0.40% (87 runs sampled)
underscore-min x 137,826 ops/sec ±2.41% (80 runs sampled)
lodash.min is 851% faster.

`_.wrap` result called:
lodash.min x 1,137,946 ops/sec ±1.81% (81 runs sampled)
underscore-min x 1,783,130 ops/sec ±1.38% (85 runs sampled)
underscore-min is 57% faster.