调用方法¶ ↑

调用方法向对象发送消息，以便它可以执行一些工作。

在 Ruby 中，你可以像这样向对象发送消息

my_method()

注意，括号是可选的

my_method

除了使用和省略括号之间存在差异的情况外，本文档在参数存在时使用括号，以避免混淆。

本节仅涵盖调用方法。另请参阅定义方法的语法文档。

接收者¶ ↑

self 是默认接收者。如果您没有指定任何接收者，将使用 self。要指定接收者，请使用 .

my_object.my_method

这将 my_method 消息发送到 my_object。任何对象都可以是接收者，但根据方法的可见性，发送消息可能会引发 NoMethodError。

您也可以使用 :: 来指定接收者，但这很少使用，因为可能会与命名空间的 :: 混淆。

链接方法调用¶ ↑

您可以通过在一次方法调用后立即进行另一次方法调用来“链接”方法调用。

此示例链接了方法 Array#append 和 Array#compact

a = [:foo, 'bar', 2]
a1 = [:baz, nil, :bam, nil]
a2 = a.append(*a1).compact
a2 # => [:foo, "bar", 2, :baz, :bam]

细节

• 第一个方法 merge 创建 a 的副本，将 a1 的每个元素（分别）追加到副本中，并返回

  [:foo, "bar", 2, :baz, nil, :bam, nil]
  

• 链接方法 compact 创建该返回值的副本，删除其 nil 值的条目，并返回

  [:foo, "bar", 2, :baz, :bam]
  

您可以链接不同类中的方法。此示例链接了方法 Hash#to_a 和 Array#reverse

h = {foo: 0, bar: 1, baz: 2}
h.to_a.reverse # => [[:baz, 2], [:bar, 1], [:foo, 0]]

细节

• 第一个方法 Hash#to_a 将 a 转换为数组，并返回

  [[:foo, 0], [:bar, 1], [:baz, 2]]
  

• 链接方法 Array#reverse 创建该返回值的副本，将其反转，并返回

  [[:baz, 2], [:bar, 1], [:foo, 0]]
  

安全导航运算符¶ ↑

&.，称为“安全导航运算符”，允许在接收者为 nil 时跳过方法调用。如果跳过调用，它将返回 nil 并且不会评估方法的参数。

REGEX = /(ruby) is (\w+)/i
"Ruby is awesome!".match(REGEX).values_at(1, 2)
# => ["Ruby", "awesome"]
"Python is fascinating!".match(REGEX).values_at(1, 2)
# NoMethodError: undefined method `values_at' for nil:NilClass
"Python is fascinating!".match(REGEX)&.values_at(1, 2)
# => nil

这允许轻松链接可能返回空值的方法。请注意，&. 仅跳过下一个调用，因此对于更长的链，有必要在每个级别添加运算符

"Python is fascinating!".match(REGEX)&.values_at(1, 2).join(' - ')
# NoMethodError: undefined method `join' for nil:NilClass
"Python is fascinating!".match(REGEX)&.values_at(1, 2)&.join(' - ')
# => nil

参数¶ ↑

发送消息时，参数有三种类型：位置参数、关键字（或命名）参数和块参数。每个发送的消息可以使用一种、两种或所有类型的参数，但参数必须按此顺序提供。

Ruby 中的所有参数都是通过引用传递的，并且不会延迟评估。

每个参数都用 , 分隔

my_method(1, '2', :three)

参数可以是表达式、哈希参数

'key' => value

或关键字参数

key: value

Hash 和关键字参数必须连续，并且必须出现在所有位置参数之后，但可以混合使用

my_method('a' => 1, b: 2, 'c' => 3)

位置参数¶ ↑

消息的位置参数紧随方法名之后

my_method(argument1, argument2)

在许多情况下，发送消息时不需要括号

my_method argument1, argument2

但是，为了避免歧义，括号是必要的。这将引发 SyntaxError，因为 ruby 不知道应该将哪个方法参数 3 发送给

method_one argument1, method_two argument2, argument3

如果方法定义包含 *argument，则额外的位置参数将作为 Array 在方法中分配给 argument。

如果方法定义不包含关键字参数，则关键字或哈希类型参数将作为单个哈希分配给最后一个参数

def my_method(options)
  p options
end

my_method('a' => 1, b: 2) # prints: {'a'=>1, :b=>2}

如果给出了太多位置参数，则会引发 ArgumentError。

默认位置参数¶ ↑

当方法定义默认参数时，您不需要向方法提供所有参数。Ruby 将按顺序填充缺失的参数。

首先，我们将介绍默认参数出现在右侧的简单情况。考虑这个方法

def my_method(a, b, c = 3, d = 4)
  p [a, b, c, d]
end

这里 c 和 d 有默认值，ruby 会为您应用这些值。如果您只向此方法发送两个参数

my_method(1, 2)

您将看到 ruby 打印 [1, 2, 3, 4]。

如果您发送三个参数

my_method(1, 2, 5)

您将看到 ruby 打印 [1, 2, 5, 4]

Ruby 从左到右填充缺失的参数。

Ruby 允许默认值出现在位置参数的中间。考虑这个更复杂的方法

def my_method(a, b = 2, c = 3, d)
  p [a, b, c, d]
end

这里 b 和 c 有默认值。如果您只向此方法发送两个参数

my_method(1, 4)

您将看到 ruby 打印 [1, 2, 3, 4]。

如果您发送三个参数

my_method(1, 5, 6)

您将看到 ruby 打印 [1, 5, 3, 6]。

用语言描述这一点会变得复杂和令人困惑。我将用变量和值来描述它。

首先 1 被分配给 a，然后 6 被分配给 d。这只留下具有默认值的参数。由于 5 尚未分配给值，因此它被赋予 b，而 c 使用其默认值 3。

关键字参数¶ ↑

关键字参数位于任何位置参数之后，并用逗号隔开，就像位置参数一样

my_method(positional1, keyword1: value1, keyword2: value2)

任何未提供的关键字参数将使用方法定义中的默认值。如果给出了方法未列出的关键字参数，并且方法定义不接受任意关键字参数，则会引发 ArgumentError。

可以省略关键字参数值，这意味着该值将根据键的名称从上下文中获取。

keyword1 = 'some value'
my_method(positional1, keyword1:)
# ...is the same as
my_method(positional1, keyword1: keyword1)

请注意，当也省略方法括号时，解析顺序可能出乎意料。

my_method positional1, keyword1:

some_other_expression

# ...is actually parsed as
my_method(positional1, keyword1: some_other_expression)

块参数¶ ↑

块参数将调用范围内的闭包发送到方法。

块参数在向方法发送消息时始终位于最后。使用 do ... end 或 { ... } 将块发送到方法。

my_method do
  # ...
end

或者

my_method {
  # ...
}

do end 的优先级低于 { }，因此

method_1 method_2 {
  # ...
}

将块发送到 method_2，而

method_1 method_2 do
  # ...
end

将块发送到 method_1。请注意，在第一种情况下，如果使用括号，则块将发送到 method_1。

块将接受来自发送它的方法的参数。参数的定义方式类似于方法定义参数的方式。块的参数位于 | ... | 中，位于 do 或 { 的后面。

my_method do |argument1, argument2|
  # ...
end

块局部参数¶ ↑

您还可以使用块参数列表中的 ; 为块声明块局部参数。为块局部参数赋值不会覆盖调用者范围之外的块外部的局部参数。

def my_method
  yield self
end

place = "world"

my_method do |obj; place|
  place = "block"
  puts "hello #{obj} this is #{place}"
end

puts "place is: #{place}"

这将打印

hello main this is block
place is world

因此，块中的 place 变量与块外部的 place 变量不同。从块参数中删除 ; place 会得到以下结果

hello main this is block
place is block

Array 到参数的转换¶ ↑

给定以下方法

def my_method(argument1, argument2, argument3)
end

您可以使用 *（或 splat）运算符将 Array 转换为参数列表。

arguments = [1, 2, 3]
my_method(*arguments)

或者

arguments = [2, 3]
my_method(1, *arguments)

两者都等效于

my_method(1, 2, 3)

您还可以使用 **（将在下面介绍）将 Hash 转换为关键字参数。

如果 Array 中的对象数量与方法的参数数量不匹配，则会引发 ArgumentError。

如果 splat 运算符在调用中排在首位，则必须使用括号以避免警告。

my_method *arguments  # warning
my_method(*arguments) # no warning

Hash 到关键字参数的转换¶ ↑

给定以下方法

def my_method(first: 1, second: 2, third: 3)
end

您可以使用 **（关键字 splat）运算符将 Hash 转换为关键字参数。

arguments = { first: 3, second: 4, third: 5 }
my_method(**arguments)

或者

arguments = { first: 3, second: 4 }
my_method(third: 5, **arguments)

两者都等效于

my_method(first: 3, second: 4, third: 5)

如果方法定义使用关键字 splat 运算符来收集任意关键字参数，它们将不会被 * 收集。

def my_method(*a, **kw)
  p arguments: a, keywords: kw
end

my_method(1, 2, '3' => 4, five: 6)

打印

{:arguments=>[1, 2], :keywords=>{'3'=>4, :five=>6}}

Proc 到 Block 的转换¶ ↑

给定一个使用块的方法

def my_method
  yield self
end

可以使用 &（块转换）运算符将 proc 或 lambda 转换为块参数。

argument = proc { |a| puts "#{a.inspect} was yielded" }

my_method(&argument)

如果块转换运算符在调用中排在第一位，则必须使用括号以避免警告。

my_method &argument  # warning
my_method(&argument) # no warning

Method 查找¶ ↑

当您发送消息时，Ruby 会查找与接收器消息名称匹配的方法。方法存储在类和模块中，因此方法查找会遍历这些，而不是对象本身。

以下是接收器类或模块 R 的方法查找顺序。

• R 的预置模块，按相反顺序。

• 在 R 中查找匹配的方法。

• R 的包含模块，按相反顺序。

如果 R 是一个具有超类的类，则会重复此过程，使用 R 的超类，直到找到一个方法。

一旦找到匹配项，方法查找就会停止。

如果找不到匹配项，则会从头开始重复此过程，但会查找 method_missing。默认的 method_missing 是 BasicObject#method_missing，它在被调用时会引发 NameError。

如果细化（一项实验性功能）处于活动状态，方法查找会发生变化。有关详细信息，请参阅 细化文档。