Variables rubis


Une variable est un emplacement de stockage qui contient toutes les données pouvant être utilisées par n'importe quel programme.

Ruby prend en charge cinq types de variables.

  • Lettres généralement minuscules, commençant par un trait de soulignement : Variable. Commençant par

  • $ : Variable globale. Commençant par

  • @ : variable d'instance.

  • @@ commence par : Variable de classe Les variables de classe sont partagées tout au long de la chaîne d'héritage

  • Comme par des lettres majuscules : constante ( Constante).

Vous avez déjà grossièrement compris ces variables dans les chapitres précédents. Ce chapitre vous expliquera ces cinq types de variables en détail.

Variables globales Ruby

Les variables globales commencent par $. La valeur d'une variable globale non initialisée est nil, ce qui générera un avertissement après avoir utilisé l'option -w.

L'attribution de valeurs aux variables globales modifiera l'état global, il n'est donc pas recommandé d'utiliser des variables globales.

L'exemple suivant montre l'utilisation de variables globales. 

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$global_variable = 10
class Class1
  def print_global
      puts "全局变量在 Class1 中输出为 #$global_variable"
  end
end
class Class2
  def print_global
      puts "全局变量在 Class2 中输出为 #$global_variable"
  end
end

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


Ici, $global_variable est la variable globale. Cela produira le résultat suivant :

Remarque : Dans Ruby, vous pouvez accéder à la valeur de n'importe quelle variable ou constante en plaçant le caractère # devant la variable ou la constante. 

全局变量在 Class1 中输出为 10
全局变量在 Class2 中输出为 10

Variables d'instance Ruby

Les variables d'instance commencent par @. Les variables d'instance non initialisées ont la valeur nil, ce qui générera un avertissement après avoir utilisé l'option -w.

L'exemple suivant montre l'utilisation de 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

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.display_details()
cust2.display_details()


Ici, @cust_id, @cust_name et @cust_addr sont des variables d'instance. Cela produira les résultats suivants : 

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 une définition de méthode.

Référencer une variable de classe non initialisée générera une erreur. Les variables de classe peuvent être partagées entre des sous-classes ou des sous-modules de la classe ou du module dans lequel elles sont définies.

La surcharge des variables de classe produit un avertissement après avoir utilisé l'option -w.

L'exemple suivant montre l'utilisation des variables 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

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.total_no_of_customers()
cust2.total_no_of_customers()


Ici, @@no_of_customers est une variable de classe. Cela produira les résultats suivants : 

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

Variables locales Ruby

Les variables locales commencent par une lettre minuscule ou un trait de soulignement _. Les variables locales s'étendent de la classe, du module, def ou do à la fin correspondante ou de l'accolade ouvrante à l'accolade fermante {}.

Lorsqu'une variable locale non initialisée est appelée, elle est interprétée comme appelant une méthode sans paramètres.

L'attribution de valeurs à des variables locales non initialisées peut également être considérée comme des déclarations de variables. La variable existera jusqu'à la fin de la portée actuelle. 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 Ruby

Les constantes commencent par une lettre majuscule. Les constantes définies dans une classe ou un module sont accessibles depuis l'intérieur de la classe ou du module, et les constantes définies en dehors de la classe ou du module sont accessibles globalement.

La constante ne peut pas être définie dans une méthode. Faire référence à une constante non initialisée générera une erreur. L'attribution d'une valeur à une constante initialisée générera un avertissement. 

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

class Example
   VAR1 = 100
   VAR2 = 200
   def show
       puts "第一个常量的值为 #{VAR1}"
       puts "第二个常量的值为 #{VAR2}"
   end
end

# 创建对象
object=Example.new()
object.show


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

第一个常量的值为 100
第二个常量的值为 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 : représente la valeur de true.

  • false : représente la valeur de false.

  • nil : représente la valeur d'undefined.

  • __FILE__ : Le nom du fichier source actuel.

  • __LINE__ : Le numéro de la ligne actuelle dans le fichier source.