Biorąc pod uwagę klasę, sprawdź, czy instancja ma metodę (Ruby)

W Ruby wiem, że mogę użyć, respond_to?aby sprawdzić, czy obiekt ma określoną metodę.

Ale biorąc pod uwagę klasę, jak mogę sprawdzić, czy instancja ma określoną metodę?

tj. coś podobnego

Foo.new.respond_to?(:bar)

Ale wydaje mi się, że musi być lepszy sposób niż utworzenie nowej instancji.

Nie wiem, dlaczego wszyscy sugerują, że powinieneś używać instance_methodsi include?kiedy method_defined?wykonuje swoją pracę.

class Test
  def hello; end
end

Test.method_defined? :hello #=> true

UWAGA

Jeśli przyjeżdżasz do Ruby z innego języka OO LUB uważasz, że method_definedoznacza to TYLKO metody, które wyraźnie zdefiniowałeś za pomocą:

def my_method
end

następnie przeczytaj to:

W Ruby właściwość (atrybut) w twoim modelu jest w zasadzie również metodą. Zwróci method_defined?również wartość true dla właściwości, a nie tylko metod.

Na przykład:

Biorąc pod uwagę instancję klasy, która ma atrybut String first_name:

<instance>.first_name.class #=> String

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

ponieważ first_namejest zarówno atrybutem, jak i metodą (oraz łańcuchem typu String).

Możesz użyć method_defined?w następujący sposób:

String.method_defined? :upcase # => true

Znacznie łatwiejsze, przenośniejsze i wydajniejsze niż instance_methods.include?sugerują to wszyscy inni.

Pamiętaj, że nie będziesz wiedział, czy klasa reaguje dynamicznie na niektóre wywołania method_missing, na przykład poprzez redefiniowanie respond_to?lub od Ruby 1.9.2 poprzez zdefiniowanie respond_to_missing?.

W rzeczywistości nie działa to zarówno dla obiektów, jak i klas.

To robi:

class TestClass
  def methodName
  end
end

Tak więc przy podanej odpowiedzi działa to:

TestClass.method_defined? :methodName # => TRUE

Ale to NIE działa:

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

Używam tego zarówno dla klas, jak i obiektów:

Klasy:

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

Obiekty:

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

Odpowiedź na „ Biorąc pod uwagę klasę, czy instancja ma metodę (Ruby) ” jest lepsza. Najwyraźniej Ruby ma to wbudowane i jakoś mi tego brakowało. Moja odpowiedź pozostawia się do odniesienia, niezależnie od tego.

Klasy Ruby odpowiadają na metody instance_methodsi public_instance_methods. W Ruby 1.8 pierwszy wyświetla wszystkie nazwy metod instancji w tablicy ciągów, a drugi ogranicza je do metod publicznych. Drugie zachowanie jest najbardziej pożądane, ponieważ respond_to?domyślnie ogranicza się również do metod publicznych.

Foo.public_instance_methods.include?('bar')

Jednak w Ruby 1.9 metody te zwracają tablice symboli.

Foo.public_instance_methods.include?(:bar)

Jeśli planujesz to robić często, możesz chcieć rozszerzyć Moduleo metodę skrótów. (Może się to wydawać dziwne, aby przypisać to Modulezamiast Class, ale ponieważ tam właśnie instance_methodsżyją metody, najlepiej trzymać się tego wzorca.)

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

Jeśli chcesz obsługiwać zarówno Ruby 1.8, jak i Ruby 1.9, byłoby to wygodne miejsce na dodanie logiki do wyszukiwania zarówno ciągów znaków, jak i symboli.

Próbować Foo.instance_methods.include? :bar

Nie jestem pewien, czy to najlepszy sposób, ale zawsze możesz to zrobić:

Foo.instance_methods.include? 'bar'

Myślę, że coś jest nie tak z method_defined?Railsami. Może to być niespójne lub coś, więc jeśli używasz Railsów, lepiej użyć czegoś z attribute_method?(attribute).

„ testowanie metody method_defined? w klasach ActiveRecord nie działa aż do wystąpienia wystąpienia ” to pytanie o niespójność.

Jeśli sprawdzasz, czy obiekt może odpowiedzieć na szereg metod, możesz zrobić coś takiego:

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

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

methods & something.methodsdołączy do dwóch tablic na ich elementów wspólnych / dopasowanie. coś.metody obejmują wszystkie sprawdzane metody, będą równe metodom. Na przykład:

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

więc

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

W tej sytuacji chciałbyś użyć symboli, ponieważ gdy wywołasz .methods, zwróci tablicę symboli, a jeśli użyjesz ["my", "methods"], zwróci false.

klass.instance_methods.include :method_namelub "method_name", w zależności od wersji Ruby, myślę.

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] 

Mam nadzieję, że to ci pomoże!

W moim przypadku praca z Ruby 2.5.3 działały idealnie następujące zdania:

value = "hello world"

value.methods.include? :upcase

Zwróci wartość logiczną true lub false.

Chociaż respond_to?zwróci prawdę tylko w przypadku metod publicznych, sprawdzanie „definicji metody” w klasie może również dotyczyć metod prywatnych.

W Ruby v2.0 + można sprawdzać zarówno zestawy publiczne, jak i prywatne

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