Rubino: Come si fa a identificare se un oggetto o ha una classe C come la sua antenata nella gerarchia delle classi?

Question

In Ruby, è possibile identificare se un oggetto o ha una classe C come antenato nella gerarchia classe utilizzando qualsiasi metodo?

ho dato un esempio sotto dove io uso un metodo ipotetico has_super_class? per realizzarlo. Come devo fare questo in realtà?

o = Array.new
o[0] = 0.5
o[1] = 1
o[2] = "This is good"
o[3] = Hash.new

o.each do |value|
  if (value.has_super_class? Numeric)
    puts "Number"
  elsif (value.has_super_class? String)
    puts "String"
  else
    puts "Useless"
  end
end

Output previsto:

Number
Number
String
Useless

Answer 1

Prova obj.kind_of?(Klassname):

1.kind_of?(Fixnum) => true
1.kind_of?(Numeric) => true
....
1.kind_of?(Kernel) => true

Il metodo kind_of? ha anche un is_a? alternativa identica.

Se si desidera verificare solo se un oggetto è un'istanza (diretta) di una classe, l'uso obj.instance_of?:

1.instance_of?(Fixnum) => true
1.instance_of?(Numeric) => false
....
1.instance_of?(Kernel) => false

È inoltre possibile elencare tutti gli antenati di un oggetto chiamando il metodo ancestors sul suo class. Per esempio 1.class.ancestors dà [Fixnum, Integer, Precision, Numeric, Comparable, Object, PP::ObjectMixin, Kernel].

Answer 2

Proprio uso .is_a?

o = [0.5, 1, "This is good", {}]

o.each do |value|
  if (value.is_a? Numeric)
    puts "Number"
  elsif (value.is_a? String)
    puts "String"
  else
    puts "Useless"
  end
end

# =>
Number
Number
String
Useless

Answer 3

o.class.ancestors

utilizzando tale elenco, siamo in grado di implementare has_super_class? in questo modo (come metodo di Singletone):

def o.has_super_class?(sc)
  self.class.ancestors.include? sc
end

Answer 4

Il modo RAD:

1.class.ancestors => [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
1.class <= Fixnum => true
1.class <= Numeric => true
1.class >= Numeric => false
1.class <= Array => nil

Se si vuole essere di fantasia con esso, si potrebbe fare qualcosa di simile:

is_a = Proc.new do |obj, ancestor|
  a = { 
    -1 => "#{ancestor.name} is an ancestor of #{obj}",
    0 => "#{obj} is a #{ancestor.name}",
    nil => "#{obj} is not a #{ancestor.name}",
  }
  a[obj.class<=>ancestor]
end

is_a.call(1, Numeric) => "Numeric is an ancestor of 1"
is_a.call(1, Array) => "1 is not a Array"
is_a.call(1, Fixnum) => "1 is a Fixnum"