What does a _ mean in block arguments?

I was wondering if somebody could please explain to me what the dash place holder does?

def remove_every_other(arr)
  arr.select.with_index { |_,idx| idx.even? }
end

In some sense, this is just another parameter like any other. There is no difference between the parameter named _ and the parameter named idx. They are both parameters like any other parameter.

So, in some sense, there is nothing special about _: it's a name like any other name and could just as well be named foo or bar or baz.

However, that is not quite true: _ is treated special by the Ruby language. More precisely, any local variable name or parameter name starting with _ is treated special by the Ruby language.

In many communities, the identifier _ or identifiers starting with _ are used to signify that something is being deliberately ignored. And this is also the usage in the Ruby community.

In order to support this usage of _ for ignored variables or parameters, the Ruby language treats local variables and parameters starting with _ special in two ways:

Unused local variable warnings

Ruby will generate warnings for unused local variables:

a = 42
b = 42

b

will generate "warning: assigned but unused variable - a".

However, if I rename the variable to _a or _, the warning will be suppressed:

_a = 42
_ = 42
b = 42

b

Duplicate parameter SyntaxError

Using the same name twice in the same parameter list (in a method parameter list, block parameter list, and lambda literal parameter list) is a SyntaxError:

def foo(a, a) end
# duplicated argument name (SyntaxError)

foo {|a, a|}
# duplicated argument name (SyntaxError)

-> (a, a) {}
# duplicated argument name (SyntaxError)

but _a or _ are valid:

def foo(_a, _a, _, _) end
foo {|_a, _a, _, _|}
-> (_a, _a, _, _) {}

Last result in IRb

There is a third usage of _ specifically in IRb which has nothing to do with the above: in IRb, the local variable _ is automatically assigned the value of the last expression that was evaluated in the current IRb session. But this is purely a feature of IRb and has nothing to do with Ruby.

Treatment in linters / style-checkers / static analyzers

The default rulesets in many linters, style-checkers, and static analyzers forbid unused parameters and local variables, on the assumption that this usually indicates a typo, a programming error, or leftover code from a refactoring. Similar to Ruby itself, they usually do allow this for variables and parameters starting with _.

This has nothing to do with the Ruby language itself, though, it is a matter of the Ruby community, more precisely, the developers of those tools following the majority usage within the community.

In this case, underscore will allow you to skip elements you do not need.

In other cases _ equals last output.

$ irb
>> 2*3
=> 6
>> _ + 7
=> 13
>> _
=> 13