Named parameters in Ruby don't work?

Question

I wonder why named parameters don't work as I expect.

 def my_method(var1, var2 = 1, var3 = 10)
   puts var1, var2, var3
 end

my_method(999, var3 = 123)

The output

999
123
10

instead of (at least, as I guess should be):

999
1
123

So, what should I do to use named parameters?

P.S. When I use the hash, it's not what I'm looking for yet:

def my_method(var1, vars = {var2: 1, var3: 10} )
   puts var1, vars[:var2], vars[:var3]
 end

my_method(999, var3: 123)

999

123


my_method(999, var2: 111, var3: 123)

999
111
123



my_method(999)
999
1
10

So I have to override each value of vars or don't override them at all. Is there any more convenient way?

What ruby version are you using? There are no named parameters in 1.9.3 and older. — Sergio Tulentsev, Jan 04 '13 at 08:33
Yes, I know. But what does `my_method(999, var3 = 123)` mean? — Alan Coromano, Jan 04 '13 at 08:37
It calls my_method with the arguments 99 and 123 and sets the local (to the caller) variable var3 to 123 — Frederick Cheung, Jan 04 '13 at 09:05

score 3 · Accepted Answer · answered Jan 04 '13 at 08:38

3

In ruby my_method(999, var3 = 123) means, assign var3 the value 123 and pass it to my_method.

There is no concept of named parameters, however, you can use a hash as an argument to my_method such as:

def my_method(args = {})
   p "#{args[:a]}, #{args[:b]}, #{args[:c]}"
end

Then you can call it with:

my_method(b: 2, c: 3, a: 1)

which will print 1, 2, 3, because b: 2, c: 3, a: 1 is inferred to be a hash by ruby. You can explicitly indicate the hash as well with:

my_method({b: 2, c: 3, a: 1})

answered Jan 04 '13 at 08:38

Candide

30,469
8
53
60

How do I set default values for `args` then? – Alan Coromano Jan 04 '13 at 08:41
One technique used is to give default values within the function (in your case `my_method`) as in: `args[:a] = args[:a] || 3` for instance. – Candide Jan 04 '13 at 08:44
1

do you mean `args[:a] ||= 3`? – Alan Coromano Jan 04 '13 at 08:50
thanks. Is there any other technique? – Alan Coromano Jan 04 '13 at 08:53
You can mix an parameters, some could be hashes, others regular params. However, if you do that ambiguity may creep in, and you will need to explicitly use the curly brackets. Overloading is another option of course. – Candide Jan 04 '13 at 08:57
Can you show me an example please? – Alan Coromano Jan 04 '13 at 09:36
I like this approach for default values for a Hash parameter: `args.merge({ a: 1, b: 1, c: 1 })`. Example: `{ a: 2 }.merge({ a: 1, b:1 }) #=> { a:2 b:1 }` – doesterr Jan 04 '13 at 12:39

score 2 · Answer 2 · edited Sep 03 '15 at 13:56

As pointed out, Ruby does not have keyword arguments (yet, they are coming in 2.0). To achieve what you are trying to do, an options hash is a very common Ruby idiom.

def my_method(var1, options = {})
  var2 = options.fetch(:var2, 1)
  var3 = options.fetch(:var3, 10)

  puts var1, var2, var3
end

my_method(999)
# => 999, 1, 10

my_method(999, var3: 123)
# => 999, 1, 123

my_method(999, var2: 111)
# => 999, 111, 10

my_method(999, var2: 111, var3: 123)
# => 999, 111, 123

my_method()
# => ArgumentError: wrong number of arguments (0 for 1)

Note that using options.fetch(:key, default) rather than options[:key] || default is frequently preferable because it allows you to explicitly specify falsy values (ie false and nil).

options = {x: nil, y: false}

x = options[:x] || 42      # sets x to 42
x = options.fetch(:x, 42)  # sets x to nil

y = options[:y] || 43      # sets y to 43
y = options.fetch(:y, 43)  # sets y to false

z = options[:z] || 44      # sets z to 44
z = options.fetch(:z, 44)  # sets z to 44

You can even pass a block to fetch which allows you to defer computation of the default value:

options.fetch(:x) { some_expensive_calculation }
# some_expensive_calculation is only called if necessary

I think you have a couple of typos in your third code block. (sets x to nil and sets y to false) — doesterr, Jan 04 '13 at 12:42
@doesterr I don't think so. Given `options = {x: nil}`, `x = options.fetch(:x, 42)` definitely sets `x` to `nil`. That's the point of using `fetch`. — Andrew Haines, Jan 04 '13 at 21:19
oops, you're right of course. don't know what I was thinking.. — doesterr, Jan 05 '13 at 14:47

score 1 · Answer 3 · answered Jan 04 '13 at 08:51

1

You can use this

  def my_method(options = {})
   puts options[:var1] || ''
   puts options[:var2] || ''
   puts options[:var3] || ''
  end

call using

my_method(var1:999, var3: 123)

or

my_method(var1:999)

answered Jan 04 '13 at 08:51

Babasaheb Gosavi

7,735
1
14
14

score 1 · Answer 4 · answered Jan 04 '13 at 13:56

1

You can also play with something like this:

def method(data)
    defaults = {var2: 1, var3: 10}
    (@var1, @var2, @var3) = defaults.merge(data).values_at(:var1, :var2, :var3)
    p @var1, @var2, @var3
end

method(var1: 999, var3: 123)

answered Jan 04 '13 at 13:56

Yevgeniy Anfilofyev

4,827
25
27

score 1 · Answer 5 · answered Feb 25 '13 at 11:04

Ruby 2.0.0 is released, now you can use named parameters.

def my_method(var1, var2: 1, var3: 10)
   puts var1, var2, var3
end

my_method(999, var3: 123)

The result:

999
1
123

Or another example:

def foo(str: "foo", num: 100)
  [str, num]
end

p foo(str: 'buz', num: 1) #=> ['buz', 1]
p foo(str: 'bar') # => ['bar', 100]
p foo(num: 2) # => ["foo", 2]
p foo # => ['foo', 100]
p foo(bar: 'buz') # => ArgumentError

Named parameters in Ruby don't work?

5 Answers5

Linked