Ruby Keyword Arguments

Donald Dong — Mon, 05 Apr 2021 23:15:22 +0000

In Ruby 2, keyword arguments are essentially the same as a hash object at the end of the positional arguments.

Ruby 2.x:

def test(*args)
  p args
end
test(1, {y: 2}) # [1, {:y=>2}]
test(1, y: 2) # [1, {:y=>2}]

Ruby 2.x:

def test2(hash={}, **kwargs)
  p [hash, kwargs]
end
test2({y: 2}) # [{}, {:y=>2}]
test2(y: 2) # [{}, {:y=>2}]

Though I have passed in a hash, it's actually picked up by the kwargs.
This... is probably not something one would expect, right?

So, in Ruby 3, keyword arguments are completely separated from the normal arguments (learn more here).

Ruby 3.0.0:

def test2(hash={}, **kwargs)
  p [hash, kwargs]
end
test2({y: 2}) # [{:y=>2}, {}]
test2(y: 2) # [{}, {:y=>2}]

If a method has explicit keyword arguments in Ruby 3, all the callers must explicitly pass in keyword arguments (or explicitly unpack a hash as the keyword args) in order to supply the keyword args.

Using this standard, one could write Ruby code that's compatible with both Ruby 2 and Ruby 3.

Caveat

There’s a catch in writing Ruby 2 and Ruby 3 compatible code though:

Ruby 2.x:

def foo; end
a = []
b = {}
foo(*a, **b) # this is okay
send(:foo, *a, **b)  # this is not okay: ArgumentError (wrong number of arguments (given 1, expected 0))

There is a bug in Ruby 2 that is causing issues when unpacking empty hashes for kwargs (fixed in Ruby 3). In some cases, we’d have to conditionally unpack the kw hashes in Ruby 2 so that the code works with both Ruby versions (unpacking empty kw hashes causes errors sometimes). As a result, the actual code would look a bit ugly (with an if statement to unpack only if the kw hash is not empty), unfortunately 😅.

Another option is to use https://github.com/ruby/ruby2_keywords but it's better to actually fix the keyword argument passing when possible.

Ruby Underscore

Donald Dong — Fri, 19 Feb 2021 20:45:43 +0000

As a Ruby programmer, you probably have seen methods or blocks look like this:

def test(a, b, _); end
proc { |_, a| ... }

But what exactly is this _ thingy, and how is it special?

Underscore is a valid object identifier

Yes, you can access, and assign values to _ and you are also able to use it as a method name.

def a(_); puts _; end # a(3) prints 3

Yet it does not work exactly the way you might expect in IRB, because it’s explicitly configured to return the last used value in the Ruby console

_ = 1
2
_ # returns 2, not 1

Not double underscore __ tho:

__ = 1
2
__ # returns 1

Underscore is treated a bit differently than other object identifiers

You could have (>= Ruby 1.9)

def test(_, _); end
def test(__, __); end
def test(__x, __x); end

however, you cannot have

def test(x, x); end # this will cause an error

Ruby explicitly allows duplicate parameter names when they’re made of underscore _.

It is most common for people to use _ to represent unused parameters (placeholders), yet as the examples above showed, you can use other symbols to avoid “unused var” warnings too 🙂

DEV Community: Donald Dong

Ruby Keyword Arguments

Caveat

Ruby Underscore

Underscore is a valid object identifier

Underscore is treated a bit differently than other object identifiers