Reposted from an old RubyGarden article
<hr />
Ruby supports idiomatic programming. Please put your favorite Ruby idioms here. They don't have to be specific to Ruby.
Using idioms does not always lead to the most readable code, but they can provide convenient shortcuts in many situations.
<h2>I want this value, unless it evaluates to false in which case I want another value instead</h2>
Normally you would write something like
<pre>
if myvar
return myvar
else
return another_value
end
</pre>
But you can use the <code>||</code> operator instead:
<pre>return myvar || another_value</pre>
You can also use the <code>||=</code> operator to assign a value to a variable if it evaluates to false. That is, instead of writing
<pre>myvar = another_value unless myvar</pre>
or
<pre>
unless myvar
myvar = another_value
end
</pre>
you could write
<pre>myvar ||= another_value</pre>
handy to put anything or anthing else, if it doesn't exist(I didn't know about that possibility for a long time):
<pre>puts page_title || "Untitled"</pre>
<h2>I want this value, unless it is nil in which case I want another value instead</h2>
Please note the difference between this idiom and the idiom above. In order to clearly see the different behavior assume myvar is <code>false</code>
<pre>
myvar.nil? ? other : myvar
</pre>
And setting myvar if it is nil (again not if it is false )
<pre>
myvar = newvalue if myvar.nil?
</pre>
while
<pre> myvar ||= newvalue</pre>
corresponds to
<pre>
myvar = newvalue unless myvar
</pre>
<h2>Invoke this method on my object, unless I have no object</h2>
If you want to invoke a method on an object in a variable, but in some cases the variable could be <code>nil</code>, you could do this:
<pre>
if myvar
return myvar.size
else
return nil
end
</pre>
But using the <code>&&</code> operator you can turn this into:
<pre>
return myvar && myvar.size
</pre>
If you want to return something other than <code>nil</code> if both <code>myvar</code> and <code>myvar.size</code> are <code>nil</code>, you can use the <code>||</code> operator again:
<pre>
return myvar && myvar.size <code>||</code> 0
</pre>
... or use the ternary operator:
<pre>
return myvar ? myvar.size : 0
</pre>
<h2>Run this code only when the file is the main program</h2>
Sometimes it is useful to add code to a file that is executed only if the file is run as the main program, but is ignored otherwise. Here's how:
<pre>
if $PROGRAM_NAME == __FILE__
do_stuff
end
</pre>
Some applications of this idiom:
<ul>
<li> Include test code at the bottom of a library file, so that running the file as a program tests the file.</li>
<li> Require a program's file into a test module, so that its functions can be tested without running the whole program.</li>
<li> Provide a Ruby API to a program's functionality.</li>
</ul>
<h2>Destroy this object when it goes out of scope</h2>
C++ programmers are used to using the "construction acquires, destruction releases" idiom to control the management of external resources such as files or sockets. They are often put off by Ruby because garbage collection and finalizers don't act like objects on the stack with destructors.
Ruby's blocks can be used to the same end. In the class that represents an external resource, define a class method that takes a block. That method
<ul>
<li> allocates an instance of the class, thereby acquiring the resource
<li> passes the instance to the block, and then
<li> releases the resource when the block returns.
</ul>
Here's an abstract example of this idiom in use:
<pre>
Resource.open( identifier ) do |resource|
process( resource )
end
# resource is now closed
</pre>
The implementation of the class method must use a <code>begin...ensure</code> statement to ensure that the resource is always released:
<pre>
def Resource.open( identifier ) # :yield: resource
resource = Resource.new( identifier )
yield resource
ensure
resource.close
end
</pre>
A practical example is the <code>open</code> method of the <code>File</code> class.
Often, though, the behaviour of new is conditional, depending on whether a block is provided. For instance, <code>File.open</code> behaves just like <code>File.new</code> <em>unless</em> you provide a block. This way, programmers can choose between the interfaces. Applying that to our general <code>Resource</code> class, we get this:
<pre>
def Resource.open( identifier ) # :yield: resource
resource = Resource.new( identifier )
if block_given?
begin
yield resource
ensure
resource.close
end
else
return resource
end
end
</pre>
Thus:
<pre>
r = Resource.open( x ) # -> some Resource object
Resource.open( x ) do |r|
# use 'r' ...
end
</pre>
<h2>Hashes of lists</h2>
Sometimes, I want to fill out a hash with keys mapped to lists of arbitrary elements. Instead of the cumbersome approach:
<pre>
h[key] = [] unless h.has_key? key
h[key] << val
</pre>
which requires three key lookups, you can turn it into
<pre>
ary = (h[key] <code>||</code>= [])
ary << val
</pre>
or the even shorter, but less readable:
<pre>
(h[key] <code>||</code>= []) << val
</pre>
This code still takes two lookups, as <code>h[key] ||= []</code> is equivalent to <code>h[key] = h[key] || []</code>. An alternative is:
<pre>
a = h.fetch(key) { h[key] = [] }
a << val
</pre>
This involves one lookup in the common case, and two lookups when creating the sub-list.
You could also consider using the following:
<pre>
h = Hash.new []
h[key] <<= val
</pre>
but note that this doesn't quite work:
<pre>
irb(main):001:0> h = Hash.new []
{}
irb(main):002:0> h[1] <<= 2; h[2] <<= 3
[2, 3]
irb(main):003:0> h
{1=>[2, 3], 2=>[2, 3]}
</pre>
Only one array is ever created; we want a new array for every key. So instead we write:
<pre>
h = Hash.new { [] }
h[key] <<= val
</pre>
You can also use this form:
<pre>
h = Hash.new{ |h,v| h[v]=[] }
h[key] << val
</pre>
<h2>Jump to first non-false expression</h2>
Blame Hal Fulton for this (see <a href="http://www.google.com/url?sa=D&q=HTTP%3A%2F%2Fwww.ruby-talk.org%2F58095">[ruby-talk:58095]</a>). His toy language at grad school included a <tt>test</tt> statement. It's similar enough to the <tt>case</tt> statement that ...
For example:
<pre>
case true
when x < 0; puts "x < 0"
when 0 <= x && x < 1; puts "x in interval [0,1)"
when 1 <= x && x < 2; puts "x in interval [1,2)"
when 2 <= x; puts "x >= 2"
end
</pre>
In fact, you can even omit the "true" and have the same semantics:
<pre>
case
when x < 0; puts "x < 0"
when 0 <= x && x < 1; puts "x in interval [0,1)"
when 1 <= x && x < 2; puts "x in interval [1,2)"
when 2 <= x; puts "x >= 2"
end
</pre>
Further, you can take advantage of Ruby's functional nature:
<pre>
puts case
when x < 0; "x < 0"
when 0 <= x && x < 1; "x in interval [0,1)"
when 1 <= x && x < 2; "x in interval [1,2)"
when 2 <= x; "x >= 2"
end
</pre>
<h2>easy to access elements in array</h2>
<pre>
val = [1, 2, 3]
a, b, c = val # Observe this particular line
p a #=> 1
p b #=> 2
p c #=> 3
</pre>
This can be useful when you want a method to return multiple values.
<pre>
def test
[42, "ruby"]
end
val, str = test
</pre>
Or, if you want just the second value:
<pre>
val = test[1]
</pre><h2>from my_hash['foo'] to my_hash.foo</h2>
<p>
<p>
If you want to reference a value corresponding to a key in hashes you may use a <em>dotted</em> notation by several means (take a look at <a href="http://www.google.com/url?sa=D&q=HTTP%3A%2F%2Fblade.nagaokaut.ac.jp%2Fcgi-bin%2Fscat.rb%2Fruby%2Fruby-talk%2F92897">[ruby-talk:92897]</a> too).
<p>
<ul>
<li> Hash could be extended to act like a Struct
</ul><p>
<pre>
class Hash
def method_missing(meth,*args)
if /=$/=~(meth=meth.id2name) then
self[meth[0...-1]] = (args.length<2 ? args[0] : args)
else
self[meth]
end
end
end
x = { 'name'=>'Gavin', 'age'=>31 }
x.weight = 171
x.feet = ['left','right']
puts x.name , x.weight , x.foo , x.inspect
#=>Gavin
#=>171
#=>nil
#=>{"name"=>"Gavin", "weight"=>171, "feet"=>["left", "right"], "age"=>31}
</pre><p>
<ul>
<li> You may get a Struct from a Hash using <a href="HTTP://rubyforge.org/snippet/detail.php?type=snippet&id=1">[Dan Berger's code snippet on RubyForge]</a> <i>Is this worthwhile, given that <a href="http://rubygarden.org/Ruby/page/show/OpenStruct" class="wikipagelink">OpenStruct</a> is in the standard library?</i>
</ul><p>
<pre>
class Hash
def to_struct(struct_name)
Struct.new(struct_name,*keys).new(*values)
end
end
h = {:name=>"Dan"}
s = h.to_struct("Foo")
puts "name: " + s.name
</pre><p>
<p>
<ul>
<li> <a href="http://rubygarden.org/Ruby/page/show/OpenStruct" class="wikipagelink">OpenStruct</a> merges Hash and Struct behaviours together. It is like a hash, but it uses the <code>obj.key</code> notation.
</ul><p>
<pre>
require 'ostruct'
x = OpenStruct.new('name' => 'Gavin', 'age' => 31)
x.weight = 171
x.feet = ['left', 'right']
puts x.name # -> "Gavin"
puts x.weight # -> 171
puts x.foo # -> nil
puts x.feet # -> ['left', 'right']
</pre>
<h2>Automagical Variable Instantiation with a Hash</h2>
If you create a hash with a default value, you can get automagical instantiation for that type. For instance:
<p>
<pre>
mlock = Hash.new {|h,k| h[k] = Mutex.new }
</pre><p>
then later on throughout my code when I need a mutex I say
<p>
<pre>
mlock["entry"].synchronize do
# blah
end
</pre><p>
and then later on when I need another I use
<p>
<pre>
mlock["exit"].synchronize do
# exit blah
end
</pre>
This prevents me from needing to declare a new mutex in <code>initialize</code> every time I need another mutex in that class.
-- <a href="http://rubygarden.org/Ruby/page/show/CharlesComstock" class="wikipagelink">CharlesComstock</a>
<h2>Simulating Java's synchronized keyword</h2>
First thing we do, is add the synchronized method to object:
<pre>class Object
def synchronized(obj)
@_class_locker ||= Hash.new {|h,k| h[k] = Mutex.new }
@_class_locker[obj.id].synchronize { yield }
end
end</pre>
Once we have this, we can use synchronized(variable_name), just like you can in java!
<p>
Example:
<pre>require 'thread'
mytest = "hello world"
thread1 = Thread.new do
# java like syntax
synchronized(mytest) {
puts "1: mytest: #{mytest}"
sleep 1
mytest = 'goodbye world'
}
end
thread2 = Thread.new do
# ruby syntax
synchronized mytest do
puts "2: mytest: #{mytest}"
end
end
thread1.join
thread2.join</pre>
<p>
Results in:
<pre>1: mytest: hello world
2: mytest: goodbye world
</pre>
<p>
<hr noshade class="wikiline" size="1">
<p>
Or, for a more ruby'ish example that does not leave any dependencies on the Object class:
<p>
<pre>require 'thread'
module JavaEmulation
def synchronized(on)
@_class_locker ||= Hash.new {|h,k| h[k] = Mutex.new }
@_class_locker[on.id].synchronize { yield }
end
end
class MyClass
include JavaEmulation
def start_threads
mytest = "hello world"
thread1 = Thread.new do
synchronized(mytest) {
puts "1: mytest: #{mytest}"
sleep 1
mytest = 'goodbye world'
}
end
thread2 = Thread.new do
synchronized mytest do
puts "2: mytest: #{mytest}"
end
end
thread1.join
thread2.join
end
end
MyClass.new.start_threads</pre>
<h2>Initializing complex objects</h2>
<p>
<p>
If an object has a lot of data that needs to be provided on initialization, the traditional method call arrangement is unsuitable, because you need to remember the order of arguments, and you can't omit arguments that you don't care about. Ruby offers some relief with variable argument lists (<code>def foo(x, y, *args)</code>) and default values (<code>def foo(x, y=5, *args)</code>, but for seriously complicated objects, these are typically not enough.
<p>
Passing a hash is one option, using keys of the hash to name the attributes you wish to set. This allows arbitrary ordering, and selective omission (to allow default values). See <a href="http://rubygarden.org/Ruby/page/show/KeywordArguments" class="wikipagelink">KeywordArguments</a> for a look at this technique.
<p>
But I prefer the following:
<pre>
complex_object = ComplexObject.new do |c|
c.width = 15
c.height = 20
c.colour = :red
c.position = [12, 4]
end
</pre>
<p>
The benefits:
<ul>
<li> it's easy to code for (see below)
<li> the syntax is arguably more natural than the hash approach (it's very Rubyesque)
<li> it's self-documenting; you can look at the documentation for the <code>ComplexObject</code> class to see which attributes you can set
</ul><p>
The disadvantages:
<ul>
<li> all attributes used must be public
</ul>-Hey, just create a Struct to be passed to the block. Then this disadvantage disappears.
<p>
The implementation:
<p>
<pre>
class ComplexObject
attr_accessor :colour, :position, :width, :height, :depth, :label
#
# Width and height _must_ be specified; all others are optional.
#
def initialize # :yield: c
# Set default values.
@colour = :white
@position = [0,0]
@depth = 0
@label = ""
yield self
# If all attributes are optional, we would code:
# yield self if block_given?
if @width.nil? or @height.nil?
raise TypeError, "Incompletely specified ComplexObject"
end
end
end
</pre>
<p>
This, to me, is a very natural coding style. The default values are easily seen in the code (usually browsable via RDoc). The post-condition is easily specified. All in eight clear lines of code for a class with six attributes.
<p>
Morover, this style is extremely useful when creating hierarchies of composite objects.
i.e.: FXRuby implements this idiom to support well structured GUI code.
<pre>
FXMainWindow.new($app, ...){|mainwindow|
FXHorizontalFrame.new(mainwindow){|hf|
FXLabel.new(hf){|label| ... }
FXButton.new(hf){|button| .. }
}
}
</pre>
As you can see, the hierarchic composition of the GUI is reflected by the structure of the code which increases readability and maintainability. I use this idiom whenever I need to build complex composite objects. --henon
<h2>Initializer alternatives</h2>
<p>
<p>
Ruby allows only one initializer method for a class, which is a problem if you want initialization to be done in different ways, or with different arguments.
<p>
One of the dynamic invocation features of Ruby can be used to relieve this, by writing a class in the following idiom:
<p>
<pre>
class Example
def initialize( method_name, *parameters_array )
send(method_name, parameters_array)
end
private
def initialize1( parameters_array )
# construct in one way
end
def initialize2( parameters_array )
# construct in another way
end
end
</pre>
<p>
where the arguments are collected into an array, and a name string is used to delegate to a particular method.
<p>
Such a class can then be instantiated variously by the client like this:
<p>
<pre>
e1 = Example.new( 'initialize1', 1, 2, 3 )
e2 = Example.new( 'initialize2', 'a', 'b' )
</pre>
<p>
which practically gives overloaded initializer methods.
<p>
(Ideally, it would be preferable to be able to instantiate like this:
<p>
<pre>
e = Example.new_alternative1( 1, 2, 3 )
</pre>
<p>
There is a hack for that:
<p>
<pre>
class Example
def initialize( method_name, *parameters_array )
send(method_name, parameters_array)
end
def self.new_alternative1(*parameters_array)
return Example.new('initialize1', parameters_array)
end
private
def initialize1( parameters_array )
# construct in one way
end
def initialize2( parameters_array )
# construct in another way
end
end
</pre>
<p>
It would work better through a mixin that metaclass-hacks to allow for easily flagging a method "initializer", though.)
<h2>Wonder of the When-be-splat</h2>
<p>
On <a href="http://www.google.com/url?sa=D&q=http%3A%2F%2Fredhanded.hobix.com%2Fbits%2FwonderOfTheWhenBeFlat.html">[redhanded]</a> _Why pointed out that * (the splat) can be used to unpack an array for a branch of a case statement.
<p>
<pre>
BOARD_MEMBERS = ['Jan', 'Julie', 'Archie', 'Stewick']
HISTORIANS = ['Braith', 'Dewey', 'Eduardo']
</pre><p>
<pre>
case name
when *BOARD_MEMBERS
"You're on the board! A congratulations is in order."
when *HISTORIANS
"You are busy chronicling every deft play."
end
</pre>
2009-11-07T01:07:06Z
244
Repost from (long-gone) RubyGarden: List of Ruby Idioms
2009-11-07T01:07:06Z