Metodo di chiamata nella classe padre dai metodi di sottoclasse in Ruby

Question

Ho usato super per inizializzare la classe genitore ma non riesco a vedere alcun modo di chiamare la classe genitrice dai metodi di sottoclasse.

So che PHP e altre lingue hanno questa funzione ma non riesco a trovare un buon modo per farlo in Ruby.

Cosa si farebbe in questa situazione?

Answer 1

Se il metodo è lo stesso nome, cioè si sta sovrascrivendo un metodo, è sufficiente utilizzare super. Altrimenti puoi usare uno alias_method o un binding.

class Parent 
    def method 
    end 
end 

class Child < Parent 
    alias_method :parent_method, :method 
    def method 
     super 
    end 

    def other_method 
     parent_method 
     #OR 
     Parent.instance_method(:method).bind(self).call 
    end 
end 

Answer 2

Il super parola chiave in Ruby in realtà chiama un metodo con lo stesso nome nella classe padre. (source)

class Foo 
    def foo 
    # Do something 
    end 
end 

class Bar < Foo 
    def foo 
    super # Calls foo() method in parent class 
    end 
end 

Answer 3

Il super keyword chiama un metodo con lo stesso nome nella classe super:

class Foo 
    def foo 
    "#{self.class}#foo" 
    end 
end 

class Bar < Foo 
    def foo 
    "Super says: #{super}" 
    end 
end 

Foo.new.foo # => "Foo#foo" 
Bar.new.foo # => "Super says: Bar#foo" 

Answer 4

altri hanno detto che già bene. Solo una nota aggiuntiva di cautela:

La sintassi super.foo di chiamare il metodo foo nella classe Super è non supportato. Piuttosto chiamerà il metodo super e sul risultato restituito, prova a chiamare foo.

class A 
    def a 
     "A::a" 
    end 
    end 

    class B < A 
    def a 
     "B::a is calling #{super.a}" # -> undefined method `a` for StringClass 
    end 
    end 

Answer 5

class Parent 
    def self.parent_method 
    "#{self} called parent method" 
    end 

    def parent_method 
    "#{self} called parent method" 
    end 
end 

class Child < Parent 

    def parent_method 
    # call parent_method as 
    Parent.parent_method    # self.parent_method gets invoked 
    # call parent_method as 
    self.class.superclass.parent_method # self.parent_method gets invoked 
    super        # parent_method gets invoked 
    "#{self} called parent method"  # returns "#<Child:0x00556c435773f8> called parent method" 
    end 

end 

Child.new.parent_method #This will produce following output 
Parent called parent method 
Parent called parent method 
#<Child:0x00556c435773f8> called parent method 
#=> "#<Child:0x00556c435773f8> called parent method" 

self.class.superclass == Parent #=> true

Parent.parent_method e self.class.superclass chiamerà self.parent_method (metodo di classe) di Parent mentre super chiama il (metodo esempio) parent_method di Parent.