¿Cómo puedo inicializar las variables de instancia de un módulo en Ruby?

Tengo algunos módulos en los que me gustaría usar variables de instancia. Actualmente los estoy inicializando así:

module MyModule
  def self.method_a(param)
    @var ||= 0
    # other logic goes here
  end
end

También podría llamar a un método init para inicializarlos:

def init
  @var = 0
end

pero esto significaría que tengo que recordar llamarlo siempre.

¿Existe una forma mejor de hacer esto?

Inicialícelos en la definición del módulo.

module MyModule
  # self here is MyModule
  @species = "frog"
  @color = "red polka-dotted"
  @log = []

  def self.log(msg)
    # self here is still MyModule, so the instance variables are still available
    @log << msg
  end
  def self.show_log
    puts @log.map { |m| "A #@color #@species says #{m.inspect}" }
  end
end

MyModule.log "I like cheese."
MyModule.log "There's no mop!"
MyModule.show_log #=> A red polka-dotted frog says "I like cheese."
                  #   A red polka-dotted frog says "There's no mop!"

Esto establecerá las variables de instancia cuando se defina el módulo. Recuerde, siempre puede volver a abrir el módulo más tarde para agregar más variables de instancia y definiciones de métodos, o para redefinir las existentes:

# continued from above...
module MyModule
  @verb = "shouts"
  def self.show_log
    puts @log.map { |m| "A #@color #@species #@verb #{m.inspect}" }
  end
end
MyModule.log "What's going on?"
MyModule.show_log #=> A red polka-dotted frog shouts "I like cheese."
                  #   A red polka-dotted frog shouts "There's no mop!"
                  #   A red polka-dotted frog shouts "What's going on?"

Puedes usar:

def init(var=0)
 @var = var
end

Y se establecerá por defecto en 0 si no pasa nada.

Si no quiere tener que llamarlo cada vez, puede usar algo como esto:

module AppConfiguration
   mattr_accessor :google_api_key
   self.google_api_key = "123456789"
...

end

para una clase, diría lo siguiente, ya que se llama a initialize cada vez que usted.

def initialize
   @var = 0
end

de Practical Ruby :

Continúa diciendo que se llamará a la inicialización de un módulo si la inicialización de una clase incluida llama a super, pero no menciona que esto es una consecuencia de cómo funciona super en todas partes, no un manejo especial para la inicialización. (¿Por qué se puede suponer que initialize recibe un tratamiento especial? Porque recibe un tratamiento especial con respecto a la visibilidad. Los casos especiales crean confusión).

Respondí una pregunta similar , puede establecer variables de instancia de clase haciendo esto

module MyModule
  class << self; attr_accessor :var; end
end

MyModule.var
=> nil

MyModule.var = 'this is saved at @var'
=> "this is saved at @var"

MyModule.var    
=> "this is saved at @var"

Aparentemente, es una mala forma inicializar variables de instancia en un módulo en Ruby. (Por razones que no entiendo completamente, pero relacionadas con el orden en el que se instancian las cosas).

Parece que la mejor práctica es usar accesores con inicialización perezosa, así:

module MyModule
  def var
    @var ||= 0 
  end
end

Luego utilícelo varcomo getter para @var.