参数传递给Ruby中

Question

传入块我想块传递给一个函数，然后调用该块与一些额外的参数如下：

def foo(&block) 
    some_array = (1..3).to_a 
    x = 7 # Simplified 
    result = some_array.map &block # Need some way to pass in 'x' here 
end 

def a_usage_that_works 
    foo do |value| 
    value 
    end 
end 

def a_usage_that_doesnt_work 
    foo do |value, x| 
    x # How do I pass in x? 
    end 
end 

# rspec to demonstrate problem/required result 
describe "spike" do 
    it "works" do 
    a_usage_that_works.should == [1,2,3] 
    end 
    it "doesn't work" do 
    a_usage_that_doesnt_work.should == [7, 7, 7] 
    end 
end 

如何传递的附加参数块？

Answer 1

创建另一个块并从中调用第一个块。

def foo(&block) 
    some_array = (1..3).to_a 
    x = 7 # Simplified 
    result = some_array.map {|elem| block.call(elem, x)} 
end 

Answer 2

您传递给它的块。

def foo(&block) 
    some_array = [1,2,3] 
    x = 7 
    some_array.map{|el| yield el, x} 
end 

p foo{|p1, p2| p2} #=>[7,7,7] 
p foo{|p1, p2| p1} #=>[1,2,3] 

Answer 3

可以使用higher-order function生成一个简化的功能：

让我们假设我们通过foo块将接受value, x。

天真策略，使用内联定义x：

def foo(&block) 
    some_array = (1..3).to_a 
    x = 7 
    simple_func = proc {|value| block.call(value, x) } 
    result = some_array.map &simple_func 
end 

策略使用分离的担忧：

def get_simple_func(block) 
    # This assumes x won't change per iteration. 
    # If it can change, you can move the calculation inside the proc. 
    # Moving it inside also allows the calculation to depend on "value", in case you want that. 
    x = complex_calculation_for_x() 
    proc {|value| block.call(value, x) } 
end 

def foo(&block) 
    some_array = (1..3).to_a 
    simple_func = get_simple_func(block) 
    result = some_array.map &simple_func 
end 

显然，你不应该使用这个时候x是一个文字值，因为它会过度工程。但是随着x的计算变得更加复杂，将其分离出来使代码更具可读性。此外，foo可以专注于将函数应用于some_array的具体任务。