What is the difference between a constant and a variable in Ruby?

Question

So, I\'m doing a Ruby course on CodeAcademy and I\'m stuck in differentiating the difference between a variable and a class. Can someone please explain the difference to me?

Answer 1

In Ruby, a constant is an identifier that starts with a capital letter; it is intended to be assigned only once. You can reassign a constant, but you should not. Doing so will generate a warning:

NAME = "Fred"
NAME = "Barney"    # => Warning: Already initialized constant NAME

A variable is an identifier that does not start with a capital letter; it may be assigned to more than once:

name = "Fred"
name = "Barney"    # => No warning

When you create a class, a constant is created with the same name as the class; that constant is bound to the class:

class Foo
end

This is equivalent to this code which creates a new anonymous class and assigns it to the constant Foo:

Foo = Class.new do
end

You can reassign the constant identifier Foo, as you can with any other constant, but of course you shouldn't, and you will still get the warning:

Foo = 123    # => Already initialized constant Foo

Answer 2

The idea of constants in Ruby is that they can get a value assigned only once while you can assign a new value to a variable as many times as you want. Now technically, you can assign a new value even to a constant. Ruby will however issue a warning in this case and you should try to avoid this case.

I guess the main point leading to confusion of people new to Ruby is that even values assigned to constants can be modified without a warning (e.g. by adding new elements to an array). References by a constant are no different to variables here in that the reference does not restrict what can be done with the value. The object referenced by either a variable or constant is always independent from that.

In this example, I assign a new array to the ARRAY constant. Later, I can happily change the array by adding a new member to it. The constant is not concerned by this.

ARRAY = []
# => []
ARRAY << :foo
ARRAY
# => [:foo]

The only thing forbidden (or, well, allowed with a warning) is if you try to assign a completely new value to a constant:

ARRAY2 = []
# => []
ARRAY2 = [:bar]
# warning: already initialized constant ARRAY2
ARRAY2
=> [:bar]

As such, it is common practice to immediately freeze values assigned to constants to fully deny any further changes and ensure that the original value is preserved (unless someone assigns a new value):

ARRAY3 = [:foo, :bar].freeze
ARRAY3 << :baz
# RuntimeError: can't modify frozen Array

Answer 3

• A variable can change its value, it can vary.
• A constant cannot change its value, it is constant.

In Ruby things are a bit more complex though. You can reassign the value of constants, but it will print a warning. This is meant to be used for debugging only and the general principle still applies that constants are meant to be used for values that never change.