Zapisywanie i ponowne użycie bloku dla wywołań metod

Question

Wiele razy dzwonię do metody RestClient::Resource#get(additional_headers = {}, &block) z tym samym blokiem, ale w różnych Zasobach zastanawiałem się, czy istnieje sposób na zapisanie bloku w zmiennej lub zapisanie go w zmiennej a Proc przekształca go w blok za każdym razem.

Edit:

Zrobiłem następujące:

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) 

uzyskać: 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) 

Złożenie ampersanda przed pozycji w wywołaniu metody, na przykład a.map!(&:to_i) wywołuje metodę to_proc dla tego obiektu i przekazuje wynikowy proces jako blok. Niektóre alternatywne formy definiowania wielokrotnego użytku blok:

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

Jeśli wywołanie metody z bloku i chcesz zaoszczędzić że blok do ponownego wykorzystania później, można to zrobić przy użyciu ampersanda w definicji metody, aby uchwycić blok jako parametr proc:

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!