Ruby - Variables, constantes et littéraux

Les variables sont les emplacements de mémoire, qui contiennent toutes les données à utiliser par n'importe quel programme.

Il existe cinq types de variables pris en charge par Ruby. Vous avez déjà parcouru une petite description de ces variables dans le chapitre précédent. Ces cinq types de variables sont expliqués dans ce chapitre.

Variables globales Ruby

Les variables globales commencent par $. Les variables globales non initialisées ont la valeur nil et produisent des avertissements avec l'option -w.

L'affectation à des variables globales modifie le statut global. Il n'est pas recommandé d'utiliser des variables globales. Ils rendent les programmes cryptiques.

Voici un exemple montrant l'utilisation de la variable globale.

#!/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

Ici, $ global_variable est une variable globale. Cela produira le résultat suivant -

NOTE - Dans Ruby, vous POUVEZ accéder à la valeur de n'importe quelle variable ou constante en mettant un caractère dièse (#) juste avant cette variable ou constante.

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

Variables d'instance Ruby

Les variables d'instance commencent par @. Les variables d'instance non initialisées ont la valeur nil et produisent des avertissements avec l'option -w.

Voici un exemple montrant l'utilisation des variables d'instance.

#!/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()

Ici, @cust_id, @cust_name et @cust_addr sont des variables d'instance. Cela produira le résultat suivant -

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

Variables de classe Ruby

Les variables de classe commencent par @@ et doivent être initialisées avant de pouvoir être utilisées dans les définitions de méthode.

Le référencement d'une variable de classe non initialisée produit une erreur. Les variables de classe sont partagées entre les descendants de la classe ou du module dans lequel les variables de classe sont définies.

Le remplacement des variables de classe produit des avertissements avec l'option -w.

Voici un exemple montrant l'utilisation de la variable de classe -

#!/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()

Ici, @@ no_of_customers est une variable de classe. Cela produira le résultat suivant -

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

Variables locales Ruby

Les variables locales commencent par une lettre minuscule ou _. La portée d'une variable locale va de class, module, def ou do jusqu'à la fin correspondante ou de l'accolade ouvrante d'un bloc à son accolade fermante {}.

Lorsqu'une variable locale non initialisée est référencée, elle est interprétée comme un appel à une méthode qui n'a pas d'arguments.

L'affectation à des variables locales non initialisées sert également de déclaration de variable. Les variables commencent à exister jusqu'à ce que la fin de la portée actuelle soit atteinte. La durée de vie des variables locales est déterminée lorsque Ruby analyse le programme.

Dans l'exemple ci-dessus, les variables locales sont id, name et addr.

Constantes rubis

Les constantes commencent par une lettre majuscule. Les constantes définies au sein d'une classe ou d'un module sont accessibles depuis cette classe ou ce module, et celles définies en dehors d'une classe ou d'un module sont accessibles globalement.

Les constantes peuvent ne pas être définies dans les méthodes. Le référencement d'une constante non initialisée produit une erreur. L'affectation d'une constante déjà initialisée génère un avertissement.

#!/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

Ici, VAR1 et VAR2 sont des constantes. Cela produira le résultat suivant -

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

Pseudo-variables Ruby

Ce sont des variables spéciales qui ont l'apparence de variables locales mais se comportent comme des constantes. Vous ne pouvez attribuer aucune valeur à ces variables.

self - L'objet récepteur de la méthode actuelle.
true - Valeur représentant vrai.
false - Valeur représentant false.
nil - Valeur représentant undefined.
__FILE__ - Le nom du fichier source actuel.
__LINE__ - Le numéro de ligne actuel dans le fichier source.

Littéraux de base Ruby

Les règles utilisées par Ruby pour les littéraux sont simples et intuitives. Cette section explique tous les littéraux Ruby de base.

Nombres entiers

Ruby prend en charge les nombres entiers. Un nombre entier peut aller de -2 ³⁰ à 2 ^30-1 ou -2 ⁶² à 2 ^62-1 . Les entiers dans cette plage sont des objets de la classe Fixnum et les entiers en dehors de cette plage sont stockés dans des objets de la classe Bignum .

Vous écrivez des entiers en utilisant un signe de début facultatif, un indicateur de base facultatif (0 pour octal, 0x pour hexadécimal ou 0b pour binaire), suivi d'une chaîne de chiffres dans la base appropriée. Les caractères de soulignement sont ignorés dans la chaîne de chiffres.

Vous pouvez également obtenir la valeur entière, correspondant à un caractère ASCII ou échapper à la séquence en la précédant d'un point d'interrogation.

Exemple

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 - La classe et les objets sont expliqués dans un chapitre séparé de ce didacticiel.

Nombres flottants

Ruby prend en charge les nombres flottants. Ce sont aussi des nombres mais avec des décimales. Les nombres à virgule flottante sont des objets de la classe Float et peuvent être l'un des suivants -

Exemple

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

Littéraux de chaîne

Les chaînes Ruby sont simplement des séquences d'octets de 8 bits et ce sont des objets de la classe String. Les chaînes entre guillemets autorisent la substitution et la notation avec barre oblique inverse, mais les chaînes entre guillemets simples n'autorisent pas la substitution et n'autorisent la notation avec barre oblique inverse que pour \\ et \ '

Exemple

#!/usr/bin/ruby -w

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

Cela produira le résultat suivant -

escape using "\"
That's right

Vous pouvez remplacer la valeur de n'importe quelle expression Ruby dans une chaîne à l'aide de la séquence #{ expr }. Ici, expr pourrait être n'importe quelle expression ruby.

#!/usr/bin/ruby -w

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

Cela produira le résultat suivant -

Multiplication Value : 86400

Notations de contre-oblique

Voici la liste des notations Backslash prises en charge par Ruby -

Notation	Personnage représenté
\ n	Nouvelle ligne (0x0a)
\ r	Retour chariot (0x0d)
\F	Formfeed (0x0c)
\ b	Retour arrière (0x08)
\une	Cloche (0x07)
\ e	Échapper (0x1b)
\ s	Espace (0x20)
\ nnn	Notation octale (n étant 0-7)
\ xnn	Notation hexadécimale (n étant 0-9, af ou AF)
\ cx, \ Cx	Contrôle-x
\ Mx	Meta-x (c \| 0x80)
\ M- \ Cx	Meta-Control-x
\X	Caractère x

Pour plus de détails sur Ruby Strings, consultez Ruby Strings .

Tableaux rubis

Les littéraux de Ruby Array sont créés en plaçant une série de références d'objets séparées par des virgules entre les crochets. Une virgule de fin est ignorée.

Exemple

#!/usr/bin/ruby

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

Cela produira le résultat suivant -

fred
10
3.14
This is a string
last element

Pour plus de détails sur les tableaux Ruby, consultez Ruby Arrays .

Ruby Hashes

Un Ruby Hash littéral est créé en plaçant une liste de paires clé / valeur entre accolades, avec une virgule ou la séquence => entre la clé et la valeur. Une virgule de fin est ignorée.

Exemple

#!/usr/bin/ruby

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

Cela produira le résultat suivant -

red is 3840
green is 240
blue is 15

Pour plus de détails sur Ruby Hashes, consultez Ruby Hashes .

Gammes de rubis

Une plage représente un intervalle qui est un ensemble de valeurs avec un début et une fin. Les plages peuvent être construites en utilisant les littéraux s..e et s ... e, ou avec Range.new.

Les plages construites en utilisant .. vont du début à la fin inclusivement. Ceux créés avec ... excluent la valeur finale. Lorsqu'elles sont utilisées comme itérateur, les plages renvoient chaque valeur de la séquence.

Une plage (1..5) signifie qu'elle comprend 1, 2, 3, 4, 5 valeurs et une plage (1 ... 5) signifie qu'elle comprend 1, 2, 3, 4 valeurs.

Exemple

#!/usr/bin/ruby

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

Cela produira le résultat suivant -

10 11 12 13 14 15

Pour plus de détails sur les gammes de rubis, consultez les gammes de rubis .

↰ Previous page Next page ↱

Ruby - Variables, constantes et littéraux

Variables globales Ruby

Variables d'instance Ruby

Variables de classe Ruby

Variables locales Ruby

Constantes rubis

Pseudo-variables Ruby

Littéraux de base Ruby

Nombres entiers

Exemple

Nombres flottants

Exemple

Littéraux de chaîne

Exemple

Notations de contre-oblique

Tableaux rubis

Exemple

Ruby Hashes

Exemple

Gammes de rubis

Exemple

Ruby avancé

Bases de Ruby

Ressources utiles Ruby