ruby module_function vs y compris le module

En ruby, je comprends que les fonctions du module peut être mis à disposition sans mélange dans le module en utilisant module_function comme illustré ici. Je peux voir comment cela est utile si vous pouvez utiliser la fonction sans mélange dans le module.

module MyModule
  def do_something
    puts "hello world"
  end
  module_function :do_something
end

Ma question est que pourquoi vous devriez avoir la fonction définie à la fois de ces moyens.

Pourquoi ne pas simplement avoir

def MyModule.do_something

def do_something

Dans ce genre de cas, il serait utile de disposer de la fonction disponible pour être mélangés dans des, ou pour être utilisé comme une méthode statique?

InformationsquelleAutor Jeff Storey | 2012-07-18

41

Pense Énumérable.

C'est le parfait exemple de quand vous avez besoin de l'inclure dans un module. Si votre classe définit #each, vous obtenez beaucoup de bonté en incluant un module (#map, #select, etc.). C'est le seul cas où j'utilise les modules mixin - lorsque le module fournit des fonctionnalités en termes de quelques méthodes définies dans la classe que vous incluez le module. Je peut dire que cela devrait être le cas en général.

Comme pour la définition de "statique" des méthodes, une meilleure approche serait:
```
module MyModule
  def self.do_something
  end
end
```
Vous n'avez pas vraiment besoin de faire appel #module_function. Je pense que c'est juste bizarre héritage des trucs.

Vous pouvez même le faire:
```
module MyModule
  extend self

  def do_something
  end
end
```
...mais il ne fonctionne pas bien si vous aussi vous souhaitez inclure le module quelque part. Je suggère de les éviter jusqu'à ce que vous apprendre les subtilités de l'Ruby métaprogrammation.

Enfin, si vous venez de le faire:
```
def do_something
end
```
...il ne va pas finir comme une fonction globale, mais comme une méthode privée sur Object (il n'y a pas de fonctions en Ruby, juste des méthodes). Il y a deux inconvénients. Tout d'abord, vous n'avez pas namespacing - si vous définissez une autre fonction avec le même nom, c'est celle qui est évaluée plus tard que vous obtenez. Deuxièmement, si vous avez des fonctionnalités mises en œuvre en termes de #method_missing, avoir une méthode privée dans Object va ombre. Et enfin, monkey patching Object est juste mal affaires 🙂

EDIT:

module_function peut être utilisé d'une manière similaire à private:
```
module Something
  def foo
    puts 'foo'
  end

  module_function

  def bar
    puts 'bar'
  end
end
```
De cette façon, vous pouvez appeler Something.bar, mais non pas Something.foo. Si vous définissez toutes les autres méthodes après cet appel à la module_function, ils seraient également disponible sans mélange dans.

Je ne l'aime pas, pour deux raisons, cependant. Tout d'abord, les modules qui sont à la fois mixte et "statique" méthodes ont l'air un peu louche. Il pourrait y avoir des cas valides, mais il ne sera pas très souvent. Comme je l'ai dit, je préfère utiliser un module comme un espace de noms ou de mélanger, mais pas les deux.

Deuxième, dans cet exemple, bar serait également disponible pour les classes/modules qui se mélangent dans Something. Je ne suis pas sûr quand c'est souhaitable, étant donné que soit la méthode utilise self et il doit être mélangé dans, ou ne l'est pas et puis il n'a pas besoin d'être mélangé dans.

Je pense que l'utilisation module_function sans passer le nom de la méthode est utilisé le plus souvent avec. En va de même pour private et protected.
- merci pour l'explication. Je comprends pourquoi vous voulez mélanger dans un module, ma question était plus sur quand vous pouvez réellement utiliser le module_function. Est-il temps que vous pourriez utiliser?
- Il y a un plus de poisson dans ce dernier exemple avec module_function: Le "privé" de la fonction foo ne peut pas être accessible à partir de l'intérieur de bar, parce que foo est alors une méthode d'instance (il n'a pas self), et il peut être appelé que lorsque ce module est mélangé à un peu de classe. Impossible quand on est un module autonome juste pour namespacing fins. Alors, comment avoir les deux? Comment utiliser le module juste pour namespacing et cacher certaines de mise en œuvre des fonctions d'assistance à partir de l'extérieur, mais de leur permettre d'être appelé par ses méthodes d'interface?
InformationsquelleAutor Stefan Kanev
14

C'est un bon moyen pour un Ruby bibliothèque pour offrir une fonctionnalité qui n'utilise pas (beaucoup) d'état interne. Donc, si vous (par exemple) vous voulez offrir un sin fonction et ne veux pas polluer le "global" (Object) de l'espace de noms, vous pouvez le définir en tant que méthode de classe en vertu d'une constante (Math).

Cependant, un développeur d'application, qui veut écrire une application mathématique, peut-être besoin sin tous les deux lignes. Si la méthode est également une méthode d'instance, elle peut simplement d'inclure les Math (ou My::Awesome::Nested::Library) module et vous pouvez maintenant appeler directement sin (stdlib exemple).

C'est vraiment le fait de faire une bibliothèque de plus confortable pour ses utilisateurs. Ils peuvent choisir eux-mêmes, s'ils veulent la fonctionnalité de votre bibliothèque sur le niveau supérieur.

Par la manière, vous pouvez obtenir une fonctionnalité similaire comme module_function en utilisant: extend self (dans la première ligne du module). À mon avis, c'est mieux et rend les choses un peu plus faciles à comprendre.

Mise à jour: Plus d'informations de fond dans cet article de blog.
- Le ruby styleguide préfère module_function sur extend self
- Merci pour le pointeur. Je suis en désaccord avec elle, bien que. module_function pourrait être plus convivial pour les débutants, mais tout le monde qui est en train de faire de graves Ruby devrait être en mesure de lire et de comprendre le extend self version. extend self est moins l'abstraction. Il utilise Ruby de base du jeu d'outils, tout en module_function pourrait être retiré de Ruby, sans perdre de fonctionnalités importantes.
- Merci de donner vos raisons. Avant de lire ce Q/r, j'ai été en utilisant self.method et class << self.
InformationsquelleAutor J-_-L
2

Si vous voulez voir un exemple de travail, découvrez la chronique de la gemme:

https://github.com/mojombo/chronic/blob/master/lib/chronic/handlers.rb

et des Gestionnaires est d'être inclus dans l'Analyseur de classe ici:

https://github.com/mojombo/chronic/blob/master/lib/chronic/parser.rb

Il utilise module_function pour envoyer les méthodes de Gestionnaires de cas spécifiques de Gestionnaire à l'aide de cette instance de la méthode invoke.

InformationsquelleAutor TalkativeTree

Vous devez vous connecter pour publier un commentaire.