Nombres en Ruby

Los nombres en Ruby se utilizan para referirse a constantes, variables, métodos, clases y módulos. El primer caracter de un nombre, ayuda a ruby a identificar su uso. Algunos nombres son palabras reservadas y no pueden usarse como nombres de variables, métodos, clases o módulos. Los nombres deben comenzar con una letra mayúscula, minúscula o un guión bajo y puede contener sólo números, leras o guiones bajos ( _ ).

Variables

Las variables pueden contener datos de todo tipo y pueden ser usadas sin necesidad de declararlas. El nombre mismo de la variable denota su alcance (local, global, de instancia, etc.)

  • El nombre de una variable local consiste de una letra minúscula (o un guión bajo) y un número arbitrario de letras minúsculas, mayúsculas, números o guiones bajos. sunil, _z, numero_de_veces son ejemplos de variables locales.
  • Las variables de instancia (instance variables) comienzan con el símbolo arroba (@) seguidas por letras minúsculas, mayúsculas, guiones bajos o números. @signo, @_, y @contador son ejemplos de variables de instancia.
  • El nombre de las variable de clase (class variables) comienza con dos símbolos arroba (@@) seguidos por letras mayúsculas, minúsculas, números o guiones bajos. Por ejemplo: @@signo, @@_, @@contador.
  • Las variables globales (global variables) comienzan con un símbolo de dolar ($) seguidas de letras mayúsculas, minúsculas, números, guiones bajos o un guión ( – ) seguido de cualquier caracter. $contador, $CONTADOR, $-x son ejemplos de variables globales.

Constantes

Los nombres de constantes comienzan con una letra mayúscula seguida de un número arbitrario de letras mayúsculas, minúsculas, números o guiones bajos. Los nombres de clases y módulos son constantes y deben seguir las convenciones de los nombres de constantes. Por ejemplo: module Matematicas, PI=3.1416, class Animales.

Nombres de métodos

En Ruby, los nombres de métodos deben comenzar con una letra minúscula (o un guión bajo). ? y ! son los únicos caracteres extraños permitidos como sufijos de los nombres de métodos (! etiqueta un método potencialmente peligroso o destructivo).

Una convención de Ruby es utilizar guiones bajos para separar las palabras en nombres de métodos o variables que contienen más de una. Para los nombres de clases, módulos y constantes, la convención es que la primera letra de cada palabra sea mayúscula.

Es importante notar que una variable, en cualquier momento determinado, puede hacer referencia a objetos de diferentes tipos. Las constantes son creadas cuando son asignadas por primera vez (normalmente dentro de la definición de clase o un módulo; no deben ser definidas dentro de un método).

En Ruby, es posible cambiar el valor de una constante, aunque hacerlo genera un mensaje de advertencia.

Las variables en Ruby actúan como referencias a objetos, que están sujetos a la recolección de basura.1

El ejemplo p007dt.rb muestra que Ruby es escrito dinámicamente:

 1 =begin
 2   El primer caracter de un nombre, ayuda a ruby a distinguir
 3   cómo debe usarse.
 4   Las variables de instancia comienzan con el símbolo @
 5   Las variables de clase comienzan con @@
 6   Las variables globales comienzan con $
 7   Las constantes comienzan con una letra mayúscula
 8   Los nombres de métodos deben comenzar con una letra minúscula
 9   ? y ! son caracteres permitidos como sufijos de nombres de métodos
10   ! etiqueta a un método como destructivo o peligroso
11   utiliza guiones bajos para separar palabros en metodos o variables
12   que contienen mas de una
13   Los nombres de clases, módulos y constantes usan letras mayúsculas 
14 =end
15 
16 # Ruby is dinámico
17 x = 7           # número entero (integer)
18 x = "house"     # cadena (string)
19 x = 7.5         # número decimal (float)
20 
21 # En Ruby, todo es un objeto
22 'Me gusta Ruby'.length

Los tipos básicos en Ruby son Numeric (subtipos de Numeric son Fixnum, Integer y Float), String, Array, Hash, Object, Symbol, Range y RegEx. En Ruby no existen los tipos de datos “primitivos”.

1 El recolector de basura descubre cuando un objeto ya no está en uso y lo elimina, liberando la memoria asignada al objeto. Este mecanismo es muy conveniente porque como programador, no tienes que preocuparte por destruír manualmente objetos que ya no están en uso.

Por otro lado, la recolección de basura, como cualquier proceso, consume recursos y el rendimiento de un programa puede verse afectado cuando está activo.

La recolección de basura no es un concepto excusivo de Ruby. Java utiliza un sistema.En lenguajes como C++ no existe la recolección \de basura. Es responsabilidad del programador eliminar los objetos que el programa no utiliza, lo que puede resultar en los famosos memory leaks si no se eliminan los objetos eficientemente.