chiarificazione metodo override rubino

Question

Ho appena affrontato questo comportamento che non capisco davvero.

module M 
    def foo 
    "module_foo" 
    end 
end 

class C 
    def foo 
    "class_foo" 
    end 
    include M 
end 

puts C.new.foo 

Perché C.new.foo effettivamente tornare class_foo? Ero quasi sicuro che il metodo dovesse essere sovrascritto da quello nel modulo. Un'altra cosa, sostituendo "class_foo" con super rende C.new.foo ritorno ` "module_foo"

che oggi si presenta come modulo è in qualche modo compreso prima che il metodo di istanza classe è definita. Potresti per favore chiarire?

Answer 1

Da programmazione rubino sezione mixins:

Infatti, moduli misti-in si comportano in modo efficace come superclassi.

Quindi quello che sperimenti è normale. vostro modulo M è una superclasse della classe C

Pertanto il metodo foo in classe C ridefinisce il metodo foo nel modulo M

Answer 2

Ecco come rubino fa metodo di ricerca: classe singleton

1. del ricevente;
2. classe ricevente;
3. eventuali metodi di moduli inclusi;
4. ricerca ripetuta nella superclasse del destinatario;
5. se nessun metodo è stato trovato, chiamata method_missing;

Potete trovare maggiori dettagli qui: http://ruby-metaprogramming.rubylearning.com/html/ruby_metaprogramming_2.html

Pertanto, per trovare un metodo, Ruby va nella classe del ricevente, e da lì si sale la catena di antenati fino a trovare il metodo. Questo comportamento viene anche chiamato "one step to the right, up up" rule: Vai di un passo a destra nella classe del ricevitore, quindi su della catena di antenati, finché non trovi il metodo. Quando si include un modulo in una classe (o anche in un altro modulo), Ruby crea una classe anonima che avvolge il modulo e inserisce la classe anonima nella catena, appena sopra la classe inclusa.