The Basics of Creating and Using Ruby Modules

Ruby auf Schienen is a wonderful open source full-stack web application framework favoring convention over configuration.  Mit wiederverwendbaren, leicht konfigurierbaren Komponenten, die normalerweise zum Erstellen von Anwendungen verwendet werden, ist das Erstellen von Anwendungen in Rails schneller und einfacher, was zu einer verbesserten Produktivität und einem höheren Geschäftswachstum führt. Es erfreut sich bei Entwicklern wachsender Beliebtheit, da es flexibel und skalierbar ist und Webentwicklern das Schreiben und Warten von Anwendungen erleichtert. 

Ruby auf Schienen legt Wert darauf, bekannte technische Muster und Prinzipien zu verwenden, um den Arbeitsaufwand beim Erstellen von Webanwendungen zu reduzieren. Auch wenn es mehrere Methoden gibt, eine Programmierherausforderung zu lösen, gibt Ruby an, dass es sich auf häufig verwendete Muster verlässt, was die Wartung und Aktualisierung von Rails-Websites erleichtert. Open-Source-Bibliotheken mit kleineren Rails-Codeblöcken zur Lösung bestimmter Probleme werden häufig verwendet, um den Entwicklungsaufwand zu reduzieren. Mit Hilfe solcher Codeblöcke können Entwickler stabile, gut getestete Gems einfügen, anstatt Zeit mit dem Schreiben der gleichen Codearten zu verbringen. Eines der leistungsstärksten Werkzeuge im Werkzeugkasten eines Ruby-Programmierers ist das Modul. Rubin Modules provide a structure to collect Ruby classes, methods, and constants into a single, separately named and defined unit.

Dies ist nützlich, damit Sie Konflikte mit vorhandenen Klassen, Methoden und Konstanten vermeiden und die Funktionalität von Modulen in Ihre Klassen einfügen (einmischen) können.

Creating a Module in Ruby

Creating a module is similar to creating a class, except you use the module keyword instead of the class keyword.

module MyFirstModule
  def say_hello
    puts "Hello"
  end
end

Modules cannot be instantiated. To use a module, you must either include or extend it within a class.

Using include and extend

• einschließen.

Mixes the module’s methods in as instance methods of the class.

• erweitern.

Mixes the module’s methods in as class methods of the class.

Beispiel

module ReusableModule
  def module_method
    puts "Module Method: Hi there!"
  end
end

class ClassThatIncludes
  include ReusableModule
end

class ClassThatExtends
  extend ReusableModule
end

puts "Include"
ClassThatIncludes.new.module_method
# => "Module Method: Hi there!"

puts "Extend"
ClassThatExtends.module_method
# => "Module Method: Hi there!"

Other Important Concepts About Modules in Ruby

1. Method Lookup Basics:

module M
  def report
    puts "'report' method in module M"
  end
end

class C
  include M
end

class D < C
end

obj = D.new
obj.report

Ausgabe:

'report' method in module M

How Method Lookup Works

When a Ruby object receives a message (method call), it searches for the method in this order:

1. The objects class (D)
2. Modules included in the class (D)
3. The superclass (C)
4. Modules included in the superclass (M)
5. Continue up the inheritance chain

In this case:

• D does not define report
• C does not define report
• C includes module M
• M defines report, so Ruby executes it

2. Defining the Same Method More Than Once

If a method is defined multiple times, the last definition takes precedence. This applies to both classes and modules.

module InterestBearing
  def calculate_interest
    puts "Placeholder! We're in module InterestBearing."
  end
end

class BankAccount
  include InterestBearing

  def calculate_interest
    puts "Placeholder! We're in class BankAccount."
    puts "And we're overriding the calculate_interest method!"
  end
end

account = BankAccount.new
account.calculate_interest

Ausgabe:

Placeholder! We're in class BankAccount.
And we're overriding the calculate_interest method!

The class method overrides the module method.

3. Mixing in Multiple Ruby Modules with the Same Method Name

module M
  def report
    puts "'report' method in module M"
  end
end

module N
  def report
    puts "'report' method in module N"
  end
end

class C
  include M
  include N
end

c = C.new
c.report

Ausgabe:

'report' method in module N

The last included module wins because it appears first in the method lookup path.

4. Including a Ruby Module More Than Once

class C
  include M
  include N
  include M
end

c = C.new
c.report

Ausgabe:

'report' method in module N

Explanation

Re-including a module has no effect if the module is already in the lookup path. Ruby does not move it to the top again. The most recently included new module (N) still takes precedence.

5. Using super with Ruby Modules

The super keyword allows you to call the next method up the method lookup chain.

module M
  def report
    puts "'report' method in module M"
  end
end

class C
  include M

  def report
    puts "'report' method in class C"
    puts "About to trigger the next higher-up report method..."
    super
    puts "Back from the 'super' call."
  end
end

c = C.new
c.report

Ausgabe:

'report' method in class C
About to trigger the next higher-up report method...
'report' method in module M
Back from the 'super' call.

What Happens Here

• Ruby first executes report in class C
• super calls the next report method in the lookup chain (from module M)
• Control then returns back to the class method

SchienenCarma hat von Anfang an an RoR gearbeitet und sich mit einer starken Belegschaft, die in RoR geschult ist, zu einem äußerst vertrauenswürdigen Namen für umfassende Ruby on Rails-Beratung, Architektur, Aufbau, Management und Erweiterung für Unternehmen auf der ganzen Welt entwickelt. 

Mehr lesen : 

• Implementierung von TinyMCE in Ruby on Rails

• Grundlegendes zum Asset-Pipeline-Plugin

• Polymorphe Assoziationen mit aktivem Datensatz

• Eine einfache Möglichkeit, die Leistung Ihrer Rails-App zu steigern

Nehmen Sie Kontakt mit uns auf.