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:

(Please, just one hidden feature per answer.)

Thank you

+15  A: 

I find using the define_method command to dynamically generate methods to be quite interesting and not as well known. For example:

((0..9).each do |n|
    define_method "press_#{n}" do
      @number = @number.to_i * 10 + n

The above code uses the 'define_method' command to dynamically create the methods "press1" through "press9." Rather then typing all 10 methods which essentailly contain the same code, the define method command is used to generate these methods on the fly as needed.

The only problem with define_method is that it doesn't allow blocks to be passed as parameters in ruby 1.8. See [this blog post]( for a workaround.
Andrew Grimm
+5  A: 

The send() method is a general-purpose method that can be used on any Class or Object in Ruby. If not overridden, send() accepts a string and calls the name of the method whose string it is passed. For example, if the user clicks the “Clr” button, the ‘press_clear’ string will be sent to the send() method and the ‘press_clear’ method will be called. The send() method allows for a fun and dynamic way to call functions in Ruby.

 %w(7 8 9 / 4 5 6 * 1 2 3 - 0 Clr = +).each do |btn|
    button btn, :width => 46, :height => 46 do
      method = case btn
        when /[0-9]/: 'press_'+btn
        when 'Clr': 'press_clear'
        when '=': 'press_equals'
        when '+': 'press_add'
        when '-': 'press_sub'
        when '*': 'press_times'
        when '/': 'press_div'

      number_field.replace strong(number)

I talk more about this feature in Blogging Shoes: The Simple-Calc Application

Sounds like a great way to open a security hole.
I'd use symbols wherever possible.
+18  A: 

Download Ruby 1.9 source, and issue make golf, then you can do things like this:

make golf

./goruby -e 'h'
# => Hello, world!

./goruby -e 'p St'
# => StandardError

./goruby -e 'p'
# => 1.0

./goruby19 -e 'p Fil.exp(".")'

Read the golf_prelude.c for more neat things hiding away.

+8  A: 

use anything that responds to ===(obj) for case comparisons:

case foo
when /baz/
when 12..15
when lambda { |x| x % 5 == 0 }
  # only works in Ruby 1.9 or if you alias Proc#call as Proc#===
when Bar
when some_object

Module (and thus Class), Regexp, Date, and many other classes define an instance method :===(other), and can all be used.

Thanks to Farrel for the reminder of Proc#call being aliased as Proc#=== in Ruby 1.9.

James A. Rosen
+43  A: 

Peter Cooper has a good list of Ruby tricks. Perhaps my favorite of his is allowing both single items and collections to be enumerated. (That is, treat a non-collection object as a collection containing just that object.) It looks like this:

[*items].each do |item|
  # ...
James A. Rosen
i love this one :)
A more explicit (and thus nicer) form of this is Array(items).each
If `items` is a string you don't have to enclose it with [*…]. String.each doesn't iterate over characters as some may expect. It just returns itself to the block.
Max Howell
What use would this ever serve? Just curious.
Ed Swangren
@Ed: it's nice if you're writing a method and want to allow the user of the method to either pass a varargs list or an Array.
James A. Rosen
+6  A: 

How about opening a file based on ARGV[0]?


$<.each_line{|l| puts l}

ruby readfile.rb testfile.txt

It's a great shortcut for writing one-off scripts. There's a whole mess of pre-defined variables that most people don't know about. Use them wisely (read: don't litter a code base you plan to maintain with them, it can get messy).

Scott Holden
`ARGF` is a little more memorable than `$<`, IMHO.
Benjamin Oakes
+6  A: 

A lot of the magic you see in Rubyland has to do with metaprogramming, which is simply writing code that writes code for you. Ruby's attr_accessor, attr_reader, and attr_writer are all simple metaprogramming, in that they create two methods in one line, following a standard pattern. Rails does a whole lot of metaprogramming with their relationship-management methods like has_one and belongs_to.

But it's pretty simple to create your own metaprogramming tricks using class_eval to execute dynamically-written code.

The following example allows a wrapper object to forwards certain methods along to an internal object:

class Wrapper
  attr_accessor :internal

  def self.forwards(*methods)
    [*methods].each do |method|
        def #{method}(*args, &blk)
          self.internal.send(#{method.to_sym.inspect}, *args, &blk)

  forwards :to_i, :length, :split

w =
w.internal = "12 13 14"
puts w.to_i
puts w.length
puts w.split('1')

Note the use of [*methods] (pointed out elsewhere in this thread) to enumerate over the arguments given. Then, for each of those given, we use class_eval to create a new method whose job it is to send the message along, including all arguments and blocks.

A great resource for metaprogramming issues is Why the Lucky Stuff's "Seeing Metaprogramming Clearly".

I wish to dive head first into metaprogramming in ruby. Could you provide some references to get started with it (Other than the given link)? Books will do too. Thanks.
PragProg's videocasting serie "The Ruby Object Model and Metaprogramming" its a good introduction to meta programming using ruby:
+35  A: 

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){|product| product.modulo(factor).zero?}

case number
  when multiple_of(3)
    puts "Multiple of 3"
  when multiple_of(7)
    puts "Multuple of 7"
I actually wrote an gem at one point to do this, but my code was (a) a mess, and (b) slow. I'm very glad that the functionality has made it into core.
James A. Rosen
+6  A: 

Fool some class or module telling it has required something that it really hasn't required:

$" << "something"

This is useful for example when requiring A that in turns requires B but we don't need B in our code (and A won't use it either through our code):

For example, Backgroundrb's bdrb_test_helper requires 'test/spec', but you don't use it at all, so in your code:

$" << "test/spec"
require File.join(File.dirname(__FILE__) + "/../bdrb_test_helper")
Does this fix problems where gem A requires foo-1.0.0, and gem B requires foo-1.0.1?
Andrew Grimm
No because "something"'s code won't be available: this only simulates that "something" is required, but it is really doesn't require it.$" is an array containing the module names loaded by require (it's used by require to prevent loading modules twice). So, if you use this to fool gems, that will produce a crash when the gems try to use the actual "something" code, because it won't exist.You may instead want to force laoding a concrete version of a gem (eg foo-1.0.0), instead of the latest one:
+13  A: 

The Symbol#to_proc function that Rails provides is really cool.

Instead of

Employee.collect { |emp| }

You can write:

This is, apparently, an "order of magnitude slower" than using a block.
Charles Roper
I just tried it out, and found there was no significant difference between the two. I'm not sure where this "order of magnitude" stuff came from. (Using Ruby 1.8.7)
Matt Grande
Doing this outside of Rails is also handy and can be done with `require 'activesupport'` since that's actually where most of these helpers are from.
Steve Graham
@thenduks: And it can be done without activesupport's help in ruby 1.8.7 and 1.9.
Andrew Grimm
+16  A: 

Warning: this item was voted #1 Most Horrendous Hack of 2008, so use with care. Actually, avoid it like the plague, but it is most certainly Hidden Ruby.

Superators Add New Operators to Ruby

Ever want a super-secret handshake operator for some unique operation in your code? Like playing code golf? Try operators like -~+~- or <--- That last one is used in the examples for reversing the order of an item.

I have nothing to do with the Superators Project beyond admiring it.

Ha ha ha, proper hack!
+19  A: 

Another fun addition in 1.9 Proc functionality is Proc#curry which allows you to turn a Proc accepting n arguments into one accepting n-1. Here it is combined with the Proc#=== tip I mentioned above:

it_is_day_of_week = lambda{ |day_of_week, date| date.wday == day_of_week }
it_is_saturday = it_is_day_of_week.curry[6]
it_is_sunday = it_is_day_of_week.curry[0]

when it_is_saturday
  puts "Saturday!"
when it_is_sunday
  puts "Sunday!"
  puts "Not the weekend"
+32  A: 

Don't know how hidden this is, but I've found it useful when needing to make a Hash out of a one-dimensional array:

fruit = ["apple","red","banana","yellow"]
=> ["apple", "red", "banana", "yellow"]

=> {"apple"=>"red", "banana"=>"yellow"}
:O Thanks for this one, it's just the thing I'm looking for
Chris Salij
+34  A: 

One trick I like it 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 =, :occupation)
tom ="Tom", "Developer")
name, occupation = *tom
Incidentally, for the curious, this works by implicitly calling to_a on the target of the splat.
Bob Aman
If you're not interested in the match, you can have `text, number = *"text 555".match(/regexp/)[1..-1]`.
Andrew Grimm
`text, number = "Something 981".scan(/([A-z]*) ([0-9]*)/){|m| Integer(m) rescue m}`
Jonas Elfström
Both good tricks, but there's got to be a point where it's too much magic, right?!
+22  A: 

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"
+13  A: 

One final one - in ruby you can use any character you want to delimit strings. Take the following code:

message = "My message"
contrived_example = "<div id=\"contrived\">#{message}</div>"

If you don't want to escape the double-quotes within the string, you can simply use a different delimiter:

contrived_example = %{<div id="contrived-example">#{message}</div>}
contrived_example = %[<div id="contrived-example">#{message}</div>]

As well as avoiding having to escape delimiters, you can use these delimiters for nicer multiline strings:

sql = %{
    SELECT strings 
    FROM complicated_table
    WHERE complicated_condition = '1'
not *any* character, but it's still pretty cool.It also works with other literals:%() / %{} / %[] / %<> / %||%r() / %r{} / %r[] / %r<> / %r||%w() / %w{} / %w[] / %w<> / %w||
+14  A: 


Module methods that are declared as *module_function* will create copies of themselves as private instance methods in the class that includes the Module:

module M
  def not!
  module_function :not!

class C
  include M

  def fun

M.not!     # => 'not!  # => 'not!'! # => NoMethodError: private method `not!' called for #<C:0x1261a00>

If you use *module_function* without any arguments, then any module methods that comes after the module_function statement will automatically become module_functions themselves.

module M

  def not!

  def yea!

class C
  include M

  def fun
    not! + ' ' + yea!
M.not!     # => 'not!'
M.yea!     # => 'yea!'  # => 'not! yea!'
If you just want to declare private methods in modules, just use the private keyword. In addition to making the method private in classes that include the module, module_function copies the method to the module instance. In most cases this is not what you want.
I know you can just use private. But this is a question on Ruby's hidden features. And, I think most people have never heard of module_function (myself included) until they see it in the doc and start to play around with it.
+7  A:

Create a new class at run time. The argument can be a class to derive from, and the block is the class body. You might also want to look at const_set/const_get/const_defined? to get your new class properly registered, so that inspect prints out a name instead of a number.

Not something you need every day, but quite handy when you do.

Justin Love
`MyClass = Array do; def hi; 'hi'; end; end` seems to be equivalent to `class MyClass < Array; def hi; 'hi'; end; end`.
Probably more true than I had thought about. It even appears that you can inherit from a variable rather than only a constant. However, the sugared version (second) doesn't appear to work if you need to construct the class name at run time. (Baring eval, of course.)
Justin Love
+2  A: 

Ruby has a call/cc mechanism allowing one to freely hop up and down the stack.

Simple example follows. This is certainly not how one would multiply a sequence in ruby, but it demonstrates how one might use call/cc to reach up the stack to short-circuit an algorithm. In this case, we're recursively multiplying a list of numbers until we either have seen every number or we see zero (the two cases where we know the answer). In the zero case, we can be arbitrarily deep in the list and terminate.

#!/usr/bin/env ruby

def rprod(k, rv, current, *nums)
  puts "#{rv} * #{current}" if current == 0 || rv == 0
  nums.empty? ? (rv * current) : rprod(k, rv * current, *nums)

def prod(first, *rest)
  callcc { |k| rprod(k, first, *rest) }

puts "Seq 1:  #{prod(1, 2, 3, 4, 5, 6)}"
puts ""
puts "Seq 2:  #{prod(1, 2, 0, 3, 4, 5, 6)}"

You can see the output here:

For a more complex example featuring continuations moving the other direction on the stack, read the source to Generator.

One shouldn't use callcc. From Matz' book:Implementation difficulties prevent other implementations of Ruby (such as JRuby, the Java-based implementation) from supporting continuations. Because they are no longer well supported, continuations should be considered a curiosity, and new Ruby code should not use them.
Marc-André Lafortune
+17  A: 

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].choice


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

This uses the 1.8.7 Array#choice method, 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 =
   # ...

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)

Note: Array#rand is provided by ActiveSupport which you can use outside of Rails as easily as `require 'activesupport'`
insanity! thank you,
Array#choice is in 1.8.7
Array#choice is 1.8.7 _only_! Don't use it, it's gone in 1.9 and will be gone in 1.8.8. Use #sample
Marc-André Lafortune
This language is impossible.
python: class DictList([dict,list][random.randint(0,1)]): pass
Anurag Uniyal
+1  A: 
class A


  def my_private_method
    puts 'private method called'

a =
a.my_private_method # Raises exception saying private method was called
a.send :my_private_method # Calls my_private_method and prints private method called'
you can also use instance_eval to get to private methods and variables.
Right. But the question is, should it be allowed? It completely violates the principle of encapsulation.
Never knew about this :)
There's a ton of libraries out there that've taken advantage of this "feature" I'm afraid.
Bob Aman
The purpose of private methods is to hide them from general use so that if/when they change, code doesn't break. If you know what you are doing - go ahead and call a private method. The fact that Ruby forces you to use the quite different looking call (with .send) makes it obvious that this call is special. Most dynamic languages let you circumvent private method definitions because sometimes it's handy.
@Sporkmonger if thats true then, all those libraries would break from Ruby 1.9 onwards.
Visibility rules in most languages are meant to protect you from mistakes, not fraud, as Stroustrop said.
Add this to "Ruby Worst Practices" list.
@everyone who hates this: its obviously a hack. you shouldn't use it except as a last resort, just like all other hacks, but when you do need it, you will be pretty glad its there, again, just like all other hacks.
Matt Briggs
@macek: I want to ask a question on abusing ruby for fun and profit!
Andrew Grimm
yeah they should really require you to call "send_private" or something, to make this more obvious...
@rogerdpack: There's `send_public` if you only want to send it to a public method. There don't seem to be equivalents for private or protected though...
Andrew Grimm
+10  A: 

Short inject, like such:

Sum of range:

=> 55
Worth noting you need Ruby 1.9 or Rails with Ruby 1.8 for this to work.
Max Howell
@Max Howell: or `require 'backports'` :-)
Marc-André Lafortune
Isn't this a duplicate of hoyhoy's answer?
Andrew Grimm
+14  A: 

Hashes with default values! An array in this case.

parties = {|hash, key| hash[key] = [] }
parties["Summer party"]
# => []

parties["Summer party"] << "Joe"
parties["Other party"] << "Jane"

Very useful in metaprogramming.

August Lilleaas
yeah true. Ruby hash can accept '<<' operator if there's already default value assign with '=' (don't care even if it's empty assignment) otherwise the hash wont accept '<<'. CMIIW
+5  A: 

I find this useful in some scripts. It makes it possible to use environment variables directly, like in shell scripts and Makefiles. Environment variables are used as fall-back for undefined Ruby constants.

>> class <<Object
>>  alias :old_const_missing :const_missing
>>  def const_missing(sym)
>>   ENV[sym.to_s] || old_const_missing(sym)
>>  end
>> end
=> nil

>> puts SHELL
=> nil
>> TERM == 'xterm'
=> true
+5  A: 

create an array of consecutive numbers:

x = [*0..5]

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

And so does `x=(0..5).to_a`
Jonas Elfström
Yep,but it's not as short and sweet ;)
+6  A: 

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]

# => { :x => 123, :y => 456, :z => 789 }

(This works because Array#zip "zips" up the values from the two arrays:  # => [[:x, 123], [:y, 456], [:z, 789]]

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

Hash[*]  # unnecessary!

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

This was indeed undocumented for a long while (see ). Note that this new form is new to Ruby 1.8.7
Marc-André Lafortune
+9  A: 

Use a Range object as an infinite lazy list:

Inf = 1.0 / 0

(1..Inf).take(5) #=> [1, 2, 3, 4, 5]

More info here:

+14  A: 

Boolean operators on non boolean values.

&& and ||

Both return the value of the last expression evaluated.

Which is why the ||= will update the variable with the value returned expression on the right side if the variable is undefined. This is not explicitly documented, but common knowledge.

However the &&= isn't quite so widely known about.

string &&= string + "suffix"

is equivalent to

if string
  string = string + "suffix"

It's very handy for destructive operations that should not proceed if the variable is undefined.

+2  A: 

James A. Rosen's tip is cool ([*items].each), but I find that it destroys hashes:

irb(main):001:0> h = {:name => "Bob"}
=> {:name=>"Bob"}
irb(main):002:0> [*h]
=> [[:name, "Bob"]]

I prefer this way of handling the case when I accept a list of things to process but am lenient and allow the caller to supply one:

irb(main):003:0> h = {:name => "Bob"}
=> {:name=>"Bob"}
irb(main):004:0> [h].flatten
=> [{:name=>"Bob"}]

This can be combined with a method signature like so nicely:

def process(*entries)
  [entries].flatten.each do |e|
    # do something with e
+4  A: 

The "ruby" binary (at least MRI's) supports a lot of the switches that made perl one-liners quite popular.

Significant ones:

  • -n Sets up an outer loop with just "gets" - which magically works with given filename or STDIN, setting each read line in $_
  • -p Similar to -n but with an automatic puts at the end of each loop iteration
  • -a Automatic call to .split on each input line, stored in $F
  • -i In-place edit input files
  • -l Automatic call to .chomp on input
  • -e Execute a piece of code
  • -c Check source code
  • -w With warnings

Some examples:

# Print each line with its number:
ruby -ne 'print($., ": ", $_)' < /etc/irbrc

# Print each line reversed:
ruby -lne 'puts $_.reverse' < /etc/irbrc

# Print the second column from an input CSV (dumb - no balanced quote support etc):
ruby -F, -ane 'puts $F[1]' < /etc/irbrc

# Print lines that contain "eat"
ruby -ne 'puts $_ if /eat/i' < /etc/irbrc

# Same as above:
ruby -pe 'next unless /eat/i' < /etc/irbrc

# Pass-through (like cat, but with possible line-end munging):
ruby -p -e '' < /etc/irbrc

# Uppercase all input:
ruby -p -e '$_.upcase!' < /etc/irbrc

# Same as above, but actually write to the input file, and make a backup first with extension .bak - Notice that inplace edit REQUIRES input files, not an input STDIN:
ruby -i.bak -p -e '$_.upcase!' /etc/irbrc

Feel free to google "ruby one-liners" and "perl one-liners" for tons more usable and practical examples. It essentially allows you to use ruby as a fairly powerful replacement to awk and sed.

+10  A: 

Auto-vivifying hashes in Ruby

def cnh # silly name "create nested hash" {|h,k| h[k] =}
my_hash = cnh
my_hash[1][2][3] = 4
my_hash # => { 1 => { 2 => { 3 =>4 } } }

This can just be damn handy.

+4  A: 

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"
+4  A: 

I just love the inline keyword rescue like this:

@user #=> nil (but I did't know) rescue "Unknown"
link_to(, url_user(, rescue 'Account removed'

This avoid breaking my App and is way better than the feature released at Rails .try()

Fabiano PS
a good way to hide bugs
Yep, also a great way to silently break the app.. one must be really careful using!
Fabiano PS
How is it better than the `NilClass#try` method?. `try` specifically is for this case and is explicit that you are protecting against unexpected `nil`s instead of any exception. Inline `rescue` does have its place, but it isn't here, imo. A better way to solve your problem would be: `@user.try(:name) || "Unknown"`. Same result, but much clearer and safer.
In the comments of a duplicate answer, Joe Martinez suggests using the "andand" gem.
Andrew Grimm
Sometimes I use .try, but all it does is return nil, sometimes, it is not enough
Fabiano PS
+1  A: 
@user #=> nil (but I did't know) rescue "Unknown"
I prefer andand for this use case.
Joe Martinez
-1: Exact copy of Fabiano PS's [answer](
Andrew Grimm
+3  A: 

I'm a fan of:

%w{An Array of strings} #=> ["An", "Array", "of", "Strings"]

It's sort of funny how often that's useful.

I use it a fair bit as well. You can use a delimiter `%w{A two\ word example}` if you need to avoid splitting on a certain space.
Andrew Grimm
+17  A: 

Wow, no one mentioned the flip flop operator:

1.upto(100) do |i|
  puts i if (i == 3)..(i == 15)
Konstantin Haase
Right... someone's gonna have to explain this one to me. It works, but I can't figure out why.
Bob Aman
The flip flop operator is a statefull if. Its state switches to true as soon as `i == 3` and switches to false *after* `i != 3` and `i == 15`. Similar to a flip-flop:
Konstantin Haase
+2  A: 

each_with_index method for any enumarable object ( array,hash,etc.) perhaps?

myarray = ["la", "li", "lu"]
myarray.each_with_index{|v,idx| puts "#{idx} -> #{v}"}

#0 -> la
#1 -> li
#2 -> lu

Maybe it's more well known than other answers but not that well known for all ruby programmers :)

With 1.9, you get `#with_index` on every `Enumerator`, aka `myarray.each.with_index` or even ``.
+5  A: 

Destructuring an Array

(a, b), c, d = [ [:a, :b ], :c, [:d1, :d2] ]


a #=> :a
b #=> :b
c #=> :c
d #=> [:d1, :d2]

Using this technique we can use simple assignment to get the exact values we want out of nested array of any depth.

+3  A: 

Defining a method that accepts any number of parameters and just discards them all

def hello(*)
    puts "hello!"

The above hello method only needs to puts "hello" on the screen and call super - but since the superclass hello defines parameters it has to as well - however since it doesn't actually need to use the parameters itself - it doesn't have to give them a name.