Local variables in `class` definition scope versus `def` method scope

Question

Here, I create a local variable in class scope:

class MyClass
  x = 1
  puts x
end

It prints 1 even if I don't create any instances of MyClass.

I want to use x in some method:

class MyClass
  x = 1
  def method
    puts x
  end
end

m = MyClass.new
m.method

And I can't. Why? I get that class definition creates a scope, but why is it not accessible in the method? Isn't scope of the method inside the scope of the class?

I can imagine that this is related to creation of a class. Since any class is an object of Class, maybe the scope of MyClass is the scope of some Class method, and the way of coupling methods of MyClass to that instance makes their scope completely different.

It also seems to me that I can't just create a scope with {} (like in C) or something like do..end. Am I correct?

Answer 1

Scope of a method is not inside the class. Each method has its own entirely new scope.

New scopes are created whenever you use the class, module, and def keywords. Using brackets, as in C, does not create a new scope, and in fact you cannot arbitrarily group lines of code using brackets. The brackets (or do...end) around a Ruby block create a block-level scope, where variables previously created in the surrounding scope are available, but variables created within the block scope do not escape into the surrounding scope afterward.

Instance methods share the scope of their instance variables with other instances methods. An instance variable defined in the scope of a class definition is available in class-level singleton methods, but not in instance methods of the class.

Illustration:

class Foo
  x = 1  # available only here
  @y = 2 # class-wide value

  def self.class_x
    @x # never set; nil value
  end

  def self.class_y
    @y # class-wide value
  end

  def initialize(z)
    x = 3  # available only here
    @z = z # value for this instance only
  end

  def instance_x
    @x # never set; nil
  end

  def instance_y
    @y # never set; nil
  end

  def instance_z
    @z # value for this instance only
  end
end

Foo.class_x # => nil
Foo.class_y # => 2

Foo.new(0).instance_x # => nil
Foo.new(0).instance_y # => nil

foo3 = Foo.new(3)
foo4 = Foo.new(4)

foo3.instance_z # => 3
foo4.instance_z # => 4

You can access class-level instance variables from within instances using the class-level getter. Continuing the example above:

class Foo
  def get_class_y
    self.class.class_y
  end
end

foo = Foo.new(0)
foo.get_class_y # => 2

There exists in Ruby the notion of a "class variable," which uses the @@ sigil. In practice, there is almost never a reasonable use case for this language construct. Typically the goal can be better achieved using a class-level instance variable, as shown here.

Answer 2

Here, I create a local variable in class scope:

class MyClass
  x = 1
  puts x
end

It prints 1 even if I don't create any instances of MyClass.

Correct. The class definition body is executed when it is read. It's just code like any other code, there is nothing special about class definition bodies.

Ask yourself: how would methods like attr_reader/attr_writer/attr_accessor, alias_method, public/protected/private work otherwise? Heck, how would def work otherwise if it didn't get executed when the class is defined? (After all, def is just an expression like any other expression!)

That's why you can do stuff like this:

class FileReader
  if operating_system == :windows
    def blah; end
  else
    def blubb; end
  end
end

I want to use x in some method:

class MyClass
  x = 1
  def method
    puts x
  end
end

m = MyClass.new
m.method

And I can't. Why? I get that class definition creates a scope, but why is it not accessible in the method? Isn't scope of the method inside the scope of the class?

No, it is not. There are 4 scopes in Ruby: script scope, module/class definition scope, method definition scope, and block/lambda scope. Only blocks/lambdas nest, all the others create new scopes.

I can imagine that this is related to creation of a class. Since any class is an object of Class, maybe the scope of MyClass is the scope of some Class method, and the way of coupling methods of MyClass to that instance makes their scope completely different.

Honestly, I don't fully understand what you are saying, but no, class definition scope is not method definition scope, class definition scope is class definition scope, and method definition scope is method definition scope.

It also seems to me that I can't just create a scope with {} (like in C) or something like do..end. Am I correct?

Like I said above: there are 4 scopes in Ruby. There is nothing like block scope in C. (The Ruby concept of "block" is something completely different than the C concept of "block.") The closest thing you can get is a JavaScript-inspired immediately-invoked lambda-literal, something like this:

foo = 1

-> {
  bar = 2
  foo + bar
}.()
# => 3

bar
# NameError

In general, that is not necessary in Ruby. In well-factored code, methods will be so small, that keeping track of local variables and their scopes and lifetimes is really not a big deal.

Answer 3

So just creating a class without any instances will lead to something actually executing in runtime (even allocating may be)? That is very not like C++. –

Check out this code:

Dog = Class.new do
  attr_accessor :name

  def initialize(name)
    @name = name
  end
end

If you execute that code, there won't be any output, but something still happened. For instance, a global variable named Dog was created, and it has a value. Here's the proof:

Dog = Class.new do
  attr_accessor :name

  def initialize(name)
    @name = name
  end
end

dog = Dog.new("Ralph")
puts dog.name

--output:--
Ralph

The assignment to the Dog constant above is equivalent to writing:

class Dog
  ...
  ...
end

And, in fact, ruby steps through each line inside the class definition and executes each line--unless the line of code is inside a def. The def is created but the code inside a def doesn't execute until the def is called.

A very common line you will see inside a class definition is:

attr_accessor :name

...which can be rewritten as:

attr_accessor(:name)

...which makes it obvious that it's a method call. Ruby executes that line--and calls the method--when you run a file containing the class definition. The attr_accessor method then dynamically creates and inserts a getter and a setter method into the class. At runtime. Yeah, this ain't C++ land anymore--welcome to NeverNever Land.

I get that class definition creates a scope, but why is it not accessible in the method?

Because that is the way Matz decided things should be: a def creates a new scope, blocking visibility of variables outside the def. However, there are ways to open up the scope gates, so to speak: blocks can see the variables defined in the surrounding scope. Check out define_method():

class MyClass
  x = 1

  define_method(:do_stuff) do
    puts x
  end

end

m = MyClass.new
m.do_stuff

--output:--
1

The block is everything between do...end. In ruby, a block is a closure, which means that when a block is created, it captures the variables in the surrounding scope, and carries those variables with it until the the block is executed. A block is like an anonymous function, which gets passed to a method as an argument.

Note that if you use the Class.new trick, you can open two scope gates:

x = 1

MyClass = Class.new do

  define_method(:do_stuff) do
    puts x
  end

end

m = MyClass.new
m.do_stuff

--output:--
1

Generally, ruby allows a programmer to do whatever they want, rules be damned.