同质参数

Question

我正在尝试做类似的事情：

def foo(mode= :serial)

  if (mode == :serial) then
    self.send(:bar, "one_type")
  else
    self.send(:bar,"second_type",:T5)
  end
end

我显然可以这样打出来。

但我最近尝试将其扩展为包含第二个功能：

def foo(mode= :serial)

  if (mode == :serial) then
    self.send(:bar, "one_type")
    self.send(:foobar, "one_type",20)
  else
    self.send(:bar,"second_type",:T5)
    self.send(:foobar, "one_type",20,:T5)
  end
end

我仍然可以继续，但我想，这里有一个模式，我应该把论点抽象到另一层，并使这更简单。

所以我想做的就是这样：

arg_arr   = [:bar, "one_type"]
arg_arr_2 = [:foobar, "one_type", 20]
if (mode == :serial) then
  self.send(arg_arr)
  self.send(arg_arr_2)
else
  arg_arr << :T5
  arg_arr2 << :T5
  self.send(arg_arr)
  self.send(arg_arr2 )
end

我尝试了一些涉及.each，.inspect的其他想法，但没有任何可行的（通常的错误是无法将数组转换为字符串，我猜测它指的是它对待它的事实数组作为整个函数名）。如果我明确地说＆＃34;使用数组元素[0]，[1]等，我可以做到这一点，但这看起来很浪费。

有没有办法在不编写硬编码参数数量的代码的情况下实现这一目标？

Answer 1

试试这个

  protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    List<BudgetEntity> budgetEntityList = new ArrayList<>(20); 
    BudgetEntity budgetEntity = new BudgetEntity();

    String budgetID[] = request.getParameterValues("budgetID");

for(int i=0;   i < budgetID.length ;   i++) {

      for(int k=0;   k < budgetEntityList.size() ;   k++) {

          budgetEntity=  budgetEntityList.get(k);
      }

            budgetEntity.setTotal(Integer.valueOf(budgetID[i]));
        }

两者都打印

def foo(a, b)
  puts a
  puts b
end

array = ['bar', 'qux']
send(:foo, *array) # using send
foo(*array) # using the method name

splat运算符bar qux打包或解包数组。

Answer 2

几年前，我做了你现在正在尝试的事情。通过方法参数前面的星号，您可以在函数中接收任意数量的参数。所以你不需要知道给定参数的数量。它被称为splat。

将您的值发送为前面带有星号的数组，它将起作用。

我用irb控制台测试了这个问题：

def test(*args)
  puts args.inspect
end

my_args = [1, 2, 3]
self.send(:test, *my_args)
# [1, 2, 3]
# => nil

或者根据需要发送任意数量的单个参数：

self.send(:test, 'a', 'b', 'c', 'd')
# ["a", "b", "c", "d"]
# => nil

如果您有一定数量的参数，这将起作用：

def test(arg1, arg2, arg3)
  puts arg1.inspect
  puts arg2.inspect
  puts arg3.inspect
end

my_args = [1, 2, 3]
self.send(:test, *my_args)
# 1
# 2
# 3
# => nil

Answer 3

首先，您不应该使用send。如果您知道方法名称，则可以使用public_send，Method#call或bar(...)。

同质参数

如果参数是同质的（例如，是同一个类的实例），您可以将它们放在一个数组中，并将此数组用作参数：

def analyze_array(array)
  puts "Elements : #{array}"
  puts "Length   : #{array.size}"
  puts "Sum      : #{array.inject(:+)}"
  puts
end

analyze_array([1,2,3])
analyze_array([1,2,3,4,5])

输出：

Elements : [1, 2, 3]
Length   : 3
Sum      : 6

Elements : [1, 2, 3, 4, 5]
Length   : 5
Sum      : 15

实施例

稍微重构一下你的代码，它可能会变成：

arg_arr   = [:bar, 1]
arg_arr_2 = [:foobar, 1, 2]

def bar(array)
  puts "  bar with one parameter : #{array}"
end

def foobar(array)
  puts "  foobar with one parameter : #{array}"
end

[:serial, :parallel].each do |mode|
  puts "Mode : #{mode}"
  [arg_arr, arg_arr_2].each do |method_and_args|
    method_name, *args = method_and_args
    args << 3 if mode != :serial
    method(method_name).call(args)
  end
end

输出：

Mode : serial
  bar with one parameter : [1]
  foobar with one parameter : [1, 2]
Mode : parallel
  bar with one parameter : [1, 3]
  foobar with one parameter : [1, 2, 3]

异质参数

对于可能属于不同类的未知数量的参数，您可以使用splat运算符（documentation）：

def analyze_parameters(*params)
  puts "Parameters : #{params}"
  puts "Number     : #{params.size}"
  puts "Classes    : #{params.map(&:class)}"
end

analyze_parameters('Test')
analyze_parameters(1, 'a', :b, [:c, :d])

输出：

Parameters : ["Test"]
Number     : 1
Classes    : [String]

Parameters : [1, "a", :b, [:c, :d]]
Number     : 4
Classes    : [Fixnum, String, Symbol, Array]

你的例子变成了：

arg_arr   = [:bar, 1 ]
arg_arr_2 = [:foobar, 1, 'a']

def bar(*params)
  puts "  bar with multiple parameters : #{params}"
end

def foobar(*params)
  puts "  foobar with multiple parameters : #{params}"
end

[:serial, :parallel].each do |mode|
  puts "Mode : #{mode}"
  [arg_arr, arg_arr_2].each do |method_and_args|
    method_name, *args = method_and_args
    args << :b if mode != :serial
    method(method_name).call(*args)
  end
end

输出：

Mode : serial
  bar with multiple parameters : [1]
  foobar with multiple parameters : [1, "a"]
Mode : parallel
  bar with multiple parameters : [1, :b]
  foobar with multiple parameters : [1, "a", :b]

Ruby以编程方式调用方法，具有可变数量的args

3 个答案:

同质参数

实施例

异质参数