@weekly_ruby_tip

One ruby tip every week ~by @squadracer

squadracer.com/
Joined August 2023
  • Tweets217
  • Following0
  • Followers39
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
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
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
||= 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
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
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
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
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
⚠️ 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
**{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
Load more