Common Ruby Idioms

The magic if clause that lets the same file serve as a library or a script:

if __FILE__ == $0
  # this library may be run as a standalone script
end

Packing and unpacking arrays:

# put the first two words in a and b and the rest in arr
a,b,*arr = *%w{a dog was following me, but then he decided to chase bob}
# this holds for method definitions to
def catall(first, *rest)
  rest.map { |word| first + word }
end
catall( 'franken', 'stein', 'berry', 'sense' ) #=> [ 'frankenstein', 'frankenberry', 'frankensense' ]

The syntatical sugar for hashes as method arguments

this(:is => :the, :same => :as)
this({:is => :the, :same => :as})

Hash initializers:

# this
animals = Hash.new { [] }
animals[:dogs] << :Scooby
animals[:dogs] << :Scrappy
animals[:dogs] << :DynoMutt
animals[:squirrels] << :Rocket
animals[:squirrels] << :Secret
animals #=> {}
# is not the same as this
animals = Hash.new { |_animals, type| _animals[type] = [] }
animals[:dogs] << :Scooby
animals[:dogs] << :Scrappy
animals[:dogs] << :DynoMutt
animals[:squirrels] << :Rocket
animals[:squirrels] << :Secret
animals #=> {:squirrels=>[:Rocket, :Secret], :dogs=>[:Scooby, :Scrappy, :DynoMutt]}

metaclass syntax

x = Array.new
y = Array.new
class << x
  # this acts like a class definition, but only applies to x
  def custom_method
     :pow
  end
end
x.custom_method #=> :pow
y.custom_method # raises NoMethodError

class instance variables

class Ticket
  @remaining = 3
  def self.new
    if @remaining > 0
      @remaining -= 1
      super
    else
      "IOU"
    end
  end
end
Ticket.new #=> Ticket
Ticket.new #=> Ticket
Ticket.new #=> Ticket
Ticket.new #=> "IOU"

Blocks, procs, and lambdas. Live and breathe them.

 # know how to pack them into an object
 block = lambda { |e| puts e }
 # unpack them for a method
 %w{ and then what? }.each(&block)
 # create them as needed
 %w{ I saw a ghost! }.each { |w| puts w.upcase }
 # and from the method side, how to call them
 def ok
   yield :ok
 end
 # or pack them into a block to give to someone else
 def ok_dokey_ok(&block)
    ok(&block)
    block[:dokey] # same as block.call(:dokey)
    ok(&block)
 end
 # know where the parentheses go when a method takes arguments and a block.
 %w{ a bunch of words }.inject(0) { |size,w| size + 1 } #=> 4
 pusher = lambda { |array, word| array.unshift(word) }
 %w{ eat more fish }.inject([], &pusher) #=> ['fish', 'more', 'eat' ]

This slideshow is quite complete on the main Ruby idioms, as in:

• Swap two values:

  x, y = y, x

• Parameters that, if not specified, take on some default value

  def somemethod(x, y=nil)

• Batches up extraneous parameters into an array

  def substitute(re, str, *rest)

And so on...

I like this:

str = "Something evil this way comes!"
regexp = /(\w[aeiou])/

str[regexp, 1] # <- This

Which is (roughly) equivalent to:

str_match = str.match(regexp)
str_match[1] unless str_match.nil?

Or at least that's what I've used to replace such blocks.

I would suggest reading through the code of popular and well designed plugins or gems from people you admire and respect.

Some examples I've run into:

if params[:controller] == 'discussions' or params[:controller] == 'account'
  # do something here
end

corresponding to

if ['account', 'discussions'].include? params[:controller]
  # do something here
end

which later would be refactored to

if ALLOWED_CONTROLLERS.include? params[:controller]
  # do something here
end

By the way, from the referenced question

a ||= b 

is equivalent to

if a == nil   
  a = b 
end

That's subtly incorrect, and is a source of bugs in newcomers' Ruby applications.

Since both (and only) nil and false evaluate to a boolean false, a ||= b is actually (almost*) equivalent to:

if a == nil || a == false
  a = b
end

Or, to rewrite it with another Ruby idiom:

a = b unless a

(*Since every statement has a value, these are not technically equivalent to a ||= b. But if you're not relying on the value of the statement, you won't see a difference.)

Here's a few, culled from various sources:

use "unless" and "until" instead of "if not" and "while not". Try not to use "unless" when an "else" condition exists, though.

Remember you can assign multiple variables at once:

a,b,c = 1,2,3

and even swap variable without a temp:

a,b = b,a

Use trailing conditionals where appropriate, e.g.

do_something_interesting unless want_to_be_bored?

Be aware of a commonly-used but not instantly obvious (to me at least) way of defining class methods:

class Animal
  class<<self
    def class_method
      puts "call me using Animal.class_method"
    end
  end
end

Some references:

• http://cbcg.net/talks/rubyidioms/index.html
• http://www.therailsway.com/2006/12/8/idiomatic-ruby
• http://www.therailsway.com/2007/1/21/more-idiomatic-ruby
• http://www.caliban.org/ruby/rubyguide.shtml