Quels sont quelques bons exemples de Mixins et ou traits de caractère?

Question

Je suis en train de lire sur Ruby, et appris sur son modèle de mixins, mais ne pouvait pas penser à beaucoup de fonctionnalités utiles mixin (parce que je ne suis pas habitué à penser de cette façon le plus probable). Alors je me demandais ce qui serait de bons exemples de fonctionnalités utiles mixin?

Merci

Edit: Un peu d'arrière-plan. Je viens de C ++ et d'autres langages objet, mais mon doute est que Ruby dit que ce n'est pas héritant mixins, mais je continue à voir mixins comme héritage multiple, donc je crains que je suis en train de les classer trop tôt dans ma zone de confort et pas vraiment Grok quel est mixin.

Answer 1

Eh bien l'exemple d'habitude je pense est la persistance

module Persistence
    def load sFileName
            puts "load code to read #{sFileName} contents into my_data"
    end
        def save sFileName
        puts "Uber code to persist #{@my_data} to #{sFileName}"
    end

end

class BrandNewClass
    include Persistence
    attr :my_data

        def data=(someData)
        @my_data = someData
    end
end

b = BrandNewClass.new
b.data = "My pwd"
b.save "MyFile.secret"
b.load "MyFile.secret"

Imaginez le module est écrit par un ninja Ruby, qui persiste l'état de votre classe à un fichier.
Supposons maintenant que j'écris une toute nouvelle classe, je peux réutiliser la fonctionnalité de persistance en mélangeant dans en disant include ModuleILike. Vous pouvez même inclure des modules lors de l'exécution. Je me charger et enregistrer des méthodes gratuitement en mélangeant tout en. Ces méthodes sont comme celles que vous vous écriviez pour votre classe. Code / Comportement / fonctionnalité réutilisation sans héritage!

Alors qu'est-ce que vous faites est y compris les méthodes à la table des méthodes pour votre classe (pas littéralement correct, mais à proximité).

Answer 2

Ils sont généralement utilisés pour ajouter une certaine forme de fonctionnalité standard à une classe, sans avoir à redéfinir tout. Vous pouvez penser probablement d'entre eux un peu comme les interfaces en Java, mais au lieu de simplement définir une liste des méthodes qui doivent être mises en œuvre, beaucoup d'entre eux en fait soit mis en œuvre en incluant le module.

Il y a quelques exemples dans la bibliothèque standard:

Singleton - Un module qui peut être mélangé dans une classe pour en faire un singleton. La méthode initialize est faite méthode privée, et une instance ajouté, ce qui assure qu'il n'y a jamais qu'un seul exemple de cette classe dans votre application.

Comparable - Si vous incluez ce module dans une classe, en définissant la méthode <=>, qui compare l'instance en cours avec un autre objet et dit qui est plus grande, est suffisante pour fournir <, <=, ==,> =, >, et entre les deux? méthodes.

Enumerable - En mélangeant dans ce module, et la définition d'une méthode chaque , vous obtenez un soutien pour toutes les autres méthodes connexes telles que Collect, injecter, sélectionner et rejetez. Si elle a également obtenu la méthode <=>, il soutiendra également trier, min et max.

DataMapper est aussi un exemple intéressant de ce qui peut être fait avec un simple instruction include, en prenant une classe standard, et en ajoutant la capacité de persister à une banque de données.

Answer 3

En ruby, la raison pour laquelle Mixins ne sont pas l'héritage multiple est que la combinaison de méthodes mixins est une chose de temps. Ce ne serait pas un gros problème, sauf que les modules et les classes de Ruby sont ouverts aux modifications. Cela signifie que si vous MIXIN un module à votre classe, puis ajoutez une méthode pour le module, la méthode pas être disponibles à votre classe; où si vous l'avez fait dans l'ordre inverse, ce serait.

Il est comme la commande d'un cornet de crème glacée. Si vous obtenez des vermicelles de chocolat et pépites de caramel que vos mixins, et repartez avec votre cône, quel genre de cornet de crème glacée vous ne changera pas si quelqu'un ajoute des vermicelles multicolores à la poubelle de vermicelles de chocolat retour à la boutique de crème glacée. Votre classe, le cornet de crème glacée, n'est pas modifié lorsque le module mixin, le bac de vermicelles est. La prochaine personne à utiliser ce module mixin va voir les changements.

Lorsque vous un module en include rubis, il appelle sur ce module Module#append_features, qui ajoutent une copie des méthodes de ce module à l'includer une fois.

L'héritage multiple, si je comprends bien, est plus comme la délégation. Si votre classe ne sait pas comment faire quelque chose, il demande à ses parents. Dans un environnement de classe ouverte, les parents d'une classe peuvent avoir été modifiés après la classe a été créée.

Il est comme une relation parent-enfant RL. Votre mère aurait pu apprendre à jongler après votre naissance, mais si quelqu'un vous demande de jongler et vous lui demander soit: vous montrer comment (copie quand vous en avez besoin) ou le faire pour vous (délégation pure), puis elle serez en mesure à ce moment-là, même si vous avez été créé avant sa capacité à jongler était.

Il est possible que vous pouvez modifier un module rubis include d'agir plus comme héritage multiple en modifiant pour maintenir une method_added liste des englobants, puis de les mettre à jour en utilisant le rappel Module#inherit, mais ce serait une grand changement de Ruby standard, et pourrait causer des problèmes majeurs lorsque vous travaillez avec le code d'autres. Vous pourriez être en train de créer une meilleure méthode qui a appelé Enumerable et géré la délégation #each ainsi.

En ce qui concerne un exemple du monde réel, est génial <=>. Si vous définissez et inclure <=> dans votre classe <=>, alors que vous aurez accès à toute une série de itérateurs, sans vous donne d'avoir à coder chacun.

Answer 4

Il est largement utilisé comme on pourrait utiliser l'héritage multiple en C ++ ou en Java de mise en œuvre des interfaces / C #. Je ne sais pas où se trouve votre expérience, mais si vous avez fait ces choses avant, mixins sont comment vous les faire en Ruby. C'est une façon systématisée d'injecter la fonctionnalité dans les classes.