Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Variables_and_Constants below:

Ruby Programming/Syntax/Variables and Constants - Wikibooks, open books for an open world

From Wikibooks, open books for an open world

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 that is the class
  • To define instance variables on the objects that belong to the class, use @ inside initialize()
• Class variables - @@
• Global variables - $
• Constants - uppercase letter

For more information on variable scopes related to classes, see Ruby 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 = 1
loop {
  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 block
puts defined?(i1)	# false; "i1" was initialized in the loop

Example:

@foobar

A variable whose name begins with '@' is an instance variable of self. An instance variable belongs to the object itself. Uninitialized instance variables have a value of nil.

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:

 class Parent
   @@foo = "Parent"
  end
  class Thing1 < Parent
    @@foo = "Thing1"
  end
  class Thing2 < 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. Every class 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 = 123
end
puts Foo::BAR   
# => 123

self

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

nil

The sole-instance of the NilClass class. Expresses nothing.

true

The sole-instance of the TrueClass class. Expresses true.

false

The sole-instance of the FalseClass class. Expresses false.

$1, $2 ... $9

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

(nil also is considered to be false, and every other value is considered to be true 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)

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

1. ↑ ^{a b c d e f g h i j k l m n o p q r s t u v w x y z} English.rb from the Ruby 1.9.2 Standard Library Documentation
2. ↑ The document on pre-defined global variables and constants from the official Ruby documentation

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4