@weekly_ruby_tip

One ruby tip every week ~by @squadracer

squadracer.com/
Joined August 2023
  • Tweets217
  • Following0
  • Followers39
148Media
goruby Ruby not concise enough? In the source code, you’ll find a file called golf_prelude.rb. Include it in the compilation and you get goruby where each method has its own abbreviation, the String class behaves like an Array, … to be as concise as possible!
make golf make install bin/goruby say "abc".cm 2 # vs puts "abc".chars.combination(2).map(&:join) # => ab ac bc

ALT make golf make install bin/goruby say "abc".cm 2 # vs puts "abc".chars.combination(2).map(&:join) # => ab ac bc

1
31
Small reference in the Ruby documentation for goruby: ruby-doc.org/3.3.6/extension… squadracer.com/en/weeklytips…
17
casecmp Case insensitive comparison casecmp? compares 2 strings without taking case into account. When it comes to unicode characters, there are a few subtleties! With a non-compatible type, the method returns nil rather than an exception.
"Squadracer" == "squadraceR" # false "Squadracer".casecmp? "squadraceR" # true "ê".casecmp? "Ê" # true "ß".casecmp? "sS" # true "ß".upcase # "SS" "incompatible".casecmp? :type # nil

ALT "Squadracer" == "squadraceR" # false "Squadracer".casecmp? "squadraceR" # true "ê".casecmp? "Ê" # true "ß".casecmp? "sS" # true "ß".upcase # "SS" "incompatible".casecmp? :type # nil

1
17
There’s also the casecmp method for comparing 2 strings without taking case into account, but it returns -1, 0 or 1 (or nil if incompatible) which can be used to sort, for example.
"a".casecmp "B" # => -1 "b".casecmp "B" # => 0 "c".casecmp "B" # => 1 %w[C E B d a f].sort(&:casecmp) # => ["a", "B", "C", "d", "E", "f"]

ALT "a".casecmp "B" # => -1 "b".casecmp "B" # => 0 "c".casecmp "B" # => 1 %w[C E B d a f].sort(&:casecmp) # => ["a", "B", "C", "d", "E", "f"]

1
10
Links to Ruby documentation for casecmp? (ruby-doc.org/3.3.6/String.ht…) and casecmp (ruby-doc.org/3.3.6/String.ht…). squadracer.com/en/weeklytips…
14
||= vs defined? Cache false/nil ||= is the most common way of caching. Except that it doesn’t handle false and nil! defined? can be a solution by checking whether the variable is defined. ⚠️ Be sure to take into account when the parser defines the variable!
def m1 = @m1 ||= puts("called") def m2 = defined?(@m2) ? @m2 : @m2 = puts("called") m1 # nil (print called) m1 # nil (print called) m2 # nil (print called) m2 # nil

ALT def m1 = @m1 ||= puts("called") def m2 = defined?(@m2) ? @m2 : @m2 = puts("called") m1 # nil (print called) m1 # nil (print called) m2 # nil (print called) m2 # nil

1
36
Links to Ruby documentation for ||= (ruby-doc.org/3.3.6/syntax/as…) defined? (ruby-doc.org/3.3.6/syntax/mi…) squadracer.com/en/weeklytips…
19
local variable, a detail on how they work They are created when the parser encounters them, not dynamically at runtime! Furthermore, a if does not create a new scope, making variables accessible after the scope has ended. This is also the case for unless, while, until and for.
a = true if true b = false if false p a # true p b # nil

ALT a = true if true b = false if false p a # true p b # nil

1
29
A more interesting example highlighting the parser step. In the 1st if, the parser sees and creates the a variable after the condition, which will therefore be false at runtime. In the 2nd case, it sees and creates b before! (A if inline is therefore not equivalent!)
if defined?(a) a = true end b = true if defined?(b) p a # nil p b # true

ALT if defined?(a) a = true end b = true if defined?(b) p a # nil p b # true

1
13
Link to Ruby documentation for local variables: ruby-doc.org/3.3.6/syntax/as… squadracer.com/en/weeklytips…
11
tap For method chaining The tap method, defined in Kernel, returns self which is passed as a block argument. To be distinguished from then, which returns the result of the block.
2.tap { _1 * 3 } # 2 # vs 2.then { _1 * 3 } # 6

ALT 2.tap { _1 * 3 } # 2 # vs 2.then { _1 * 3 } # 6

1
1
26
The main benefit is to be able to alter the object in the method chain. Another use case is to be able to inspect an intermediate state without having to rewrite everything.
3.times.to_a.tap { _1[1] = 5 } # [0, 5, 2] # vs a = 3.times.to_a a[1] = 5 a # [0, 5, 2] 3.times .tap { p _1 } # #<Enumerator: 3:times> .map { _1 * 2 } .tap { p _1 } # [0, 2, 4] .filter(&:positive?) # [2, 4]

ALT 3.times.to_a.tap { _1[1] = 5 } # [0, 5, 2] # vs a = 3.times.to_a a[1] = 5 a # [0, 5, 2] 3.times .tap { p _1 } # #<Enumerator: 3:times> .map { _1 * 2 } .tap { p _1 } # [0, 2, 4] .filter(&:positive?) # [2, 4]

1
18
Link to Ruby documentation for tap: ruby-doc.org/3.3.5/Kernel.ht… squadracer.com/en/weeklytips…
20
**{double splat operator} The double splat operator (or keyword splat) has been around since Ruby 2.0. It’s the equivalent of the splat operator but for Hash.
{a: 1, **{b: 2}} # {:a=>1, :b=>2} {a: 1, **{}} # {:a=>1} def m(**options)= options m(a: 1, 2 => :b) # {:a=>1, 2=>:b} m({a: 1, 2 => :b}) # ArgumentError m(**{a: 1, 2 => :b}) # {:a=>1, 2=>:b}

ALT {a: 1, **{b: 2}} # {:a=>1, :b=>2} {a: 1, **{}} # {:a=>1} def m(**options)= options m(a: 1, 2 => :b) # {:a=>1, 2=>:b} m({a: 1, 2 => :b}) # ArgumentError m(**{a: 1, 2 => :b}) # {:a=>1, 2=>:b}

1
23
⚠️ There is a subtle difference with the splat operator. It doesn’t handle nil. Well, not yet, because after more than 10 years, it will in Ruby 3.4.0 (see Issue 20064: bugs.ruby-lang.org/issues/20…).
[*nil] # [] {**nil} # TypeError (< 3.4.0) {**nil} # {} (>= 3.4.0)

ALT [*nil] # [] {**nil} # TypeError (< 3.4.0) {**nil} # {} (>= 3.4.0)

1
11
Link to Ruby documentation for double splat operator: ruby-doc.org/3.3.5/syntax/ca… squadracer.com/en/weeklytips…
9
Need to speed up? Benchmark allows you to measure the execution time of a block with measure. You’ll find user and system CPU times, as well as the sum of the two. In brackets, the actual time. The unit is seconds. In this example, it’s long but not CPU-intensive.
require 'benchmark' puts Benchmark.measure { sleep 1 } # user time system time total real time # 0.000041 0.000026 0.000067 ( 1.005110)

ALT require 'benchmark' puts Benchmark.measure { sleep 1 } # user time system time total real time # 0.000041 0.000026 0.000067 ( 1.005110)

1
30
Comparing implementations is generally more interesting, and can be done with bm or bmbm. The bmbm is run twice to « warm up » the code for a more accurate result. For example, compare flat_map and map { ... }.flatten and check that flat_map is indeed faster.
require 'benchmark' result = Benchmark.bmbm do |bm| list = (0..1_000).to_a bm.report "flat_map" do list.flat_map { |x| [x, x * x] } end bm.report "map.flatten" do list.map { |x| [x, x * x] }.flatten end end puts result # Rehearsal ----------------------------------------------- # flat_map 0.000085 0.000000 0.000085 ( 0.000085) # map.flatten 0.000230 0.000001 0.000231 ( 0.000231) # -------------------------------------- total: 0.000316sec # # user system total real # flat_map 0.000080 0.000000 0.000080 ( 0.000078) # map.flatten 0.000215 0.000001 0.000216 ( 0.000214)

ALT require 'benchmark' result = Benchmark.bmbm do |bm| list = (0..1_000).to_a bm.report "flat_map" do list.flat_map { |x| [x, x * x] } end bm.report "map.flatten" do list.map { |x| [x, x * x] }.flatten end end puts result # Rehearsal ----------------------------------------------- # flat_map 0.000085 0.000000 0.000085 ( 0.000085) # map.flatten 0.000230 0.000001 0.000231 ( 0.000231) # -------------------------------------- total: 0.000316sec # # user system total real # flat_map 0.000080 0.000000 0.000080 ( 0.000078) # map.flatten 0.000215 0.000001 0.000216 ( 0.000214)

1
15
fast-ruby presents some interesting comparisons, like while vs loop, which do you think is faster? github.com/fastruby/fast-rub… Link to Ruby documentation for Benchmark: ruby-doc.org/3.3.5/stdlibs/b… squadracer.com/en/weeklytips…
16
rescue ... else A case to handle if there are no exceptions? Ruby allows default case handling only if there is no exception with else!
begin print 'begin ' rescue print 'rescue ' else print 'else ' end # begin else

ALT begin print 'begin ' rescue print 'rescue ' else print 'else ' end # begin else

1
15
more replies
The else is only allowed if there are rescue and can therefore be used wherever rescue can be used: block, method and even class!
def m else "else" end # else without rescue is useless (SyntaxError) class C 'really?' rescue 'why not' else 'everything good' end # "everything good"

ALT def m else "else" end # else without rescue is useless (SyntaxError) class C 'really?' rescue 'why not' else 'everything good' end # "everything good"

1
12
Link to Ruby documentation for exception handling: ruby-doc.org/3.3.5/syntax/ex… squadracer.com/en/weeklytips…
13
Load more