Grunderna i att skapa och använda Ruby-moduler

Ruby on Rails är ett fantastiskt ramverk för fullstack-webbapplikationer med öppen källkod som prioriterar konventioner framför konfiguration.  Med återanvändbara, lätt konfigurerbara komponenter som normalt används för att skapa applikationer går det snabbare och enklare att bygga applikationer i Rails, vilket resulterar i förbättrad produktivitet och affärstillväxt. Det vinner inflytande bland utvecklare eftersom det är flexibelt, skalbart och enkelt för webbutvecklare att skriva och underhålla applikationer. 

Ruby on Rails lägger tonvikten på att använda kända tekniska mönster och principer för att minska arbetsbelastningen när man bygger webbapplikationer. Även om det finns flera metoder för att lösa en programmeringsutmaning, säger Ruby sig förlita sig på vanliga mönster som gör Rails webbplatser lättare att underhålla och uppgradera. Bibliotek med öppen källkod med mindre block av Rails-kod som löser särskilda problem används vanligtvis för att minska utvecklingskostnader. Med hjälp av sådana kodblock kan utvecklare infoga stabila, väl beprövade ädelstenar istället för att lägga tid på att skriva samma slags koder. Ett av de mest kraftfulla verktygen i en Ruby-programmerares verktygslåda är modulen. Rubin Moduler tillhandahålla en struktur för att samla Ruby-klasser, metoder och konstanter i en enda enhet med eget namn och egen definition.

Detta är användbart så att du kan undvika konflikter med befintliga klasser, metoder och konstanter, och även så att du kan lägga till (mixa in) modulernas funktionalitet i dina klasser.

Skapa en modul i Ruby

Att skapa en modul går till på ungefär samma sätt som att skapa en klass, med den skillnaden att man använder nyckelordet ”module” istället för nyckelordet ”class”.

modul MyFirstModule
  def say_hello
    puts "Hello"
  end
end

Moduler kan inte instansieras. För att använda en modul måste du antingen inkludera den eller utöka den inom en klass.

Användning av include och extend

• inkludera

Införlivar modulens metoder som instansmetoder i klassen.

• förlänga

Införlivar modulens metoder som klassmetoder i klassen.

Exempel

modul ReusableModule
  def module_method
    puts "Modulmetod: Hej!"
  end
end

klass ClassThatIncludes
  include ReusableModule
end

klass ClassThatExtends
  extend ReusableModule
end

puts "Inkludera"
ClassThatIncludes.new.module_method
# => "Modulmetod: Hej!"

puts "Utöka"
ClassThatExtends.module_method
# => "Modulmetod: Hej!"

Andra viktiga begrepp om moduler i Ruby

1. Grunderna i metoduppslag:

modul M
  def report
    puts "'report'-metoden i modul M"
  end
end

klass C
  include M
end

klass D < C
end

obj = D.new
obj.report

Produktion:

'Metoden 'report” i modulen M

Hur metoduppslag fungerar

När ett Ruby-objekt tar emot ett meddelande (metodanrop) söker det efter metoden i följande ordning:

1. Objektklassen (D)
2. Moduler som ingår i kursen (D)
3. Överklassen (C)
4. Moduler som ingår i superklassen (M)
5. Fortsätt uppåt i arvskedjan

I det här fallet:

• D definierar inte rapporten
• I C finns ingen definition av ”report”
• C innehåller modulen M
• M definierar rapporten, så Ruby kör den

2. Att definiera samma metod mer än en gång

Om en metod definieras flera gånger har den sista definitionen företräde. Detta gäller både klasser och moduler.

modul InterestBearing
  def calculate_interest
    puts "Platshållare! Vi befinner oss i modulen InterestBearing."
  end
end

klass BankAccount
  include InterestBearing

  def calculate_interest
    puts "Platshållare! Vi befinner oss i klassen BankAccount."
    puts "Och vi överskriver metoden calculate_interest!"
  end
end

account = BankAccount.new
account.calculate_interest

Produktion:

Platshållare! Vi befinner oss i klassen BankAccount.
Och vi överskriver metoden `calculate_interest`!

Klassmetoden åsidosätter modulmetoden.

3. Att blanda in flera Ruby-moduler med samma metodnamn

modul M
  def report
    puts "'report'-metoden i modul M"
  end
end

modul N
  def report
    puts "'report'-metoden i modul N"
  end
end

class C
  include M
  include N
end

c = C.new
c.report

Produktion:

'Metoden 'report” i modulen N

Den senast inkluderade modulen vinner eftersom den förekommer först i metodsökvägen.

4. Att inkludera en Ruby-modul mer än en gång

klass C
  include M
  include N
  include M
slut

c = C.new
c.report

Produktion:

'Metoden 'report” i modulen N

Förklaring

Att inkludera en modul på nytt har ingen effekt om modulen redan finns i sökvägen. Ruby flyttar inte upp den till toppen igen. Den senast inkluderade nya modulen (N) har fortfarande företräde.

5. Att använda super med Ruby-moduler

Med nyckelordet ”super” kan du anropa nästa metod i metoduppslagskedjan.

modul M
  def report
    puts "'report'-metoden i modul M"
  end
end

klass C
  include M

  def report
    puts "'report'-metoden i klass C"
    puts "Ska nu anropa nästa överordnade "report"-metod...'
    super
    puts 'Tillbaka från "super'-anropet."
  end
end

c = C.new
c.report

Produktion:

'Metoden 'report' i klassen C
Ska just anropa den närmast överordnade rapportmetoden...
Metoden 'report' i modulen M
Tillbaka från 'super”-anropet.

Vad händer här?

• Ruby kör först rapporten i klass C
• super anropar nästa rapportmetod i uppslagskedjan (från modul M)
• Kontrollen återgår sedan till klassmetoden

RailsCarma har arbetat på RoR från början och med en stark arbetsstyrka utbildad i RoR har det vuxit till att bli ett mycket pålitligt namn i slutändan Ruby on Rails konsulttjänster, arkitektur, byggnad, förvaltning och utbyggnad till företag runt om i världen. 

Läs mer : 

• Implementering av TinyMCE i Ruby on Rails

• Förstå Asset Pipeline Plugin

• Polymorfa associationer med aktiva rekord

• Ett enkelt sätt att öka prestandan för din Rails-app

Kontakta oss.