Metodi statici nei moduli rubino?

Question

È possibile dichiarare metodi statici in un modulo in 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'esempio precedente non verrà stampato "chiuso".

È possibile avere solo i metodi di istanza in un modulo?

Answer 1

Definire il modulo simili (cioè fare exit un metodo di istanza nel modulo):

module Software 
    def exit 
    puts "exited" 
    end 
end 

e quindi utilizzare extend anziché include

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

In uso:

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

Ex planation

obj.extend(module, ...) aggiunge obj i metodi di istanza da ciascun modulo dato come parametro

... quindi quando usato nel contesto di una definizione di classe (con la classe stessa come il ricevitore) i metodi diventano metodi di classe.

Answer 2

E 'possibile includere metodi statici in un modulo:

module Software 

    def self.exit 
    puts "exited" 

    end 
end 

Software.exit 

L'esecuzione di questo stampe 'usciti' come previsto.

Answer 3

Due cose devono cambiare per essere in grado di chiamare Windows.exit:

1. Software#exit deve essere un metodo di istanza
2. Windows esigenze di extendSoftware, non include esso.

Questo perché extend ing un altro modulo mette i metodi di istanza del modulo come classe metodi del modulo corrente, mentre include ing un modulo mette i metodi come nuovi metodi di istanza.

module Software 
    def exit 
     puts "exited" 
    end 
end 

class Windows 
    extend Software 

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

end 

Windows.start 

uscita è:

 
started 
exited 

Answer 4

Metti la tua metodi di classe in un modulo nidificato, e quindi sovrascrivere il "incluso" gancio. Questo hook è chiamato ogni volta che il tuo modulo è incluso.All'interno del gancio, aggiungere i metodi della classe a chi ha fatto la comprendono:

module Foo 

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

    module ClassMethods 

    def foo 
     'foo' 
    end 

    end 

end 

Ora tutte le classi tra cui Foo ottiene un metodo di classe di nome foo:

class MyClass 
    include Foo 
end 

p MyClass.foo # "foo" 

Eventuali metodi non-classe possono essere definiti in Foo come di solito.