Rubin - lexikalischer Umfang vs Vererbung

Question

Dies ist eine Fortsetzung diese ursprüngliche SO Frage: Using "::" instead of "module ..." for Ruby namespacing

In der ursprünglichen Frage SO, hier ist das Szenario vorgestellt, das ich habe immer noch nicht verstehen:

FOO = 123 

module Foo 
    FOO = 555 
end 

module Foo 
    class Bar 
    def baz 
     puts FOO 
    end 
    end 
end 

class Foo::Bar 
    def glorf 
    puts FOO 
    end 
end 

puts Foo::Bar.new.baz # -> 555 
puts Foo::Bar.new.glorf # -> 123 

Kann jemand eine Erklärung liefern, warum der erste Anruf zurückkehrt und warum der zweite Anruf 123 zurückgibt?

Answer 1

Sie können module Something, jedes Auftreten von class Something oder def something als „Gateway“ in einen neuen Bereich denken gefunden. Wenn Ruby nach der Definition eines Namens sucht, auf den verwiesen wurde, sucht er zuerst im aktuellen Bereich (der Methode, der Klasse oder des Moduls), und wenn er dort nicht gefunden wird, wird er durch jeden mit "Gateway" und Suche zurückgehen der Umfang dort.

In Ihrem Beispiel das Verfahren baz ist definiert als

module Foo 
    class Bar 
    def baz 
     puts FOO 
    end 
    end 
end 

Also, wenn der Wert von FOO zu bestimmen versucht, zuerst die Klasse Bar wird geprüft, und da Bar enthält keine FOO die Suche nach oben bewegt über das "class Bar Gateway" in das Modul Foo, das den enthaltenen Bereich enthält. Foo enthält eine Konstante FOO (555), also ist dies das Ergebnis, das Sie sehen.

Verfahren glorf ist definiert als:

class Foo::Bar 
    def glorf 
    puts FOO 
    end 
end 

Hier wird das „Gateway“ class Foo::Bar ist, so dass, wenn nicht innerhalb FOOBar gefunden wird das „Tor“ durchläuft das Modul Foo und gerade in der obersten Ebene , wo es eine andere FOO (123) gibt, was angezeigt wird.

Hinweis, wie class Foo::Bar Verwendung erzeugt ein einzelnes „Gateway“, über den Umfang der Foo Skipping, aber module Foo; class Bar ... öffnet zwei separate „Gateways“

Answer 2

wow, große Frage. Die beste Antwort, die ich mir vorstellen kann, ist, dass Sie in diesem Fall ein Namespace definieren. diese

Check out:

FOO = 123 

module Foo 
    FOO = 555 
end 

module Foo 
    class Bar 
    def baz 
     puts FOO 
    end 

    def glorf3 
     puts ::FOO 
    end 
    end 
end 

class Foo::Bar 
    def glorf2 
    puts Foo::FOO 
    end 

    def glorf 
    puts FOO 
    end 
end 

puts Foo::Bar.new.baz # -> 555 
puts Foo::Bar.new.glorf # -> 123 
puts Foo::Bar.new.glorf2 # -> 555 
puts Foo::Bar.new.glorf3 # -> 123 

Also mein Gedanke ist, dass, wenn Sie definieren:

module Foo 
    FOO = 555 
end 

Sie FOO im Namensraum von Foo erstellen. Also, wenn Sie es hier verwenden:

module Foo 
    class Bar 
    def baz 
     puts FOO 
    end 
    end 
end 

Sie im Foo Namespace sind. Wenn Sie jedoch darauf verweisen in:

class Foo::Bar 
    def glorf 
    puts FOO 
    end 
end 

FOO wird aus dem Standard-Namespace kommt (wie durch ::FOO dargestellt).

Answer 3

der erste Anruf:

puts Foo::Bar.new.baz # -> 555 

druckt das Ergebnis der Methode aufgerufen baz einer Instanz der Klasse Foo :: Bar

Hinweis, dass Foo :: Bar # baz Definition ist eigentlich ein Verschluss auf FOO.Nach Rubys Bereichsregeln:

1. FOO wird in Foo :: Bar (die Klasse, nicht die Instanz) gesucht Umfang, ist es nicht gefunden wird,
2. FOO in gesucht wird der umschließenden Umfang Foo (denn wir sind in der Moduldefinition) und es wird festgestellt (555)

der zweite Anruf:

druckt das Ergebnis des Aufrufens Methode glorf einer Instanz der Klasse Foo :: Bar

Hinweis, dass Foo :: Bar # glorf Definition diesmal ist auch eine Schließung auf FOO, aber wenn wir Rubys Bereichsregeln folgen werden Sie feststellen, dass der Wert auf dieser Zeit geschlossen ist :: FOO (Top-Level-Umfang FOO) auf folgende Weise:

1. FOO wird in Foo :: Bar (die Klasse, nicht die Instanz) gesucht Namespace, ist es nicht
2. FOO gesucht im umgebenden Gültigkeitsbereich ('Top-Level') gefunden, und es ist dort (123)

Answer 4

glorf ist eine Methode der Klasse Foo, in => [Foo, Module, Object, Kernel, BasicObject]

innerhalb dass Rahmen (dh in default/Hauptmodul) wird FOO 123

zugeordnet Modul Foo ist definiert als

module Foo 
    FOO = 555 
    class Bar 
    def baz 
     puts FOO 
    end 
    end 
end 

wo das Verfahren baz Klasse Bar in Modul Foo gehört => [Bar, Foo, Object, Kernel, BasicObject]

und in diesem Umfang FOO wurde 555