podwójny dwukropek Ruby (: :) operator różnice użytkowania

Question

Czy jest jakaś różnica między

module Foo 
    class Engine < Rails::Engine 
    end 
end 

i

module Foo 
    class Engine < ::Rails::Engine 
    end 
end 

Answer 1

stałych w Ruby są zagnieżdżone jak plików i katalogów w systemie plików. Stałe są więc jednoznacznie identyfikowane przez ich ścieżki.

Aby narysować analogię z systemem plików:

::Rails::Engine #is an absolute path to the constant. 
# like /Rails/Engine in FS. 

Rails::Engine #is a path relative to the current tree level. 
# like ./Rails/Engine in FS. 

Oto ilustracja ewentualnego błędu:

module Foo 

    # We may not know about this in real big apps 
    module Rails 
    class Engine 
    end 
    end 

    class Engine1 < Rails::Engine 
    end 

    class Engine2 < ::Rails::Engine 
    end 
end 

Foo::Engine1.superclass 
=> Foo::Rails::Engine # not what we want 

Foo::Engine2.superclass 
=> Rails::Engine # correct 

Answer 2

Rails::Engine #is a path relative to the current tree level. 
# like ./Rails/Engine in FS. 

To nie jest do końca prawdą!

Rzućmy przykład:

module M 
    Y = 1 
    class M 
    Y = 2 
    class M 
     Y = 3 
    end 
    class C 
     Y = 4 
     puts M::Y 
    end 
    end 
end 

# => 3 

module M 
    Y = 1 
    class M 
    Y = 2 
    class C 
     Y = 4 
     puts M::Y 
    end 
    end 
end 

# => 2 

module M 
    Y = 1 
    class M 
    Y = 2 
    class M 
     Y = 4 
     puts M::Y 
    end 
    end 
end 

# => 4 

Więc kiedy mówisz M :: Y rubin patrzy na najbliższy umowach definicja bez względu na to, czy jest wewnątrz bieżącego zakresu lub zakresu zewnętrznej lub zewnętrznej zakres zewnętrznej itp