Ruby字符串操作指南：常用方法与技巧

简介

在 Ruby 中，字符串拥有丰富的内置方法，这些方法使得文本的修改和操作变得异常简单。在各种程序开发中，这是一项非常常见的任务。

本教程将引导您学习如何利用 Ruby 字符串方法来执行以下操作：确定字符串的长度，通过索引和切片提取子字符串，添加和删除空格及其他字符，改变字符串中字符的大小写，以及查找和替换文本。完成本教程后，您将能够将这些实用的方法应用到您自己的 Ruby 程序中。

确定字符串长度

字符串方法 length 返回字符串中包含的字符数量。当您需要强制执行最小或最大密码长度，或者需要截断较长的字符串以用于缩写时，此方法会非常有用。

以下是一个打印句子长度的示例：

open_source = "Sammy contributes to open source."
print open_source.length

33

请注意，字符串中的每个字符，包括字母、数字、空格字符和符号，都将被计算在内。

要检查一个字符串是否为空，您可以检查其长度是否为 0，或者更简洁地使用 empty? 方法。

name = ""
name.empty? # => true

name = "Sammy"
name.empty? # => false

name = " "
name.empty? # => false

接下来，让我们了解如何对字符串进行索引并访问其内容。

访问字符串中的字符

使用切片（slice）方法可以获取字符串中您想要的部分，以便进行打印或进一步处理。

与数组类似，字符串中的每个字符都对应一个索引号，索引从 0 开始计数。

对于字符串 “Sammy”，索引的分解如下所示：

切片方法允许您获取单个字符或一系列字符。传递一个整数将返回该索引处的字符。传递两个用逗号分隔的整数，则表示返回从第一个索引到最后一个索引（包括）之间的所有字符。切片方法也接受范围（如 1..4）来指定要提取的字符。

"Sammy".slice(0)    # => "S"
"Sammy".slice(1,2)  # => "am"
"Sammy".slice(1..4) # => "ammy"

[] 语法是 slice 方法的别名，因此您可以将字符串当作数组一样处理。

"Sammy"[0]    # => "S"
"Sammy"[1,2]  # => "am"
"Sammy"[1..4] # => "ammy"

您还可以通过负索引从字符串末尾访问单个字符。-1 代表字符串的最后一个字符，-2 代表倒数第二个字符，依此类推。

最后，您可以使用 chars 方法将字符串转换为字符数组。

"Sammy".chars # => ["S", "a", "m", "m", "y"]

这对于操作或转换字符串中的字符可能非常有用。

接下来，让我们看看如何改变字符串中字符的大小写。

转换为大写和小写

这是文章《如何在Ruby中使用字符串方法》的第2部分（共6部分）。

upcase 和 downcase 方法返回一个新字符串，其中包含原始字符串中所有字母转换为大写或小写后的内容。字符串中的任何非字母字符都不会被改变。

让我们将字符串“Sammy Shark”转换为全部大写：

name = "Sammy Shark"
print name.upcase

SAMMY SHARK

现在，让我们把字符串转换为全小写：

print name.downcase

sammy shark

upcase 和 downcase 函数通过将字符串的大小写统一，使得字符串的评估和比较更加简便。例如，如果要求用户输入用户名，并且用户输入的用户名首字母大写，你可以将用户的输入转换为小写形式，然后与一个已知的小写值进行比较。

在Ruby中，字符串也有一个 capitalize 方法，用于将第一个字符变为大写，并返回一个新的字符串。

"sammy".capitalize # "Sammy"

这是一种方便的方法，但要注意如何使用它；它只将首字母转为大写，可能不适合你所需要的用例。

Ruby还提供了一个 swapcase 方法，该方法返回一个大小写交换的字符串。

text = "Sammy"
print text.swapcase

sAMMY

下面定义的 downcase、upcase、capitalize 和 swapcase 方法都返回一个新的字符串，原字符串保持不变。如果你想做的不仅仅是立即打印出文本，这一点非常重要。请看下面的例子。

text = "sammy"
text.capitalize

print "Hello, #{text}!"

Hello, sammy!

尽管我们调用了 capitalize 函数对文本变量进行处理，但是我们从来没有获取到 capitalize 返回的值。我们需要像这样重写程序：

text = "sammy"
text = text.capitalize

print "Hello, #{text}!"

Hello, Sammy!

你可以使用 downcase!、upcase!、capitalize! 和 swapcase! 来修改原始字符串。

text = "sammy"
text = text.capitalize!

print "Hello, #{text}!"

要小心，虽然变异原始字符串有其不利之处。Ruby 提供了两种方法，你可以根据自己的需要选择其中之一。

现在让我们对字符串进行添加和删除空格的操作。

填充和删除字符串

这是文章《如何在Ruby中使用字符串方法》的第3部分（共6部分）。

如果你要编写一个需要格式化文本的程序，你经常会发现需要调整字符串的对齐方式，例如在字符串前面、后面或周围添加空格。而另一些时候，你可能需要从字符串的开头或结尾删除不必要的字符，如多余的空格或特殊字符。

使用 center 方法在字符串周围添加空格

center 方法可以在字符串周围添加空格，使其达到指定的总长度。

"Sammy".center(21) # "      Sammy      "

如果你想使用不同的填充字符，可以将其作为第二个参数指定。

"[Sammy]".center(21, "<>") # "<><><>[Sammy]<><><>"

使用 ljust 和 rjust 方法进行左对齐和右对齐

ljust 和 rjust 方法分别在字符串的左侧或右侧添加空格或字符，其工作方式与 center 方法类似。

"Sammy".ljust(20) # "Sammy               "
"Sammy".rjust(20) # "               Sammy"
"Sammy".rjust(20, "!") # "!!!!!!!!!!!!!!!Sammy"

使用 strip、lstrip 和 rstrip 方法去除空格

要从字符串中去除前导空格，可以使用 lstrip 方法。要去除尾随空格，请使用 rstrip。使用 strip 方法可以同时去除前导和尾随空格。

" Sammy".lstrip # "Sammy"
"Sammy ".rstrip # "Sammy"
" Sammy ".strip # "Sammy"

你可以使用 center!、ljust!、rjust!、lstrip!、rstrip! 和 strip! 方法来直接修改原始字符串（带有感叹号的方法通常表示会修改原对象）。

使用 chop 方法删除字符串末尾字符

有时候你需要从一个字符串的结尾删除一些字符。Ruby 的 chop 方法就是做这个的；它会从字符串中删除最后一个字符。

"Sammy".chop # "Samm"

这对于从字符串中删除换行符（\n）特别有用。

"This string has a newline\n".chop # "This string has a newline"

chop 方法不改变原始字符串，而是返回一个新的字符串。chop! 方法则直接修改现有的字符串。

使用 chomp 方法删除字符串末尾的指定字符或换行符

chomp 方法可以从字符串的末尾删除指定的字符序列。

"Sammy".chomp("my") # "Sam"

如果你没有指定要删除的字符串，chomp 函数将会删除字符串末尾的换行符（\n、\r 或 \r\n）。

"This string has a newline\n".chomp # "This string has a newline"

然而，如果字符串中不包含换行符，chomp 只会返回原始字符串。

"Sammy".chomp # "Sammy"

这使得使用 chomp 方法比 chop 方法更安全，因为它仅在存在换行符时才移除它们，而 chop 总是移除最后一个字符。

chomp! 方法的行为

Ruby 有一个 chomp! 方法，它会改变原始字符串并返回修改后的字符串（如果进行了替换）。然而，与 chomp 不同的是，如果 chomp! 方法没有改变字符串，它会返回 nil。

string = "Hello\n"
string.chomp! # "Hello"

string = "Hello"
string.chomp! # nil

接下来，让我们来看看如何在字符串中搜索文本。

寻找字符和文本

在Ruby中查找字符串：`include?`、`index`、`start_with?`和`end_with?`方法详解

这是文章《如何在Ruby中使用字符串方法》的第4部分（共6部分）。

在Ruby中处理字符串时，经常需要判断一个字符串是否包含另一个字符串，或者查找特定字符/子字符串的位置。本节将详细介绍几个常用的字符串查找方法：include?、index、start_with?和end_with?。

使用 `include?` 方法检查字符串包含性

include? 方法用于检查一个字符串是否包含另一个字符串。如果目标字符串存在，则返回 true，否则返回 false。

"Sammy".include?("a") # true
"Sammy".include?("b") # false

使用 `index` 方法查找字符或子字符串的首次出现位置

index 方法返回指定字符或子字符串首次出现的起始索引。如果字符或子字符串不存在，则返回 nil。

"Sammy".index("a") # 1
"Sammy".index("mm") # 2
"Sammy".index("Fish") # nil

需要注意的是，index 方法只能找到字符或子字符串的第一次出现。例如：

text = "Sammy has a balloon"
text.index("a") # 1

在字符串“Sammy has a balloon”中，字母“a”出现了四次。但 index 方法只返回了第一次出现的位置（索引为1）。

查找所有出现位置的进阶方法

如果需要查找所有出现的位置，可以将字符串转换为字符数组，并结合数组方法进行遍历和筛选。以下是一个实现示例：

text = "Sammy has a balloon"
indices = text.chars
.each_with_index
.select{|char, index| char == "a" }
.map{|pair| pair.last}

print indices

[1, 7, 10, 13]

上述代码的解释：

• text.chars 将字符串转换为字符数组。
• .each_with_index 返回一个包含每个元素及其索引的二维数组（例如：[['S', 0], ['a', 1], ...]）。
• .select{|char, index| char == "a" } 筛选出所有字符为“a”的元素。
• .map{|pair| pair.last} 将筛选后的二维数组转换为一维数组，只包含索引值。

使用 `start_with?` 方法检查字符串开头

除了在字符串中查找字符，您还可以使用 start_with? 方法来检查字符串是否以特定的字符或子字符串开头。

text = "Sammy has a balloon"
text.start_with?("S") # true (注意：Ruby字符串比较区分大小写)
text.start_with?("Sammy has") # true

start_with? 方法还可以接受多个字符串作为参数。如果其中任何一个与字符串开头匹配，则返回 true。

text = "Sammy has a balloon"
text.start_with?("Sammy the Shark", "Sammy") # true

在这个例子中，“Sammy the Shark”不匹配，但“Sammy”匹配，因此返回值为 true。

使用 `end_with?` 方法检查字符串结尾

与 start_with? 类似，您可以使用 end_with? 方法来检查一个字符串是否以给定的子字符串结尾。它的用法与 start_with? 方法完全相同。

text = "Sammy has a balloon"
text.end_with?("balloon") # true
text.end_with?("boomerang") # false
text.end_with?("boomerang", "balloon") # true

至此，我们已经详细探讨了在Ruby中查找字符串的各种方法。接下来，我们将学习如何替换字符串中的文本。

替换字符串中的文本

（此处应为下一部分内容，根据原文章结构，此标题作为过渡）

这是文章《如何在Ruby中使用字符串方法》的第5部分（共6部分）。

在文字处理软件中，查找和替换功能允许您搜索一个字符串并用另一个字符串替换它。在Ruby中，您可以使用sub和gsub方法来实现这个功能。

sub方法用另一个字符串替换字符串的第一个匹配项。

Sammy 不再有气球了，它飞走了。我们将“has”修改为“had”。

balloon = "Sammy has a balloon"
print balloon.sub("has","had")

我们的输出将会是这样的:

Sammy had a balloon.

sub方法只会替换第一个与匹配项相符的内容，将其替换为新的文本。让我们使用一个修改过的字符串，其中包含两个“has”单词的出现次数。

balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.sub("has","had")

Sammy had a balloon. The balloon has a ribbon

只有第一次出现的地方改变了。

要将它们全部改变，请使用gsub方法，该方法执行全局替换。

balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.gsub("has","had")

Sammy had a balloon. The balloon had a ribbon

sub和gsub方法始终返回新的字符串，原始字符串保持不变。让我们通过将字符串中的“balloon”更改为“boomerang”来证明这一点。

text = "Sammy has a balloon"
text.gsub("balloon", "boomerang")
print text

Sammy has a balloon

Sammy 有一个气球

输出并未显示我们所期望的结果，因为虽然我们指定了替代物，但我们从未将 gsub 的结果赋给一个新的变量。为了获得我们想要的结果，我们可以像下面这样重写程序：

text = "Sammy has a balloon"
text = text.sub("balloon", "boomerang")
print text

或者，你可以使用 sub! 代替，它可以修改原始字符串。我们尝试一下通过进行一些字符串替换。我们将把“红气球”改为“蓝回旋镖”。

text = "Sammy has a red balloon"
text.sub!("red", "blue")
text.sub!("balloon", "boomerang")
print text

"Sammy has a red balloon".gsub(/[aeiou]/, "@")

"S@mmy h@s @ r@d b@ll@@n"

"Sammy has a red balloon".gsub(/[aeiou]/, {"a" => "@", "o" => "0"})
# "S@mmy h@s @ r@d b@ll00n"