Ruby / Rails中的括号参数

Question

学习Ruby / Rails，并使用ERB模板遇到这个：

作品 ：

<%= link_to image_tag(link.screenshot.url(:thumb)), link.screenshot.url(:original) %>

不起作用 ：

<%= link_to image_tag link.screenshot.url(:thumb), link.screenshot.url(:original) %>

在第一个中， image_tag的参数在括号中。 另一方面，他们不是。

我在Ruby中已经明白，方法并不总是需要在括号中使用它们的参数，但是在这种情况下跳过它们的惯例似乎是有问题的。

刚刚处理它？ ERB模板的Pecularity？ 还是我错过了更大的东西？

一如既往，谢谢。

Answer 1

此示例中缺少括号表示解析此类表达式的问题。 通常，在Ruby中，当明确“如何传递参数”时，可以省略它们。

让我们考虑以下情况 - 我已经定义了add和multi方法：

def add(*args)
  args.inject(:+)
end

def multi(*args)
  args.inject(:*)
end

所以以下是明确的：

add 1, 2, 3, 4
# => 10

multi 1, 2, 3, 4
# => 24

但以防万一：

add 1, multi 2, 3, 4

什么是预期的产出？ 您可以考虑几种情况：

add(1, multi(2, 3), 4)
# => 11

add(1, multi(2, 3, 4))
# => 25

add(1, multi(2), 3, 4)
# => 10

使用括号时 - 您可以计算输出，因为您知道哪个参数用于哪个方法。 如果没有使用 - 你不能，所以Ruby也不能这样做。

让我们回到你提到的方法。 Ruby不知道方法是否：

<%= link_to image_tag link.screenshot.url(:thumb), link.screenshot.url(:original) %>

应该被视为：

<%= link_to image_tag(link.screenshot.url(:thumb)), link.screenshot.url(:original) %>

要么：

<%= link_to image_tag(link.screenshot.url(:thumb), link.screenshot.url(:original)) %>

希望它能够解决这个问题！

祝好运！

Answer 2

在确定如何解释带有省略括号的嵌套函数调用时，ruby不会查看方法签名以及它们允许的参数数量。 相反，它只是遵循一组固定的优先规则，在您的情况下会导致带有和不带括号的不同结果：

def a(*arguments)
  puts "a called with #{arguments.inspect}"
  return :a_result
end

def b(*arguments)
  puts "b called with #{arguments.inspect}"
  return :b_result
end

def c(*arguments)
  puts "c called with #{arguments.inspect}"
  return :c_result
end

def d(*arguments)
  puts "d called with #{arguments.inspect}"
  return :d_result
end

puts (a b(c(:foo)), d(:bar)).inspect
# c called with [:foo]
# b called with [:c_result]
# d called with [:bar]
# a called with [:b_result, :d_result]
# :a_result

puts (a b c(:foo), d(:bar) ).inspect
# c called with [:foo]
# d called with [:bar]
# b called with [:c_result, :d_result]
# a called with [:b_result]
# :a_result

因此，在省略了b s parens的情况下，该调用被等效地解释为

a(b(c(:foo), d(:bar)))

如果其中一个函数不允许这些数量的参数，则该行将失败。 更危险的是，当函数允许可变数量的参数时，正如我的示例函数所做的那样，您将执行与您可能想到的不同的操作，并且可能只会在很久之后发现错误。