方法

在 Ruby 中，我们可以将程序划分为称为方法的程序化组件或模块。我们已经熟悉像 print()、get()、step() 和 length() 这样的函数。方法可以被复制和重用，这种编程技术称为模块化或过程式方法，也被称为分而治之的方法。我们应该始终尝试设计可以在其他程序中复用的方法。

总体上，有两种类型的方法，我们将在接下来的部分中进行探讨。

方法的结构

以下幻灯片展示了方法定义的各个部分：

方法名只能包含字母（A–Z 和 a–z）以及下划线符号（_）。也可以包含数字（0–9），但方法名不能以数字开头。例如，Key_2 是一个合法的方法名，但 2_key 不是。方法名是区分大小写的，这意味着 name、Name 和 NAME 是三个不同的方法。

方法定义主要有三个部分：

• 头部：第一行包含 def。
• 主体：位于方法头部下方的语句块。
• 结束点：最后一行包含 end。

方法头部包含关键字 def、方法名 sayHello 以及括号 ()。

让我们编写上述示例的代码。

1def sayHello() # 函数定义
2  print("Hello")
3end
4sayHello()

最后一行告诉程序运行 sayHello() 函数。这一行被称为方法调用或调用方法。

1def first()
2  print("现在进入方法 \"first\"。\n")
3end
4def second()
5  print("现在进入方法 \"second\"。\n")
6end
7print("主程序从这里开始。\n")
8first() # 调用 first
9print("回到主程序。\n")
10second() # 调用 second
11print("再次回到主程序。\n")

在该程序中：

• 我们定义了两个简单的方法 —— first 和 second。
• 我们借助 print 语句演示了执行顺序。

return 语句

以下幻灯片展示了一个返回值的方法。示例说明了（1）如何在方法体中使用 return 语句，以及（2）如何在方法头部中编写参数 (a,b)。

注意：Ruby 中的每个方法都是返回值的方法。如果没有 return 语句，Ruby 会隐式返回最后一个表达式的值（没有值时返回 nil）。

让我们编写上述示例的代码。

1def getSum(a,b) # 函数定义
2  mysum = a + b # 将 a 和 b 相加，并将结果赋给变量 mysum
3  return mysum # 返回 mysum 的值
4end
5print(getSum(5,6))

在上述代码中：

• 最后一行调用了 print() 方法。它以 5 和 6 作为参数 a 和 b 的值，调用 getSum 方法。
• 变量 mysum 保存了 a 和 b 的和，即 11。
• 语句 return mysum 将 11 作为方法调用的结果返回给 print() 语句。

注意：本节中的图示旨在强调 return 语句必须是方法体中的最后一行。在 return 语句之后编写的任何语句都是不可达的。

练习：创建和调用方法

以下是几个用于练习创建和调用方法的示例程序。点击“显示答案”按钮后，您将看到解决相应问题的程序。您可以将给出的解决方案复制粘贴到代码编辑器中，以确保您的输出与给定答案一致。编程中可能存在多种正确的解决方案。

创建乘法表的函数

编写一个函数 showTableOf4()，用于显示接收参数的数值的 20 项乘法表。依次使用不同的参数值调用 showTableOf4() 函数。

示例输出

14 x 1 = 4
24 x 2 = 8
34 x 3 = 12
44 x 4 = 16
54 x 5 = 20
64 x 6 = 24
74 x 7 = 28
84 x 8 = 32
94 x 9 = 36
104 x 10 = 40
114 x 11 = 44
124 x 12 = 48
134 x 13 = 52
144 x 14 = 56
154 x 15 = 60
164 x 16 = 64
174 x 17 = 68
184 x 18 = 72
194 x 19 = 76
204 x 20 = 80

1# 在此处编写您的代码

您可以在上方的代码编辑器中运行以下代码：

1def showTableOf4()
2   for i in 0..20
3      print("4 x #{i} = ",4*i,"\n")
4    end
5end
6showTableOf4()

在上述程序中：

• 我们实现了一个方法 showTableOf4()。
• 在方法体中，我们使用 for 循环配合 range(1,21) 来显示 4 的乘法表。
• 循环体结束后，我们调用该函数。

我们还可以定义一个 showTable 方法，接收一个整数作为参数，用于显示其乘法表。该程序展示了参数化方法的复用性，可用于生成 4、5 和 15 的乘法表。

1def showTable(n)
2   print('** 表格为 ',n,' **',"\n")
3   for i in 0..20
4      print(n," x ",i," = ",n*i,"\n")
5   end
6   print("------------------------------\n")
7end
8showTable(4)
9showTable(5)
10showTable(15)

您可以在上方的代码编辑器中运行以下代码：

1def showTableOf4()
2   for i in 0..20
3      print("4 x #{i} = ",4*i,"\n")
4    end
5end
6showTableOf4()

在上述程序中：

• 我们实现了一个方法 showTableOf4()。
• 在方法体中，我们使用 for 循环配合 range(1,21) 来显示 4 的乘法表。
• 循环体结束后，我们调用该函数。

我们还可以定义一个 showTable 方法，接收一个整数作为参数，用于显示其乘法表。该程序展示了参数化方法的复用性，可用于生成 4、5 和 15 的乘法表。

1def showTable(n)
2   print('** 表格为 ',n,' **',"\n")
3   for i in 0..20
4      print(n," x ",i," = ",n*i,"\n")
5   end
6   print("------------------------------\n")
7end
8showTable(4)
9showTable(5)
10showTable(15)

查找不同值的方法

编写一个方法 showDistinct，接收一个数组作为参数，并打印数组中的不同元素。假设数组已按升序排列。调用您的函数以显示结果。

示例输入 1

1[2, 5, 5, 8, 8, 8, 9, 30, 45]

示例输出 1

1原始数组: [2, 5, 5, 8, 8, 8, 9, 30, 45]
2不同数组: [2, 5, 8, 9, 30, 45]

示例输入 2

1[2, 5, 5, 8, 8, 8]

示例输出 2

1原始数组: [2, 5, 5, 8, 8, 8]
2不同数组: [2, 5, 8]

1# 在此处编写您的代码

您可以在上方的代码编辑器中运行以下代码：

1def showDistinct(p)
2   # 执行去重操作 (p)
3   lp = p.length
4   r = [p[0]]*lp
5   i = k = 1
6 
7    while i<lp
8        if(p[i] != p[i-1])
9            r[k]=p[i]
10            k += 1
11        end
12        i += 1
13    end
14 
15   print('原始列表: ',p,"\n")
16   print('不同列表: ',r[0...k],"\n")
17end
18 
19showDistinct([2,5,5,8,8,8])

在上述程序中：

• 我们实现了一个函数 showDistinct()，接收一个列表（p）作为参数。
• 使用 length() 方法计算列表长度并赋值给变量 lp。
• 创建一个大小为 lp 的新数组 r，并将数组 p 的第一个元素复制到 r 的所有位置。
• 创建变量 i 和 k，并初始化为 1。
• 使用 while 循环检查并跳过重复值，同时将非重复值从数组 p 移动到 r。
• 显示两个数组。
• 方法体结束后，编写主程序调用该方法。

您可以在上方的代码编辑器中运行以下代码：

1def showDistinct(p)
2   # 执行去重操作 (p)
3   lp = p.length
4   r = [p[0]]*lp
5   i = k = 1
6while i<lp
7    if(p[i] != p[i-1])
8        r[k]=p[i]
9        k += 1
10    end
11    i += 1
12end
13
14print('原始列表: ',p,"\n")
15print('不同列表: ',r[0...k],"\n")
16end
17showDistinct([2,5,5,8,8,8])

在上述程序中：

• 我们实现了一个函数 showDistinct()，接收一个列表 (p) 作为参数。
• 使用 length() 方法计算列表长度并赋值给变量 lp。
• 创建一个大小为 lp 的新数组 r，并将数组 p 的第一个元素复制到 r 的所有位置。
• 创建变量 i 和 k，并初始化为 1。
• 使用 while 循环检查并跳过重复值，同时将非重复值从数组 p 移动到 r。
• 显示两个数组。
• 方法体结束后，编写主程序调用该方法。

在数组中搜索字符串的方法

编写一个方法，检查字符串或字符是否存在于数组中。如果存在，显示其在数组中的索引。调用您的函数以显示结果。

示例输入 1

• 第一个参数：数组

  1['2','55','888','9','30','45']

• 第二个参数：字符串

  1'888'

示例输出 1

1888 在索引 2 处找到

示例输入 2

• 第一个参数：数组

  1['2','55','888','9','30','45']

• 第二个参数：字符串

  1'50'

示例输出 2

150 在数组中未找到

1# 在此处编写您的代码

您可以在上方的代码编辑器中运行以下代码：

1def searchStr(p, r)
2   # 执行字符串搜索
3   lp = p.length
4   i = 0
5   found = 0
6   while i<lp
7        if (p[i] == r)
8         print(r," 在索引 ",i," 处找到")
9         found = 1
10        end
11      i += 1
12    end
13 
14   if found == 0
15      print(r," 在数组中未找到")
16    end
17end
18p = ['2','55','888','9','30','45']
19key = '50'
20searchStr(p,key)

在上述程序中：

• 我们实现了一个方法 searchStr()，接收一个列表（p）和一个待搜索的变量（r）。
• 使用 length() 方法计算数组 p 的长度，并赋值给新变量 lp。
• 创建两个变量 i 和 found，并初始化为 0。
• 使用 while 循环检查数组 p 中每个索引处的值是否等于 r。
• 如果找到匹配值，则显示其在数组中的索引。
• 方法体结束后，通过传递数组 p 和 key 的值来调用函数。

您可以在上方的代码编辑器中运行以下代码：

1def searchStr(p, r)
2   # 执行字符串搜索
3   lp = p.length
4   i = 0
5   found = 0
6   while i<lp
7        if (p[i] == r)
8         print(r," 在索引 ",i," 处找到")
9         found = 1
10        end
11      i += 1
12    end
13if found == 0
14print(r," 在数组中未找到")
15end
16end
17p = ['2','55','888','9','30','45']
18key = '50'
19searchStr(p,key)

在上述程序中：

• 我们实现了一个方法 searchStr()，接收一个列表 (p) 和一个待搜索的变量 (r)。
• 使用 length() 方法计算数组 p 的长度，并赋值给新变量 lp。
• 创建两个变量 i 和 found，并初始化为 0。
• 使用 while 循环检查数组 p 中每个索引处的值是否等于 r。
• 如果找到匹配值，则显示其在数组中的索引。
• 方法体结束后，通过传递数组 p 和 key 的值来调用函数。

显示斐波那契序列的方法

斐波那契序列是一个每个数是前两个数之和的序列。编写一个方法 fibo，接收参数 n 以指定斐波那契序列的项数。n 的值应小于或等于 20。该方法将返回一个包含序列的数组。调用您的函数以显示结果。

示例输入

110

示例输出

1斐波那契序列的前 10 项为：
2[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
3*** 生成斐波那契数列结束 ***

1# 在此处编写您的代码

您可以在上方的代码编辑器中运行以下代码：

1def fibo(n)
2   if (n < 1)
3      print("似乎所需斐波那契数的数量无效：",n,"\n")
4   else
5        fib = [0]*n
6        if (n > 1)
7            fib[1] = 1
8        end
9        count = 2
10        while count < n
11            fib[count] = fib[count-2] + fib[count-1]
12            count += 1
13        end
14        return fib
15    end
16end
17nterms = 10
18print("斐波那契序列的前 ",nterms," 项为：","\n")
19print(fibo(nterms),"\n")
20print("*** 生成斐波那契数列结束 ***")

在上述程序中：

• 我们完成了一个方法 fibo()，接收 n 作为参数。
• 变量 n 表示斐波那契序列的总项数。
• 第一个 if 语句限制 n 的值不能小于 1。
• 程序中的一个新特性是 fib = [0] * n。语法 [0] * n 用于创建一个包含 n 个元素的数组，每个元素初始值为 0。
• 这个包含 n 个零的数组存储在变量 fib 中。这是一种轻松生成大数组或包含 n 个值的数组的方法，无需手动输入大量数据。根据场景，我们可以选择其他初始值代替 0。
• 第二个 if 语句检查 n 的值。如果大于 1，则将 1 赋值给 fib[1]。
• 我们使用变量 count 来记录当前项数，初始值为 2。
• 在 while 循环中，语句 fib[count] = fib[count-2] + fib[count-1] 生成斐波那契序列。此过程重复直到 count 小于 n。
• 方法返回列表 fib。
• 方法体结束后，我们在 print() 语句中调用该方法，以显示方法返回的列表。

您可以在上方的代码编辑器中运行以下代码：

1def fibo(n)
2   if (n < 1)
3      print("似乎所需斐波那契数的数量无效：",n,"\n")
4   else
5        fib = [0]*n
6        if (n > 1)
7            fib[1] = 1
8        end
9        count = 2
10        while count < n
11            fib[count] = fib[count-2] + fib[count-1]
12            count += 1
13        end
14        return fib
15    end
16end
17nterms = 10
18print("斐波那契序列的前 ",nterms," 项为：","\n")
19print(fibo(nterms),"\n")
20print("*** 生成斐波那契数列结束 ***")

在上述程序中：

• 我们完成了一个方法 fibo()，接收 n 作为参数。
• 变量 n 表示斐波那契序列的总项数。
• 第一个 if 语句限制 n 的值不能小于 1。
• 程序中的一个新特性是 fib = [0] * n。语法 [0] * n 用于创建一个包含 n 个元素的数组，每个元素初始值为 0。
• 这个包含 n 个零的数组存储在变量 fib 中。这是一种轻松生成大数组或包含 n 个值的数组的方法，无需手动输入大量数据。根据场景，我们可以选择其他初始值代替 0。
• 第二个 if 语句检查 n 的值。如果大于 1，则将 1 赋值给 fib[1]。
• 我们使用变量 count 来记录当前项数，初始值为 2。
• 在 while 循环中，语句 fib[count] = fib[count-2] + fib[count-1] 生成斐波那契序列。此过程重复直到 count 小于 n。
• 方法返回列表 fib。
• 方法体结束后，我们在 print() 语句中调用该方法，以显示方法返回的列表。