Rubino sui binari è un meraviglioso framework open source per applicazioni web full-stack che privilegia le convenzioni rispetto alla configurazione. Grazie ai componenti riutilizzabili e facilmente configurabili normalmente utilizzati per la creazione di applicazioni, la creazione di applicazioni in Rails è più rapida e semplice, con conseguente miglioramento della produttività e della crescita aziendale. Sta guadagnando terreno tra gli sviluppatori poiché è flessibile, scalabile e facile per gli sviluppatori web scrivere e gestire applicazioni.
Rubino sui binari pone l'accento sull'utilizzo di modelli e principi ingegneristici noti al fine di ridurre il carico di lavoro durante la creazione di applicazioni web. Anche se esistono diversi metodi per risolvere una sfida di programmazione, Ruby afferma di fare affidamento su modelli comunemente utilizzati che rendono i siti Web Rails più facili da mantenere e aggiornare. Le librerie open source con blocchi più piccoli di codice Rails che risolvono problemi particolari vengono comunemente utilizzate per ridurre il sovraccarico di sviluppo. Con l'aiuto di tali blocchi di codice, gli sviluppatori possono inserire gemme stabili e ben testate invece di perdere tempo a scrivere gli stessi tipi di codici. Uno degli strumenti più potenti nella cassetta degli attrezzi di un programmatore Ruby è il modulo. Rubino Moduli forniscono una struttura per raccogliere le classi, i metodi e le costanti di Ruby in un'unica unità definita e nominata separatamente.
Ciò è utile per evitare conflitti con classi, metodi e costanti esistenti e anche per poter aggiungere (mixare) la funzionalità dei moduli nelle tue classi.
Creare un modulo in Ruby
La creazione di un modulo è simile alla creazione di una classe, con la differenza che si usa la parola chiave module invece della parola chiave class.
modulo MyFirstModule
def say_hello
mette "Ciao"
fine
fine
I moduli non possono essere istanziati. Per utilizzare un modulo, è necessario includerlo o estenderlo all'interno di una classe.
Utilizzo di include e extend
- includere
Mescola i metodi del modulo come metodi di istanza della classe.
- estendere
Mescola i metodi del modulo come metodi della classe.
Esempio
modulo Modulo riutilizzabile
def modulo_metodo
mette "Metodo del modulo: Ciao!"
end
fine
classe ClasseCheInclude
include Modulo riutilizzabile
fine
classeCheEstende
estende ReusableModule
fine
mette "Include"
ClassThatIncludes.new.module_method
# => "Metodo modulo: Ciao!"
puts "Estendere"
ClasseCheEstende.module_method
# => "Metodo modulo: Ciao!"
Altri concetti importanti sui moduli in Ruby
1. Nozioni di base sulla ricerca dei metodi:
modulo M
def rapporto
mette "'report' metodo nel modulo M"
fine
fine
classe C
include M
fine
classe D < C
fine
obj = D.new
obj.report
Produzione:
'metodo 'report' nel modulo M
Come funziona la ricerca del metodo
Quando un oggetto Ruby riceve un messaggio (chiamata di metodo), cerca il metodo in questo ordine:
- La classe degli oggetti (D)
- Moduli inclusi nella classe (D)
- La superclasse (C)
- Moduli inclusi nella superclasse (M)
- Continuare a risalire la catena ereditaria
In questo caso:
- D non definisce il rapporto
- C non definisce il rapporto
- C include il modulo M
- M definisce il report, quindi Ruby lo esegue
2. Definizione dello stesso metodo più volte
Se un metodo è definito più volte, l'ultima definizione ha la precedenza. Questo vale sia per le classi che per i moduli.
modulo Interessi
def calcola_interesse
puts "Segnaposto! Siamo nel modulo InterestBearing".
fine
fine
classe ContoBanca
include InteresseCorrelato
def calcola_interessi
puts "Segnaposto! Siamo nella classe BankAccount".
puts "E stiamo sovrascrivendo il metodo calcola_interesse!"
fine
fine
conto = BankAccount.new
conto.calcola_interesse
Produzione:
Segnaposto! Siamo nella classe BankAccount.
E stiamo sovrascrivendo il metodo calculate_interest!
Il metodo della classe sovrascrive il metodo del modulo.
3. Mescolare più moduli Ruby con lo stesso nome di metodo
modulo M
def rapporto
mette "'report' metodo nel modulo M"
fine
fine
modulo N
def rapporto
mette "'report' metodo nel modulo N"
fine
fine
classe C
include M
includere N
fine
c = C.new
c.report
Produzione:
'metodo 'report' nel modulo N
L'ultimo modulo incluso vince perché appare per primo nel percorso di ricerca dei metodi.
4. Includere un modulo Ruby più di una volta
classe C includere M includere N includere M fine c = C.new c.report
Produzione:
'metodo 'report' nel modulo N
Spiegazione
La reinclusione di un modulo non ha effetto se il modulo è già presente nel percorso di ricerca. Ruby non lo sposta di nuovo in cima. Il nuovo modulo incluso più di recente (N) ha ancora la precedenza.
5. Usare super con i moduli Ruby
La parola chiave super consente di chiamare il metodo successivo nella catena di ricerca dei metodi.
modulo M
def rapporto
mette "'report' metodo nel modulo M"
fine
fine
classe C
include M
def rapporto
puts "'report' metodo nella classe C"
puts "In procinto di attivare il prossimo metodo di report di livello superiore..."
super
puts "Ritorno dalla chiamata 'super'".
end
fine
c = C.new
c.report
Produzione:
'Metodo 'report' nella classe C In procinto di attivare il metodo di report successivo... Metodo 'report' nel modulo M Di ritorno dalla chiamata 'super'.
Cosa succede qui
- Ruby esegue prima il rapporto nella classe C
- super chiama il metodo di report successivo nella catena di ricerca (dal modulo M)
- Il controllo torna quindi al metodo della classe
RailsCarma ha lavorato su RoR sin dalla sua fase nascente e con una forte forza lavoro addestrata in RoR, è cresciuto fino a diventare un nome di grande fiducia nella consulenza end-to-end, architettura, costruzione, gestione ed estensione di Ruby on Rails ad aziende di tutto il mondo.
Per saperne di più :
Iscriviti per gli ultimi aggiornamenti
Informazioni sull'autore del post
Italian 
English 
Japanese 
German 
French 
Spanish 
Swedish