Obtenir la liste des méthodes d'instance d'une classe

J'ai un cours:

class TestClass
  def method1
  end

  def method2
  end

  def method3
  end
end

Comment puis - je obtenir une liste de mes méthodes de cette classe ( method1, method2, method3)?

Vous voulez vraiment TestClass.instance_methods, sauf si vous êtes intéressé par ce que TestClasslui-même peut faire.

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"]

Ou vous pouvez appeler methods(pas instance_methods) sur l'objet:

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

TestClass.methods(false) 

pour obtenir uniquement les méthodes appartenant à cette classe uniquement.

TestClass.instance_methods(false) renvoie les méthodes de votre exemple donné (car ce sont des méthodes d'instance de TestClass).

TestClass.instance_methods

ou sans toutes les méthodes héritées

TestClass.instance_methods - Object.methods

(Était 'TestClass.methods - Object.methods')

Vous pouvez obtenir une liste plus détaillée (par exemple structurée en définissant une classe) avec des gemmes comme le débogage ou looksee .

$ 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

Selon Ruby Doc instance_methods

Renvoie un tableau contenant les noms des méthodes d'instance publique et protégée dans le récepteur. Pour un module, ce sont les méthodes publiques et protégées; pour une classe, ce sont les méthodes d'instance (et non singleton). Si le paramètre facultatif est false, les méthodes de tous les ancêtres ne sont pas incluses. Je prends l'exemple de la documentation officielle.

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

Voyons la sortie.

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]

Pour obtenir uniquement ses propres méthodes et exclure celles héritées:

Depuis l'instance:

self.methods - self.class.superclass.instance_methods

De dehors:

TestClass.instance_methods - TestClass.superclass.instance_methods

Ajoutez-le à la classe:

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

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

(avec ruby ​​2.6.x)