Rubin: bessere Art und Weise verschiedene Methoden wie Procs aus einem Modul

Question

Es ist ziemlich einfach zurück, ein Verfahren wie ein proc aus einem Modul zurückzukehren:

module Foo 
    def self.bar 
    # Method implementation 
    end 

    def self.baz 
    # Method implementation 
    end 

    def self.qux 
    # Method implemenatation 
    end 

    def self.zoo 
    # Method implementation 
    end 
end 

Foo.method(:bar) # Returns a proc object 

Aber was, wenn ich mehr als eine zurückkehren möge (aber nicht alle) Methode aus dem gleichen Modul? Ein Weg, dies zu tun ist: [:bar,:baz].inject([]) {|memo,i| memo << Foo.method(i)}

Gibt es eine bessere, agiler Weg, das gleiche zu tun?

Answer 1

Sie können immer Affe Patchen verwenden, um es aber machen Sie sehen wollen:

class Object 
    def get_methods(*methods) 
    methods.map { |m| method(m) } 
    end 
end 


module Foo 
    def self.bar 
    # Method implementation 
    end 

    def self.baz 
    # Method implementation 
    end 
end 

Foo.get_methods(:foo, :baz) 

Answer 2

Diese Versuchen:

Foo.methods(false).map {|e| Foo.method(e)} 

Foo.methods(false) alle Klassenmethoden zurück, die nicht als Array geerbt und map wird über jedes Element iterieren.

EDIT

Nach Berücksichtigung der Kommentare unter:

proc_arr = [:bar, :baz].map {|e| Foo.method(e)} 

Answer 3

Ich weiß nicht, ob es einen besseren Weg, aber vielleicht ist dies ein bisschen sauberer als Ihre Lösung:

proc_methods = [] 
# => [] 
(Foo.methods - Object.methods).each { |m| proc_methods << Foo.method(m) } 
# => [:bar, :baz] 
proc_methods 
# => [#<Method: Foo.bar>, #<Method: Foo.baz>] 

Foo seine Methoden aus Object Klasse erbt, das ist der Standard Wurzel all Ruby-OB Jekte. (http://ruby-doc.org/core-2.2.3/Object.html)

Mit Foo.methods - Object.methods behalten Sie nur Ihre benutzerdefinierten Methoden.