Ruby 方法 (Methods)

Begindev 编辑部 March 26, 2026

定义和调用方法是 Ruby 编程中的一个基础概念，它允许你高效地组织和重用代码。理解如何定义方法、传递参数以及处理返回值，有利于编写结构良好且易于维护的 Ruby 程序。

本章将深入探讨方法的各项细节，为你提供创建自定义可复用代码块所需的知识和技能。

1. 定义方法

在 Ruby 中，方法（Method）是执行特定任务的代码块。我们使用 def 关键字来定义方法，紧接着是方法名、括号内可选的参数，最后使用 end 关键字来标记方法定义的结束。

def greet(name)  # 定义一个名为 'greet' 的方法，接收一个参数 'name'
  puts "你好，#{name}！" # 打印包含该名字的问候语
end # 方法定义结束

在上面的例子中：

def greet(name)：这一行定义了一个名为 greet 的方法。它接收一个参数 name。
puts "你好，#{name}！"：这是方法的主体（body）。它使用了字符串插值技术，将 name 的值插入到问候语中。
end：这个关键字标志着方法定义的结束。

2. 方法命名规范

Ruby 中的方法名应当具有描述性，并遵循以下约定：

使用小写字母。
单词之间使用下划线分隔（即蛇形命名法 snake_case）。
选择能清晰表明方法功能的名称。

一些优秀的方法名示例：

calculate_area
get_user_name
is_valid_email

3. 无参数的方法

方法也可以在不接收任何参数的情况下被定义。

def say_hello # 定义一个名为 'say_hello' 的方法，不接收任何参数
  puts "你好！" # 打印问候语
end # 方法定义结束

4. 调用方法

要执行一个方法，你需要通过它的名称来“调用（Call）”它，后面通常跟上括号。如果该方法需要接收参数，你必须在括号内提供这些参数。

4.1 基础调用

greet("Alice") # 传入参数 "Alice" 调用 'greet' 方法
# 输出: 你好，Alice！

say_hello() # 不传参数调用 'say_hello' 方法
# 输出: 你好！

say_hello # 当方法不接收参数时，调用时省略括号也是完全可以接受的
# 输出: 你好！

4.2 传递参数调用

当调用带有参数的方法时，请确保你提供了在方法定义中规定的正确数量和类型的参数。

def add(x, y) # 定义一个方法 'add'，接收两个参数 x 和 y
  puts x + y # 打印这两个参数的和
end # 方法定义结束

add(5, 3) # 传入参数 5 和 3 调用 'add' 方法
# 输出: 8

5. 方法的返回值

5.1 隐式返回 (Implicit Return)

在 Ruby 中，方法内最后一个被评估的表达式的值会被隐式（自动）返回。除非你想从方法的中间提前返回一个值，否则你不需要显式地使用 return 关键字。

def multiply(x, y) # 定义一个方法 'multiply'，接收两个参数 x 和 y
  x * y # 隐式返回 x 和 y 的乘积
end # 方法定义结束

result = multiply(4, 6) # 调用 'multiply' 方法，并将结果存储在 'result' 变量中
puts result # 打印 result 的值
# 输出: 24

在这个例子中，multiply 方法隐式返回了 x * y 的计算结果。

5.2 显式返回 (Explicit Return)

你可以使用 return 关键字来显式指定方法的返回值，或者用来提前退出方法。

def divide(x, y) # 定义一个方法 'divide'，接收两个参数 x 和 y
  return "不能除以零" if y == 0 # 如果 y 为零，则返回一条错误信息（提前退出）
  x / y # 如果 y 不为零，则返回 x 除以 y 的商
end # 方法定义结束

puts divide(10, 2) # 传入 10 和 2 调用 divide
# 输出: 5

puts divide(8, 0) # 传入 8 和 0 调用 divide
# 输出: 不能除以零

在这个例子中，如果 y 等于 0，方法会使用 return 关键字显式返回字符串 "不能除以零" 并结束运行。否则，它会继续执行并返回 x / y 的结果。

6. 方法参数进阶

方法可以接收参数（即调用方法时传入的值），并可以返回值（即方法执行的结果）。理解如何灵活运用参数和返回值，是创建高适应性和高复用性方法的关键。

6.1 默认参数 (Default Parameters)

你可以为方法参数指定默认值。如果调用者没有为带有默认值的参数提供实际值，程序就会使用这个默认值。

def greet(name = "访客") # 定义方法 'greet'，接收可选参数 'name'，默认值为 "访客"
  puts "你好，#{name}！" # 打印包含名字的问候语
end # 方法定义结束

greet("Bob") # 传入参数 "Bob" 调用 'greet' 方法
# 输出: 你好，Bob！

greet # 不传任何参数调用 'greet' 方法
# 输出: 你好，访客！

在这个例子中，name 参数拥有默认值 "访客"。当我们在不提供任何参数的情况下调用 greet 方法时，name 的值就会自动采用 "访客"。

6.2 可变数量参数 (*args)

Ruby 允许你使用 *args（星号语法）来定义接收可变数量参数的方法。当你无法提前预知方法会被传入多少个参数时，这非常有用。

def sum(*numbers) # 定义方法 'sum'，将传入的可变数量参数收集为一个名为 'numbers' 的数组
  total = 0 # 初始化变量 'total' 为 0
  numbers.each { |number| total += number } # 遍历 'numbers' 数组，将每个数字累加到 'total' 变量中
  total # 返回 'total' 的最终值
end # 方法定义结束

puts sum(1, 2, 3) # 传入参数 1, 2 和 3 调用 'sum' 方法
# 输出: 6

puts sum(4, 5, 6, 7) # 传入参数 4, 5, 6 和 7 调用 'sum' 方法
# 输出: 22

在这个例子中，sum 方法可以接收任意数量的参数。*numbers 参数将所有传入的值收集到一个名为 numbers 的数组中。然后，方法遍历这个数组并计算数字的总和。

6.3 关键字参数 (Keyword Arguments)

关键字参数允许你使用“键值对 (key-value)”的语法向方法传递参数。这不仅能让你的代码可读性大增，在方法拥有众多可选参数时尤为好用。

def create_user(name:, age:, city: "未知") # 定义方法 'create_user'，接收关键字参数 'name', 'age'，以及带有默认值 "未知" 的可选关键字参数 'city'
  puts "姓名: #{name}, 年龄: #{age}, 城市: #{city}" # 打印用户信息
end # 方法定义结束

create_user(name: "Charlie", age: 30, city: "纽约") # 使用所有关键字参数调用 'create_user' 方法
# 输出: 姓名: Charlie, 年龄: 30, 城市: 纽约

create_user(name: "Diana", age: 25) # 仅使用 'name' 和 'age' 关键字参数调用 'create_user' 方法
# 输出: 姓名: Diana, 年龄: 25, 城市: 未知

在这个例子中，create_user 接收 name、age 和 city 作为关键字参数。其中 city 拥有默认值 "未知"。在调用方法时，你可以以任意顺序指定参数，只要遵循 键: 值 的格式即可。

7. 实战演示

让我们通过一些更具实践意义的例子来巩固你的理解。

7.1 计算矩形面积

def calculate_rectangle_area(length, width) # 定义方法 'calculate_rectangle_area'，接收参数 'length' (长) 和 'width' (宽)
  length * width # 返回长和宽的乘积，即矩形的面积
end # 方法定义结束

area = calculate_rectangle_area(10, 5) # 传入参数 10 和 5 调用该方法，将结果存入变量 'area'
puts "矩形的面积是: #{area}" # 打印矩形面积
# 输出: 矩形的面积是: 50

7.2 检查数字是否为偶数

def is_even?(number) # 定义方法 'is_even?'，接收一个参数 'number'
  number % 2 == 0 # 如果数字是偶数（能被 2 整除且没有余数）则返回 true，否则返回 false
end # 方法定义结束

puts is_even?(4) # 传入 4 调用 'is_even?' 方法
# 输出: true

puts is_even?(7) # 传入 7 调用 'is_even?' 方法
# 输出: false

7.3 格式化字符串

def format_string(string, uppercase: false, reverse: false) # 定义方法 'format_string'，接收一个字符串参数，以及默认值为 false 的两个可选关键字参数
  string = string.upcase if uppercase # 如果 'uppercase' 参数为真，则将字符串转换为大写
  string = string.reverse if reverse # 如果 'reverse' 参数为真，则将字符串反转
  string # 返回修改后的字符串
end # 方法定义结束

puts format_string("hello", uppercase: true) # 传入 "hello" 并将 'uppercase' 设为 true 调用该方法
# 输出: HELLO

puts format_string("world", reverse: true) # 传入 "world" 并将 'reverse' 设为 true 调用该方法
# 输出: dlrow

puts format_string("ruby", uppercase: true, reverse: true) # 传入 "ruby" 并将两者都设为 true 调用该方法
# 输出: YBUR