Fast Ruby 
In Erik Michaels-Ober’s great talk, ‘Writing Fast Ruby’: Video @ Baruco 2014, Slide, he presented us with many idioms that lead to faster running Ruby code. He inspired me to document these to let more people know. I try to link to real commits so people can see that this can really have benefits in the real world. This does not mean you can always blindly replace one with another. It depends on the context (e.g. gsub versus tr). Friendly reminder: Use with caution!
Each idiom has a corresponding code example that resides in code.
All results listed in README.md are running with Ruby 4.0.0 on macOS 15.6.1. Machine information: MacBook Pro (14-inch, Nov 2024), Apple M4 Pro, 48 GB RAM. Your results may vary, but you get the idea. : )
You can checkout the GitHub Actions build for these benchmark results ran against different Ruby implementations.
Let’s write faster code, together! <3
Analyze your code
Checkout the fasterer project - it’s a static analysis that checks speed idioms written in this repo.
Use benchmark-ips (2.0+).
Template
require "benchmark/ips"
def fast
end
def slow
end
Benchmark.ips do |x|
x.report("fast code description") { fast }
x.report("slow code description") { slow }
x.compare!
end
Idioms
Index
General
attr_accessor vs getter and setter code
https://www.rubydoc.info/stdlib/core/Module:attr_accessor
$ ruby -v code/general/attr-accessor-vs-getter-and-setter.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
getter_and_setter 1.122M i/100ms
attr_accessor 1.303M i/100ms
Calculating -------------------------------------
getter_and_setter 10.999M (± 2.1%) i/s (90.92 ns/i) - 56.083M in 5.101077s
attr_accessor 12.517M (± 1.5%) i/s (79.89 ns/i) - 63.841M in 5.101477s
Comparison:
attr_accessor: 12517008.0 i/s
getter_and_setter: 10999275.5 i/s - 1.14x slower
begin...rescue vs respond_to? for Control Flow code
$ ruby -v code/general/begin-rescue-vs-respond-to.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
begin...rescue 230.601k i/100ms
respond_to? 1.915M i/100ms
Calculating -------------------------------------
begin...rescue 2.390M (± 0.9%) i/s (418.40 ns/i) - 11.991M in 5.017466s
respond_to? 18.745M (± 1.8%) i/s (53.35 ns/i) - 93.843M in 5.007990s
Comparison:
respond_to?: 18744998.8 i/s
begin...rescue: 2390076.1 i/s - 7.84x slower
define_method vs module_eval for Defining Methods code
$ ruby -v code/general/define_method-vs-module-eval.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
module_eval with string
630.000 i/100ms
define_method 685.000 i/100ms
Calculating -------------------------------------
module_eval with string
5.633k (±18.1%) i/s (177.53 μs/i) - 27.090k in 5.009884s
define_method 7.239k (±17.6%) i/s (138.14 μs/i) - 34.250k in 5.040522s
Comparison:
define_method: 7238.9 i/s
module_eval with string: 5632.8 i/s - same-ish: difference falls within error
The run above measured the old code, which built 10 random names on every call and defined them on one class that kept growing.
The one below measures the current code, where every call defines the same 10 names on a new class.
$ ruby -v code/general/define_method-vs-module-eval.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
define_method 15.939k i/100ms
module_eval with string 2.507k i/100ms
Calculating -------------------------------------
define_method 132.661k (±12.4%) i/s (7.54 μs/i) - 669.438k in 5.046213s
module_eval with string 18.753k (±18.6%) i/s (53.32 μs/i) - 95.266k in 5.079985s
Comparison:
define_method: 132661.5 i/s
module_eval with string: 18753.2 i/s - 7.07x slower
String#constantize vs a comparison for inflection code
ActiveSupport’s String#constantize “resolves the constant reference expression in its receiver”.
Read the rationale here
$ ruby -v code/general/constantize-vs-comparison.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
using an if statement
1.507M i/100ms
String#constantize 1.048M i/100ms
Calculating -------------------------------------
using an if statement
15.518M (± 1.2%) i/s (64.44 ns/i) - 78.355M in 5.050041s
String#constantize 10.556M (± 1.0%) i/s (94.73 ns/i) - 53.448M in 5.063570s
Comparison:
using an if statement: 15517955.2 i/s
String#constantize: 10556362.4 i/s - 1.47x slower
Method vs forwarded method vs delegated method code
$ ruby -v code/general/method-vs-forwarded-method-vs-delegated-method.rb
ruby 2.2.0p0 (2014-12-25 revision 49005) [x86_64-darwin19]
Warming up --------------------------------------
method 247.079k i/100ms
forwarded method 183.323k i/100ms
delegated method 136.666k i/100ms
Calculating -------------------------------------
method 2.481M (± 0.5%) i/s - 12.601M in 5.078755s
forwarded method 1.830M (± 0.8%) i/s - 9.166M in 5.009606s
delegated method 1.365M (± 0.6%) i/s - 6.833M in 5.006191s
Comparison:
method: 2481182.0 i/s
forwarded method: 1829835.8 i/s - 1.36x (± 0.00) slower
delegated method: 1365026.7 i/s - 1.82x (± 0.00) slower
The run above is from the PR, when the delegated report called pop(1).
The one below measures the current code, where all three push 1.
$ ruby -v code/general/method-vs-forwarded-method-vs-delegated-method.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
method 566.282k i/100ms
forwarded method 452.579k i/100ms
delegated method 222.869k i/100ms
Calculating -------------------------------------
method 5.690M (± 1.0%) i/s (175.74 ns/i) - 28.880M in 5.075387s
forwarded method 4.580M (± 3.9%) i/s (218.33 ns/i) - 23.082M in 5.039438s
delegated method 2.229M (± 2.1%) i/s (448.72 ns/i) - 11.143M in 5.000248s
Comparison:
method: 5690282.1 i/s
forwarded method: 4580179.6 i/s - 1.24x slower
delegated method: 2228579.5 i/s - 2.55x slower
raise vs E2MM#Raise for raising (and defining) exceptions code custom exception code
Ruby’s Exception2MessageMapper module allows one to define and raise exceptions with predefined messages.
$ ruby -v code/general/raise-vs-e2mmap.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Ruby exception: E2MM#Raise
8.751k i/100ms
Ruby exception: Kernel#raise
254.268k i/100ms
Calculating -------------------------------------
Ruby exception: E2MM#Raise
88.269k (± 0.5%) i/s (11.33 μs/i) - 446.301k in 5.056287s
Ruby exception: Kernel#raise
2.571M (± 1.0%) i/s (389.01 ns/i) - 12.968M in 5.044976s
Comparison:
Ruby exception: Kernel#raise: 2570660.6 i/s
Ruby exception: E2MM#Raise: 88268.9 i/s - 29.12x slower
$ ruby -v code/general/raise-custom-vs-e2mmap.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Custom exception: E2MM#Raise
8.837k i/100ms
Custom exception: Kernel#raise
263.896k i/100ms
Calculating -------------------------------------
Custom exception: E2MM#Raise
88.322k (± 0.6%) i/s (11.32 μs/i) - 441.850k in 5.002885s
Custom exception: Kernel#raise
2.599M (± 2.1%) i/s (384.78 ns/i) - 13.195M in 5.079300s
Comparison:
Custom exception: Kernel#raise: 2598894.6 i/s
Custom exception: E2MM#Raise: 88322.1 i/s - 29.43x slower
begin...end until vs while true vs until false vs loop vs infinite range code
The first run only had while true and loop.
The second is from #143, which added begin...end until, and the third from #228, which added until false and the infinite range.
$ ruby -v code/general/loop-vs-while-true.rb
ruby 2.2.3p173 (2015-08-18 revision 51636) [x86_64-linux]
Calculating -------------------------------------
While Loop 1.000 i/100ms
Kernel loop 1.000 i/100ms
-------------------------------------------------
While Loop 0.536 (± 0.0%) i/s - 3.000 in 5.593042s
Kernel loop 0.223 (± 0.0%) i/s - 2.000 in 8.982355s
Comparison:
While Loop: 0.5 i/s
Kernel loop: 0.2 i/s - 2.41x slower
$ ruby -v code/general/loop-vs-while-true.rb
ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-linux]
Warming up --------------------------------------
Begin Until 1.000 i/100ms
While Loop 1.000 i/100ms
Kernel loop 1.000 i/100ms
Calculating -------------------------------------
Begin Until 0.211 (± 0.0%) i/s - 2.000 in 9.469782s
While Loop 0.192 (± 0.0%) i/s - 1.000 in 5.212417s
Kernel loop 0.072 (± 0.0%) i/s - 1.000 in 13.921672s
Comparison:
Begin Until: 0.2 i/s
While Loop: 0.2 i/s - 1.10x slower
Kernel loop: 0.1 i/s - 2.94x slower
$ ruby -v code/general/loop-vs-while-true-vs-until-false-vs-infinite-range.rb
ruby 3.3.0dev (2023-11-12 master 60e19a0b5f) [x86_64-linux]
Warming up --------------------------------------
While loop 1.000 i/100ms
Until loop 1.000 i/100ms
Kernel loop 1.000 i/100ms
Infinite range 1.000 i/100ms
Calculating -------------------------------------
While loop 0.600 (± 0.0%) i/s - 3.000 in 5.002930s
Until loop 0.594 (± 0.0%) i/s - 3.000 in 5.054004s
Kernel loop 0.258 (± 0.0%) i/s - 2.000 in 7.754873s
Infinite range 0.207 (± 0.0%) i/s - 2.000 in 9.664227s
Comparison:
While loop: 0.6 i/s
Until loop: 0.6 i/s - 1.01x slower
Kernel loop: 0.3 i/s - 2.33x slower
Infinite range: 0.2 i/s - 2.90x slower
$ ruby -v code/general/loop-vs-while-true.rb
ruby 3.4.10 (2026-06-30 revision 2b0b7728dc) +PRISM [aarch64-linux]
Warming up --------------------------------------
Begin Until 1.000 i/100ms
While Loop 1.000 i/100ms
Until loop 1.000 i/100ms
Kernel loop 1.000 i/100ms
Infinite range 1.000 i/100ms
Calculating -------------------------------------
Begin Until 0.715 (± 0.0%) i/s (1.40 s/i) - 4.000 in 5.593345s
While Loop 0.713 (± 0.0%) i/s (1.40 s/i) - 4.000 in 5.607034s
Until loop 0.710 (± 0.0%) i/s (1.41 s/i) - 4.000 in 5.634041s
Kernel loop 0.387 (± 0.0%) i/s (2.59 s/i) - 2.000 in 5.172241s
Infinite range 0.399 (± 0.0%) i/s (2.50 s/i) - 2.000 in 5.008409s
Comparison:
Begin Until: 0.7 i/s
While Loop: 0.7 i/s - 1.00x slower
Until loop: 0.7 i/s - 1.01x slower
Infinite range: 0.4 i/s - 1.79x slower
Kernel loop: 0.4 i/s - 1.85x slower
$ ruby -v code/general/loop-vs-while-true.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
While Loop 1.000 i/100ms
Kernel loop 1.000 i/100ms
Calculating -------------------------------------
While Loop 1.331 (± 0.0%) i/s (751.41 ms/i) - 7.000 in 5.260296s
Kernel loop 0.528 (± 0.0%) i/s (1.89 s/i) - 3.000 in 5.709880s
Comparison:
While Loop: 1.3 i/s
Kernel loop: 0.5 i/s - 2.52x slower
$ ruby -v code/general/loop-vs-while-true.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
Begin Until 1.000 i/100ms
While Loop 1.000 i/100ms
Until loop 1.000 i/100ms
Kernel loop 1.000 i/100ms
Infinite range 1.000 i/100ms
Calculating -------------------------------------
Begin Until 0.666 (± 0.0%) i/s (1.50 s/i) - 4.000 in 6.006927s
While Loop 0.687 (± 0.0%) i/s (1.46 s/i) - 4.000 in 5.826603s
Until loop 0.686 (± 0.0%) i/s (1.46 s/i) - 4.000 in 5.828591s
Kernel loop 0.520 (± 0.0%) i/s (1.92 s/i) - 3.000 in 5.767842s
Infinite range 0.386 (± 0.0%) i/s (2.59 s/i) - 2.000 in 5.184388s
Comparison:
While Loop: 0.7 i/s
Until loop: 0.7 i/s - 1.00x slower
Begin Until: 0.7 i/s - 1.03x slower
Kernel loop: 0.5 i/s - 1.32x slower
Infinite range: 0.4 i/s - 1.78x slower
ancestors.include? vs <= code
$ ruby -v code/general/inheritance-check.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
less than or equal 1.150M i/100ms
ancestors.include? 179.611k i/100ms
Calculating -------------------------------------
less than or equal 11.426M (± 1.4%) i/s (87.52 ns/i) - 57.493M in 5.032894s
ancestors.include? 1.880M (± 1.0%) i/s (531.84 ns/i) - 9.519M in 5.063302s
Comparison:
less than or equal: 11425608.6 i/s
ancestors.include?: 1880262.8 i/s - 6.08x slower
Method Invocation
call vs send vs method_missing code
$ ruby -v code/method/call-vs-send-vs-method_missing.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
call 1.670M i/100ms
send 1.182M i/100ms
method_missing 837.965k i/100ms
Calculating -------------------------------------
call 16.799M (± 0.3%) i/s (59.53 ns/i) - 85.150M in 5.068737s
send 11.845M (± 0.3%) i/s (84.42 ns/i) - 60.281M in 5.089071s
method_missing 8.392M (± 0.3%) i/s (119.17 ns/i) - 42.736M in 5.092719s
Comparison:
call: 16799285.6 i/s
send: 11845293.0 i/s - 1.42x slower
method_missing: 8391692.6 i/s - 2.00x slower
Normal way to apply method vs &method(...) code
$ ruby -v code/general/block-apply-method.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
normal 698.536k i/100ms
&method 322.901k i/100ms
Calculating -------------------------------------
normal 6.978M (± 0.9%) i/s (143.31 ns/i) - 34.927M in 5.005888s
&method 3.214M (± 0.5%) i/s (311.12 ns/i) - 16.145M in 5.023139s
Comparison:
normal: 6977718.6 i/s
&method: 3214214.6 i/s - 2.17x slower
Function with single Array argument vs splat arguments code
$ ruby -v code/general/array-argument-vs-splat-arguments.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Function with single Array argument
1.910M i/100ms
Function with splat arguments
18.841k i/100ms
Calculating -------------------------------------
Function with single Array argument
18.818M (± 1.2%) i/s (53.14 ns/i) - 95.479M in 5.074468s
Function with splat arguments
217.060k (±11.2%) i/s (4.61 μs/i) - 1.093M in 5.099583s
Comparison:
Function with single Array argument: 18818207.9 i/s
Function with splat arguments: 217059.9 i/s - 86.70x slower
Hash vs OpenStruct on access assuming you already have a Hash or an OpenStruct code
$ ruby -v code/general/hash-vs-openstruct-on-access.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash 2.028M i/100ms
OpenStruct 1.478M i/100ms
Calculating -------------------------------------
Hash 20.290M (± 0.5%) i/s (49.29 ns/i) - 103.430M in 5.097815s
OpenStruct 14.807M (± 0.6%) i/s (67.54 ns/i) - 75.387M in 5.091599s
Comparison:
Hash: 20289714.4 i/s
OpenStruct: 14806564.8 i/s - 1.37x slower
Hash vs OpenStruct (creation) code
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash 2.652M i/100ms
OpenStruct 31.241k i/100ms
Calculating -------------------------------------
Hash 26.301M (± 1.0%) i/s (38.02 ns/i) - 132.614M in 5.042769s
OpenStruct 313.539k (± 1.8%) i/s (3.19 μs/i) - 1.593M in 5.083245s
Comparison:
Hash: 26300561.3 i/s
OpenStruct: 313538.7 i/s - 83.88x slower
$ ruby -v code/general/format-vs-round-and-to-s.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Float#round 465.786k i/100ms
Kernel#format 618.743k i/100ms
String#% 562.895k i/100ms
Calculating -------------------------------------
Float#round 4.780M (± 0.6%) i/s (209.21 ns/i) - 24.221M in 5.067359s
Kernel#format 6.200M (± 1.4%) i/s (161.29 ns/i) - 31.556M in 5.090736s
String#% 5.642M (± 1.1%) i/s (177.25 ns/i) - 28.708M in 5.088913s
Comparison:
Kernel#format: 6199975.0 i/s
String#%: 5641863.3 i/s - 1.10x slower
Float#round: 4779984.9 i/s - 1.30x slower
Array
Array#bsearch vs Array#find code
WARNING: bsearch ONLY works on sorted array. More details please see #29.
$ ruby -v code/array/bsearch-vs-find.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
find 1.000 i/100ms
bsearch 189.387k i/100ms
Calculating -------------------------------------
find 0.703 (± 0.0%) i/s (1.42 s/i) - 4.000 in 5.692110s
bsearch 1.893M (± 1.6%) i/s (528.21 ns/i) - 9.469M in 5.003152s
Comparison:
bsearch: 1893194.5 i/s
find: 0.7 i/s - 2691605.95x slower
Array#length vs Array#size vs Array#count code
Use #length when you only want to know how many elements in the array, #count could also achieve this. However #count should be use for counting specific elements in array. Note #size is an alias of #length.
$ ruby -v code/array/length-vs-size-vs-count.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#length 5.024M i/100ms
Array#size 4.994M i/100ms
Array#count 3.781M i/100ms
Calculating -------------------------------------
Array#length 50.668M (± 0.8%) i/s (19.74 ns/i) - 256.237M in 5.057495s
Array#size 50.580M (± 0.7%) i/s (19.77 ns/i) - 254.704M in 5.035880s
Array#count 38.202M (± 0.8%) i/s (26.18 ns/i) - 192.843M in 5.048306s
Comparison:
Array#length: 50667869.8 i/s
Array#size: 50580088.8 i/s - same-ish: difference falls within error
Array#count: 38201768.5 i/s - 1.33x slower
Array#shuffle.first vs Array#sample code
Array#shuffle allocates an extra array.
Array#sample indexes into the array without allocating an extra array.
This is the reason why Array#sample exists.
—— @sferik rails/rails#17245
$ ruby -v code/array/shuffle-first-vs-sample.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#shuffle.first 88.991k i/100ms
Array#sample 2.503M i/100ms
Calculating -------------------------------------
Array#shuffle.first 891.780k (± 0.5%) i/s (1.12 μs/i) - 4.539M in 5.089459s
Array#sample 25.133M (± 0.6%) i/s (39.79 ns/i) - 127.660M in 5.079516s
Comparison:
Array#sample: 25133099.8 i/s
Array#shuffle.first: 891779.8 i/s - 28.18x slower
Array#[](0) vs Array#first code
$ ruby -v code/array/array-first-vs-index.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#[0] 3.922M i/100ms
Array#first 3.697M i/100ms
Calculating -------------------------------------
Array#[0] 39.347M (± 0.7%) i/s (25.41 ns/i) - 200.006M in 5.083307s
Array#first 37.289M (± 1.1%) i/s (26.82 ns/i) - 188.546M in 5.056917s
Comparison:
Array#[0]: 39347487.6 i/s
Array#first: 37288935.3 i/s - 1.06x slower
Array#[](-1) vs Array#last code
$ ruby -v code/array/array-last-vs-index.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#[-1] 3.906M i/100ms
Array#last 3.727M i/100ms
Calculating -------------------------------------
Array#[-1] 39.303M (± 0.7%) i/s (25.44 ns/i) - 199.228M in 5.069210s
Array#last 37.280M (± 1.1%) i/s (26.82 ns/i) - 190.075M in 5.099254s
Comparison:
Array#[-1]: 39303493.5 i/s
Array#last: 37279563.5 i/s - 1.05x slower
Array#insert vs Array#unshift code
$ ruby -v code/array/insert-vs-unshift.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#unshift 37.000 i/100ms
Array#insert 1.000 i/100ms
Calculating -------------------------------------
Array#unshift 379.798 (± 1.1%) i/s (2.63 ms/i) - 1.924k in 5.066300s
Array#insert 1.717 (± 0.0%) i/s (582.49 ms/i) - 9.000 in 5.242429s
Comparison:
Array#unshift: 379.8 i/s
Array#insert: 1.7 i/s - 221.23x slower
Array#concat vs Array#+ code
Array#+ returns a new array built by concatenating the two arrays together to
produce a third array. Array#concat appends the elements of the other array to self.
This means that the + operator will create a new array each time it is called
(which is expensive), while concat only appends the new element.
$ ruby -v code/array/array-concat-vs-+.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#concat 126.000 i/100ms
Array#+ 1.000 i/100ms
Calculating -------------------------------------
Array#concat 1.259k (± 1.1%) i/s (793.98 μs/i) - 6.300k in 5.002769s
Array#+ 5.170 (± 0.0%) i/s (193.42 ms/i) - 26.000 in 5.033770s
Comparison:
Array#concat: 1259.5 i/s
Array#+: 5.2 i/s - 243.60x slower
Array#new vs range + map vs Integer#upto + map vs Integer#times + map code
Typical slowdown is 40-60% depending on the size of the array. See the corresponding
pull request for performance characteristics.
The first run is from before range + map and Integer#upto + map were added.
The second is from #227.
ruby 2.3.0p0 (2015-12-25 revision 53290) [x86_64-darwin15]
Calculating -------------------------------------
Array#new 63.875k i/100ms
Fixnum#times + map 48.010k i/100ms
-------------------------------------------------
Array#new 1.070M (± 2.2%) i/s - 5.365M
Fixnum#times + map 678.097k (± 2.7%) i/s - 3.409M
Comparison:
Array#new: 1069837.0 i/s
Fixnum#times + map: 678097.4 i/s - 1.58x slower
ruby 3.3.0dev (2023-11-12 master 60e19a0b5f) [x86_64-linux]
Warming up --------------------------------------
Array#new 162.771k i/100ms
range + map 101.765k i/100ms
Integer#times + map 64.009k i/100ms
Integer#upto + map 86.411k i/100ms
Calculating -------------------------------------
Array#new 1.629M (± 1.1%) i/s - 8.301M in 5.096134s
range + map 1.009M (± 1.3%) i/s - 5.088M in 5.045700s
Integer#times + map 621.555k (± 2.0%) i/s - 3.136M in 5.048250s
Integer#upto + map 810.206k (± 2.4%) i/s - 4.061M in 5.015800s
Comparison:
Array#new: 1629141.5 i/s
range + map: 1008629.1 i/s - 1.62x slower
Integer#upto + map: 810205.5 i/s - 2.01x slower
Integer#times + map: 621555.5 i/s - 2.62x slower
$ ruby -v code/array/array-new-vs-fixnum-times-map.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#new 424.914k i/100ms
Fixnum#times + map 187.997k i/100ms
Calculating -------------------------------------
Array#new 4.251M (± 0.4%) i/s (235.25 ns/i) - 21.671M in 5.098122s
Fixnum#times + map 1.886M (± 0.4%) i/s (530.31 ns/i) - 9.588M in 5.084632s
Comparison:
Array#new: 4250785.8 i/s
Fixnum#times + map: 1885679.9 i/s - 2.25x slower
$ ruby -v code/array/array-new-vs-fixnum-times-map.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
Array#new 250.048k i/100ms
range + map 122.278k i/100ms
Integer#upto + map 137.831k i/100ms
Integer#times + map 123.032k i/100ms
Calculating -------------------------------------
Array#new 2.572M (± 3.8%) i/s (388.86 ns/i) - 13.002M in 5.056173s
range + map 1.707M (± 4.0%) i/s (585.74 ns/i) - 8.559M in 5.013655s
Integer#upto + map 1.321M (±11.3%) i/s (757.04 ns/i) - 6.616M in 5.008470s
Integer#times + map 1.067M (±13.2%) i/s (937.27 ns/i) - 5.413M in 5.073819s
Comparison:
Array#new: 2571608.0 i/s
range + map: 1707229.6 i/s - 1.51x slower
Integer#upto + map: 1320940.0 i/s - 1.95x slower
Integer#times + map: 1066929.7 i/s - 2.41x slower
Array#sort.reverse vs Array#sort_by + block code
$ ruby -v code/array/sort-reverse-vs-sort_by-with-block.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#sort.reverse 55.279k i/100ms
Array#sort_by &:-@ 22.773k i/100ms
Calculating -------------------------------------
Array#sort.reverse 560.570k (± 0.9%) i/s (1.78 μs/i) - 2.819M in 5.029648s
Array#sort_by &:-@ 229.324k (± 0.6%) i/s (4.36 μs/i) - 1.161M in 5.064717s
Comparison:
Array#sort.reverse: 560570.1 i/s
Array#sort_by &:-@: 229323.6 i/s - 2.44x slower
Subset check: (a1 - a2).empty? vs alternatives code
To check whether every element of a1 is also in a2, (a1 - a2).empty? is
consistently the fastest across modern Ruby versions for the common case where
a1 is actually a subset.
Caveat: the winner is highly data-dependent. a1.all? { |e| a2.include?(e) }
short-circuits on the first miss, so it wins when a1 is not a subset, but it
is O(n*m) and degrades badly on large true subsets.
Note also that Set#subset? (including the to_set conversion) was ~6.8x slower
on Ruby 3.3/3.4 but only ~1.7x slower on Ruby 4.0, where Set became much
faster. If you already hold Sets (or check repeatedly), Set#subset? scales
best.
$ ruby -v code/array/subset-check.rb
ruby 3.3.10 (2025-10-23 revision 343ea05002) [arm64-darwin25]
Warming up --------------------------------------
(a1 - a2).empty? 86.499k i/100ms
(a1 & a2) == a1 73.860k i/100ms
(a1 & a2).size == n 74.102k i/100ms
a1.all? { include? } 67.703k i/100ms
a1.to_set.subset? 12.068k i/100ms
Calculating -------------------------------------
(a1 - a2).empty? 849.546k (± 2.7%) i/s (1.18 μs/i) - 4.325M in 5.090893s
(a1 & a2) == a1 746.103k (± 2.0%) i/s (1.34 μs/i) - 3.767M in 5.048711s
(a1 & a2).size == n 780.447k (± 1.9%) i/s (1.28 μs/i) - 3.927M in 5.032254s
a1.all? { include? } 715.301k (± 2.4%) i/s (1.40 μs/i) - 3.588M in 5.016435s
a1.to_set.subset? 124.189k (± 0.8%) i/s (8.05 μs/i) - 627.536k in 5.053052s
Comparison:
(a1 - a2).empty?: 849546.4 i/s
(a1 & a2).size == n: 780446.7 i/s - 1.09x slower
(a1 & a2) == a1: 746103.3 i/s - 1.14x slower
a1.all? { include? }: 715300.6 i/s - 1.19x slower
a1.to_set.subset?: 124189.5 i/s - 6.84x slower
$ ruby -v code/array/subset-check.rb
ruby 3.4.7 (2025-10-08 revision 7a5688e2a2) +PRISM [arm64-darwin25]
Comparison:
(a1 - a2).empty?: 807172.5 i/s
(a1 & a2).size == n: 719880.2 i/s - 1.12x slower
a1.all? { include? }: 713213.0 i/s - 1.13x slower
(a1 & a2) == a1: 687629.1 i/s - 1.17x slower
a1.to_set.subset?: 119834.6 i/s - 6.74x slower
$ ruby -v code/array/subset-check.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin25]
Comparison:
(a1 - a2).empty?: 784706.1 i/s
a1.all? { include? }: 727520.9 i/s - 1.08x slower
(a1 & a2).size == n: 701969.3 i/s - 1.12x slower
(a1 & a2) == a1: 670252.7 i/s - 1.17x slower
a1.to_set.subset?: 467206.3 i/s - 1.68x slower
$ ruby -v code/array/subset-check.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Comparison:
(a1 - a2).empty?: 547122.9 i/s
a1.all? { include? }: 506861.9 i/s - same-ish: difference falls within error
(a1 & a2).size == n: 427211.2 i/s - 1.28x slower
a1.to_set.subset?: 341619.6 i/s - 1.60x slower
(a1 & a2) == a1: 329130.1 i/s - 1.66x slower
Enumerable
Enumerable#each + push vs Enumerable#map code
$ ruby -v code/enumerable/each-push-vs-map.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#each + push 31.310k i/100ms
Array#map 51.371k i/100ms
Calculating -------------------------------------
Array#each + push 320.334k (± 0.6%) i/s (3.12 μs/i) - 1.628M in 5.082743s
Array#map 511.854k (± 1.3%) i/s (1.95 μs/i) - 2.569M in 5.019061s
Comparison:
Array#map: 511854.5 i/s
Array#each + push: 320334.1 i/s - 1.60x slower
Enumerable#each vs for loop code
$ ruby -v code/enumerable/each-vs-for-loop.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
For loop 54.498k i/100ms
#each 63.984k i/100ms
Calculating -------------------------------------
For loop 525.548k (± 8.8%) i/s (1.90 μs/i) - 2.670M in 5.128917s
#each 641.789k (± 0.3%) i/s (1.56 μs/i) - 3.263M in 5.084548s
Comparison:
#each: 641788.6 i/s
For loop: 525547.8 i/s - 1.22x slower
Enumerable#each_with_index vs while loop code
rails/rails#12065
$ ruby -v code/enumerable/each_with_index-vs-while-loop.rb
ruby 2.2.0p0 (2014-12-25 revision 49005) [x86_64-darwin14]
Calculating -------------------------------------
While Loop 22.553k i/100ms
each_with_index 11.963k i/100ms
-------------------------------------------------
While Loop 240.752k (± 7.1%) i/s - 1.218M
each_with_index 126.753k (± 5.9%) i/s - 634.039k
Comparison:
While Loop: 240752.1 i/s
each_with_index: 126753.4 i/s - 1.90x slower
The next run is from #155, with an extra “While optimal” loop that also copies ARRAY to a local variable (left out: it ties with the cached size).
Its reports ran 1000 calls each, so its i/s are per 1000 calls.
$ ruby -v code/enumerable/each_with_index-vs-while-loop.rb
ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux]
Calculating -------------------------------------
While optimal 443.606 (± 2.5%) i/s - 2.250k in 5.075720s
While cached size 441.961 (± 0.5%) i/s - 2.244k in 5.077426s
While loop 363.202 (± 3.3%) i/s - 1.836k in 5.061400s
each_with_index 277.373 (± 1.1%) i/s - 1.404k in 5.062208s
Comparison:
While optimal: 443.6 i/s
While cached size: 442.0 i/s - same-ish: difference falls within error
While loop: 363.2 i/s - 1.22x slower
each_with_index: 277.4 i/s - 1.60x slower
$ ruby -v code/enumerable/each_with_index-vs-while-loop.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
While Loop 49.050k i/100ms
each_with_index 36.684k i/100ms
Calculating -------------------------------------
While Loop 501.430k (± 2.9%) i/s (1.99 μs/i) - 2.551M in 5.091049s
each_with_index 369.364k (± 0.3%) i/s (2.71 μs/i) - 1.871M in 5.065187s
Comparison:
While Loop: 501430.2 i/s
each_with_index: 369364.5 i/s - 1.36x slower
$ ruby -v code/enumerable/each_with_index-vs-while-loop.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
While cached size 40.277k i/100ms
While Loop 36.196k i/100ms
each_with_index 28.712k i/100ms
Calculating -------------------------------------
While cached size 396.703k (± 1.8%) i/s (2.52 μs/i) - 2.014M in 5.076466s
While Loop 374.002k (± 3.3%) i/s (2.67 μs/i) - 1.882M in 5.032566s
each_with_index 290.320k (± 0.6%) i/s (3.44 μs/i) - 1.464M in 5.043785s
Comparison:
While cached size: 396703.1 i/s
While Loop: 374002.4 i/s - 1.06x slower
each_with_index: 290320.1 i/s - 1.37x slower
Enumerable#map…Array#flatten vs Enumerable#flat_map code
– @sferik rails/rails@3413b88, Replace map.flatten with flat_map, Replace map.flatten(1) with flat_map
$ ruby -v code/enumerable/map-flatten-vs-flat_map.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#map.flatten(1) 19.072k i/100ms
Array#map.flatten 8.810k i/100ms
Array#flat_map 21.362k i/100ms
Calculating -------------------------------------
Array#map.flatten(1) 196.444k (± 1.2%) i/s (5.09 μs/i) - 991.744k in 5.049225s
Array#map.flatten 89.917k (± 1.2%) i/s (11.12 μs/i) - 458.120k in 5.095661s
Array#flat_map 215.149k (± 0.6%) i/s (4.65 μs/i) - 1.089M in 5.063916s
Comparison:
Array#flat_map: 215149.2 i/s
Array#map.flatten(1): 196443.8 i/s - 1.10x slower
Array#map.flatten: 89916.9 i/s - 2.39x slower
Enumerable#reverse.each vs Enumerable#reverse_each code
Enumerable#reverse allocates an extra array.
Enumerable#reverse_each yields each value without allocating an extra array.
This is the reason why Enumerable#reverse_each exists.
– @sferik rails/rails#17244
$ ruby -v code/enumerable/reverse-each-vs-reverse_each.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Array#reverse.each 58.610k i/100ms
Array#reverse_each 63.669k i/100ms
Calculating -------------------------------------
Array#reverse.each 586.309k (± 0.7%) i/s (1.71 μs/i) - 2.989M in 5.098469s
Array#reverse_each 635.904k (± 2.3%) i/s (1.57 μs/i) - 3.183M in 5.009371s
Comparison:
Array#reverse_each: 635904.1 i/s
Array#reverse.each: 586309.0 i/s - 1.08x slower
Enumerable#sort_by.first vs Enumerable#min_by code
Enumerable#sort_by performs a sort of the enumerable and allocates a
new array the size of the enumerable. Enumerable#min_by doesn’t
perform a sort or allocate an array the size of the enumerable.
Similar comparisons hold for Enumerable#sort_by.last vs
Enumerable#max_by, Enumerable#sort.first vs Enumerable#min, and
Enumerable#sort.last vs Enumerable#max.
$ ruby -v code/enumerable/sort_by-first-vs-min_by.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Enumerable#min_by 40.784k i/100ms
Enumerable#sort_by...first
32.912k i/100ms
Calculating -------------------------------------
Enumerable#min_by 408.114k (± 0.3%) i/s (2.45 μs/i) - 2.080M in 5.096613s
Enumerable#sort_by...first
334.401k (± 0.7%) i/s (2.99 μs/i) - 1.679M in 5.019698s
Comparison:
Enumerable#min_by: 408113.9 i/s
Enumerable#sort_by...first: 334400.9 i/s - 1.22x slower
Enumerable#detect vs Enumerable#select.first code
$ ruby -v code/enumerable/select-first-vs-detect.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Enumerable#select.first
37.402k i/100ms
Enumerable#detect 247.638k i/100ms
Calculating -------------------------------------
Enumerable#select.first
373.115k (± 0.6%) i/s (2.68 μs/i) - 7.480M in 20.049160s
Enumerable#detect 2.462M (± 0.8%) i/s (406.12 ns/i) - 49.280M in 20.014730s
Comparison:
Enumerable#detect: 2462330.2 i/s
Enumerable#select.first: 373115.1 i/s - 6.60x slower
Enumerable#select.last vs Enumerable#reverse.detect code
$ ruby -v code/enumerable/select-last-vs-reverse-detect.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Enumerable#reverse.detect
23.133k i/100ms
Enumerable#select.last
562.000 i/100ms
Calculating -------------------------------------
Enumerable#reverse.detect
241.463k (± 5.5%) i/s (4.14 μs/i) - 1.226M in 5.092374s
Enumerable#select.last
5.640k (± 0.9%) i/s (177.30 μs/i) - 28.662k in 5.082075s
Comparison:
Enumerable#reverse.detect: 241463.1 i/s
Enumerable#select.last: 5640.3 i/s - 42.81x slower
Enumerable#sort vs Enumerable#sort_by code
$ ruby -v code/enumerable/sort-vs-sort_by.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Enumerable#sort_by (Symbol#to_proc)
16.077k i/100ms
Enumerable#sort_by 15.265k i/100ms
Enumerable#sort 4.580k i/100ms
Calculating -------------------------------------
Enumerable#sort_by (Symbol#to_proc)
162.709k (± 0.9%) i/s (6.15 μs/i) - 819.927k in 5.039602s
Enumerable#sort_by 152.611k (± 0.7%) i/s (6.55 μs/i) - 763.250k in 5.001512s
Enumerable#sort 45.814k (± 1.4%) i/s (21.83 μs/i) - 233.580k in 5.099352s
Comparison:
Enumerable#sort_by (Symbol#to_proc): 162709.4 i/s
Enumerable#sort_by: 152611.3 i/s - 1.07x slower
Enumerable#sort: 45814.3 i/s - 3.55x slower
Enumerable#inject Symbol vs Enumerable#inject Proc code
Of note, to_proc for 1.8.7 is considerable slower than the block format
$ ruby -v code/enumerable/inject-symbol-vs-block.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
inject symbol 183.846k i/100ms
inject to_proc 4.100k i/100ms
inject block 3.882k i/100ms
Calculating -------------------------------------
inject symbol 1.841M (± 0.4%) i/s (543.31 ns/i) - 9.376M in 5.094226s
inject to_proc 41.165k (± 0.3%) i/s (24.29 μs/i) - 209.100k in 5.079636s
inject block 39.550k (± 0.6%) i/s (25.28 μs/i) - 197.982k in 5.006073s
Comparison:
inject symbol: 1840578.1 i/s
inject to_proc: 41164.7 i/s - 44.71x slower
inject block: 39550.0 i/s - 46.54x slower
Array#sum vs Array#inject(:+) code
Array#sum needs Ruby 2.4 or newer.
For Floats the two differ: Array#sum compensates for rounding errors.
$ ruby -v code/enumerable/inject-symbol-plus-vs-sum.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
Array#sum 157.012k i/100ms
Array#inject(:+) 100.674k i/100ms
Calculating -------------------------------------
Array#sum 1.527M (± 4.2%) i/s (655.01 ns/i) - 7.694M in 5.039404s
Array#inject(:+) 977.701k (± 9.6%) i/s (1.02 μs/i) - 4.933M in 5.045534s
Comparison:
Array#sum: 1526686.2 i/s
Array#inject(:+): 977701.4 i/s - 1.56x slower
BigDecimal
On current CRuby, building a BigDecimal from the number is faster than from a String.
On Ruby 2.5 it was the other way around, as the 2.5 runs below show.
The first run is from #172, when both files were one.
$ ruby -v code/bigdecimal/string-vs-numeric.rb
ruby 2.5.3p105 (2018-10-18 revision 65156) [x86_64-darwin18]
Calculating -------------------------------------
integer string new 2.497M (± 2.0%) i/s - 12.645M in 5.066385s
float string new 2.414M (± 2.0%) i/s - 12.182M in 5.048473s
integer string to_d 2.402M (± 1.8%) i/s - 12.010M in 5.001784s
float string to_d 2.318M (± 1.8%) i/s - 11.663M in 5.032429s
integer new 1.601M (± 1.2%) i/s - 8.022M in 5.010201s
integer to_d 1.563M (± 1.8%) i/s - 7.817M in 5.001726s
float new 517.635k (± 4.5%) i/s - 2.604M in 5.042605s
float to_d 529.413k (± 3.6%) i/s - 2.671M in 5.051477s
Comparison:
integer string new: 2496860.3 i/s
float string new: 2414122.8 i/s - same-ish: difference falls within error
integer string to_d: 2401929.3 i/s - 1.04x slower
float string to_d: 2318272.7 i/s - 1.08x slower
integer new: 1601402.4 i/s - 1.56x slower
integer to_d: 1563335.6 i/s - 1.60x slower
float to_d: 529412.7 i/s - 4.72x slower
float new: 517634.5 i/s - 4.82x slower
$ ruby -v code/bigdecimal/integer-string-vs-numeric.rb
ruby 2.5.9p229 (2021-04-05 revision 67939) [aarch64-linux]
Warming up --------------------------------------
integer new 414.193k i/100ms
integer to_d 403.499k i/100ms
integer string new 550.222k i/100ms
integer string to_d 495.285k i/100ms
Calculating -------------------------------------
integer new 4.270M (± 4.1%) i/s (234.17 ns/i) - 21.538M in 5.043465s
integer to_d 3.937M (± 6.7%) i/s (254.03 ns/i) - 19.771M in 5.022536s
integer string new 5.491M (± 1.7%) i/s (182.11 ns/i) - 27.511M in 5.010070s
integer string to_d 4.985M (± 0.5%) i/s (200.61 ns/i) - 25.260M in 5.067219s
Comparison:
integer string new: 5491160.4 i/s
integer string to_d: 4984891.5 i/s - 1.10x slower
integer new: 4270484.2 i/s - 1.29x slower
integer to_d: 3936547.2 i/s - 1.39x slower
$ ruby -v code/bigdecimal/integer-string-vs-numeric.rb
ruby 3.4.10 (2026-06-30 revision 2b0b7728dc) +PRISM [aarch64-linux]
Warming up --------------------------------------
integer new 724.240k i/100ms
integer to_d 669.146k i/100ms
integer string new 476.320k i/100ms
integer string to_d 473.860k i/100ms
Calculating -------------------------------------
integer new 8.201M (± 8.4%) i/s (121.94 ns/i) - 41.282M in 5.033937s
integer to_d 7.789M (± 1.9%) i/s (128.39 ns/i) - 39.480M in 5.068714s
integer string new 4.675M (± 6.1%) i/s (213.88 ns/i) - 23.816M in 5.093797s
integer string to_d 4.537M (± 9.6%) i/s (220.43 ns/i) - 22.745M in 5.013831s
Comparison:
integer new: 8200675.5 i/s
integer to_d: 7788881.6 i/s - same-ish: difference falls within error
integer string new: 4675490.6 i/s - 1.75x slower
integer string to_d: 4536507.4 i/s - 1.81x slower
$ ruby -v code/bigdecimal/integer-string-vs-numeric.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
integer new 833.601k i/100ms
integer to_d 998.642k i/100ms
integer string new 612.931k i/100ms
integer string to_d 622.024k i/100ms
Calculating -------------------------------------
integer new 11.461M (± 8.4%) i/s (87.25 ns/i) - 57.518M in 5.018754s
integer to_d 9.982M (± 7.9%) i/s (100.18 ns/i) - 49.932M in 5.002014s
integer string new 6.318M (± 0.8%) i/s (158.29 ns/i) - 31.872M in 5.045082s
integer string to_d 6.048M (± 7.3%) i/s (165.34 ns/i) - 30.479M in 5.039416s
Comparison:
integer new: 11460706.3 i/s
integer to_d: 9982400.0 i/s - same-ish: difference falls within error
integer string new: 6317520.9 i/s - 1.81x slower
integer string to_d: 6048156.9 i/s - 1.89x slower
$ ruby -v code/bigdecimal/float-string-vs-numeric.rb
ruby 2.5.9p229 (2021-04-05 revision 67939) [aarch64-linux]
Warming up --------------------------------------
float new 156.784k i/100ms
float to_d 140.804k i/100ms
float string new 544.740k i/100ms
float string to_d 489.796k i/100ms
Calculating -------------------------------------
float new 1.571M (± 1.7%) i/s (636.41 ns/i) - 7.996M in 5.088751s
float to_d 1.443M (± 1.3%) i/s (693.24 ns/i) - 7.322M in 5.075776s
float string new 5.430M (± 0.9%) i/s (184.16 ns/i) - 27.237M in 5.016063s
float string to_d 4.714M (± 8.8%) i/s (212.13 ns/i) - 24.000M in 5.091113s
Comparison:
float string new: 5429956.2 i/s
float string to_d: 4714097.3 i/s - 1.15x slower
float new: 1571305.9 i/s - 3.46x slower
float to_d: 1442500.1 i/s - 3.76x slower
$ ruby -v code/bigdecimal/float-string-vs-numeric.rb
ruby 3.4.10 (2026-06-30 revision 2b0b7728dc) +PRISM [aarch64-linux]
Warming up --------------------------------------
float new 562.944k i/100ms
float to_d 515.554k i/100ms
float string new 464.840k i/100ms
float string to_d 383.190k i/100ms
Calculating -------------------------------------
float new 6.390M (± 1.2%) i/s (156.50 ns/i) - 32.088M in 5.021892s
float to_d 5.731M (± 2.4%) i/s (174.50 ns/i) - 28.871M in 5.037882s
float string new 4.741M (± 2.3%) i/s (210.93 ns/i) - 23.707M in 5.000438s
float string to_d 4.826M (± 1.7%) i/s (207.19 ns/i) - 24.141M in 5.001873s
Comparison:
float new: 6389585.0 i/s
float to_d: 5730786.4 i/s - 1.11x slower
float string to_d: 4826386.1 i/s - 1.32x slower
float string new: 4740952.5 i/s - 1.35x slower
$ ruby -v code/bigdecimal/float-string-vs-numeric.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
float new 808.735k i/100ms
float to_d 710.639k i/100ms
float string new 603.015k i/100ms
float string to_d 589.930k i/100ms
Calculating -------------------------------------
float new 7.953M (± 3.4%) i/s (125.74 ns/i) - 40.437M in 5.084493s
float to_d 7.089M (± 7.2%) i/s (141.06 ns/i) - 35.532M in 5.012103s
float string new 6.205M (± 2.2%) i/s (161.16 ns/i) - 31.357M in 5.053567s
float string to_d 6.022M (± 4.0%) i/s (166.06 ns/i) - 30.676M in 5.093998s
Comparison:
float new: 7952955.5 i/s
float to_d: 7089229.6 i/s - 1.12x slower
float string new: 6204880.6 i/s - 1.28x slower
float string to_d: 6022060.1 i/s - 1.32x slower
Date
Date.iso8601 vs Date.parse code
When expecting well-formatted data from e.g. an API, iso8601 is faster and will raise an ArgumentError on malformed input.
$ ruby -v code/date/iso8601-vs-parse.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Date.iso8601 195.684k i/100ms
Date.parse 62.633k i/100ms
Calculating -------------------------------------
Date.iso8601 2.008M (± 0.8%) i/s (497.99 ns/i) - 10.176M in 5.067673s
Date.parse 627.349k (± 0.7%) i/s (1.59 μs/i) - 3.194M in 5.092000s
Comparison:
Date.iso8601: 2008075.4 i/s
Date.parse: 627349.2 i/s - 3.20x slower
Hash
Hash#[] vs Hash#fetch code
If you use Ruby 2.2, Symbol could be more performant than String as Hash keys.
Read more regarding this: Symbol GC in Ruby 2.2 and Unraveling String Key Performance in Ruby 2.2.
$ ruby -v code/hash/bracket-vs-fetch.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#[], symbol 3.471M i/100ms
Hash#fetch, symbol 2.869M i/100ms
Hash#[], string 1.969M i/100ms
Hash#fetch, string 1.746M i/100ms
Calculating -------------------------------------
Hash#[], symbol 34.983M (± 0.8%) i/s (28.59 ns/i) - 177.026M in 5.060743s
Hash#fetch, symbol 28.927M (± 1.1%) i/s (34.57 ns/i) - 146.331M in 5.059120s
Hash#[], string 19.711M (± 1.7%) i/s (50.73 ns/i) - 100.431M in 5.096713s
Hash#fetch, string 17.825M (± 1.4%) i/s (56.10 ns/i) - 90.775M in 5.093555s
Comparison:
Hash#[], symbol: 34982573.5 i/s
Hash#fetch, symbol: 28927450.2 i/s - 1.21x slower
Hash#[], string: 19710678.7 i/s - 1.77x slower
Hash#fetch, string: 17825222.3 i/s - 1.96x slower
Hash#dig vs Hash#[] vs Hash#fetch code
Ruby 2.3 introduced Hash#dig which is a readable
and performant option for retrieval from a nested hash, returning nil if an extraction step fails.
See #102 (comment) for more info.
$ ruby -v code/hash/dig-vs-[]-vs-fetch.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#dig 1.939M i/100ms
Hash#[] 1.903M i/100ms
Hash#[] || 1.787M i/100ms
Hash#[] && 725.944k i/100ms
Hash#fetch 1.246M i/100ms
Hash#fetch fallback 803.269k i/100ms
Calculating -------------------------------------
Hash#dig 19.434M (± 0.8%) i/s (51.46 ns/i) - 98.877M in 5.088095s
Hash#[] 19.005M (± 2.2%) i/s (52.62 ns/i) - 95.141M in 5.008511s
Hash#[] || 17.879M (± 0.7%) i/s (55.93 ns/i) - 91.138M in 5.097648s
Hash#[] && 7.303M (± 0.6%) i/s (136.93 ns/i) - 37.023M in 5.069773s
Hash#fetch 12.634M (± 2.0%) i/s (79.15 ns/i) - 63.570M in 5.033708s
Hash#fetch fallback 8.117M (± 1.0%) i/s (123.20 ns/i) - 40.967M in 5.047539s
Comparison:
Hash#dig: 19434078.6 i/s
Hash#[]: 19004999.7 i/s - same-ish: difference falls within error
Hash#[] ||: 17879337.5 i/s - 1.09x slower
Hash#fetch: 12633982.2 i/s - 1.54x slower
Hash#fetch fallback: 8116930.3 i/s - 2.39x slower
Hash#[] &&: 7302991.9 i/s - 2.66x slower
Hash[] vs Hash#dup code
Source: https://tenderlovemaking.com/2015/02/11/weird-stuff-with-hashes/
Does this mean that you should switch to Hash[]?
Only if your benchmarks can prove that it’s a bottleneck.
Please please please don’t change all of your code because
this shows it’s faster. Make sure to measure your app performance first.
$ ruby -v code/hash/bracket-vs-dup.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash[] 684.060k i/100ms
Hash#dup 612.214k i/100ms
Calculating -------------------------------------
Hash[] 7.555M (± 2.8%) i/s (132.37 ns/i) - 38.307M in 5.074888s
Hash#dup 5.851M (± 2.1%) i/s (170.90 ns/i) - 29.386M in 5.024310s
Comparison:
Hash[]: 7554758.4 i/s
Hash#dup: 5851408.7 i/s - 1.29x slower
Hash#fetch with argument vs Hash#fetch + block code
Note that the speedup in the block version comes from avoiding repeated
construction of the argument. If the argument is a constant, number symbol or
something of that sort the argument version is actually slightly faster
See also #39 (comment)
$ ruby -v code/hash/fetch-vs-fetch-with-block.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#fetch + const 3.136M i/100ms
Hash#fetch + block 3.313M i/100ms
Hash#fetch + arg 2.266M i/100ms
Calculating -------------------------------------
Hash#fetch + const 32.198M (± 1.0%) i/s (31.06 ns/i) - 163.090M in 5.065722s
Hash#fetch + block 33.319M (± 1.1%) i/s (30.01 ns/i) - 168.953M in 5.071324s
Hash#fetch + arg 22.838M (± 1.3%) i/s (43.79 ns/i) - 115.561M in 5.060964s
Comparison:
Hash#fetch + block: 33319415.6 i/s
Hash#fetch + const: 32198246.2 i/s - 1.03x slower
Hash#fetch + arg: 22837560.4 i/s - 1.46x slower
Hash#each_key instead of Hash#keys.each code
Hash#keys.each allocates an array of keys;
Hash#each_key iterates through the keys without allocating a new array.
This is the reason why Hash#each_key exists.
—— @sferik rails/rails#17099
$ ruby -v code/hash/keys-each-vs-each_key.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#keys.each 494.495k i/100ms
Hash#each_key 510.269k i/100ms
Calculating -------------------------------------
Hash#keys.each 5.026M (± 0.5%) i/s (198.95 ns/i) - 25.219M in 5.017574s
Hash#each_key 5.118M (± 1.2%) i/s (195.39 ns/i) - 26.024M in 5.085610s
Comparison:
Hash#each_key: 5117890.6 i/s
Hash#keys.each: 5026302.4 i/s - 1.02x slower
Hash#key? instead of Hash#keys.include? code
Hash#keys.include? allocates an array of keys and performs an O(n) search;
Hash#key? performs an O(1) hash lookup without allocating a new array.
$ ruby -v code/hash/keys-include-vs-key.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#keys.include? 2.217k i/100ms
Hash#key? 2.683M i/100ms
Calculating -------------------------------------
Hash#keys.include? 26.005k (± 5.6%) i/s (38.45 μs/i) - 130.803k in 5.047937s
Hash#key? 26.686M (± 1.3%) i/s (37.47 ns/i) - 134.156M in 5.028106s
Comparison:
Hash#key?: 26685586.3 i/s
Hash#keys.include?: 26005.2 i/s - 1026.16x slower
Hash#value? instead of Hash#values.include? code
Hash#values.include? allocates an array of values and performs an O(n) search;
Hash#value? performs an O(n) search without allocating a new array.
$ ruby -v code/hash/values-include-vs-value.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#values.include? 5.620k i/100ms
Hash#value? 7.474k i/100ms
Calculating -------------------------------------
Hash#values.include? 62.053k (± 2.8%) i/s (16.12 μs/i) - 314.720k in 5.076009s
Hash#value? 71.151k (± 4.4%) i/s (14.05 μs/i) - 358.752k in 5.051774s
Comparison:
Hash#value?: 71150.8 i/s
Hash#values.include?: 62052.8 i/s - 1.15x slower
Hash#values.compact instead of Hash#values.select or Hash#select.values (to get non-nil values) code
To collect the non-nil values of a hash, Hash#select { |_k, v| !v.nil? }.values allocates an intermediate hash before extracting its values;
Hash#values.select { |v| !v.nil? } skips the intermediate hash but still runs a block per element;
Hash#values.compact drops the nils in C without a Ruby-level block, which is fastest.
$ ruby -v code/hash/select-values-vs-values-select-vs-values-compact.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin25]
Warming up --------------------------------------
Hash#select.values 2.887k i/100ms
Hash#values.select 3.526k i/100ms
Hash#values.compact 57.606k i/100ms
Calculating -------------------------------------
Hash#select.values 29.102k (± 1.3%) i/s (34.36 μs/i) - 147.237k in 5.060206s
Hash#values.select 35.490k (± 0.7%) i/s (28.18 μs/i) - 179.826k in 5.067223s
Hash#values.compact 580.469k (± 4.2%) i/s (1.72 μs/i) - 2.938M in 5.070648s
Comparison:
Hash#values.compact: 580468.7 i/s
Hash#values.select: 35489.9 i/s - 16.36x slower
Hash#select.values: 29101.7 i/s - 19.95x slower
$ ruby -v code/hash/select-values-vs-values-select-vs-values-compact.rb
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [aarch64-linux]
Warming up --------------------------------------
Hash#values.compact 58.469k i/100ms
Hash#values.select 2.835k i/100ms
Hash#select.values 2.604k i/100ms
Calculating -------------------------------------
Hash#values.compact 598.295k (± 1.7%) i/s (1.67 μs/i) - 3.040M in 5.081752s
Hash#values.select 28.417k (± 3.1%) i/s (35.19 μs/i) - 144.585k in 5.087922s
Hash#select.values 25.617k (± 3.7%) i/s (39.04 μs/i) - 130.200k in 5.082509s
Comparison:
Hash#values.compact: 598295.2 i/s
Hash#values.select: 28417.3 i/s - 21.05x slower
Hash#select.values: 25617.3 i/s - 23.36x slower
Hash#merge! vs Hash#[]= code
$ ruby -v code/hash/merge-bang-vs-[]=.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#merge! 8.974k i/100ms
Hash#[]= 20.052k i/100ms
Calculating -------------------------------------
Hash#merge! 91.391k (± 0.5%) i/s (10.94 μs/i) - 457.674k in 5.008010s
Hash#[]= 202.686k (± 0.9%) i/s (4.93 μs/i) - 1.023M in 5.045877s
Comparison:
Hash#[]=: 202686.0 i/s
Hash#merge!: 91390.8 i/s - 2.22x slower
Hash#update vs Hash#[]= code
$ ruby -v code/hash/update-vs-[]=.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#[]= 19.739k i/100ms
Hash#update 9.126k i/100ms
Calculating -------------------------------------
Hash#[]= 202.714k (± 1.1%) i/s (4.93 μs/i) - 1.026M in 5.064063s
Hash#update 91.615k (± 0.7%) i/s (10.92 μs/i) - 465.426k in 5.080450s
Comparison:
Hash#[]=: 202713.9 i/s
Hash#update: 91615.2 i/s - 2.21x slower
Hash#merge vs Hash#**other code
$ ruby -v code/hash/merge-vs-double-splat-operator.rb
ruby 4.0.0 (2025-12-25 revision 553f1675f3) +PRISM [arm64-darwin24]
Warming up --------------------------------------
Hash#**other 979.615k i/100ms
Hash#merge 798.516k i/100ms
Calculating ---------------------------------
> README 内容过长，已截取前 64 KB。完整内容请前往 GitHub 仓库查看。
评论