Hidden features of Ruby

Question

Continuing the "Hidden features of ..." meme, let's share the lesser-known but useful features of Ruby programming language.

Try to limit this discussion with core Ruby, without any Ruby on Rails stuff.

See also:

• Hidden features of C#
• Hidden features of Java
• Hidden features of JavaScript
• Hidden features of Ruby on Rails
• Hidden features of Python

(Please, just one hidden feature per answer.)

Thank you

Answer 1

Wow, no one mentioned the flip flop operator:

1.upto(100) do |i|
  puts i if (i == 3)..(i == 15)
end

Answer 2

create an array of consecutive numbers:

x = [*0..5]

sets x to [0, 1, 2, 3, 4, 5]

Answer 3

From Ruby 1.9 Proc#=== is an alias to Proc#call, which means Proc objects can be used in case statements like so:

def multiple_of(factor)
  Proc.new{|product| product.modulo(factor).zero?}
end

case number
  when multiple_of(3)
    puts "Multiple of 3"
  when multiple_of(7)
    puts "Multiple of 7"
end

Answer 4

One of the cool things about ruby is that you can call methods and run code in places other languages would frown upon, such as in method or class definitions.

For instance, to create a class that has an unknown superclass until run time, i.e. is random, you could do the following:

class RandomSubclass < [Array, Hash, String, Fixnum, Float, TrueClass].sample

end

RandomSubclass.superclass # could output one of 6 different classes.

This uses the 1.9 Array#sample method (in 1.8.7-only, see Array#choice), and the example is pretty contrived but you can see the power here.

Another cool example is the ability to put default parameter values that are non fixed (like other languages often demand):

def do_something_at(something, at = Time.now)
   # ...
end

Of course the problem with the first example is that it is evaluated at definition time, not call time. So, once a superclass has been chosen, it stays that superclass for the remainder of the program.

However, in the second example, each time you call do_something_at, the at variable will be the time that the method was called (well, very very close to it)

Answer 5

Fixnum#to_s(base) can be really useful in some case. One such case is generating random (pseudo)unique tokens by converting random number to string using base of 36.

Token of length 8:

rand(36**8).to_s(36) => "fmhpjfao"
rand(36**8).to_s(36) => "gcer9ecu"
rand(36**8).to_s(36) => "krpm0h9r"

Token of length 6:

rand(36**6).to_s(36) => "bvhl8d"
rand(36**6).to_s(36) => "lb7tis"
rand(36**6).to_s(36) => "ibwgeh"

Answer 6

I'm late to the party, but:

You can easily take two equal-length arrays and turn them into a hash with one array supplying the keys and the other the values:

a = [:x, :y, :z]
b = [123, 456, 789]

Hash[a.zip(b)]
# => { :x => 123, :y => 456, :z => 789 }

(This works because Array#zip "zips" up the values from the two arrays:

a.zip(b)  # => [[:x, 123], [:y, 456], [:z, 789]]

And Hash[] can take just such an array. I've seen people do this as well:

Hash[*a.zip(b).flatten]  # unnecessary!

Which yields the same result, but the splat and flatten are wholly unnecessary--perhaps they weren't in the past?)