Pourquoi Ruby a-t-il des méthodes à la fois privées et protégées?

Avant de lire cet article , je pensais que le contrôle d’access dans Ruby fonctionnait comme ceci:

  • public – accessible par n’importe quel object (par exemple, Obj.new.public_method )
  • protected – accessible uniquement à partir de l’object lui-même, ainsi que des sous-classes
  • private – même chose que protégée, mais la méthode n’existe pas dans les sous-classes

Cependant, il semble que protected et private agissent de la même manière, sauf que vous ne pouvez pas appeler private méthodes private avec un récepteur explicite (c.-à-d. self.protected_method fonctionne, mais self.private_method ne fonctionne pas).

A quoi ça sert? Quand y a-t-il un scénario où vous ne voudriez pas appeler votre méthode avec un récepteur explicite?

protected méthodes protected peuvent être appelées par toute instance de la classe définissant ou de ses sous-classes.

private méthodes private ne peuvent être appelées qu’à partir de l’object appelant. Vous ne pouvez pas accéder directement aux méthodes privées d’une autre instance.

Voici un exemple pratique rapide:

 def compare_to(x) self.some_method <=> x.some_method end 

some_method ne peut pas être private ici. Il doit être protected car vous en avez besoin pour prendre en charge les récepteurs explicites. Vos méthodes d’assistance internes typiques peuvent généralement être private car elles n’ont jamais besoin d’être appelées comme ceci.

Il est important de noter que cela diffère de la façon dont Java ou C ++ fonctionne. private in Ruby est similaire à protected en Java / C ++ dans la mesure où les sous-classes ont access à la méthode. Dans Ruby, il est impossible de restreindre l’access à une méthode à partir de ses sous-classes, comme vous le pouvez avec private en Java.

La visibilité dans Ruby est en grande partie une “recommandation” puisque vous pouvez toujours accéder à une méthode à l’aide de send :

 irb(main):001:0> class A irb(main):002:1> private irb(main):003:1> def not_so_private_method irb(main):004:2> puts "Hello World" irb(main):005:2> end irb(main):006:1> end => nil irb(main):007:0> foo = A.new => # irb(main):009:0> foo.send :not_so_private_method Hello World => nil 

La différence

  • Tout le monde peut appeler vos méthodes publiques.
  • Vous pouvez appeler vos méthodes protégées, ou un autre membre de votre classe (ou une classe descendante) peut appeler vos méthodes protégées depuis l’extérieur. Personne d’autre ne peut.
  • Vous seul pouvez appeler vos méthodes privées, car elles ne peuvent être appelées qu’avec un récepteur implicite de self . Même vous ne pouvez pas appeler self.some_private_method ; vous devez appeler private_method avec self implicite. ( iGEL fait remarquer: “Il y a cependant une exception. Si vous avez une méthode privée age =, vous pouvez (et devez) l’appeler avec self pour la séparer des variables locales.”)

En Ruby, ces distinctions ne sont que des conseils d’un programmeur à un autre. Les méthodes non publiques sont une façon de dire “je me réserve le droit de changer cela, ne comptez pas dessus”. Mais vous obtenez toujours les ciseaux pointus d’ send et pouvez appeler n’importe quelle méthode que vous aimez.

Un bref tutoriel

 # dwarf.rb class Dwarf include Comparable def initialize(name, age, beard_strength) @name = name @age = age @beard_strength = beard_strength end attr_reader :name, :age, :beard_strength public :name private :age protected :beard_strength # Comparable module will use this comparison method for >, <, ==, etc. def <=>(other_dwarf) # One dwarf is allowed to call this method on another beard_strength <=> other_dwarf.beard_strength end def greet "Lo, I am #{name}, and have mined these #{age} years.\ My beard is #{beard_strength} strong!" end def blurt # Not allowed to do this: private methods can't have an explicit receiver "My age is #{self.age}!" end end require 'irb'; IRB.start 

Ensuite, vous pouvez lancer ruby dwarf.rb et faire ceci:

 gloin = Dwarf.new('Gloin', 253, 7) gimli = Dwarf.new('Gimli', 62, 9) gloin > gimli # false gimli > gloin # true gimli.name # 'Gimli' gimli.age # NoMethodError: private method `age' called for # gimli.beard_strength # NoMethodError: protected method `beard_strength' called for # gimli.greet # "Lo, I am Gimli, and have mined these 62 years.\ My beard is 9 strong!" gimli.blurt # private method `age' called for # 

Méthodes privées en Ruby:

Si une méthode est privée dans Ruby, elle ne peut pas être appelée par un récepteur explicite (object). Il ne peut s’agir que d’un appel implicite. Il peut être appelé implicitement par la classe dans laquelle il a été décrit ainsi que par les sous-classes de cette classe.

Les exemples suivants l’illustreront mieux:

1) Une classe d’animaux avec une méthode privée nom_classe

 class Animal def intro_animal class_name end private def class_name "I am a #{self.class}" end end 

Dans ce cas:

 n = Animal.new n.intro_animal #=>I am a Animal n.class_name #=>error: private method `class_name' called 

2) Une sous-classe d’Animal appelée Amphibien:

 class Amphibian < Animal def intro_amphibian class_name end end 

Dans ce cas:

  n= Amphibian.new n.intro_amphibian #=>I am a Amphibian n.class_name #=>error: private method `class_name' called 

Comme vous pouvez le voir, les méthodes privées ne peuvent être appelées que de manière implicite. Ils ne peuvent pas être appelés par des récepteurs explicites. Pour la même raison, les méthodes privées ne peuvent pas être appelées en dehors de la hiérarchie de la classe de définition.

Méthodes protégées en Ruby:

Si une méthode est protégée dans Ruby, elle peut être appelée implicitement à la fois par la classe de définition et par ses sous-classes. De plus, ils peuvent également être appelés par un récepteur explicite tant que le récepteur est auto ou de même classe que celui de soi:

1) Une classe d'animaux avec la méthode protégée protect_me

 class Animal def animal_call protect_me end protected def protect_me p "protect_me called from #{self.class}" end end 

Dans ce cas:

 n= Animal.new n.animal_call #=> protect_me called from Animal n.protect_me #=>error: protected method `protect_me' called 

2) Une classe de mammifères héritée de la classe des animaux

 class Mammal < Animal def mammal_call protect_me end end 

Dans ce cas

 n= Mammal.new n.mammal_call #=> protect_me called from Mammal 

3) Une classe d'amphibiens héritée de la classe animale (identique à la classe des mammifères)

 class Amphibian < Animal def amphi_call Mammal.new.protect_me #Receiver same as self self.protect_me #Receiver is self end end 

Dans ce cas

 n= Amphibian.new n.amphi_call #=> protect_me called from Mammal #=> protect_me called from Amphibian 

4) Une classe appelée Tree

 class Tree def tree_call Mammal.new.protect_me #Receiver is not same as self end end 

Dans ce cas:

 n= Tree.new n.tree_call #=>error: protected method `protect_me' called for # 

Considérons une méthode privée en Java. Bien sûr, il peut être appelé depuis la même classe, mais il peut aussi être appelé par une autre instance de la même classe:

 public class Foo { private void myPrivateMethod() { //stuff } private void anotherMethod() { myPrivateMethod(); //calls on self, no explicit receiver Foo foo = new Foo(); foo.myPrivateMethod(); //this works } } 

Donc, si l’appelant est une instance différente de ma même classe, ma méthode privée est en fait accessible depuis l’extérieur, pour ainsi dire. Cela donne l’impression que ce n’est pas si privé.

En Ruby, en revanche, une méthode privée est censée être privée uniquement à l’instance actuelle. C’est ce que permet de supprimer l’option d’un récepteur explicite.

D’un autre côté, je dois certainement souligner qu’il est assez courant dans la communauté Ruby de ne pas utiliser ces contrôles de visibilité, étant donné que Ruby vous permet de les contourner quand même. Contrairement au monde Java, la tendance est de rendre tout accessible et de faire confiance aux autres développeurs.

Comparaison des contrôles d’access de Java avec Ruby: Si la méthode est déclarée privée en Java, elle ne peut être accédée que par d’autres méthodes de la même classe. Si une méthode est déclarée protégée, elle peut être accédée par d’autres classes qui existent dans le même package, ainsi que par des sous-classes de la classe dans un package différent. Lorsqu’une méthode est publique, elle est visible par tous. En Java, le concept de visibilité du contrôle d’access dépend de l’emplacement de ces classes dans la hiérarchie inheritance / package.

Alors que dans Ruby, la hiérarchie d’inheritance ou le package / module ne correspond pas. Il s’agit de quel object est le récepteur d’une méthode.

Pour une méthode privée dans Ruby, il ne peut jamais être appelé avec un récepteur explicite. Nous pouvons (seulement) appeler la méthode privée avec un récepteur implicite.

Cela signifie également que nous pouvons appeler une méthode privée depuis une classe dans laquelle elle est déclarée, ainsi que toutes les sous-classes de cette classe.

 class Test1 def main_method method_private end private def method_private puts "Inside methodPrivate for #{self.class}" end end class Test2 < Test1 def main_method method_private end end Test1.new.main_method Test2.new.main_method Inside methodPrivate for Test1 Inside methodPrivate for Test2 class Test3 < Test1 def main_method self.method_private #We were trying to call a private method with an explicit receiver and if called in the same class with self would fail. end end Test1.new.main_method This will throw NoMethodError 

Vous ne pouvez jamais appeler la méthode privée en dehors de la hiérarchie de classes où elle a été définie.

La méthode protégée peut être appelée avec un récepteur implicite, comme si elle était privée. De plus, la méthode protégée peut également être appelée par un récepteur explicite (uniquement) si le destinataire est "self" ou "un object de la même classe".

  class Test1 def main_method method_protected end protected def method_protected puts "InSide method_protected for #{self.class}" end end class Test2 < Test1 def main_method method_protected # called by implicit receiver end end class Test3 < Test1 def main_method self.method_protected # called by explicit receiver "an object of the same class" end end InSide method_protected for Test1 InSide method_protected for Test2 InSide method_protected for Test3 class Test4 < Test1 def main_method Test2.new.method_protected # "Test2.new is the same type of object as self" end end Test4.new.main_method class Test5 def main_method Test2.new.method_protected end end Test5.new.main_method This would fail as object Test5 is not subclass of Test1 Consider Public methods with maximum visibility 

Résumé

Public: Les méthodes publiques ont une visibilité maximale

Protected: la méthode protégée peut être appelée avec un récepteur implicite, comme si c'était privé. De plus, la méthode protégée peut également être appelée par un récepteur explicite (uniquement) si le destinataire est "self" ou "un object de la même classe".

Privé: pour une méthode privée dans Ruby, il ne peut jamais être appelé avec un récepteur explicite. Nous pouvons (seulement) appeler la méthode privée avec un récepteur implicite. Cela signifie également que nous pouvons appeler une méthode privée depuis une classe dans laquelle elle est déclarée, ainsi que toutes les sous-classes de cette classe.

Une partie de la raison pour laquelle les sous-classes de Ruby peuvent accéder aux méthodes privées est que l’inheritance Ruby avec les classes est mince.

http://ruby-doc.org/core-2.0.0/Class.html

Cela signifie que, fondamentalement, une sous-classe “inclut” la classe parente afin que les fonctions de la classe parente, y compris les fonctions privées , soient également définies dans la sous-classe.

Dans d’autres langages de programmation, l’appel d’une méthode implique que la méthode nomme une hiérarchie de classe parente et recherche la première classe parente qui répond à la méthode. En revanche, dans Ruby, bien que la hiérarchie de la classe parente soit toujours présente, les méthodes de la classe parente sont directement incluses dans la liste des méthodes définies par la sous-classe.