Why Does Ruby Seem to Hoist Variable Declarations from Inside a Case Statement Even If That Code Path Is Not Executed

Why does Ruby seem to hoist variable declarations from inside a case statement even if that code path is not executed?

When the Ruby parser sees the sequence identifier, equal-sign, value,
as in this expression

x = 1

it allocates space for a local variable called x. The creation of the
variable—not the assignment of a value to it, but the internal
creation of a variable—always takes place as a result of this kind of
expression, even if the code isn’t executed! Consider this example:

if false
x = 1
p x # Output: nil
p y # Fatal Error: y is unknown

The assignment to x isn’t executed, because it’s wrapped in a failing
conditional test. But the Ruby parser sees the sequence x = 1, from
which it deduces that the program involves a local variable x. The
parser doesn’t care whether x is ever assigned a value. Its job is
just to scour the code for local variables for which space needs to
be allocated. The result is that x inhabits a strange kind of variable limbo.
It has been brought into being and initialized to nil.
In that respect, it differs from a variable that has no existence at
all; as you can see in the example, examining x gives you the value
nil, whereas trying to inspect the non-existent variable y results
in a fatal error. But although x exists, it has not played any role in
the program. It exists only as an artifact of the parsing process.

Well-Grounded Rubyist chapter 6.1.2

Why can I refer to a variable outside of an if/unless/case statement that never ran?

It's because of how the Ruby parser works. Variables are defined by the parser, which walks through the code line-by-line, regardless of whether it will actually be executed.

Once the parser sees x =, it defines the local variable x (with value nil) henceforth in the current scope. Since if/unless/case/for/while do not create a new scope, x is defined and available outside the code block. And since the inner block is never evaluated as the conditional is false, x is not assigned to (and is thus nil).

Here's a similar example:

defined?(x) and x = 0
x #=> nil

Note that this is a rather high-level overview of what happens, and isn't necessarily exactly how the parser works.

Ruby: Variables defined in If/else statement are accessible outside of if/else?

Variables are local to a function, class or module defintion, a proc, a block.

In ruby if is an expression and the branches don't have their own scope.

Also note that whenever the parser sees a variable assignment, it will create a variable in the scope, even if that code path isn't executed:

def test
if false
a = 1
puts a

# ok, it's nil.

It's bit similar to JavaScript, though it doesn't hoist the variable to the top of the scope:

def test
puts a
a = 1

# NameError: undefined local variable or method `a' for ...

So even if what you were saying were true, it still wouldn't be nil.

Changing params in an if structure causes error (undefined method '[]' for nil:NilClass) in Ruby on Rails

from Holger Just's comment above:

Ruby initializes a new local variable named params with nil (which in your case shadows the method of the same name) even if the code is not actually executed. Ruby does this for all potential assignments, irregardless if they are actually executed or not, as in Ruby, the creation of variable is a separate step from the assignment.

Strange meaning of || and ||= in Ruby (2.0, 1.9.3, jruby 1.7.4)

I don't know if it is desirable, but it comes from how Ruby parses the code. Whenever you have a piece of code that assigns a local variable, that local variable is assigned nil even if that piece of code is not evaluated. In your code line 2:

baz || baz = 0

the first baz returned an error because no such variable was assigned. Hence the assignment baz = 0 that follows it was not evaluated, but nevertheless it was parsed, so in the context to follow, a local variable baz was created, and is initialized to nil.

With your second code chunk, foo is not assigned during true if foo and foo. After that, foo = (true if foo) has an assignment to foo, so even though (true if foo) is evaluated before assigment of foo, an error is not raised in that line.

Variable getting initialized with nil

"[A local variable] is initialized if it appears on the left‐hand side (before the equals sign (U+003D)) of an assignment expression, even if the expression does not actually execute. Variables of the latter sort have the value nil."

EDIT: This answer used to point to a fairly good Ruby reference, which has apparently been replaced by a malware site. I've removed the link but retained the quotation of the answer.

Related Topics

Leave a reply