Create a Ruby Method That Accepts a Hash of Parameters

Create a ruby method that accepts a hash of parameters

If you pass paramaters to a Ruby function in hash syntax, Ruby will assume that is your goal. Thus:

def login_success(hsh = {})
  puts hsh[:msg]
end

Create a ruby method that accepts a hash of parameters and adds them to my method's hash

If you want to be able to override your options, you can do it using Hash#reverse_merge method:

def n(options = {})
  opts = options.reverse_merge(a: 1, b: 2)
  # ...
end

How do methods use hash arguments in Ruby?

Example:

def foo(regular, hash={})
    puts "regular: #{regular}"
    puts "hash: #{hash}"
    puts "a: #{hash[:a]}"
    puts "b: #{hash[:b]}"
end

foo("regular argument", a: 12, :b => 13)

I use hash={} to specify that the last argument is a hash, with default value of empty hash. Now, when I write:

foo("regular argument", a: 12, :b => 13)

It's actually a syntactic sugar for:

foo("regular argument", {a: 12, :b => 13})

Also, {a: 12} is syntactic sugar for {:a => 12}.

When all of this is combined together, you get a syntax that looks similar to named arguments in other languages.

Passing hashes instead of method parameters

Both approaches have their own advantages and disadvantages, when you use an options hash replacing standard arguments you lose clarity in the code defining the method but gain clarity whenever you use the method because of the pseudo-named paramaters created by using an options hash.

My general rule is if you either have a lot of arguments for a method (more than 3 or 4) or lots of optional arguments then use an options hash otherwise use standard arguments. However when using an options hash it is important to always include a comment with the method definition describing the possible arguments.

How to write a method in ruby that takes hash-style, square bracketed arguments, like mymethod[arg]?

You're quite close. object[sth] is just a syntax sugar for object.[](sth). So to do what you need you have to define some_stats method that returns the object which defines [] method:

class Stats
  def [](key)
    if key.to_s =~ /something/
     #do something
     return something
  else
    #do something else
    return something_else
  end
end

def some_stats
  Stats.new
end

some_stats[:something_new] #=> something
some_stats[:not_new] #=> something_else

Accepting either a hash or an array of hashes as arguments to a Ruby method

For me, the best solution is to change the method to:

def self.store(*hashes)
  params = hashes.flatten
  puts params.inspect
end

• If you pass a single hash, it will be an array
• If you pass an array of hashes, it remains the same
• If you pases N hashes, it compacts all parameters into a one dimensional array.

You can pass whatever you want.

self.store({:key => 'value'}) # => [{:key => 'value'}]
self.store({:key => 'value'}, {:foo => 'bar'}) # => [{:key => 'value'}, {:foo => 'bar'}]
self.store([{:key => 'value'}, {:foo => 'bar'}]) # => [{:key => 'value'}, {:foo => 'bar'}]

Passing a hash as an initial value when creating an object

Your initialize method is looking for two parameters, but your input contains only one, the hash. Here's how you can handle a hash containing Fahrenheit:

  def initialize(temp)
    @f = temp[:f] 
  end

If you want to handle input in either F or C, I'll leave that as an exercise for you.

---

Related Topics