Qu'est-ce que le double-colon de Ruby `::`?

Qu'est-ce que ce double colon ::? Par exemple Foo::Bar.

j'ai trouvé un définition :

le :: est un opérateur unaire qui permet: des constantes, des méthodes d'instances et des méthodes de classes définies au sein d' une classe ou d'un module, pour être accessible à partir de n'importe où en dehors de la classe ou du module.

À quoi sert la portée (privée, protégée) si vous pouvez simplement l'utiliser ::pour exposer quelque chose?

::est fondamentalement un opérateur de résolution d'espace de noms. Il vous permet d'accéder aux éléments des modules ou aux éléments de niveau classe des classes. Par exemple, supposons que vous disposiez de cette configuration:

module SomeModule
    module InnerModule
        class MyClass
            CONSTANT = 4
        end
    end
end

Vous pouvez accéder CONSTANTde l'extérieur du module en tant que SomeModule::InnerModule::MyClass::CONSTANT.

Cela n'affecte pas les méthodes d'instance définies sur une classe, car vous accédez à celles dont la syntaxe est différente (le point .).

Remarque pertinente: Si vous souhaitez revenir à l'espace de noms de niveau supérieur, procédez comme suit: :: SomeModule - Benjamin Oakes

Cet exemple simple l'illustre:

MR_COUNT = 0        # constant defined on main Object class
module Foo
  MR_COUNT = 0
  ::MR_COUNT = 1    # set global count to 1
  MR_COUNT = 2      # set local count to 2
end

puts MR_COUNT       # this is the global constant: 1
puts Foo::MR_COUNT  # this is the local constant: 2

Tiré de http://www.tutorialspoint.com/ruby/ruby_operators.htm

::Vous permet d'accéder à une constante, un module ou une classe définie dans une autre classe ou module. Il est utilisé pour fournir des espaces de noms afin que les noms de méthode et de classe n'entrent pas en conflit avec d'autres classes de différents auteurs.

Lorsque vous voyez ActiveRecord::Basedans Rails, cela signifie que Rails a quelque chose comme

module ActiveRecord
  class Base
  end
end

c'est-à-dire une classe appelée à l' Baseintérieur d'un module ActiveRecordqui est ensuite référencé comme ActiveRecord::Base(vous pouvez le trouver dans la source Rails dans activerecord-nnn / lib / active_record / base.rb)

Une utilisation courante de :: est d'accéder aux constantes définies dans les modules, par exemple

module Math
  PI = 3.141 # ...
end

puts Math::PI

L' ::opérateur ne vous permet pas de contourner la visibilité des méthodes marquées privées ou protégées.

À quoi sert la portée (privée, protégée) si vous pouvez simplement utiliser :: pour exposer quoi que ce soit?

Dans Ruby, tout est exposé et tout peut être modifié de n'importe où ailleurs.

Si vous vous inquiétez du fait que les classes peuvent être modifiées depuis l'extérieur de la "définition de classe", alors Ruby n'est probablement pas pour vous.

D'un autre côté, si vous êtes frustré par le verrouillage des classes Java, alors Ruby est probablement ce que vous recherchez.

En plus des réponses précédentes, il est valide d'utiliser Ruby ::pour accéder aux méthodes d'instance. Tous les éléments suivants sont valables:

MyClass::new::instance_method
MyClass::new.instance_method
MyClass.new::instance_method
MyClass.new.instance_method

_{Selon les meilleures pratiques, je crois que seule la dernière est recommandée.}

Non, ce n'est pas pour accéder à toutes les méthodes, c'est un opérateur de «résolution», c'est-à-dire que vous l'utilisez pour résoudre la portée (ou l'emplacement que vous pouvez dire) d'un symbole constant / statique.

Par exemple, dans le premier de votre ligne, Rails l'utilise pour trouver la classe de base dans ActiveRecord.Module, dans votre deuxième, il est utilisé pour localiser la méthode de classe (statique) de la classe Routes, etc., etc.

Il n'est pas utilisé pour exposer quoi que ce soit, il sert à «localiser» des éléments autour de vos oscilloscopes.

http://en.wikipedia.org/wiki/Scope_resolution_operator

Étonnamment, les 10 réponses ici disent la même chose. Le '::' est un opérateur de résolution d'espace de noms, et oui c'est vrai. Mais il y a un problème que vous devez réaliser à propos de l'opérateur de résolution d'espace de noms en ce qui concerne l' algorithme de recherche constante . Comme Matz le décrit dans son livre, «Le langage de programmation Ruby», la recherche constante comporte plusieurs étapes. Premièrement, il recherche une constante dans la portée lexicale où la constante est référencée. S'il ne trouve pas la constante dans la portée lexicale, il recherche alors la hiérarchie d'héritage . En raison de cet algorithme de recherche constante, nous obtenons ci-dessous les résultats attendus:

module A
  module B
      PI = 3.14
      module C
        class E
          PI = 3.15
        end
        class F < E
          def get_pi
            puts PI
          end
        end
      end
  end
end
f = A::B::C::F.new
f.get_pi
> 3.14

Alors que F hérite de E, le module B est dans la portée lexicale de F. Par conséquent, les instances F se référeront à la constante PI définie dans le module B. Maintenant, si le module B n'a pas défini PI, alors les instances F se référeront au PI constante définie dans la superclasse E.

Mais que se passerait-il si nous utilisions '::' plutôt que d'imbriquer des modules? Aurions-nous le même résultat? Non!

En utilisant l'opérateur de résolution d'espace de noms lors de la définition des modules imbriqués, les modules et classes imbriqués ne sont plus dans la portée lexicale de leurs modules externes. Comme vous pouvez le voir ci-dessous, PI défini dans A :: B n'est pas dans la portée lexicale de A :: B :: C :: D et donc nous obtenons une constante non initialisée lorsque nous essayons de faire référence à PI dans la méthode d'instance get_pi:

module A
end

module A::B
  PI = 3.14
end

module A::B::C
  class D
    def get_pi
      puts PI
    end
  end
end
d = A::B::C::D.new
d.get_pi
NameError: uninitialized constant A::B::C::D::PI
Did you mean?  A::B::PI

Il s'agit d'empêcher les définitions de se heurter à d'autres codes liés à votre projet. Cela signifie que vous pouvez séparer les choses.

Par exemple, vous pouvez avoir une méthode appelée "exécuter" dans votre code et vous pourrez toujours appeler votre méthode plutôt que la méthode "exécuter" qui a été définie dans une autre bibliothèque que vous avez liée.

module Amimal
      module Herbivorous
            EATER="plants" 
      end
end

Amimal::Herbivorous::EATER => "plants"

:: Est utilisé pour créer une portée. Afin d'accéder à Constant EATER à partir de 2 modules, nous devons cibler les modules pour atteindre la constante

Ruby on rails utilise ::pour la résolution d'espace de noms.

class User < ActiveRecord::Base

  VIDEOS_COUNT = 10
  Languages = { "English" => "en", "Spanish" => "es", "Mandarin Chinese" => "cn"}

end

Pour l'utiliser :

User::VIDEOS_COUNT
User::Languages
User::Languages.values_at("Spanish") => "en"

En outre, d'autres utilisations sont: lors de l'utilisation d'itinéraires imbriqués

OmniauthCallbacksController est défini sous utilisateurs.

Et acheminé comme:

devise_for :users, controllers: {omniauth_callbacks: "users/omniauth_callbacks"}


class Users::OmniauthCallbacksController < Devise::OmniauthCallbacksController

end