È passato un po 'di tempo da quando ho trovato codice rubino che non capivo, ma ci sono parti di binari che spingono davvero la mia comprensione del rubino.
Detto questo, anche se ci si trova a un livello più intermedio con la lingua, capire come funziona il funzionamento delle guide sarebbe probabilmente un ottimo modo per migliorare il gioco.
Per quanto riguarda dove iniziare, vorrei iniziare scrivendo i plugin. Pensa a un buon plugin che potresti scrivere che non è stato ancora fatto, o qualcosa che pensi di poter fare meglio. Qualunque cosa tu voglia fare, è probabile che avrai bisogno di collegarti a una specie di rail per farlo, il che ti darà un buon punto di partenza. Una volta che hai un po 'di conoscenza di una data area del framework, vedi se ci sono dei bachi aperti in quell'area che puoi aggiustare.
La barriera è piuttosto alta, poiché le rotaie sono un programma piuttosto ampio e complesso scritto da persone che hanno un alto livello di padronanza con un linguaggio incredibilmente flessibile. È anche una grande sfida che probabilmente ti renderà un programmatore migliore alla fine. :)
Edit: per dare una mano ringhiera
Questo è in realtà piuttosto interessante se si tratta di un frammento progettato per illustrare come variabili di classe e le classi singleton funzionano, ma ci sono modi molto più chiare per realizzare la stessa cosa se è un codice "reale".
Singleton Classe
In ruby, ogni oggetto ha una classe genitore che ottiene i suoi metodi da. Questo è abbastanza normale per le lingue OO. Ciò che non è normale è rubino ha anche un concetto chiamato "oggetto individuazione, ciò significa che gli oggetti possono avere metodi che sono solo su una specifica istanza, ma non sulla classe genitore. Ecco un breve esempio IRB
irb(main):001:0> foo = "bar"
=> "bar"
irb(main):002:0> def foo.foo_method
irb(main):003:1> "this is _only_ on the foo instance, not on all strings"
irb(main):004:1> end
=> nil
irb(main):005:0> foo.foo_method
=> "this is _only_ on the foo instance, not on all strings"
irb(main):006:0> "bar".foo_method
NoMethodError: undefined method `foo_method' for "bar":String
from (irb):6
irb(main):007:0> foo = "New string"
=> "New string"
irb(main):008:0> foo.foo_method
NoMethodError: undefined method `foo_method' for "New string":String
from (irb):8
In primo luogo, assegniamo una stringa a una variabile, quindi definiamo un metodo su quell'istanza. La chiamata del metodo funziona, ma non è possibile chiamarla su una nuova stringa. L'assegnazione di una nuova istanza di stringa alla nostra variabile foo non ha
Per rendere possibile l'individuazione dell'oggetto, è necessario che ci sia qualcosa tra l'istanza e la classe genitore, che è la classe singleton, e ogni istanza ne ha una che è unica rispetto a tutte le altre obje istanze di ct. Quando ruby sta cercando un metodo, esaminerà la classe singleton prima della classe genitore.
Che ci crediate o no, anche se non ne avete mai sentito parlare, probabilmente lo avete già usato. Se si desidera aggiungere un "metodo di classe" a qualcosa, di solito si esegue questa operazione
class Foo
def self.bar
"i am on the class"
end
end
Foo.bar #=> "I am on the class"
di partire dalla cima, la dichiarazione class Foo è l'esatto equivalente di questo Foo = Class.new do. Quello che sta succedendo è che stai assegnando una nuova istanza di tipo Class alla costante Foo. (per inciso, questo è ciò che amo del rubino.)
All'interno di una definizione di classe, self si riferisce alla classe, quindi dire def self.bar significa essenzialmente "definire la barra dei metodi sulla classe singleton dell'istanza di classe che è memorizzata nella costante Foo ".
Se trovi questa roba complessa, è perché lo è. Non penso che ci sia qualcosa di più completo in ruby che non sia quello che succede durante le ricerche di metodo, e le classi singleton sono una parte importante di ciò che lo rende così complesso.
Variabili Classe
Una variabile di classe è preceduto da @@, e fondamentalmente è una variabile il cui ambito è tutte le istanze, l'oggetto di classe, e tutte le classi che ereditano dalla classe.Farò una rapida irb per illustrare questo in azione
irb(main):003:0* class Foo
irb(main):004:1> @@instance_count = 0
irb(main):005:1>
irb(main):006:1* def initialize
irb(main):007:2> @@instance_count += 1
irb(main):008:2> end
irb(main):009:1>
irb(main):010:1* def count
irb(main):011:2> @@instance_count
irb(main):012:2> end
irb(main):013:1> end
=> nil
irb(main):014:0>
irb(main):015:0* class Bar < Foo
irb(main):016:1> end
=> nil
irb(main):017:0>
irb(main):018:0* f = Foo.new
=> #<Foo:0x7fa9089c7da0>
irb(main):019:0> f.count
=> 1
irb(main):020:0>
irb(main):021:0* b = Bar.new
=> #<Bar:0x7fa9089be0e8>
irb(main):022:0> b.count
=> 2
irb(main):023:0>
irb(main):024:0* f.count
=> 2
Per prima cosa, definiamo Foo. Foo ha una variabile di classe che tiene traccia di quante istanze sono state create. Per fare ciò, incrementiamo quella variabile nel costruttore, e infine definiamo semplicemente un getter veloce. Il bar amplia appena Foo.
Ora, per vederlo in azione, facciamo un nuovo foo, e controlliamo il conteggio, che è 1. Quindi, creiamo una nuova barra e controlliamo il conteggio, ora siamo a 2. Solo per essere sicuri che sia Foo che Bar condividono lo stesso conteggio, controlliamo di nuovo l'istanza di foo, ed ora è 2.
Le variabili di classe sono una funzionalità molto situazionale che di solito non si vede al di fuori del codice quadro. Di solito viene utilizzato quando si desidera tenere traccia di tutte le istanze di una determinata classe.
Ringhiera Codice
class << Object.new
@@var = 6
end
String.class_variable_get(:@@var) #=> 6
Il codice sta mostrando quei due concetti in azione. Innanzitutto, apriamo la classe singleton di un nuovo oggetto e inseriamo una variabile di classe. Se fosse qualcosa di diverso da una variabile di classe, quelle prime tre righe sarebbero il codice rubino più inutile al mondo. Ma poiché è una variabile di classe, diventa visibile alla classe, tutte le istanze della classe, tutte le classi che ereditano dalla classe e tutte le istanze di tutte le classi che ereditano dalla classe. Dal momento che la classe di cui stiamo parlando è oggetto, questo significa tutto. Quindi, class_variable_get su String lo dà a te, ma puoi accedere a quella variabile da qualsiasi classe o istanza che desideri.
mi dispiace
Questo è orribilmente complected roba che è molto difficile da spiegare in modo chiaro. Questi concetti mi hanno portato a circa una settimana di sforzi abbastanza concertati per avvolgere la mia mente. Se avete domande su ciò che ho scritto, sentitevi liberi di chiedere, ma non scoraggiatevi se non lo "prendete".
Non ascoltare questi altri ragazzi, ci sono tonnellate che puoi fare adesso senza conoscere Ruby. Inizia con la documentazione e i test, man mano che ottieni comprensione –
Accetto w/@Chuck Vose "Inizia con la documentazione e i test, fatti strada mentre ottieni comprensione". Inoltre, scegli una parte del framework che ti interessa e scrivi un plug-in o due che estenda le sue capacità. Questo dovrebbe davvero aiutare a capire gli interni di quell'area. Una volta che hai capito, guarda i biglietti per quell'area e guarda cosa puoi fare. Buona fortuna! – Brian