Ruby: variables, constantes y literales

Las variables son las ubicaciones de la memoria, que contienen los datos que utilizará cualquier programa.

Hay cinco tipos de variables compatibles con Ruby. También ha realizado una pequeña descripción de estas variables en el capítulo anterior. Estos cinco tipos de variables se explican en este capítulo.

Variables globales de Ruby

Las variables globales comienzan con $. Las variables globales no inicializadas tienen el valor nil y producen advertencias con la opción -w.

La asignación a variables globales altera el estado global. No se recomienda utilizar variables globales. Hacen programas crípticos.

A continuación se muestra un ejemplo que muestra el uso de la variable global.

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

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

NOTE - En Ruby, PUEDE acceder al valor de cualquier variable o constante poniendo un carácter de almohadilla (#) justo antes de esa variable o constante.

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

Variables de instancia de Ruby

Las variables de instancia comienzan con @. Las variables de instancia no inicializadas tienen el valor nil y producen advertencias con la opción -w.

A continuación, se muestra un ejemplo que muestra el uso de variables de instancia.

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

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

Variables de clase Ruby

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

Hacer referencia a una variable de clase no inicializada produce un error. Las variables de clase se comparten entre los descendientes de la clase o módulo en el que se definen las variables de clase.

Las variables de clase anuladas producen advertencias con la opción -w.

Aquí hay un ejemplo que muestra el uso de la variable de clase:

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

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

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

Variables locales de Ruby

Las variables locales comienzan con una letra minúscula o _. El alcance de una variable local va desde clase, módulo, def o do hasta el final correspondiente o desde la llave de apertura de un bloque a su llave cerrada {}.

Cuando se hace referencia a una variable local no inicializada, se interpreta como una llamada a un método que no tiene argumentos.

La asignación a variables locales no inicializadas también sirve como declaración de variable. Las variables comienzan a existir hasta que se alcanza el final del ámbito actual. La vida útil de las variables locales se determina cuando Ruby analiza el programa.

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

Constantes de rubí

Las constantes comienzan con una letra mayúscula. Se puede acceder a las constantes definidas dentro de una clase o módulo desde dentro de esa clase o módulo, y las definidas fuera de una clase o módulo se puede acceder globalmente.

Es posible que las constantes no se definan dentro de los métodos. Hacer referencia a una constante no inicializada produce un error. Hacer una asignación a una constante que ya está inicializada produce una advertencia.

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

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

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

Pseudovariables Ruby

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

self - El objeto receptor del método actual.
true - Valor que representa verdadero.
false - Valor que representa falso.
nil - Valor que representa indefinido.
__FILE__ - El nombre del archivo fuente actual.
__LINE__ - El número de línea actual en el archivo fuente.

Literales básicos de Ruby

Las reglas que usa Ruby para los literales son simples e intuitivas. Esta sección explica todos los literales básicos de Ruby.

Números enteros

Ruby admite números enteros. Un número entero puede oscilar entre -2 ³⁰ y 2 ^30-1 o entre -2 ⁶² y 2 ^62-1 . Los enteros dentro de este rango son objetos de la clase Fixnum y los enteros fuera de este rango se almacenan en objetos de la clase Bignum .

Escribe enteros usando un signo inicial opcional, un indicador de base opcional (0 para octal, 0x para hexadecimal o 0b para binario), seguido de una cadena de dígitos en la base adecuada. Los caracteres de subrayado se ignoran en la cadena de dígitos.

También puede obtener el valor entero, correspondiente a un carácter ASCII o escapar de la secuencia precediéndola con un signo de interrogación.

Ejemplo

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 - Las clases y los objetos se explican en un capítulo aparte de este tutorial.

Números flotantes

Ruby admite números flotantes. También son números pero con decimales. Los números de coma flotante son objetos de la clase Float y pueden ser cualquiera de los siguientes:

Ejemplo

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

Literales de cadena

Las cadenas de Ruby son simplemente secuencias de bytes de 8 bits y son objetos de la clase String. Las cadenas entre comillas dobles permiten la sustitución y la notación de barra invertida, pero las cadenas entre comillas simples no permiten la sustitución y permiten la notación de barra invertida solo para \\ y \ '

Ejemplo

#!/usr/bin/ruby -w

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

Esto producirá el siguiente resultado:

escape using "\"
That's right

Puede sustituir el valor de cualquier expresión de Ruby en una cadena usando la secuencia #{ expr }. Aquí, expr podría ser cualquier expresión rubí.

#!/usr/bin/ruby -w

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

Esto producirá el siguiente resultado:

Multiplication Value : 86400

Notaciones de barra invertida

A continuación se muestra la lista de notaciones de barra invertida compatibles con Ruby:

Notación	Personaje representado
\norte	Nueva línea (0x0a)
\ r	Retorno de carro (0x0d)
\F	Formfeed (0x0c)
\segundo	Retroceso (0x08)
\un	Campana (0x07)
\mi	Escape (0x1b)
\ s	Espacio (0x20)
\ nnn	Notación octal (siendo n 0-7)
\ xnn	Notación hexadecimal (n es 0-9, af o AF)
\ cx, \ Cx	Control-x
\ Mx	Meta-x (c \| 0x80)
\ M- \ Cx	Meta-Control-x
\X	Personaje x

Para obtener más detalles sobre Ruby Strings, consulte Ruby Strings .

Matrices de rubí

Los literales de Ruby Array se crean colocando una serie de referencias de objetos separadas por comas entre corchetes. Se ignora una coma al final.

Ejemplo

#!/usr/bin/ruby

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

Esto producirá el siguiente resultado:

fred
10
3.14
This is a string
last element

Para obtener más detalles sobre Ruby Arrays, consulte Ruby Arrays .

Ruby Hashes

Un Ruby Hash literal se crea colocando una lista de pares clave / valor entre llaves, con una coma o la secuencia => entre la clave y el valor. Se ignora una coma al final.

Ejemplo

#!/usr/bin/ruby

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

Esto producirá el siguiente resultado:

red is 3840
green is 240
blue is 15

Para obtener más detalles sobre Ruby Hashes, consulte Ruby Hashes .

Rangos de rubí

Un rango representa un intervalo que es un conjunto de valores con un inicio y un final. Los rangos se pueden construir usando los literales s..e y s ... e, o con Range.new.

Los rangos construidos usando .. van desde el principio hasta el final inclusive. Los creados con ... excluyen el valor final. Cuando se utiliza como iterador, los rangos devuelven cada valor de la secuencia.

Un rango (1..5) significa que incluye 1, 2, 3, 4, 5 valores y un rango (1 ... 5) significa que incluye 1, 2, 3, 4 valores.

Ejemplo

#!/usr/bin/ruby

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

Esto producirá el siguiente resultado:

10 11 12 13 14 15

Para obtener más detalles sobre Ruby Ranges, consulte Ruby Ranges .

↰ Previous page Next page ↱