Come ottengo il nome della classe del genitore in Ruby

Supponiamo che io abbia classi Ae Bdove Beredita A. Come faccio a stampare il nome della classe genitore inB

class A
end

class B < A
end

Alcune cose che ho provato

>> B.new.class #=> B   #which is correct
>> B.new.parent  #=> Undefined method `parent`
>> B.parent   #=> Object
>> B.parent.class #=> Class

Grazie :)

class A
end

class B < A
end

B.superclass # => A
B.superclass.name # => "A"

Se vuoi lo stack completo degli antenati prova:

object.class.ancestors

Per esempio:

> a = Array.new
=> []
> a.class.ancestors
=> [Array, Enumerable, Object, Kernel, BasicObject]

Dato un oggetto (Classe istanziata) è possibile derivare la Classe genitore

>> x = B.new
>> x.class.superclass.name
=>"A"

Nel caso in cui Google porti qui qualcuno che sta lavorando in Rails, quello che potresti volere invece è base_class, poiché superclassattraverserà anche la struttura di ereditarietà di ActiveRecord.

class A < ActiveRecord::Base
end

class B < A
end

> A.superclass
=> ActiveRecord::Base
> B.superclass
=> A

> A.base_class
=> A
> B.base_class
=> A

Ulteriormente...

class C < B
end

> C.base_class
=> A

In altre parole, base_classti offre la parte superiore dell'albero dell'ereditarietà ma limitato al contesto della tua applicazione. Un giusto avvertimento però, per quanto riguarda Rails, la "tua applicazione" include tutte le gemme che stai utilizzando, quindi se hai un modello che sottoclasse qualcosa definito in una gemma, base_classrestituirà la classe della gemma, non la tua.

Il termine che stai cercando è superclass. E in effetti puoi fare B.superclassper ottenere A. (Puoi anche B.ancestorsottenere un elenco di tutte le classi e i moduli da cui eredita, qualcosa di simile [B, A, Object, Kernel, BasicObject].)

L'ereditarietà è una relazione tra due classi. L'ereditarietà crea una relazione padre figlio tra le classi. È un meccanismo per il riutilizzo del codice e per consentire estensioni indipendenti del software originale tramite classi e interfacce pubbliche.Il vantaggio dell'ereditarietà è che le classi più in basso nella gerarchia ottengono le funzionalità di quelle più in alto, ma possono anche aggiungere funzionalità specifiche proprie .

In Ruby, una classe può ereditare solo da una singola altra classe. (cioè una classe può ereditare da una classe che eredita da un'altra classe che eredita da un'altra classe, ma una singola classe non può ereditare da molte classi contemporaneamente). La classe BasicObject è la classe genitore di tutte le classi in Ruby. I suoi metodi sono quindi disponibili per tutti gli oggetti a meno che non vengano esplicitamente sostituiti.

Ruby supera immediatamente l'ereditarietà di una singola classe utilizzando il mixin.

Proverò a spiegare con un esempio.

module Mux
 def sam
  p "I am an module"
 end
end
class A
  include Mux
end
class B < A
end
class C < B
end
class D < A
end

È possibile tracciare utilizzando class_name.superclass.name ed eseguire questo processo a meno che non si trovi BasicOject in questa gerarchia. BasicObject è una super classe di ogni classe. supponiamo di voler vedere l'albero della gerarchia di classe C.

 C.superclass
   => B
 B.superclass
  => A
 A.superclass
  => Object
 Object.superclass
  => BasicObject

Puoi vedere l'intera gerarchia della classe C. Punto da notare usando questo approccio non troverai moduli inclusi o anteposti nelle classi genitore.

C'è un altro approccio per trovare la gerarchia completa, inclusi i moduli. Secondo gli antenati di Ruby doc . Restituisce un elenco di moduli inclusi / anteposti in mod (inclusa la mod stessa).

C.ancestors
 => [C, B, A, Mux, Object, Kernel, BasicObject]

Qui, Mux e Kernel sono moduli.

http://rubylearning.com/satishtalim/ruby_inheritance.html https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)