Ruby Language
modules

Syntaxis

• Verklaring

  module Name;
  
      any ruby expressions;
  
  end
  

Opmerkingen

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

Een eenvoudige mix met 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

Nu is Bar een mix van zijn eigen methoden en de methoden van SomeMixin .

Merk op dat een mixin in een klasse wordt gebruikt, afhankelijk van hoe deze wordt toegevoegd:

• het include trefwoord evalueert de modulecode in de klassencontext (bijvoorbeeld methodedefinities zijn methoden voor instanties van de klasse),
• extend zal de modulecode evalueren in de context van de singleton-klasse van het object (methoden zijn direct beschikbaar op het uitgebreide object).

Module als naamruimte

Modules kunnen andere modules en klassen bevatten:

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

Een eenvoudige mixin met verlenging

Een mixin is slechts een module die aan een klasse kan worden toegevoegd (gemengd). een manier om dit te doen is met de uitbreidingsmethode. De extend voegt methoden van de mixin toe als klassemethoden.

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 

Modules en klassensamenstelling

U kunt modules gebruiken om complexere klassen te bouwen door middel van compositie . De include ModuleName richtlijn neemt de methoden van een module op in een 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 bevat nu methoden van zowel Foo als Bar naast zijn eigen 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!'