Latest web development tutorials

Variables Ruby

Variable tient toutes les données peuvent être utilisées par un programme stocké.

Ruby prend en charge cinq types de variables.

  • En général, les lettres minuscules, en commençant par un trait de soulignement: Variable (Variable).
  • $ Au début: une variable globale (variable globale).
  • @ Le début: les variables d'instance (variable d'instance).
  • @@ Début: variable de classe (variable de catégorie) les variables de classe sont partagés entre la chaîne d'héritage
  • Commencez par une lettre majuscule: Constant (Constant).

Vous avez dans les chapitres précédents sur la compréhension de ces variables, ce chapitre vous fournir une explication détaillée de ces cinq types de variables.

variable globale Ruby

Les variables globales commencent par $. variable globale Uninitialized estnul,dans l'option -w, un avertissement est généré.

Pour l'affectation variable globale va changer l'état global, donc nous ne recommandons pas l'utilisation de 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, $ variable_globale est une variable globale. On obtient les résultats suivants:

Remarque: Dans Ruby, vous pouvez placer le caractère # devant une variable ou constante, pour accéder à une variable ou valeur constante.

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

variables d'instance Ruby

@ Variable d'instance pour commencer. variable d'instance non initialisée estnul,dans l'option -w, un avertissement est généré.

L'exemple suivant montre l'utilisation de variables d'instance. 

#! / Usr / bin / ruby

classe client
   initialiser def (id, nom, addr)
      @ Cust_id = id
      @ Cust_name = nom
      @ Cust_addr = addr
   fin
   display_details def ()
      puts "id client # @ cust_id"
      puts "Nom du client # @ cust_name"
      puts "Adresse du client # @ cust_addr"
    fin
fin

# Créer un objet cust1 = Customer.new ( "1", "John", "Sagesse Apartments, Ludhiya")
Cust2 = Customer.new ( "2", "Poul", "route Nouvel Empire, Khandala")

# méthode d'appel cust1.display_details ()
() cust2.display_details

Ici, @ cust_id, @ cust_name et @cust_addr est une variable d'instance. On obtient 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

Au début des variables @@ de classe et doit être initialisé avant de pouvoir utiliser plus tard dans la définition de la méthode.

Référence une classe variable non initialisée va générer une erreur. Les variables de classe définies dans la classe ou sous-classe de modules ou sous-modules peuvent être partagés.

Après avoir utilisé l'option -w, la surcharge des variables de classe va produire un avertissement.

L'exemple suivant montre l'utilisation de 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. On obtient les résultats suivants: 

Nombre total de clients: 1
Nombre total de clients: 2

variables locales Ruby

Les variables locales commencent par une lettre minuscule ou un trait de soulignement _. La portée des variables locales de la classe, module, def ou faire l'extrémité correspondante de l'accolade aux accolades gauche ou à droite {}.

Lorsque vous appelez une variable locale non initialisée, il est interprété comme appelant une méthode sans paramètres.

affectation variable locale non initialisée peut également être utilisé comme une déclaration de variable. Variable existera jusqu'à la fin du domaine actuel jusqu'à présent. Cycle de vie des variables locales déterminées à Ruby parser.

Dans l'exemple ci-dessus, la variable locale est l'identifiant, le nom et adr.

constantes Ruby

Constant avec une lettre majuscule. Définir des constantes au sein de la classe ou le module peut être consulté à partir de la classe ou du module, définies en dehors d'une des constantes de classe ou modules sont accessibles à l'échelle mondiale.

Les constantes ne peuvent pas être définies dans le procédé. Référence une erreur constante uninitialized se produit. Déjà valeurs constantes initialisées va générer un avertissement. 

#! / Usr / bin / ruby
# - * - Codage: UTF-8 - * -

Exemple de classe
   VAR1 = 100
   VAR2 = 200
   def show
       puts "La première constante est # {VAR1}"
       puts "La deuxième constante est # {VAR2}"
   fin
fin

# Créer un objet Object = Example.new ()
object.show

Ici, VAR1 et VAR2 sont des constantes. On obtient les résultats suivants: 

La première valeur constante de 100
La seconde constante est de 200

Ruby pseudo-variable

Ils sont des variables spéciales, avec l'apparition des variables locales, mais agit comme une constante. Vous ne pouvez pas attribuer une valeur à ces variables.

  • auto: objets récepteurs de la méthode actuelle.
  • vrai: le représentant de la vraie valeur.
  • false: La valeur représente faux.
  • nil: valeur indéfinie représentant.
  • __FILE__: Le nom actuel du fichier source.
  • __LINE__: Numéro de ligne du fichier source.