Ruby - Variablen, Konstanten und Literale

Variablen sind die Speicherorte, die alle Daten enthalten, die von einem Programm verwendet werden sollen.

Es gibt fünf Arten von Variablen, die von Ruby unterstützt werden. Sie haben bereits im vorherigen Kapitel eine kleine Beschreibung dieser Variablen durchgearbeitet. Diese fünf Arten von Variablen werden in diesem Kapitel erläutert.

Ruby Global Variables

Globale Variablen beginnen mit $. Nicht initialisierte globale Variablen haben den Wert nil und erzeugen mit der Option -w Warnungen.

Die Zuweisung zu globalen Variablen ändert den globalen Status. Es wird nicht empfohlen, globale Variablen zu verwenden. Sie machen Programme kryptisch.

Hier ist ein Beispiel, das die Verwendung globaler Variablen zeigt.

#!/usr/bin/ruby

$global_variable = 10
class Class1
   def print_global
      puts "Global variable in Class1 is #$global_variable"
   end
end
class Class2
   def print_global
      puts "Global variable in Class2 is #$global_variable"
   end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

Hier ist $ global_variable eine globale Variable. Dies führt zu folgendem Ergebnis:

NOTE - In Ruby können Sie auf den Wert einer Variablen oder Konstante zugreifen, indem Sie ein Hash-Zeichen (#) direkt vor diese Variable oder Konstante setzen.

Global variable in Class1 is 10
Global variable in Class2 is 10

Ruby-Instanzvariablen

Instanzvariablen beginnen mit @. Nicht initialisierte Instanzvariablen haben den Wert nil und erzeugen mit der Option -w Warnungen.

Hier ist ein Beispiel, das die Verwendung von Instanzvariablen zeigt.

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.display_details()
cust2.display_details()

Hier sind @cust_id, @cust_name und @cust_addr Instanzvariablen. Dies führt zu folgendem Ergebnis:

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Ruby-Klassenvariablen

Klassenvariablen beginnen mit @@ und müssen initialisiert werden, bevor sie in Methodendefinitionen verwendet werden können.

Das Verweisen auf eine nicht initialisierte Klassenvariable führt zu einem Fehler. Klassenvariablen werden von Nachkommen der Klasse oder des Moduls geteilt, in dem die Klassenvariablen definiert sind.

Überschreibende Klassenvariablen erzeugen Warnungen mit der Option -w.

Hier ist ein Beispiel, das die Verwendung der Klassenvariablen zeigt -

#!/usr/bin/ruby

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
   def total_no_of_customers()
      @@no_of_customers += 1
      puts "Total number of customers: #@@no_of_customers"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

Hier ist @@ no_of_customers eine Klassenvariable. Dies führt zu folgendem Ergebnis:

Total number of customers: 1
Total number of customers: 2

Lokale Ruby-Variablen

Lokale Variablen beginnen mit einem Kleinbuchstaben oder _. Der Umfang einer lokalen Variablen reicht von Klasse, Modul, Def oder Do bis zum entsprechenden Ende oder von der öffnenden Klammer eines Blocks bis zu seiner geschlossenen Klammer {}.

Wenn auf eine nicht initialisierte lokale Variable verwiesen wird, wird dies als Aufruf einer Methode ohne Argumente interpretiert.

Die Zuordnung zu nicht initialisierten lokalen Variablen dient auch als Variablendeklaration. Die Variablen beginnen zu existieren, bis das Ende des aktuellen Bereichs erreicht ist. Die Lebensdauer lokaler Variablen wird bestimmt, wenn Ruby das Programm analysiert.

Im obigen Beispiel sind die lokalen Variablen id, name und addr.

Rubinkonstanten

Konstanten beginnen mit einem Großbuchstaben. Auf Konstanten, die innerhalb einer Klasse oder eines Moduls definiert sind, kann innerhalb dieser Klasse oder dieses Moduls zugegriffen werden, und auf Konstanten, die außerhalb einer Klasse oder eines Moduls definiert sind, kann global zugegriffen werden.

Konstanten dürfen nicht innerhalb von Methoden definiert werden. Das Verweisen auf eine nicht initialisierte Konstante führt zu einem Fehler. Wenn Sie einer bereits initialisierten Konstante eine Zuweisung vornehmen, wird eine Warnung ausgegeben.

#!/usr/bin/ruby

class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

# Create Objects
object = Example.new()
object.show

Hier sind VAR1 und VAR2 Konstanten. Dies führt zu folgendem Ergebnis:

Value of first Constant is 100
Value of second Constant is 200

Ruby Pseudo-Variablen

Es handelt sich um spezielle Variablen, die wie lokale Variablen aussehen, sich jedoch wie Konstanten verhalten. Sie können diesen Variablen keinen Wert zuweisen.

• self - Das Empfängerobjekt der aktuellen Methode.

• true - Wert, der wahr darstellt.

• false - Wert, der false darstellt.

• nil - Wert, der undefiniert darstellt.

• __FILE__ - Der Name der aktuellen Quelldatei.

• __LINE__ - Die aktuelle Zeilennummer in der Quelldatei.

Ruby Basic Literals

Die Regeln, die Ruby für Literale verwendet, sind einfach und intuitiv. In diesem Abschnitt werden alle grundlegenden Ruby-Literale erläutert.

Ganzzahlige Zahlen

Ruby unterstützt Ganzzahlen. Eine Ganzzahl kann zwischen -2 ³⁰ und 2 ^30-1 oder -2 ⁶² bis 2 ^{62-1 liegen} . Ganzzahlen innerhalb dieses Bereichs sind Objekte der Klasse Fixnum, und Ganzzahlen außerhalb dieses Bereichs werden in Objekten der Klasse Bignum gespeichert .

Sie schreiben Ganzzahlen mit einem optionalen Vorzeichen, einem optionalen Basisindikator (0 für Oktal, 0x für Hex oder 0b für Binär), gefolgt von einer Ziffernfolge in der entsprechenden Basis. Unterstriche werden in der Ziffernfolge ignoriert.

Sie können auch den ganzzahligen Wert abrufen, der einem ASCII-Zeichen entspricht, oder die Sequenz umgehen, indem Sie ihm ein Fragezeichen voranstellen.

Beispiel

123                  # Fixnum decimal
1_234                # Fixnum decimal with underline
-500                 # Negative Fixnum
0377                 # octal
0xff                 # hexadecimal
0b1011               # binary
?a                   # character code for 'a'
?\n                  # code for a newline (0x0a)
12345678901234567890 # Bignum

NOTE - Klasse und Objekte werden in einem separaten Kapitel dieses Tutorials erläutert.

Floating Numbers

Ruby unterstützt schwebende Zahlen. Sie sind auch Zahlen, aber mit Dezimalstellen. Gleitkommazahlen sind Objekte der Klasse Float und können eine der folgenden sein:

Beispiel

123.4                # floating point value
1.0e6                # scientific notation
4E20                 # dot not required
4e+20                # sign before exponential

String-Literale

Ruby-Strings sind einfach Sequenzen von 8-Bit-Bytes und Objekte der Klasse String. Zeichenfolgen mit doppelten Anführungszeichen ermöglichen Substitution und Backslash-Notation, Zeichenfolgen mit einfachen Anführungszeichen ermöglichen jedoch keine Substitution und Backslash-Notation nur für \\ und \ '

Beispiel

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

Dies führt zu folgendem Ergebnis:

escape using "\"
That's right

Sie können den Wert eines beliebigen Ruby-Ausdrucks mithilfe der Sequenz in eine Zeichenfolge einsetzen #{ expr }. Hier könnte expr ein beliebiger rubinroter Ausdruck sein.

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

Dies führt zu folgendem Ergebnis:

Multiplication Value : 86400

Backslash-Notationen

Im Folgenden finden Sie eine Liste der von Ruby unterstützten Backslash-Notationen:

Notation	Zeichen dargestellt
\ n	Newline (0x0a)
\ r	Wagenrücklauf (0x0d)
\ f	Formfeed (0x0c)
\ b	Rücktaste (0x08)
\ein	Bell (0x07)
\ e	Flucht (0x1b)
\ s	Leerzeichen (0x20)
\ nnn	Oktalschreibweise (n ist 0-7)
\ xnn	Hexadezimale Notation (n ist 0-9, af oder AF)
\ cx, \ Cx	Control-x
\ Mx	Meta-x (c | 0x80)
\ M- \ Cx	Meta-Control-x
\ x	Zeichen x

Weitere Informationen zu Ruby Strings finden Sie unter Ruby Strings .

Ruby Arrays

Literale von Ruby Array werden erstellt, indem eine durch Kommas getrennte Reihe von Objektreferenzen zwischen die eckigen Klammern gesetzt wird. Ein nachfolgendes Komma wird ignoriert.

Beispiel

#!/usr/bin/ruby

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

Dies führt zu folgendem Ergebnis:

fred
10
3.14
This is a string
last element

Weitere Informationen zu Ruby-Arrays finden Sie in Ruby-Arrays .

Ruby Hashes

Ein wörtlicher Ruby Hash wird erstellt, indem eine Liste von Schlüssel / Wert-Paaren zwischen geschweiften Klammern mit einem Komma oder der Sequenz => zwischen dem Schlüssel und dem Wert platziert wird. Ein nachfolgendes Komma wird ignoriert.

Beispiel

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

Dies führt zu folgendem Ergebnis:

red is 3840
green is 240
blue is 15

Weitere Informationen zu Ruby Hashes finden Sie unter Ruby Hashes .

Ruby Ranges

Ein Bereich stellt ein Intervall dar, bei dem es sich um eine Reihe von Werten mit einem Anfang und einem Ende handelt. Bereiche können mit den Literalen s..e und s ... e oder mit Range.new erstellt werden.

Bereiche, die mit .. erstellt wurden, verlaufen vom Anfang bis einschließlich zum Ende. Diejenigen, die mit ... erstellt wurden, schließen den Endwert aus. Bei Verwendung als Iterator geben Bereiche jeden Wert in der Sequenz zurück.

Ein Bereich (1..5) bedeutet, dass er 1, 2, 3, 4, 5 Werte enthält, und ein Bereich (1 ... 5) bedeutet, dass er 1, 2, 3, 4 Werte enthält.

Beispiel

#!/usr/bin/ruby

(10..15).each do |n| 
   print n, ' ' 
end

Dies führt zu folgendem Ergebnis:

10 11 12 13 14 15

Weitere Informationen zu Ruby Ranges finden Sie unter Ruby Ranges .