Liste der Instanzmethoden einer Klasse abrufen

Ich habe ein klasse:

class TestClass
  def method1
  end

  def method2
  end

  def method3
  end
end

Wie kann ich eine Liste meiner Methoden in dieser Klasse erhalten ( method1, method2, method3)?

Sie wollen tatsächlich TestClass.instance_methods, es sei denn, Sie interessieren sich für das, was TestClassselbst tun kann.

class TestClass
  def method1
  end

  def method2
  end

  def method3
  end
end

TestClass.methods.grep(/method1/) # => []
TestClass.instance_methods.grep(/method1/) # => ["method1"]
TestClass.methods.grep(/new/) # => ["new"]

Oder Sie können das Objekt aufrufen methods(nicht instance_methods):

test_object = TestClass.new
test_object.methods.grep(/method1/) # => ["method1"]

TestClass.methods(false) 

um nur Methoden zu erhalten, die nur zu dieser Klasse gehören.

TestClass.instance_methods(false) würde die Methoden aus Ihrem angegebenen Beispiel zurückgeben (da es sich um Instanzmethoden von TestClass handelt).

TestClass.instance_methods

oder ohne alle geerbten Methoden

TestClass.instance_methods - Object.methods

(War 'TestClass.methods - Object.methods')

Sie können eine detailliertere Liste (z. B. strukturiert durch Definieren der Klasse) mit Edelsteinen wie Debugging oder Looksee erhalten .

$ irb --simple-prompt

class TestClass
  def method1
  end

  def method2
  end

  def method3
  end
end

tc_list = TestClass.instance_methods(false)
#[:method1, :method2, :method3]
puts tc_list
#method1
#method2
#method3

Laut Ruby Doc instance_methods

Gibt ein Array zurück, das die Namen der öffentlichen und geschützten Instanzmethoden im Empfänger enthält. Für ein Modul sind dies die öffentlichen und geschützten Methoden. Für eine Klasse sind dies die Instanzmethoden (nicht Singleton-Methoden). Wenn der optionale Parameter false ist, sind die Methoden aller Vorfahren nicht enthalten. Ich nehme das offizielle Dokumentationsbeispiel.

module A
  def method1()  
    puts "method1 say hi"
  end
end
class B
  include A #mixin
  def method2()  
     puts "method2 say hi"
  end
end
class C < B #inheritance
  def method3() 
     puts "method3 say hi"
  end
end

Lassen Sie uns die Ausgabe sehen.

A.instance_methods(false)
  => [:method1]

A.instance_methods
  => [:method1]
B.instance_methods
 => [:method2, :method1, :nil?, :===, ...# ] # methods inherited from parent class, most important :method1 is also visible because we mix module A in class B

B.instance_methods(false)
  => [:method2]
C.instance_methods
  => [:method3, :method2, :method1, :nil?, :===, ...#] # same as above
C.instance_methods(false)
 => [:method3]

So erhalten Sie nur eigene Methoden und schließen geerbte aus:

Aus der Instanz heraus:

self.methods - self.class.superclass.instance_methods

Von außen:

TestClass.instance_methods - TestClass.superclass.instance_methods

Fügen Sie es der Klasse hinzu:

class TestClass
  class << self
    def own_methods
      self.instance_methods - self.superclass.instance_methods
    end
  end
end

TestClass.own_methods
=> [:method1, :method2, method3]

(mit Rubin 2.6.x)