Come ottengo il nome della classe del genitore in Ruby

Question

Supponiamo di avere una classe A e B dove B eredita A. Come si stampa genitore nome della classe in B

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 :)

Answer 1

class A 
end 

class B < A 
end 

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

Answer 2

Il termine che stai cercando è superclass. E infatti puoi fare B.superclass per ottenere A. (Si può anche fare B.ancestors per ottenere un elenco di tutte le classi e moduli che eredita dalla -. Qualcosa di simile [B, A, Object, Kernel, BasicObject])

Answer 3

Dato un oggetto (crea un'istanza di classe) è possibile derivare la classe padre

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

Answer 4

Se si desidera che lo stack completo antenato prova:

object.class.ancestors 

Per esempio:

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

Answer 5

Nel caso in cui Google porti qui qualcuno che lavora in Rails, ciò che si desidera invece è base_class, come superclass attraverserà 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 

Ancora più ...

class C < B 
end 

> C.base_class 
=> A 

In altre parole, base_class ti dà la cima dell'albero eredità ma limitato al contesto dell'applicazione. Tuttavia, per quanto riguarda Rails, "la tua applicazione" include qualsiasi gemma che stai usando, quindi se hai un modello che sottoclassi qualcosa definito in una gemma, base_class restituirà la classe della gemma, non la tua.

Answer 6

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

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 più 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 sovrascritti esplicitamente.

Ruby superare l'eredità di classe singola in una sola volta 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 rintracciare utilizzando class_name.superclass.name e fare questo processo a meno che non hai trovato BasicOject in questa gerarchia. BasicObject è super classe o ogni classe. vediamo supponiamo di voler vedere l'albero della gerarchia della classe C.

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

Si può vedere l'intera gerarchia di classe C. punto da notare con questo approccio che non troverete i moduli che sono inclusi o anteposti nelle classi genitore.

C'è un altro approccio per trovare la gerarchia completa compresi i moduli. Secondo Ruby doc ancestors. Restituisce un elenco di moduli inclusi/inseriti 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)