Ruby Variables

Una variable es una ubicación de almacenamiento que contiene cualquier dato que pueda ser utilizado por cualquier programa.

Ruby admite cinco tipos de variables.

  • Generalmente comienzan con letras minúsculas o guion bajo: variables (Variable).
  • $$ al inicio: variable global (Global variable).
  • @@ al inicio: variable de instancia (Instance variable).
  • @@@@ al inicio: variable de clase (Class variable). Las variables de clase se comparten en toda la cadena de herencia.
  • Comienzan con letra mayúscula: constante (Constant).

Ya ha tenido una idea general de estas variables en capítulos anteriores; en este capítulo le explicaremos en detalle estos cinco tipos de variables.

Ruby Variables globales

Las variables globales comienzan con $. El valor de una variable global no inicializada esnily, al usar la opción -w, se generará una advertencia.

Asignar un valor a una variable global cambia el estado global, por lo que no se recomienda usar variables globales.

El siguiente ejemplo muestra el uso de variables globales.

Ejemplo

#!/usr/bin/ruby # -*- coding: UTF-8 -*- $global_variable = 10 class Class1 def print_global puts "La variable global se imprime en Class1 como #$global_variable" end end class Class2 def print_global puts "La variable global se imprime en Class2 como #$global_variable" end end class1obj = Class1.new class1obj.print_global class2obj = Class2.new class2obj.print_global

Pruébalo »

Aquí, $global_variable es una variable global. Esto producirá el siguiente resultado:

Nota:En Ruby, puede acceder al valor de cualquier variable o constante colocando el carácter # delante de la variable o constante.

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

Ruby Variables de instancia

Las variables de instancia comienzan con @. El valor de una variable de instancia no inicializada esnily, al usar la opción -w, se generará una advertencia.

El siguiente ejemplo muestra el uso de variables de instancia.

Ejemplo

#!/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 #Crear objeto cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya") cust2=Customer.new("2", "Poul", "New Empire road, Khandala") #Llamar al método cust1.display_details() cust2.display_details()

Pruébalo »

Aquí, @cust_id, @cust_name y @cust_addr son variables de instancia. Esto producirá el siguiente resultado:

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

Ruby Variables de clase

Las variables de clase comienzan con @@ y deben inicializarse antes de poder usarse en definiciones de métodos.

Hacer referencia a una variable de clase no inicializada producirá un error. Las variables de clase se pueden compartir entre subclases o submódulos de la clase o módulo donde se definen.

Al usar la opción -w, redefinir una variable de clase generará una advertencia.

El siguiente ejemplo muestra el uso de variables de clase.

Ejemplo

#!/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 #Crear objeto cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya") cust2=Customer.new("2", "Poul", "New Empire road, Khandala") #Llamar al método cust1.total_no_of_customers() cust2.total_no_of_customers()

Pruébalo »

Aquí, @@no_of_customers es una variable de clase. Esto producirá el siguiente resultado:

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

Ruby Variables locales

Las variables locales comienzan con una letra minúscula o un guion bajo _. El ámbito de una variable local va desde class, module, def o do hasta su correspondiente final, o desde la llave izquierda hasta la llave derecha {}.

Cuando se llama a una variable local no inicializada, se interpreta como una llamada a un método sin argumentos.

Asignar un valor a una variable local no inicializada también se puede considerar como una declaración de variable. La variable existe hasta que finaliza el ámbito actual. El ciclo de vida de las variables locales se determina cuando Ruby analiza el programa.

En el ejemplo anterior, las variables locales son id, name y addr.

Ruby Constantes

Las constantes comienzan con una letra mayúscula. Las constantes definidas dentro de una clase o módulo pueden ser accedidas desde el interior de la clase o módulo; las constantes definidas fuera de una clase o módulo pueden ser accedidas globalmente.

Las constantes no pueden definirse dentro de un método. Hacer referencia a una constante no inicializada producirá un error. Asignar un valor a una constante ya inicializada producirá una advertencia.

Ejemplo

#!/usr/bin/ruby # -*- coding: UTF-8 -*- class Example VAR1 = 100 VAR2 = 200 def show puts "El valor de la primera constante es #{VAR1}" puts "El valor de la segunda constante es #{VAR2}" end end #Crear objeto object=Example.new() object.show

Pruébalo »

Aquí, VAR1 y VAR2 son constantes. Esto producirá el siguiente resultado:

第一个常量的值为 100
第二个常量的值为 200

Ruby Variables pseudo

Son variables especiales que tienen la apariencia de variables locales, pero se comportan como constantes. No puede asignarles ningún valor.

  • self:El objeto receptor del método actual.
  • true:Representa el valor true.
  • false:Representa el valor false.
  • nil:Representa el valor undefined.
  • __FILE__:El nombre del archivo fuente actual.
  • __LINE__:El número de la línea actual en el archivo fuente.
Otras extensiones