Es ist schon eine Weile her, seit ich über Ruby-Code gestolpert bin, den ich nicht verstanden habe, aber es gibt Teile von Schienen, die mein Verständnis von Ruby wirklich vorantreiben.
Selbst wenn Sie auf einem fortgeschrittenen Level mit der Sprache sind, ist es wahrscheinlich eine großartige Möglichkeit, Ihr Spiel zu verbessern.
Wie für den Anfang, würde ich beginnen, indem ich Plugins schreibe. Denken Sie an ein cooles Plugin, das Sie schreiben könnten, das noch nicht gemacht wurde, oder etwas, von dem Sie denken, dass Sie es besser machen könnten. Was auch immer Sie tun möchten, sind die Chancen, dass Sie in eine Art Rails Interna, um es zu tun, die Sie für einen guten Start zu starten müssen. Sobald Sie ein gewisses Wissen über einen bestimmten Bereich des Frameworks haben, können Sie feststellen, ob es in diesem Bereich offene Fehler gibt, die Sie beheben können.
Die Barriere ist ziemlich hoch, da Rails ein ziemlich großes und komplexes Programm ist, das von Leuten geschrieben wurde, die ein hohes Maß an Beherrschung mit einer unglaublich flexiblen Sprache besitzen. Es ist auch eine große Herausforderung, die Sie am Ende wahrscheinlich zu einem besseren Programmierer machen wird. :)
Edit: auszuhelfen Geländer
Dies ist eigentlich ziemlich interessant ist, wenn es ein Ausschnitt ist entworfen, um darzustellen, wie Klassenvariablen und Singleton-Klassen arbeiten, aber es gibt viel klare Möglichkeiten, das Gleiche zu erreichen, wenn es ist "echter" Code.
Singleton Klasse
In Rubin, hat jedes Objekt eine übergeordnete Klasse, die sie von ihren Methoden bekommen. Das ist ziemlich normal für OO-Sprachen. Was nicht normal ist Rubin hat auch ein Konzept „Objektindividuation genannt, das bedeutet, dass Objekte Methoden haben können, die nur auf einer bestimmte Instanz sind, aber nicht auf der übergeordneten Klasse. Hier ist ein schnelles irb Beispiel
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
Zuerst weisen wir einer Variablen eine Zeichenkette zu und als nächstes definieren wir eine Methode für diese Instanz.Aufrufen der Methode funktioniert, aber das Aufrufen einer neuen Zeichenkette funktioniert nicht.Es hat auch keine neue Zeichenketteninstanz für unsere foo-Variable Diese Methode
Um Objekt-Individuation möglich zu machen, muss etwas zwischen der Instanz und der Eltern-Klasse sein.Das Ding ist die Singleton-Klasse, und jede Instanz hat eine, die von allen anderen Objekten eindeutig ist ct-Instanzen. Wenn Ruby nach einer Methode sucht, wird die Singleton-Klasse vor der Elternklasse betrachtet.
Ob Sie es glauben oder nicht, auch wenn Sie noch nie davon gehört haben, haben Sie es wahrscheinlich schon benutzt. Wenn Sie eine „Klassenmethode“ zu etwas hinzufügen möchten, tun Sie dies in der Regel
class Foo
def self.bar
"i am on the class"
end
end
Foo.bar #=> "I am on the class"
Um von oben zu beginnen, die Anweisung class Foo die genaue Äquivalent dieser Foo = Class.new do ist. Was passiert, ist, dass Sie der Konstante Foo eine neue Instanz vom Typ Klasse zuweisen. (nebenbei, das ist, was ich an Ruby Liebe. die meisten der Syntax ist eigentlich nur Zucker um einige Kern-Konzept)
Innerhalb einer Klassendefinition bezieht sich selbst auf die Klasse, also sagt def self.bar im Wesentlichen sagen "definieren Methodenleiste für die Singleton-Klasse der Klasseninstanz, die in der Konstante Foo gespeichert ist ".
Wenn Sie dieses Zeug komplex finden, ist es, weil es ist. Ich denke nicht, dass es etwas anderes in Ruby gibt, als in den Methoden-Lookups, und Singleton-Klassen sind ein großer Teil dessen, was es so komplex macht.
Klassenvariablen
Eine Klassenvariable wird durch @@ Präfix und im Grunde ist eine Variable, deren Umfang alle Instanzen, die Klasse-Objekt, und alle Klassen, die von der Klasse erben.Ich mache eine schnelle IRB, um dies in Aktion zu veranschaulichen
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
Zuerst definieren wir Foo. Foo hat eine Klassenvariable, die verfolgt, wie viele Instanzen erstellt wurden. Um das zu tun, erhöhen wir diese Variable im Konstruktor und definieren schließlich einen schnellen Getter. Bar verlängert nur Foo.
Jetzt, um es in Aktion zu sehen, machen wir einen neuen Foo, und überprüfen Sie die Anzahl, die 1 ist. Als nächstes erstellen wir einen neuen Balken, und überprüfen Sie die Anzahl, wir sind jetzt bei 2. Nur um sicher zu gehen dass sowohl Foo als auch Bar die gleiche Anzahl haben, überprüfen wir unsere foo-Instanz erneut und es ist jetzt 2.
Klassenvariablen sind ein sehr situatives Merkmal, das normalerweise außerhalb des Framework-Codes nicht zu sehen ist. Es wird normalerweise verwendet, wenn Sie alle Instanzen einer bestimmten Klasse verfolgen möchten.
Banisters-Code
class << Object.new
@@var = 6
end
String.class_variable_get(:@@var) #=> 6
Ihr Code diese beiden Konzepte in Aktion zeigt. Zuerst öffnen wir die Singleton-Klasse eines neuen Objekts und legen eine Klassenvariable darauf. Wenn es etwas anderes als eine Klassenvariable wäre, wären diese ersten drei Zeilen der nutzloseste Ruby-Code der Welt. Da es sich jedoch um eine Klassenvariable handelt, werden für die Klasse alle Instanzen der Klasse, alle Klassen, die von der Klasse erben und alle Instanzen aller Klassen, die von der Klasse erben, sichtbar. Da die Klasse, von der wir sprechen, Objekt ist, bedeutet das alles. Wenn Sie also class_variable_get für String angeben, erhalten Sie diese Variable, aber Sie können auf diese Variable von jeder gewünschten Klasse oder Instanz aus zugreifen.
Es tut mir leid
Dieses schreckliche Sachen complected ist, die sehr hart ist eindeutig zu erklären. Diese Konzepte brauchten ungefähr eine Woche lang ziemlich konzertierte Anstrengungen, um mich einzuwickeln. Wenn Sie Fragen zu dem, was ich geschrieben habe, haben, zögern Sie nicht zu fragen, aber seien Sie nicht entmutigt, wenn Sie es nicht "bekommen".
Hören Sie nicht auf diese anderen Jungs, es gibt Tonnen, die Sie jetzt tun können, ohne Ruby zu kennen. Beginne mit der Dokumentation und den Tests, arbeite dich nach oben, während du dich verstehst. –
Ich stimme zu @Chuck Vose "Beginne mit der Dokumentation und den Tests, arbeite dich nach oben, während du Verständnis bekommst". Darüber hinaus - wählen Sie einen Teil des Frameworks, das Sie interessiert und schreiben Sie ein oder zwei Plugins, die seine Fähigkeiten erweitern. Dies sollte wirklich helfen, die Interna dieses Bereichs zu verstehen. Sobald Sie dieses Verständnis haben, schauen Sie @ Tickets für diesen Bereich und sehen Sie, was Sie tun können. Viel Glück! – Brian