Grunderna för att skapa och använda moduler i Rails

Ruby on Rails är en underbar öppen källkod full-stack webbapplikationsramverk som gynnar konvention 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.

Moduler tillhandahåller en struktur för att samla Ruby-klasser, metoder och konstanter i en enda, separat namngiven och definierad enhet.

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: Att skriva en modul liknar att skriva en klass, förutom att du börjar din definition med modulnyckelordet istället för klassnyckelordet.

modul MyFirstModule

def säg_hej

sätter "Hej"

slutet

slutet

Eftersom vi inte kan instansiera modulen så för att använda modulen måste vi utöka ar inkludera modulen till en klass.

inkluderar: blandar in specificerade modulmetoder som instansmetoder i målklassen

extend : blandar in specificerade modulmetoder som klassmetoder i målklassen

modul ReusableModule

def module_metod

sätter "Modulmetod: Hej då!"

slutet

slutet

klass KlassSomInkluderar

inkluderar ReusableModule

slutet

klass ClassThatExtends

utöka ReusableModule

slutet

sätter "Inkludera"

ClassThatIncludes.new.module_method # "Modulmetod: Hej!"

sätter "förläng"

ClassThatExtends.module_method # "Modulmetod: Hej!"

============================================================

Annan punkt om Module in Ruby:

1: ) Illustrerar grunderna för metodsökning:

modul M

def rapport

lägger "rapporteringsmetoden i modul M"

slutet

slutet

klass C

inkluderar M

slutet

klass D < C

slutet

obj = D.ny

obj.rapport

Produktion:

#=> 'rapport' metod i modul M

Arbetsflöde: Anta att jag är ett Ruby-objekt och att jag har fått meddelandet "rapport". Jag måste försöka hitta en metod som heter rapport i min metod

sökväg. rapporten, om den finns, finns i en klass eller modul.

Jag är en instans av en klass som heter D. Definierar D en instansmetodrapport?

Nej.

Blandar D in några moduler?

Nej.

Definierar D:s superklass, C, en rapportinstansmetod?

Nej.

Blandar C in några moduler?

Ja: M.

Definierar M en rapportmetod?

Ja.

Bra! Jag kör den metoden.

2:) Definiera samma metod mer än en gång:

Om du definierar en metod två gånger i samma klass, har den andra definitionen företräde framför den första. Detsamma gäller moduler.

modul Räntebärande

def calculate_interest

sätter "Platshållare! Vi är i modulen InterestBearing.”

slutet

slutet

klass Bankkonto

inkluderar Räntebärande

def calculate_interest

sätter "Platshållare! Vi är i klass Bankkonto.”

sätter "Och vi åsidosätter calculate_interest-metoden!"

slutet

slutet

konto = Bankkonto.nytt

konto.beräkna_ränta

Produktion:

#=>Platshållare! Vi är i klass Bankkonto.

#=>Och vi åsidosätter calculate_interest-metoden!

3:) Blandning i två moduler med en definierad metod med samma namn:

modul M

def rapport

lägger "rapporteringsmetoden i modul M"

slutet

slutet

modul N

def rapport

lägger "rapporteringsmetoden i modul N"

slutet

slutet

klass C

inkluderar M

inkluderar N

slutet

c = C.ny

c.rapportera

Produktion:

#=> rapportmetoden i modul N

4:) Inklusive en modul mer än en gång

klass C

inkluderar M

inkluderar N

inkluderar M

slutet

c = C.ny

c.rapportera

#=> rapportmetoden i modul N

Arbetsflöde:

Du kan förvänta dig att när du körde rapportmetoden skulle du få M:s version, eftersom M var den senast inkluderade modulen.

Men att återinkludera en modul gör ingenting. Eftersom M redan ligger på sökvägen, har den andra instruktionen inkludera M ingen effekt. N anses fortfarande vara den senast inkluderade modulen:

5:) Gå upp för metodsökvägen med super: Inuti brödtexten i en metoddefinition kan du använda supernyckelordet för att hoppa upp till den näst högsta definitionen, i metodsökningsvägen, av den metod du för närvarande använder verkställande.

modul M

def rapport

lägger "rapporteringsmetoden i modul M"

slutet

slutet

klass C

inkluderar M

def rapport

lägger "rapporteringsmetoden i klass C"

sätter "Är på väg att utlösa nästa rapportmetod högre upp..."

super

sätter "Tillbaka från "super" samtalet."

slutet

slutet

B

C

D

c = C.ny

c.rapportera

#=> 'rapport' metod i klass C

På väg att utlösa nästa rapportmetod högre upp...

'rapport' metod i modul M Tillbaka från 'super' samtalet.

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.