Created
January 16, 2018 08:32
-
-
Save 284km/e8ecdda970e691c939f5bb92e813c4fe to your computer and use it in GitHub Desktop.
fast-ruby-wo-ruby2.5-de-yatta-ya-tu
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| $ ruby -v code/general/array-argument-vs-splat-arguments.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Function with single Array argument | |
| 172.485k i/100ms | |
| Function with splat arguments | |
| 3.260k i/100ms | |
| Calculating ------------------------------------- | |
| Function with single Array argument | |
| 3.448M (±23.6%) i/s - 16.214M in 5.005600s | |
| Function with splat arguments | |
| 38.757k (±20.7%) i/s - 189.080k in 5.077914s | |
| Comparison: | |
| Function with single Array argument: 3447710.8 i/s | |
| Function with splat arguments: 38757.2 i/s - 88.96x slower | |
| $ ruby -v code/general/assignment.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Parallel Assignment 166.912k i/100ms | |
| Sequential Assignment | |
| 202.810k i/100ms | |
| Calculating ------------------------------------- | |
| Parallel Assignment 6.384M (±17.0%) i/s - 31.046M in 5.023915s | |
| Sequential Assignment | |
| 5.115M (±25.9%) i/s - 23.323M in 5.021852s | |
| Comparison: | |
| Parallel Assignment: 6383727.5 i/s | |
| Sequential Assignment: 5114858.3 i/s - same-ish: difference falls within error | |
| $ ruby -v code/general/attr-accessor-vs-getter-and-setter.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| getter_and_setter 128.727k i/100ms | |
| attr_accessor 129.443k i/100ms | |
| Calculating ------------------------------------- | |
| getter_and_setter 1.904M (±25.2%) i/s - 9.011M in 5.011442s | |
| attr_accessor 3.019M (±15.8%) i/s - 14.757M in 5.020575s | |
| Comparison: | |
| attr_accessor: 3018621.4 i/s | |
| getter_and_setter: 1903583.3 i/s - 1.59x slower | |
| $ ruby -v code/general/begin-rescue-vs-respond-to.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| begin...rescue 35.321k i/100ms | |
| respond_to? 147.491k i/100ms | |
| Calculating ------------------------------------- | |
| begin...rescue 432.791k (±18.8%) i/s - 2.084M in 5.026122s | |
| respond_to? 4.520M (±23.0%) i/s - 21.091M in 5.007179s | |
| Comparison: | |
| respond_to?: 4520476.9 i/s | |
| begin...rescue: 432790.9 i/s - 10.44x slower | |
| $ ruby -v code/general/block-apply-method.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| normal 103.140k i/100ms | |
| &method 50.054k i/100ms | |
| Calculating ------------------------------------- | |
| normal 2.039M (± 8.2%) i/s - 10.211M in 5.053170s | |
| &method 637.515k (±16.1%) i/s - 3.103M in 5.019935s | |
| Comparison: | |
| normal: 2038920.1 i/s | |
| &method: 637515.4 i/s - 3.20x slower | |
| $ ruby -v code/general/define_method-vs-module-eval.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| module_eval with string | |
| 145.000 i/100ms | |
| define_method 208.000 i/100ms | |
| Calculating ------------------------------------- | |
| module_eval with string | |
| 1.289k (±22.3%) i/s - 6.090k in 5.027555s | |
| define_method 1.915k (±21.8%) i/s - 8.736k in 5.008652s | |
| Comparison: | |
| define_method: 1915.0 i/s | |
| module_eval with string: 1288.5 i/s - same-ish: difference falls within error | |
| $ ruby -v code/general/format-vs-round-and-to-s.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Float#round 69.039k i/100ms | |
| Kernel#format 76.722k i/100ms | |
| String#% 76.762k i/100ms | |
| Calculating ------------------------------------- | |
| Float#round 1.525M (± 7.2%) i/s - 7.594M in 5.009725s | |
| Kernel#format 989.244k (±20.1%) i/s - 4.680M in 5.068918s | |
| String#% 1.007M (±10.9%) i/s - 4.990M in 5.018505s | |
| Comparison: | |
| Float#round: 1525134.6 i/s | |
| String#%: 1007412.9 i/s - 1.51x slower | |
| Kernel#format: 989243.7 i/s - 1.54x slower | |
| $ ruby -v code/general/hash-vs-openstruct-on-access.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash 188.945k i/100ms | |
| OpenStruct 112.713k i/100ms | |
| Calculating ------------------------------------- | |
| Hash 5.215M (±11.7%) i/s - 25.885M in 5.054386s | |
| OpenStruct 3.138M (±11.9%) i/s - 15.442M in 5.030047s | |
| Comparison: | |
| Hash: 5214729.7 i/s | |
| OpenStruct: 3138005.5 i/s - 1.66x slower | |
| $ ruby -v code/general/hash-vs-openstruct.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash 95.583k i/100ms | |
| OpenStruct 56.005k i/100ms | |
| Calculating ------------------------------------- | |
| Hash 1.588M (±13.9%) i/s - 7.838M in 5.080869s | |
| OpenStruct 610.830k (±12.1%) i/s - 3.024M in 5.031959s | |
| Comparison: | |
| Hash: 1587741.4 i/s | |
| OpenStruct: 610830.2 i/s - 2.60x slower | |
| $ ruby -v code/general/loop-vs-while-true.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| While Loop 1.000 i/100ms | |
| Kernel loop 1.000 i/100ms | |
| Calculating ------------------------------------- | |
| While Loop 0.508 (± 0.0%) i/s - 3.000 in 5.905939s | |
| Kernel loop 0.155 (± 0.0%) i/s - 1.000 in 6.453996s | |
| Comparison: | |
| While Loop: 0.5 i/s | |
| Kernel loop: 0.2 i/s - 3.28x slower | |
| $ ruby -v code/general/raise-vs-e2mmap.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Ruby exception: E2MM#Raise | |
| 2.187k i/100ms | |
| Ruby exception: Kernel#raise | |
| 49.667k i/100ms | |
| Calculating ------------------------------------- | |
| Ruby exception: E2MM#Raise | |
| 21.502k (±17.3%) i/s - 102.789k in 5.030376s | |
| Ruby exception: Kernel#raise | |
| 759.485k (±18.8%) i/s - 3.626M in 5.038795s | |
| Comparison: | |
| Ruby exception: Kernel#raise: 759484.7 i/s | |
| Ruby exception: E2MM#Raise: 21501.9 i/s - 35.32x slower | |
| Warming up -------------------------------------- | |
| Custom exception: E2MM#Raise | |
| 1.993k i/100ms | |
| Custom exception: Kernel#raise | |
| 49.530k i/100ms | |
| Calculating ------------------------------------- | |
| Custom exception: E2MM#Raise | |
| 20.227k (±14.4%) i/s - 99.650k in 5.033951s | |
| Custom exception: Kernel#raise | |
| 704.986k (±19.0%) i/s - 3.418M in 5.047258s | |
| Comparison: | |
| Custom exception: Kernel#raise: 704986.3 i/s | |
| Custom exception: E2MM#Raise: 20227.0 i/s - 34.85x slower | |
| $ ruby -v code/array/array-first-vs-index.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#[0] 240.813k i/100ms | |
| Array#first 243.103k i/100ms | |
| Calculating ------------------------------------- | |
| Array#[0] 8.729M (± 6.8%) i/s - 43.587M in 5.020359s | |
| Array#first 7.368M (±11.6%) i/s - 36.465M in 5.028923s | |
| Comparison: | |
| Array#[0]: 8729125.7 i/s | |
| Array#first: 7368312.1 i/s - same-ish: difference falls within error | |
| $ ruby -v code/array/array-last-vs-index.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#[-1] 256.377k i/100ms | |
| Array#last 213.085k i/100ms | |
| Calculating ------------------------------------- | |
| Array#[-1] 8.147M (±10.2%) i/s - 40.251M in 5.000085s | |
| Array#last 7.963M (± 5.1%) i/s - 39.847M in 5.018219s | |
| Comparison: | |
| Array#[-1]: 8147456.7 i/s | |
| Array#last: 7962517.9 i/s - same-ish: difference falls within error | |
| $ ruby -v code/array/bsearch-vs-find.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| find 1.000 i/100ms | |
| bsearch 40.983k i/100ms | |
| Calculating ------------------------------------- | |
| find 0.193 (± 0.0%) i/s - 1.000 in 5.183402s | |
| bsearch 476.821k (±26.0%) i/s - 2.131M in 5.058429s | |
| Comparison: | |
| bsearch: 476820.9 i/s | |
| find: 0.2 i/s - 2471554.46x slower | |
| $ ruby -v code/array/insert-vs-unshift.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#unshift 6.000 i/100ms | |
| Array#insert 1.000 i/100ms | |
| Calculating ------------------------------------- | |
| Array#unshift 100.163 (±17.0%) i/s - 480.000 in 5.024950s | |
| Array#insert 0.689 (± 0.0%) i/s - 4.000 in 5.887419s | |
| Comparison: | |
| Array#unshift: 100.2 i/s | |
| Array#insert: 0.7 i/s - 145.40x slower | |
| $ ruby -v code/array/length-vs-size-vs-count.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#length 231.194k i/100ms | |
| Array#size 217.332k i/100ms | |
| Array#count 182.695k i/100ms | |
| Calculating ------------------------------------- | |
| Array#length 7.943M (±29.3%) i/s - 35.604M in 5.012680s | |
| Array#size 9.363M (±17.0%) i/s - 44.553M in 5.010789s | |
| Array#count 7.588M (±18.8%) i/s - 36.174M in 5.001706s | |
| Comparison: | |
| Array#size: 9363284.1 i/s | |
| Array#length: 7943471.6 i/s - same-ish: difference falls within error | |
| Array#count: 7588228.2 i/s - same-ish: difference falls within error | |
| $ ruby -v code/array/shuffle-first-vs-sample.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#shuffle.first 31.091k i/100ms | |
| Array#sample 194.510k i/100ms | |
| Calculating ------------------------------------- | |
| Array#shuffle.first 336.062k (±16.1%) i/s - 1.648M in 5.053078s | |
| Array#sample 5.420M (±20.4%) i/s - 25.675M in 5.035196s | |
| Comparison: | |
| Array#sample: 5419896.7 i/s | |
| Array#shuffle.first: 336062.5 i/s - 16.13x slower | |
| $ ruby -v code/enumerable/each-push-vs-map.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#each + push 8.961k i/100ms | |
| Array#map 9.313k i/100ms | |
| Calculating ------------------------------------- | |
| Array#each + push 81.047k (±28.2%) i/s - 367.401k in 5.046026s | |
| Array#map 147.942k (±16.3%) i/s - 726.414k in 5.058821s | |
| Comparison: | |
| Array#map: 147941.6 i/s | |
| Array#each + push: 81046.7 i/s - 1.83x slower | |
| $ ruby -v code/enumerable/each-vs-for-loop.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| For loop 13.132k i/100ms | |
| #each 11.700k i/100ms | |
| Calculating ------------------------------------- | |
| For loop 162.939k (±14.6%) i/s - 801.052k in 5.034647s | |
| #each 165.043k (±26.7%) i/s - 748.800k in 5.001420s | |
| Comparison: | |
| #each: 165043.0 i/s | |
| For loop: 162938.6 i/s - same-ish: difference falls within error | |
| $ ruby -v code/enumerable/each_with_index-vs-while-loop.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| While Loop 14.237k i/100ms | |
| each_with_index 10.831k i/100ms | |
| Calculating ------------------------------------- | |
| While Loop 205.013k (±16.6%) i/s - 996.590k in 5.004116s | |
| each_with_index 94.660k (±31.2%) i/s - 433.240k in 5.070814s | |
| Comparison: | |
| While Loop: 205013.3 i/s | |
| each_with_index: 94659.7 i/s - 2.17x slower | |
| $ ruby -v code/enumerable/inject-symbol-vs-block.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| inject symbol 27.414k i/100ms | |
| inject to_proc 1.135k i/100ms | |
| inject block 1.205k i/100ms | |
| Calculating ------------------------------------- | |
| inject symbol 341.991k (±23.7%) i/s - 1.617M in 5.018806s | |
| inject to_proc 15.935k (±16.4%) i/s - 77.180k in 5.036196s | |
| inject block 12.308k (±19.3%) i/s - 59.045k in 5.023202s | |
| Comparison: | |
| inject symbol: 341991.3 i/s | |
| inject to_proc: 15935.1 i/s - 21.46x slower | |
| inject block: 12308.5 i/s - 27.78x slower | |
| $ ruby -v code/enumerable/map-flatten-vs-flat_map.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#map.flatten(1) 3.413k i/100ms | |
| Array#map.flatten 2.473k i/100ms | |
| Array#flat_map 4.580k i/100ms | |
| Calculating ------------------------------------- | |
| Array#map.flatten(1) 34.556k (±25.4%) i/s - 160.411k in 5.012501s | |
| Array#map.flatten 31.396k (± 8.2%) i/s - 155.799k in 5.003752s | |
| Array#flat_map 63.758k (±12.4%) i/s - 316.020k in 5.043112s | |
| Comparison: | |
| Array#flat_map: 63758.1 i/s | |
| Array#map.flatten(1): 34555.6 i/s - 1.85x slower | |
| Array#map.flatten: 31395.6 i/s - 2.03x slower | |
| $ ruby -v code/enumerable/reverse-each-vs-reverse_each.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Array#reverse.each 17.269k i/100ms | |
| Array#reverse_each 19.714k i/100ms | |
| Calculating ------------------------------------- | |
| Array#reverse.each 179.068k (±11.7%) i/s - 880.719k in 5.002053s | |
| Array#reverse_each 200.765k (±12.8%) i/s - 985.700k in 5.015926s | |
| Comparison: | |
| Array#reverse_each: 200764.8 i/s | |
| Array#reverse.each: 179067.8 i/s - same-ish: difference falls within error | |
| $ ruby -v code/enumerable/select-first-vs-detect.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Enumerable#select.first | |
| 11.958k i/100ms | |
| Enumerable#detect 50.802k i/100ms | |
| Calculating ------------------------------------- | |
| Enumerable#select.first | |
| 122.212k (±12.1%) i/s - 2.392M in 20.036922s | |
| Enumerable#detect 578.132k (±13.0%) i/s - 11.278M in 20.023042s | |
| Comparison: | |
| Enumerable#detect: 578132.2 i/s | |
| Enumerable#select.first: 122211.9 i/s - 4.73x slower | |
| $ ruby -v code/enumerable/select-last-vs-reverse-detect.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Enumerable#reverse.detect | |
| 91.141k i/100ms | |
| Enumerable#select.last | |
| 10.611k i/100ms | |
| Calculating ------------------------------------- | |
| Enumerable#reverse.detect | |
| 1.195M (±16.5%) i/s - 5.833M in 5.036308s | |
| Enumerable#select.last | |
| 97.583k (±22.7%) i/s - 456.273k in 5.022239s | |
| Comparison: | |
| Enumerable#reverse.detect: 1194871.8 i/s | |
| Enumerable#select.last: 97583.0 i/s - 12.24x slower | |
| $ ruby -v code/enumerable/sort-vs-sort_by.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Enumerable#sort_by (Symbol#to_proc) | |
| 2.856k i/100ms | |
| Enumerable#sort_by 2.230k i/100ms | |
| Enumerable#sort 1.155k i/100ms | |
| Calculating ------------------------------------- | |
| Enumerable#sort_by (Symbol#to_proc) | |
| 39.095k (±14.3%) i/s - 191.352k in 5.013246s | |
| Enumerable#sort_by 33.645k (±22.4%) i/s - 156.100k in 5.041323s | |
| Enumerable#sort 12.307k (± 2.8%) i/s - 62.370k in 5.071805s | |
| Comparison: | |
| Enumerable#sort_by (Symbol#to_proc): 39094.6 i/s | |
| Enumerable#sort_by: 33644.8 i/s - same-ish: difference falls within error | |
| Enumerable#sort: 12307.1 i/s - 3.18x slower | |
| $ ruby -v code/hash/bracket-vs-dup.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash[] 71.469k i/100ms | |
| Hash#dup 43.755k i/100ms | |
| Calculating ------------------------------------- | |
| Hash[] 1.103M (±14.8%) i/s - 5.432M in 5.039376s | |
| Hash#dup 476.351k (±21.7%) i/s - 2.232M in 5.077712s | |
| Comparison: | |
| Hash[]: 1102521.8 i/s | |
| Hash#dup: 476351.3 i/s - 2.31x slower | |
| $ ruby -v code/hash/bracket-vs-fetch.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash#[], symbol 224.974k i/100ms | |
| Hash#fetch, symbol 236.788k i/100ms | |
| Hash#[], string 229.985k i/100ms | |
| Hash#fetch, string 192.211k i/100ms | |
| Calculating ------------------------------------- | |
| Hash#[], symbol 7.439M (± 8.2%) i/s - 37.121M in 5.026232s | |
| Hash#fetch, symbol 6.652M (± 5.9%) i/s - 33.150M in 5.001578s | |
| Hash#[], string 6.308M (±13.7%) i/s - 30.588M in 5.026569s | |
| Hash#fetch, string 4.404M (±11.4%) i/s - 21.720M in 5.017091s | |
| Comparison: | |
| Hash#[], symbol: 7438534.7 i/s | |
| Hash#fetch, symbol: 6652350.7 i/s - same-ish: difference falls within error | |
| Hash#[], string: 6307904.4 i/s - same-ish: difference falls within error | |
| Hash#fetch, string: 4403800.8 i/s - 1.69x slower | |
| $ ruby -v code/hash/dig-vs-[]-vs-fetch.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash#dig 175.660k i/100ms | |
| Hash#[] 182.178k i/100ms | |
| Hash#[] || 214.134k i/100ms | |
| Hash#[] && 135.660k i/100ms | |
| Hash#fetch 182.511k i/100ms | |
| Hash#fetch fallback 139.144k i/100ms | |
| Calculating ------------------------------------- | |
| Hash#dig 4.906M (±17.7%) i/s - 23.538M in 5.012352s | |
| Hash#[] 5.262M (±13.5%) i/s - 25.323M in 5.004348s | |
| Hash#[] || 4.537M (±21.1%) i/s - 20.985M in 5.011660s | |
| Hash#[] && 2.297M (±16.0%) i/s - 11.124M in 5.011231s | |
| Hash#fetch 2.046M (±24.4%) i/s - 9.673M in 5.038970s | |
| Hash#fetch fallback 2.200M (±20.1%) i/s - 10.575M in 5.020148s | |
| Comparison: | |
| Hash#[]: 5262060.0 i/s | |
| Hash#dig: 4906290.0 i/s - same-ish: difference falls within error | |
| Hash#[] ||: 4537194.8 i/s - same-ish: difference falls within error | |
| Hash#[] &&: 2296573.5 i/s - 2.29x slower | |
| Hash#fetch fallback: 2199787.3 i/s - 2.39x slower | |
| Hash#fetch: 2045500.3 i/s - 2.57x slower | |
| $ ruby -v code/hash/fetch-vs-fetch-with-block.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash#fetch + const 186.881k i/100ms | |
| Hash#fetch + block 196.367k i/100ms | |
| Hash#fetch + arg 187.141k i/100ms | |
| Calculating ------------------------------------- | |
| Hash#fetch + const 6.526M (±15.8%) i/s - 31.770M in 5.007967s | |
| Hash#fetch + block 5.999M (±26.3%) i/s - 27.491M in 5.033090s | |
| Hash#fetch + arg 5.385M (±19.1%) i/s - 25.825M in 5.025253s | |
| Comparison: | |
| Hash#fetch + const: 6526304.2 i/s | |
| Hash#fetch + block: 5999100.0 i/s - same-ish: difference falls within error | |
| Hash#fetch + arg: 5385420.1 i/s - same-ish: difference falls within error | |
| $ ruby -v code/hash/hash-key-sort_by-vs-sort.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| sort_by + to_h 9.181k i/100ms | |
| sort + to_h 4.814k i/100ms | |
| Calculating ------------------------------------- | |
| sort_by + to_h 182.788k (±12.9%) i/s - 899.738k in 5.038242s | |
| sort + to_h 66.955k (±19.0%) i/s - 322.538k in 5.030962s | |
| Comparison: | |
| sort_by + to_h: 182787.9 i/s | |
| sort + to_h: 66954.8 i/s - 2.73x slower | |
| $ ruby -v code/hash/keys-each-vs-each_key.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash#keys.each 62.063k i/100ms | |
| Hash#each_key 59.085k i/100ms | |
| Calculating ------------------------------------- | |
| Hash#keys.each 773.466k (±21.9%) i/s - 3.724M in 5.060971s | |
| Hash#each_key 1.216M (±17.1%) i/s - 5.908M in 5.020543s | |
| Comparison: | |
| Hash#each_key: 1215976.1 i/s | |
| Hash#keys.each: 773466.0 i/s - 1.57x slower | |
| $ ruby -v code/hash/merge-bang-vs-[]=.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash#merge! 1.309k i/100ms | |
| Hash#[]= 4.873k i/100ms | |
| Calculating ------------------------------------- | |
| Hash#merge! 10.945k (±26.0%) i/s - 49.742k in 5.070663s | |
| Hash#[]= 57.486k (±14.7%) i/s - 287.507k in 5.120441s | |
| Comparison: | |
| Hash#[]=: 57486.3 i/s | |
| Hash#merge!: 10945.2 i/s - 5.25x slower | |
| $ ruby -v code/hash/merge-bang-vs-merge-vs-dup-merge-bang.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| {}#merge!(Hash) do end | |
| 961.000 i/100ms | |
| Hash#merge({}) 622.000 i/100ms | |
| Hash#dup#merge!({}) 488.000 i/100ms | |
| Calculating ------------------------------------- | |
| {}#merge!(Hash) do end | |
| 12.870k (±17.9%) i/s - 62.465k in 5.040817s | |
| Hash#merge({}) 7.587k (±19.8%) i/s - 36.698k in 5.079915s | |
| Hash#dup#merge!({}) 5.382k (±12.7%) i/s - 26.840k in 5.074350s | |
| Comparison: | |
| {}#merge!(Hash) do end: 12870.3 i/s | |
| Hash#merge({}): 7587.3 i/s - 1.70x slower | |
| Hash#dup#merge!({}): 5382.2 i/s - 2.39x slower | |
| $ ruby -v code/hash/merge-vs-double-splat-operator.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash#**other 62.055k i/100ms | |
| Hash#merge 54.067k i/100ms | |
| Calculating ------------------------------------- | |
| Hash#**other 877.911k (± 5.0%) i/s - 4.406M in 5.031349s | |
| Hash#merge 557.682k (±14.4%) i/s - 2.757M in 5.063112s | |
| Comparison: | |
| Hash#**other: 877910.5 i/s | |
| Hash#merge: 557682.4 i/s - 1.57x slower | |
| $ ruby -v code/hash/merge-vs-merge-bang.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Hash#merge 678.000 i/100ms | |
| Hash#merge! 1.527k i/100ms | |
| Calculating ------------------------------------- | |
| Hash#merge 5.372k (±21.9%) i/s - 24.408k in 5.001183s | |
| Hash#merge! 11.795k (±23.2%) i/s - 54.972k in 5.063160s | |
| Comparison: | |
| Hash#merge!: 11794.8 i/s | |
| Hash#merge: 5372.2 i/s - 2.20x slower | |
| $ ruby -v code/method/call-vs-send-vs-method_missing.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| call 111.656k i/100ms | |
| send 120.507k i/100ms | |
| method_missing 113.230k i/100ms | |
| Calculating ------------------------------------- | |
| call 3.832M (±15.0%) i/s - 18.758M in 5.015863s | |
| send 2.853M (±24.6%) i/s - 13.256M in 5.006891s | |
| method_missing 2.461M (±18.6%) i/s - 11.889M in 5.012577s | |
| Comparison: | |
| call: 3831690.2 i/s | |
| send: 2853300.4 i/s - same-ish: difference falls within error | |
| method_missing: 2461426.2 i/s - 1.56x slower | |
| $ ruby -v code/proc-and-block/block-vs-to_proc.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Block 4.800k i/100ms | |
| Symbol#to_proc 3.006k i/100ms | |
| Calculating ------------------------------------- | |
| Block 46.527k (±24.8%) i/s - 216.000k in 5.069511s | |
| Symbol#to_proc 58.173k (±18.8%) i/s - 276.552k in 5.006044s | |
| Comparison: | |
| Symbol#to_proc: 58172.9 i/s | |
| Block: 46527.4 i/s - same-ish: difference falls within error | |
| $ ruby -v code/proc-and-block/proc-call-vs-yield.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| block.call 87.402k i/100ms | |
| block + yield 224.487k i/100ms | |
| block argument 242.040k i/100ms | |
| yield 244.420k i/100ms | |
| Calculating ------------------------------------- | |
| block.call 1.301M (±18.7%) i/s - 6.293M in 5.044014s | |
| block + yield 6.679M (± 5.9%) i/s - 33.449M in 5.026407s | |
| block argument 7.302M (±12.5%) i/s - 35.822M in 5.002973s | |
| yield 6.946M (±10.5%) i/s - 34.463M in 5.016937s | |
| Comparison: | |
| block argument: 7301591.5 i/s | |
| yield: 6945549.1 i/s - same-ish: difference falls within error | |
| block + yield: 6679123.1 i/s - same-ish: difference falls within error | |
| block.call: 1301031.4 i/s - 5.61x slower | |
| $ ruby -v code/range/cover-vs-include.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| range#cover? 133.347k i/100ms | |
| range#include? 6.116k i/100ms | |
| range#member? 7.595k i/100ms | |
| plain compare 162.533k i/100ms | |
| Calculating ------------------------------------- | |
| range#cover? 2.356M (± 9.7%) i/s - 11.735M in 5.038701s | |
| range#include? 75.963k (±13.5%) i/s - 373.076k in 5.023592s | |
| range#member? 80.812k (± 7.8%) i/s - 402.535k in 5.013786s | |
| plain compare 2.990M (±10.1%) i/s - 14.791M in 5.006154s | |
| Comparison: | |
| plain compare: 2989589.1 i/s | |
| range#cover?: 2355788.7 i/s - 1.27x slower | |
| range#member?: 80811.8 i/s - 36.99x slower | |
| range#include?: 75962.6 i/s - 39.36x slower | |
| $ ruby -v code/string/===-vs-=~-vs-match.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#=~ 137.352k i/100ms | |
| Regexp#=== 139.365k i/100ms | |
| String#match 120.050k i/100ms | |
| Calculating ------------------------------------- | |
| String#=~ 2.376M (± 8.8%) i/s - 11.812M in 5.012705s | |
| Regexp#=== 2.286M (± 7.5%) i/s - 11.428M in 5.030705s | |
| String#match 1.903M (±11.2%) i/s - 9.484M in 5.055780s | |
| Comparison: | |
| String#=~: 2376477.0 i/s | |
| Regexp#===: 2285634.6 i/s - same-ish: difference falls within error | |
| String#match: 1902543.2 i/s - 1.25x slower | |
| $ ruby -v code/string/casecmp-vs-downcase-==.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#downcase + == 173.896k i/100ms | |
| String#casecmp 197.587k i/100ms | |
| Calculating ------------------------------------- | |
| String#downcase + == 3.859M (±12.4%) i/s - 18.955M in 5.010341s | |
| String#casecmp 5.111M (± 5.9%) i/s - 25.489M in 5.005113s | |
| Comparison: | |
| String#casecmp: 5111313.8 i/s | |
| String#downcase + ==: 3859143.8 i/s - 1.32x slower | |
| $ ruby -v code/string/concatenation.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#+ 151.823k i/100ms | |
| String#concat 84.030k i/100ms | |
| String#append 120.605k i/100ms | |
| "foo" "bar" 176.286k i/100ms | |
| "#{'foo'}#{'bar'}" 191.994k i/100ms | |
| Calculating ------------------------------------- | |
| String#+ 3.730M (±13.0%) i/s - 18.371M in 5.028022s | |
| String#concat 3.897M (±11.1%) i/s - 19.159M in 5.005293s | |
| String#append 4.136M (±11.9%) i/s - 20.382M in 5.010490s | |
| "foo" "bar" 7.040M (± 9.1%) i/s - 34.905M in 5.004878s | |
| "#{'foo'}#{'bar'}" 6.398M (±16.4%) i/s - 30.719M in 5.015434s | |
| Comparison: | |
| "foo" "bar": 7039771.3 i/s | |
| "#{'foo'}#{'bar'}": 6398207.0 i/s - same-ish: difference falls within error | |
| String#append: 4135926.7 i/s - 1.70x slower | |
| String#concat: 3897301.8 i/s - 1.81x slower | |
| String#+: 3730338.2 i/s - 1.89x slower | |
| $ ruby -v code/string/end-string-checking-match-vs-end_with.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#=~ 62.454k i/100ms | |
| String#end_with? 182.542k i/100ms | |
| Calculating ------------------------------------- | |
| String#=~ 896.679k (±10.6%) i/s - 4.434M in 5.010651s | |
| String#end_with? 3.882M (±14.9%) i/s - 18.984M in 5.027443s | |
| Comparison: | |
| String#end_with?: 3882219.3 i/s | |
| String#=~: 896679.0 i/s - 4.33x slower | |
| $ ruby -v code/string/gsub-vs-sub.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#gsub 45.958k i/100ms | |
| String#sub 60.405k i/100ms | |
| String#dup["string"]= | |
| 79.832k i/100ms | |
| Calculating ------------------------------------- | |
| String#gsub 520.254k (±16.4%) i/s - 2.528M in 5.034572s | |
| String#sub 745.968k (± 8.4%) i/s - 3.745M in 5.068259s | |
| String#dup["string"]= | |
| 952.986k (±17.8%) i/s - 4.630M in 5.048721s | |
| Comparison: | |
| String#dup["string"]=: 952986.4 i/s | |
| String#sub: 745968.0 i/s - same-ish: difference falls within error | |
| String#gsub: 520253.7 i/s - 1.83x slower | |
| $ ruby -v code/string/gsub-vs-tr.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#gsub 42.672k i/100ms | |
| String#tr 137.420k i/100ms | |
| Calculating ------------------------------------- | |
| String#gsub 539.506k (±12.7%) i/s - 2.688M in 5.086031s | |
| String#tr 2.408M (±11.3%) i/s - 11.956M in 5.027902s | |
| Comparison: | |
| String#tr: 2407907.2 i/s | |
| String#gsub: 539506.1 i/s - 4.46x slower | |
| $ ruby -v code/string/mutable_vs_immutable_strings.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| Without Freeze 208.134k i/100ms | |
| With Freeze 228.862k i/100ms | |
| Calculating ------------------------------------- | |
| Without Freeze 4.854M (±26.7%) i/s - 22.270M in 5.040891s | |
| With Freeze 8.655M (±13.4%) i/s - 42.568M in 5.018422s | |
| Comparison: | |
| With Freeze: 8655358.5 i/s | |
| Without Freeze: 4854314.5 i/s - 1.78x slower | |
| $ ruby -v code/string/start-string-checking-match-vs-start_with.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#=~ 56.262k i/100ms | |
| String#start_with? 112.860k i/100ms | |
| Calculating ------------------------------------- | |
| String#=~ 812.827k (±16.4%) i/s - 3.938M in 5.016243s | |
| String#start_with? 4.577M (±25.5%) i/s - 20.992M in 5.049912s | |
| Comparison: | |
| String#start_with?: 4576725.1 i/s | |
| String#=~: 812827.0 i/s - 5.63x slower | |
| $ ruby -v code/string/start_with-vs-substring-==.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#start_with? 88.868k i/100ms | |
| String#[0, n] == 41.545k i/100ms | |
| String#[RANGE] == 36.418k i/100ms | |
| String#[0...n] == 21.422k i/100ms | |
| Calculating ------------------------------------- | |
| String#start_with? 1.136M (±33.5%) i/s - 4.977M in 5.039887s | |
| String#[0, n] == 506.402k (±21.0%) i/s - 2.410M in 5.067625s | |
| String#[RANGE] == 367.381k (±20.8%) i/s - 1.748M in 5.016954s | |
| String#[0...n] == 279.253k (±23.7%) i/s - 1.307M in 5.060554s | |
| Comparison: | |
| String#start_with?: 1136406.9 i/s | |
| String#[0, n] ==: 506401.6 i/s - 2.24x slower | |
| String#[RANGE] ==: 367380.8 i/s - 3.09x slower | |
| String#[0...n] ==: 279253.5 i/s - 4.07x slower | |
| $ ruby -v code/string/sub!-vs-gsub!-vs-[]=.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#['string']= 56.643k i/100ms | |
| String#sub!'string' 36.014k i/100ms | |
| String#gsub!'string' 27.817k i/100ms | |
| String#[/regexp/]= 46.548k i/100ms | |
| String#sub!/regexp/ 43.076k i/100ms | |
| String#gsub!/regexp/ 22.684k i/100ms | |
| Calculating ------------------------------------- | |
| String#['string']= 990.611k (±21.3%) i/s - 4.701M in 5.038717s | |
| String#sub!'string' 525.399k (±13.3%) i/s - 2.593M in 5.019111s | |
| String#gsub!'string' 300.535k (±23.2%) i/s - 1.419M in 5.018897s | |
| String#[/regexp/]= 609.016k (±18.1%) i/s - 2.979M in 5.073942s | |
| String#sub!/regexp/ 385.780k (±20.5%) i/s - 1.852M in 5.007762s | |
| String#gsub!/regexp/ 240.494k (±16.2%) i/s - 1.180M in 5.028568s | |
| Comparison: | |
| String#['string']=: 990611.1 i/s | |
| String#[/regexp/]=: 609016.0 i/s - 1.63x slower | |
| String#sub!'string': 525398.8 i/s - 1.89x slower | |
| String#sub!/regexp/: 385780.3 i/s - 2.57x slower | |
| String#gsub!'string': 300534.8 i/s - 3.30x slower | |
| String#gsub!/regexp/: 240494.3 i/s - 4.12x slower | |
| $ ruby -v code/string/sub-vs-chomp.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#sub/regexp/ 25.527k i/100ms | |
| String#chomp'string' 97.642k i/100ms | |
| Calculating ------------------------------------- | |
| String#sub/regexp/ 538.764k (±27.6%) i/s - 2.476M in 5.033812s | |
| String#chomp'string' 2.591M (±27.6%) i/s - 11.815M in 5.015555s | |
| Comparison: | |
| String#chomp'string': 2590895.8 i/s | |
| String#sub/regexp/: 538764.3 i/s - 4.81x slower | |
| $ ruby -v code/string/tmp.rb | |
| ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16] | |
| Warming up -------------------------------------- | |
| String#gsub 35.543k i/100ms | |
| String#tr 114.681k i/100ms | |
| Calculating ------------------------------------- | |
| String#gsub 449.793k (±18.6%) i/s - 2.168M in 5.029250s | |
| String#tr 2.123M (±20.6%) i/s - 9.977M in 5.020428s | |
| Comparison: | |
| String#tr: 2123266.7 i/s | |
| String#gsub: 449793.4 i/s - 4.72x slower | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment