调用方法 ↑

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

在 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]

详细信息

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

h = {foo: 0, bar: 1, baz: 2}
h.to_a.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 不知道应该将哪个方法 argument3 发送到

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

你可以使用*（或展开）运算符将Array转换为参数列表

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

或

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

两者等同于

my_method(1, 2, 3)

您还可以使用 **（接下来描述）将 Hash 转换为关键字参数。

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

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

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

Hash 转换为关键字参数转换 ↑

给定以下方法

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

您可以使用 **（关键字展开）运算符将 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)

如果方法定义使用关键字展开运算符来收集任意关键字参数，则不会通过 * 收集它们

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 转换为块转换 ↑

给定一个使用块的方法

def my_method
  yield self
end

您可以使用 &（块转换）运算符将过程或 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 的超类，直到找到方法。

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

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

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