Hidden features of Ruby

One trick I like is to use the splat (`*`) expander on objects other than Arrays. Here's an example on a regular expression match:

match, text, number = *"Something 981".match(/([A-z]*) ([0-9]*)/)

Other examples include:

a, b, c = *('A'..'Z')

Job = Struct.new(:name, :occupation)
tom = Job.new("Tom", "Developer")
name, occupation = *tom

To combine multiple regexes with `|`, you can use

Regexp.union /Ruby\d/, /test/i, "cheat"

to create a Regexp similar to:

/(Ruby\d|[tT][eE][sS][tT]|cheat)/

private unless Rails.env == 'test'
# e.g. a bundle of methods you want to test directly
Looks like a cool and (in some cases) nice/useful hack/feature of Ruby.

Another tiny feature - convert a `Fixnum` into any base up to 36:

>> 1234567890.to_s(2)
=> "1001001100101100000001011010010"

>> 1234567890.to_s(8)
=> "11145401322"

>> 1234567890.to_s(16)
=> "499602d2"

>> 1234567890.to_s(24)
=> "6b1230i"

>> 1234567890.to_s(36)
=> "kf12oi"

And as Huw Walters has commented, converting the other way is just as simple:

>> "kf12oi".to_i(36)
=> 1234567890

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)

I just read all the answers... one notable omission was destructuring assignment:

> (a,b),c = [[1,2],3]
=> [[1,2],3]
> a
=> 1

It also works for block parameters. This is useful when you have nested arrays, each element of which represents something distinct. Instead of writing code like "array[0][1]", you can break that nested array down and give a descriptive name to each element, in a single line of code.

The sprintf shortcut
--------------------

My favourite ruby feature. Syntax is `format_string % argument`

"%04d" % 1 # => "0001"
"%0.2f" % Math::PI # => "3.14"

Works as well for arrays (`format_string % array_of_arguments`)

"%.2f %.3f %.4f" % ([Math::PI]*3)
# => "3.14 3.142 3.1416"