How do you use global variables or constant values in Ruby?
-
22-07-2019 - |
Question
I have a program that looks like:
$offset = Point.new(100, 200);
def draw(point)
pointNew = $offset + point;
drawAbsolute(point)
end
draw(Point.new(3, 4));
the use of $offset
seems a bit weird.
In C, if I define something outside of any function, it is a global variable automatically. Why in Ruby does it have to be $offset
but cannot be offset
and still be global? If it is offset
, then it is a local? But local to where, because it feels very much global.
Are there better ways to write the code above? The use of $offset
may seem a bit ugly at first.
Update: I can put this offset inside a class
definition, but what if two or several classes need to use this constant? In this case do I still need to define an $offset
?
Solution
One thing you need to realize is in Ruby everything is an object. Given that, if you don't define your methods within Module
or Class
, Ruby will put it within the Object
class. So, your code will be local to the Object
scope.
A typical approach on Object Oriented Programming is encapsulate all logic within a class:
class Point
attr_accessor :x, :y
# If we don't specify coordinates, we start at 0.
def initialize(x = 0, y = 0)
# Notice that `@` indicates instance variables.
@x = x
@y = y
end
# Here we override the `+' operator.
def +(point)
Point.new(self.x + point.x, self.y + point.y)
end
# Here we draw the point.
def draw(offset = nil)
if offset.nil?
new_point = self
else
new_point = self + offset
end
new_point.draw_absolute
end
def draw_absolute
puts "x: #{self.x}, y: #{self.y}"
end
end
first_point = Point.new(100, 200)
second_point = Point.new(3, 4)
second_point.draw(first_point)
Hope this clarifies a bit.
OTHER TIPS
Variable scope in Ruby is controlled by sigils to some degree. Variables starting with $
are global, variables with @
are instance variables, @@
means class variables, and names starting with a capital letter are constants. All other variables are locals. When you open a class or method, that's a new scope, and locals available in the previous scope aren't available.
I generally prefer to avoid creating global variables. There are two techniques that generally achieve the same purpose that I consider cleaner:
Create a constant in a module. So in this case, you would put all the classes that need the offset in the module
Foo
and create a constantOffset
, so then all the classes could accessFoo::Offset
.Define a method to access the value. You can define the method globally, but again, I think it's better to encapsulate it in a module or class. This way the data is available where you need it and you can even alter it if you need to, but the structure of your program and the ownership of the data will be clearer. This is more in line with OO design principles.
One of the reasons why the global variable needs an prefix (the $
) is because in Ruby, unlike in C, you don't have to declare your variables before assigning to them so without a specific prefix for globals given a statement like offset = Point.new(100, 200)
inside your draw method then Ruby wouldn't know if you were referring to the existing variable or creating a new local variable inside your method. Same with the @
prefix for instance variables.
I think it's local to the file you declared offset. Consider every file to be a method itself.
Maybe put the whole thing into a class and then make offset a class variable with @@offset = Point.new(100, 200);
?