Speichern und Wiederverwendung von Block für Methodenaufrufe

Question

Ich rufe die RestClient::Resource#get(additional_headers = {}, &block) Methode mehrmals mit dem gleichen Block, aber auf anderen Ressourcen, ich frage mich, ob es eine Möglichkeit gibt, den Block in eine Variable zu speichern, oder zu speichern ein Proc wandelt es jedes Mal in einen Block um.

Edit:

Ich habe folgendes:

resource = RestClient::Resource.new('https://foo.com') 
redirect = lambda do |response, request, result, &block| 
    if [301, 302, 307].include? response.code 
    response.follow_redirection(request, result, &block) 
    else 
     response.return!(request, result, &block) 
    end 
end 
@resp = resource.get (&redirect) 

ich: Syntax error, unexpected tAMPER

Answer 1

foo = lambda do |a,b,c| 
    # your code here 
end 

bar.get(&foo) 
jim.get(&foo) 
jam.get(&foo) 

Retourampersand vor einem Element in einem Methodenaufruf, z.B. a.map!(&:to_i) ruft die to_proc-Methode für dieses Objekt auf und übergibt das resultierende Proc als einen Block. Einige alternative Formen der Definition Ihrer wiederverwendbaren Block:

foo = Proc.new{ |a,b,c| ... } 
foo = proc{ |a,b,c| ... } 
foo = ->(a,b,c){ ... } 

Wenn Sie eine Methode mit einem Block aufrufen und Sie wollen später dass Block für eine Wiederverwendung speichern, können Sie dies durch ein kaufmännisches mit in der Methodendefinition des Blocks als proc Parameter zu erfassen:

class DoMany 
    def initialize(*items,&block) 
    @a = items 
    @b = block # don't use an ampersand here 
    end 
    def do_first 
    # Invoke the saved proc directly 
    @b.call(@a.first) 
    end 
    def do_each 
    # Pass the saved proc as a block 
    @a.each(&@b) 
    end 
end 

d = DoMany.new("Bob","Doug"){ |item| puts "Hello, #{item}!" } 

d.do_first 
#=> Hello, Bob! 

d.do_each 
#=> Hello, Bob! 
#=> Hello, Doug!