"In Ruby there's more than one way of doing the same thing" - what does this mean?

Question

Feel free to delete this topic if it's discussed or quite obvious. I hail from C# background and I'm planning to learn Ruby. Everything I read about it seems quite intriguing. But I'm confused over this basic philosophy of Ruby that "there's more than one way to do one thing". Can someone provide 2 or 3 simple arithmetic or string examples to make this point clear, like if its about the syntaxes or logics etc.

Thanks

Answer 1

"More than one way of doing something" means having the choice of doing something the way you want it. That way you can use various programming styles, no matter what background you're coming from.

---

Iteration using for vs. blocks

You can iterate over an array of things like so. This is pretty basic, and if you're from a Java background, this feels kind of natural.

for something in an_array
   print something
end

A more Ruby-like way would be the following:

an_array.each do |something|
    print something
end

The first is a rather well known way of doing things. The second one is using blocks, a very powerful concept that you'll find in many Ruby idioms. Basically, the array knows how to iterate over its contents, so you can modify this and add something like:

an_array.each_with_index do |something, index|
    print "At #{index}, there is #{something}"
end

You could have done it like this too, but now you see that the above one looks easier:

index = 0
for something in an_array
    print "At #{index}, there is #{something}"
    index += 1
end

---

Passing arguments as usual or using Hashes

Normally, you would pass arguments like so:

def foo(arg1, arg2, arg3)
    print "I have three arguments, which are #{arg1}, #{arg2} and #{arg3}"
end

foo("very", "easy", "classic")

=> "I have three arguments, which are very easy and classic"

However, you may also use a Hash to do that:

def foo(args)
    print "I have multiple arguments, they are #{args[:arg1]}, #{args[:arg2]} and #{args[:arg3]}"
end

foo :arg1 => "in a", :arg2 => "hash", :arg3 => "cool"

=> "I have three arguments, which are in a hash and cool"

The second form is one used excessively by Ruby on Rails. The nice thing is that you now have named parameters. When you are passing them, you will more easily remember what they are used for.

Answer 2

A somewhat trivial example is the use of alias/alias_method (also note that there are two similar ways for almost the same thing, e. g. alias versus alias_method).

Consider that you are working in a project and you forgot which API to use.

What was the name of the method again?

Well, you can just remain within the domain logic of your program at hand, and continue to work with it the way you want to; then you are going to simply add an alias in the main entry point of your other program.

People can use by default .collect or they can use .map, it makes little difference what you personally would use (I use .map since it is shorter).

The use of aliases helped me because after some months, I often can not remember how to use something. Yes, I could look it up, but why would I have to bother anyway? I can just use an alias instead. (Note that I do try to remain as simple as possible with aliases and APIs.)

Answer 3

It means a lot of confusion, style wars, and bugs due to subtle differences, all in the name of freedom of choice.