A variable in Ruby can be distinguished by the characters at the start of its name. There's no restriction to the length of a variable's name (with the exception of the heap size).

The first character indicates the scope:

• Local variables - lowercase letter or underscore
• Instance variables - @
  • In class scope, instance variables belong to the object thatis the class
  • To define instance variables on the objects thatbelong to the class, use @ inside initialize()
• Class variables - @@
• Global variables - $
• Constants - uppercase letter

For more information on variable scopes related to classes, seeRuby Programming/Syntax/Classes.

Example:

foobar_foobar

A variable whose name begins with a lowercase letter (a-z) or underscore (_) is a local variable or method invocation.

A local variable is only accessible from within the block of its initialization. For example:

i0 = 1loop {  i1 = 2  puts defined?(i0)# true; "i0" was initialized in the ascendant block  puts defined?(i1)# true; "i1" was initialized in this block  break}puts defined?(i0)# true; "i0 was initialized in this blockputs defined?(i1)# false; "i1" was initialized in the loop

Example:

@foobar

A variable whose name begins with '' is an instance variable of . An instance variable belongs to theobject itself. Uninitialized instance variables have a value of .

A class variable is shared by all instances of a class and begins with '@@'.Example:

@@foobar

An important note is that the class variable is shared by all the descendants of the class.Example:

classParent@@foo="Parent"endclassThing1<Parent@@foo="Thing1"endclassThing2<Parent@@foo="Thing2"end>>Parent.class_eval("@@foo")=>"Thing2">>Thing1.class_eval("@@foo")=>"Thing2">>Thing2.class_eval("@@foo")=>"Thing2">>Thing2.class_variables=>[]Parent.class_variables=>[:@@foo]

This shows us that all our classes were changing the same variable. Class variables behave like global variables which are visible only in the inheritance tree. Because Ruby resolves variables by looking up the inheritance tree *first*, this can cause problems if two subclasses both add a class variable with the same name.

Example:

$foobar

A variable whose name begins with '' has a global scope; meaning it can be accessed from anywhere within the program during runtime.

Usage:

FOOBAR

A variable whose name begins with an uppercase letter (A-Z) is a constant. A constant can be reassigned a value after its initialization, but doing so will generate a warning. Everyclass is a constant.

Trying to access an uninitialized constant raises the NameError exception.

Constants are looked up based on your scope or via the scope resolution operator (i.e. '::').For example

 class A   A2 = 'a2'   class B     def go       A2      end   end end instance_of_b = A::B.new a2 = A::A2

Another example

class Foo  BAR = 123endputs Foo::BAR   # => 123

self

Execution context of the current method, which could refer to an instance, class, or module.

nil

The sole-instance of theNilClass class. Expresses nothing.

true

The sole-instance of theTrueClass class. Expresses true.

false

The sole-instance of theFalseClass class. Expresses false.

$1, $2 ... $9

These are contents of capturing groups for regular expression matches. They are local to thecurrent thread and stack frame!

(nil also is considered to befalse, and every other value is considered to betrue in Ruby.)The value of a pseudo variable cannot be changed. Substitution to a pseudo variable causes an exception to be raised.

Many pre-defined variables are useful when dealing with regular expressions or Ruby interpreter parameters.

To avoid the criticism that two-character, punctuation-based variable names are cryptic or confusing, part of the standard library is "English" which defines the longer names listed in the table above. To include these names, just require the English library as follows.^[1]

Without ‘English’:

   $\ = ' -- '   "waterbuffalo" =~ /buff/   print $", $', $$, "\n"

With English:

   require "English"      $OUTPUT_FIELD_SEPARATOR = ' -- '   "waterbuffalo" =~ /buff/   print $LOADED_FEATURES, $POSTMATCH, $PID, "\n"

Note that there are some pre-defined constants at parse time, as well, namely

 __FILE__   (current file) __LINE__   (current line)

and

 __dir__    (current directory) __method__ (current method)

(new in Ruby 2.0)

Alist of predefined global constants can be found in the Ruby language documentation.^[2] Among the notable ones are:

1. ↑^{abcdefghijklmnopqrstuvwxyz}English.rb from theRuby 1.9.2 Standard Library Documentation
2. ↑The document onpre-defined global variables and constants from the official Ruby documentation

• Book:Ruby Programming