Juan de Frías
Desarrollo web ágil

Mucha gente desconoce Ruby cuando se pone a programar en Rails. Uno de los conceptos más importantes que tiene Ruby son los modules

Los modules (o módulos) son una forma de agrupar métodos, clases y constantes. A diferencia de una clase, un module no tiene instancias de sí mismo. Principalmente, los modules se utilizan para:
– Uso de namespaces para evitar colisión de nombres y clases.
– Para la llamada “mixin”, una especie de herencia que explico más adelante.

Para explicar el porqué se usan como namespaces veamos el siguiente ejemplo de sintaxis de un module, muy parecida a la sintaxis de una clase de Ruby:

module Example
  PI = 3.141592
  def method1
    # ...
  end

  def method2
    # ...
  end
end

  En Ruby, el operador unitario “::” se usa para acceder desde fuera a constantes, métodos de instancia o métodos de clase de dentro de una clase o module, teniendo en cuenta que en Ruby las clases y métodos pueden ser consideradas constantes también. Así pues, si queremeos acceder a la constante “PI” definida en el module Example, utilizaremos los “::”, del siguiente modo:

Example::PI

  Mientras que si queremos ejecutar el método “method1” del “module Example” usaremos:

Example.method1

Sabiendo en parte ya cómo funcionan y se definen los modules, ahora hay que aprender a poder utilizarlos. Supongamos que el archivo que contiene el module Example se llama “example.rb”. Pues bien, para poder utilizar dicho module, necesitaremos la sentecia “require”, similar a la sentencia “include” de C y C++. Sería del siquiente modo, sin la extensión “.rb”, si no queremos:

require 'example'

Habiendo entendido este concepto, nos podemos plantear utilizar estas funcionalidades extra que nos proporciona un module dentro de una clase. Para ello, necesitamos la sentencia “include” de Ruby, utilizada del siguiente modo:

include Modulename

 Lo que ocurre es que muchas veces el module y la clase que utilizan dicho module no se encuentren en el mismo archivo, por lo que necesitaremos utilizar la sentencia “require” antes explicada. Así pues, consideremos un archivo myclass.rb que contendrá una clase que use el module Example definido en ‘example.rb’, tal que así:

require 'example'

class MyClass
  include Example

  def hello_world
    # ...
  end
end

De este modo, podemos ejecutar algo del tipo:

mc = MyClass.new
mc.method1
mc.method2
mc.hello_wold

Llegado este punto, podemos entender ya los “mixins”, que consisten en una especie de herencia múltiple. Traducido a Ruby y a lo que acabamos de ver, significa que una clase puede usar varios modules a la vez. Así pues, podríamos tener definido un segundo module en otro archivo, por ejemplo “example2.rb”, resultando:

module Example2
  def method3
    # ...
  end

  def method4
    # ...
  end
end

Y ahora podríamos utilzar dicho module en la clase “MyClass” del siguiente modo:

require 'example'
require 'example2'

class MyClass
  include Example
  include Example2

  def hello_world
    # ...
  end
end

Pudiendo ahora ejecutar:

mc = MyClass.new
mc.method1
mc.method2
mc.method3
mc.method4
mc.hello_wold

Como apunte final, comentar que del mismo que hemos usado “include” para métodos de instancia, podríamos usar “extend” para métodos de clase.