Überprüfen Sie bei einer gegebenen Klasse, ob die Instanz eine Methode hat (Ruby).

Ich weiß in Ruby, dass ich verwenden kann respond_to? damit überprüfen , ob ein Objekt eine bestimmte Methode hat.

Aber wie kann ich angesichts der Klasse überprüfen, ob die Instanz eine bestimmte Methode hat?

dh so etwas wie

Foo.new.respond_to?(:bar)

Aber ich denke, es muss einen besseren Weg geben, als eine neue Instanz zu instanziieren.

Ich weiß nicht, warum alle vorschlagen, dass Sie verwenden sollten instance_methodsund include?wann method_defined?der Job erledigt wird.

class Test
  def hello; end
end

Test.method_defined? :hello #=> true

HINWEIS

Wenn Sie aus einer anderen OO-Sprache zu Ruby kommen oder der Meinung sind, dass method_defineddies NUR Methoden bedeutet, die Sie explizit definiert haben mit:

def my_method
end

dann lies das:

In Ruby ist eine Eigenschaft (ein Attribut) in Ihrem Modell im Grunde auch eine Methode. Dies method_defined?gilt auch für Eigenschaften, nicht nur für Methoden.

Beispielsweise:

Bei einer Instanz einer Klasse mit einem String-Attribut first_name:

<instance>.first_name.class #=> String

<instance>.class.method_defined?(:first_name) #=> true

da first_nameist sowohl ein Attribut als auch eine Methode (und eine Zeichenfolge vom Typ Zeichenfolge).

Sie können method_defined?wie folgt verwenden:

String.method_defined? :upcase # => true

Viel einfacher, tragbarer und effizienter als die instance_methods.include? alle anderen vermuten.

Denken Sie daran, dass Sie nicht wissen, ob eine Klasse dynamisch auf einige Aufrufe reagiert method_missing, z. B. durch Neudefinition respond_to?oder seit Ruby 1.9.2 durch Definieren respond_to_missing?.

Tatsächlich funktioniert dies nicht für Objekte und Klassen.

Das macht:

class TestClass
  def methodName
  end
end

Mit der gegebenen Antwort funktioniert dies also:

TestClass.method_defined? :methodName # => TRUE

Das funktioniert aber NICHT:

t = TestClass.new
t.method_defined? : methodName  # => ERROR!

Also benutze ich dies sowohl für Klassen als auch für Objekte:

Klassen:

TestClass.methods.include? 'methodName'  # => TRUE

Objekte:

t = TestClass.new
t.methods.include? 'methodName'  # => TRUE

Die Antwort auf " Bei einer gegebenen Klasse prüfen, ob die Instanz eine Methode (Ruby) hat " ist besser. Anscheinend hat Ruby dieses eingebaut und ich habe es irgendwie verpasst. Meine Antwort bleibt unabhängig davon als Referenz.

Ruby-Klassen reagieren auf die Methoden instance_methodsund public_instance_methods. In Ruby 1.8 listet der erste alle Instanzmethodennamen in einem Array von Zeichenfolgen auf und der zweite beschränkt ihn auf öffentliche Methoden. Das zweite Verhalten ist das, was Sie höchstwahrscheinlich wollen, da es respond_to?sich standardmäßig auch auf öffentliche Methoden beschränkt.

Foo.public_instance_methods.include?('bar')

In Ruby 1.9 geben diese Methoden jedoch Arrays von Symbolen zurück.

Foo.public_instance_methods.include?(:bar)

Wenn Sie dies häufig planen, möchten Sie möglicherweise Moduleeine Verknüpfungsmethode hinzufügen. (Es mag seltsam erscheinen, dies Modulestattdessen zuzuweisen Class, aber da dort die instance_methodsMethoden leben, ist es am besten, sich an dieses Muster zu halten.)

class Module
  def instance_respond_to?(method_name)
    public_instance_methods.include?(method_name)
  end
end

Wenn Sie sowohl Ruby 1.8 als auch Ruby 1.9 unterstützen möchten, ist dies ein praktischer Ort, um die Logik für die Suche nach Zeichenfolgen und Symbolen hinzuzufügen.

Versuchen Foo.instance_methods.include? :bar

Ich bin mir nicht sicher, ob dies der beste Weg ist, aber Sie können dies immer tun:

Foo.instance_methods.include? 'bar'

Ich denke, mit method_defined?Rails stimmt etwas nicht . Es kann inkonsistent sein oder so. Wenn Sie also Rails verwenden, ist es besser, etwas von zu verwendenattribute_method?(attribute) .

" Testen auf method_defined? für ActiveRecord-Klassen funktioniert erst nach einer Instanziierung " ist eine Frage zur Inkonsistenz.

Wenn Sie überprüfen, ob ein Objekt auf eine Reihe von Methoden reagieren kann, können Sie Folgendes tun:

methods = [:valid?, :chase, :test]

def has_methods?(something, methods)
  methods & something.methods == methods
end

Sie methods & something.methodsverbinden die beiden Arrays mit ihren gemeinsamen / übereinstimmenden Elementen. Something.methods enthält alle Methoden, nach denen Sie suchen. Es entspricht den Methoden. Beispielsweise:

[1,2] & [1,2,3,4,5]
==> [1,2]

so

[1,2] & [1,2,3,4,5] == [1,2]
==> true

In dieser Situation möchten Sie Symbole verwenden, da beim Aufrufen von .methods ein Array von Symbolen zurückgegeben wird und wenn Sie diese verwendet haben ["my", "methods"] false zurückgegeben wird.

klass.instance_methods.include :method_nameoder "method_name", abhängig von der Ruby-Version, denke ich.

class Foo
 def self.fclass_method
 end
 def finstance_method
 end
end

foo_obj = Foo.new
foo_obj.class.methods(false)
=> [:fclass_method] 

foo_obj.class.instance_methods(false)
=> [:fclass_method] 

Hoffe das hilft dir!

In meinem Fall mit Ruby 2.5.3 haben die folgenden Sätze perfekt funktioniert:

value = "hello world"

value.methods.include? :upcase

Es wird ein boolescher Wert true oder false zurückgegeben.

Während respond_to? nur für öffentliche Methoden true zurückgegeben wird, kann die Überprüfung auf "Methodendefinition" für eine Klasse auch private Methoden betreffen.

Unter Ruby v2.0 + können sowohl öffentliche als auch private Sets überprüft werden

Foo.private_instance_methods.include?(:bar) || Foo.instance_methods.include?(:bar)