Ruby Language
Module

Syntax

• Erklärung

  module Name;
  
      any ruby expressions;
  
  end
  

Bemerkungen

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

Ein einfaches Mixin mit 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

Jetzt ist Bar eine Mischung aus eigenen Methoden und den Methoden von SomeMixin .

Beachten Sie, dass die Verwendung eines Mixins in einer Klasse davon abhängt, wie er hinzugefügt wird:

• das include Schlüsselwort wertet den Modulcode im Klassenkontext aus (z. B. werden Methodendefinitionen Methoden auf Instanzen der Klasse sein),
• extend wertet den Modulcode im Kontext der Singleton-Klasse des Objekts aus (Methoden sind direkt für das erweiterte Objekt verfügbar).

Modul als Namensraum

Module können andere Module und Klassen enthalten:

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

Eine einfache Mischung mit verlängern

Ein Mixin ist nur ein Modul, das einer Klasse hinzugefügt (gemischt) werden kann. Eine Möglichkeit, dies zu tun, ist die Erweiterungsmethode. Die extend fügt Methoden des Mixins als Klassenmethoden hinzu.

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 

Module und Klassenzusammensetzung

Sie können Module verwenden, um durch Komposition komplexere Klassen zu erstellen. Die include ModuleName Anweisung include ModuleName integriert die Methoden eines Moduls in eine Klasse.

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 enthält jetzt sowohl Methoden aus Foo als auch Bar sowie eigene Methoden.

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!'