Méthodes statiques dans les modules ruby?

Question

Est-il possible de déclarer des méthodes statiques dans un module dans ruby?

module Software 
    def self.exit 
    puts "exited" 
    end 
end 

class Windows 
    include Software 

    def self.start 
    puts "started" 
    self.exit 
    end 
end 

Windows.start 

L'exemple ci-dessus n'imprime pas "sortie".

Est-il seulement possible d'avoir des méthodes d'instance dans un module?

Answer 1

Définir votre module comme celui-ci (à savoir faire exit une méthode d'instance dans le module):

module Software 
    def exit 
    puts "exited" 
    end 
end 

puis utilisez extend plutôt que include

class Windows 
    extend Software 
    # your self.start method as in the question 
end 

En utilisation:

irb(main):016:0> Windows.start 
started 
exited 
=> nil 

Ex aplanissement

obj.extend(module, ...) ajoute à obj les méthodes d'instance de chaque module donné comme paramètre

... donc quand il est utilisé dans le cadre d'une définition de classe (avec la classe comme le récepteur) les méthodes deviennent des méthodes de classe.

Answer 2

Il est possible d'inclure des méthodes statiques dans un module:

module Software 

    def self.exit 
    puts "exited" 

    end 
end 

Software.exit 

L'exécution de cette impression 'quitté' comme prévu.

Answer 3

Deux choses doivent changer pour pouvoir appeler Windows.exit:

1. Software#exit doit être une méthode d'instance
2. Windows besoins à extendSoftware, pas include il.

En effet, un autre module extend ing met en les méthodes de classe du module courant des méthodes d'instance de ce module, alors que include un module met ing les méthodes que de nouvelles méthodes d'instance.

module Software 
    def exit 
     puts "exited" 
    end 
end 

class Windows 
    extend Software 

    def self.start 
     puts "started" 
     self.exit 
    end 

end 

Windows.start 

sortie est:

 
started 
exited 

Answer 4

Mettez vos méthodes de classe dans un module imbriqué, puis remplacer le crochet "inclus". Ce hook est appelé à chaque fois que votre module est inclus.A l'intérieur du crochet, ajoutez les méthodes de la classe à qui ne le comprennent:

module Foo 

    def self.included(o) 
    o.extend(ClassMethods) 
    end 

    module ClassMethods 

    def foo 
     'foo' 
    end 

    end 

end 

Maintenant, toute classe, y compris Foo obtient une méthode de classe nommée foo:

class MyClass 
    include Foo 
end 

p MyClass.foo # "foo" 

Toutes les méthodes non-classe peuvent être définies dans Foo comme d'habitude.