Ruby Language
moduler

Syntax

• Deklaration

  module Name;
  
      any ruby expressions;
  
  end
  

Anmärkningar

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

En enkel mixin med inkludera

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 är Bar en blandning av sina egna metoder och metoderna från SomeMixin .

Observera att hur en mixin används i en klass beror på hur den läggs till:

• nyckelordet include utvärderar modulkoden i klassens sammanhang (t.ex. metoddefinitioner kommer att vara metoder i klassens instanser),
• extend kommer att utvärdera modulkoden i samband med singletonklassen för objektet (metoder finns tillgängliga direkt på det utvidgade objektet).

Modul som namnutrymme

Moduler kan innehålla andra moduler och klasser:

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

En enkel mixin med förlängning

En mixin är bara en modul som kan läggas till (mixas in) i en klass. ett sätt att göra det är med förlängningsmetoden. extend lägger till blandningsmetoder som klassmetoder.

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 

Moduler och klassens sammansättning

Du kan använda moduler för att bygga mer komplexa klasser genom komposition . Direktivet om include ModuleName innehåller en moduls metoder i en klass.

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 innehåller nu metoder från både Foo och Bar utöver sina egna metoder.

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