Módulos

Los módulos son similares a las clases en que contienen una colección de métodos, constantes y otros módulos y definiciones. Pero a diferencia de las clases, no se pueden crear clases derivadas de los módulos.

Utilidades de los módulos

Primero, actúan como librería, definiendo métodos cuyos nombres no interfieran con otros definidos en otros sitios.

# trig.rb  
module Trig  
  PI = 3.1416  
  # métodos 
  def Trig.sin(x)  
    # ...  
  end  
  def Trig.cos(x)  
    # ...  
  end  
end  
 
# moral.rb  
module Moral  
  MUY_MAL = 0  
  MAL     = 1  
  def Moral.sin(maldad)  
    # ...  
  end  
end  
 
# modulos.rb  
require 'trig'  
require 'moral'  
Trig.sin(Trig::PI/4)    # "::" -> PI/4 de la clas Trig 
Moral.sin(Moral::MUY_MAL)

Segundo, permiten aumentar las funcionalidades de las clases: si una clase usa un módulo, los métodos de este módulo estarán disponibles en los objetos que procedan de esta clase.

module D  
  def initialize(nombre)  
    @nombre =nombre  
  end  
  def to_s  
    @nombre  
  end  
end  
 
module Debug  
  include D  
  # Los métodos que actúan como preguntas,
  # se les añade una ?
  def quien_soy?
    "#{self.class.name} (\##{self.object_id}): #{self.to_s}"
  end
end
 
class Gramola
  # la instrucción 'include' hace referencia a un módulo.
  # Si el módulo está en otro fichero, hay que usar 'require'
  # antes de usar el 'include'. 
  include Debug  
  # ...  
end  
 
class OchoPistas 
  include Debug  
  # ...  
end  
 
gr = Gramola.new("West End Blues")
op = Ochopistas.new("Real Pillow")
puts gr.quien_soy?
puts op.quien_soy?

Cuando se usa require o load, se pone el nombre del item entre comillas; sin embargo, esto no hace falta con include. Esto es así porque en el primer caso toman strings como argumentos, mietnras que include toma el nombre del módulo en la forma de una constante.

módulos vs clases

La principal diferencia entre heredar de una clase y usar un módulo, es que puedes usar más de un módulo al mismo tiempo. Recordar, que no se permitía tener más de una clase madre. Esto permite añadir numerosas funciones al código.

Otra ventaja, es que podemos almacenar nuestros programas de forma modular: cada módulo añade una característica. Esto también lo permitían las clases, pero la ventaje de los módulos, es que no hace falta crear una serie de jerarquías, que podría llegar a ser engorroso.

RAILS: el código de Rails hace un fuerte uso de los módulos, en particular, la técnica de reabrir las definiciones de clases y módulos.

Si no se indica lo contrario, el contenido de esta página se ofrece bajo Creative Commons Attribution 3.0 License