Small Refactorings in Ruby (opens in new tab)

   def foo_matches?
     @foo == :bar
   end

It also failed to consider that the naming of the method and the usage of Ruby naming conventions is just as important as what goes on in the body.

Ternary: "If instance variable foo equals symbol bar, then return symbol foo_matches, else return nil"

Ruby Idiom: "Return symbol foo_matches if instance variable foo equals symbol bar"

To me, I don't see it as saving characters as much as the ternary version feeling less idiomatic. In the ternary version you've got to convert 5 sigils into meaning in your head to reason out that method, plus the ? and : sigils as ternary operators are less frequently used in Ruby anyways, so you may have to pause a bit longer on them since the ? and colon are frequently used for query-style methods and symbols respectively. That adds context as a requirement to interpreting them in your head. The idiomatic version is functionally equivalent, but reads a little better converted to English. You've only got to convert 4 programming language sigils into meaning and there's no ambiguity of the colon sigil and the ? goes away entirely.

    def my_method
        if @foo == :bar
            :foo_matches
        else
            nil
        end
    end

    def my_longer_method
    ...
        variable = if @foo == :bar
                       :foo_matches
                   else
                       nil
                   end
    ...
    end

This is why Matz gave us benchmark:

    steve at thoth in ~/tmp
    $ cat benchmark.rb 
    require 'benchmark'

    n = 500000
    Benchmark.bm do |x|
      x.report("==") do
        n.times do 
          foo = "lol"
          foo == "bar" || foo == "baz" || foo == :sed || foo == 5
        end
      end

      x.report("include?") do
        n.times do
          foo = "lol"
          ["bar", "baz", :sed, 5].include?(foo)
        end
      end
    end

    steve at thoth in ~/tmp
    $ ruby benchmark.rb
           user     system      total        real
    ==  0.370000   0.000000   0.370000 (  0.367943)
    include?  0.550000   0.000000   0.550000 (  0.551897)

edit:

[1] Note that by guessing I'm referring to any optimizations that don't involve profiling your project, and that includes benchmarks of Ruby style, which are interesting to observe and can help you learn certain things about Ruby but are deceiving as far as understanding what actually makes a difference in your project. The sane way to optimize is to profile.

Actually, static array version came ahead in my tests, which is probably due to memory allocations for strings.

If you're not constantly reallocating the array you're checking against, it takes 1.5x more time to run. If you're allocating the array each time it's 3.5-4x more time.

https://gist.github.com/4549975

That said, I didn't know try could take a block instead of a symbol, so thanks for sharing :-)