Ruby Language
moduli

Sintassi

• Dichiarazione

  module Name;
  
      any ruby expressions;
  
  end
  

Osservazioni

module foo; end # Syntax error: class/module name must be CONSTANT

Un semplice mixin con include

module SomeMixin
  def foo
    puts "foo!"
  end
end

class Bar
  include SomeMixin
  def baz
    puts "baz!"
  end
end

b = Bar.new
b.baz         # => "baz!"
b.foo         # => "foo!"
# works thanks to the mixin

Now Bar è un mix dei suoi metodi e dei metodi di SomeMixin .

Si noti che il modo in cui un mixin viene utilizzato in una classe dipende da come viene aggiunto:

• la parola chiave include valuta il codice del modulo nel contesto della classe (ad esempio, le definizioni del metodo saranno metodi sulle istanze della classe),
• extend il codice del modulo nel contesto della classe singleton dell'oggetto (i metodi sono disponibili direttamente sull'oggetto esteso).

Modulo come spazio dei nomi

I moduli possono contenere altri moduli e classi:

module Namespace

    module Child

        class Foo; end

    end # module Child

    # Foo can now be accessed as:
    #
    Child::Foo

end # module Namespace

# Foo must now be accessed as:
# 
Namespace::Child::Foo

Un semplice mixin con estensione

Un mixin è solo un modulo che può essere aggiunto (mescolato in) a una classe. un modo per farlo è con il metodo estendere. Il metodo di extend aggiunge metodi del mixin come metodi di classe.

module SomeMixin
  def foo
    puts "foo!"
  end
end

class Bar
  extend SomeMixin
  def baz
    puts "baz!"
  end
end

b = Bar.new
b.baz         # => "baz!"
b.foo         # NoMethodError, as the method was NOT added to the instance
Bar.foo       # => "foo!"
# works only on the class itself 

Moduli e composizione di classe

È possibile utilizzare i moduli per creare classi più complesse attraverso la composizione . La direttiva include ModuleName incorpora i metodi di un modulo in una classe.

module Foo
  def foo_method
    puts 'foo_method called!'
  end
end

module Bar
  def bar_method
    puts 'bar_method called!'
  end
end

class Baz
  include Foo
  include Bar

  def baz_method
    puts 'baz_method called!'
  end  
end

Baz ora contiene metodi di Foo e Bar oltre ai propri metodi.

new_baz = Baz.new
new_baz.baz_method #=> 'baz_method called!'
new_baz.bar_method #=> 'bar_method called!'
new_baz.foo_method #=> 'foo_method called!'