如何在Ruby中使用字符串方法

介绍

Ruby strings 有许多内置方法，可以轻松修改和操作文本，这是许多程序中的常见任务。

在本教程中，您将使用字符串方法来确定字符串的长度、索引和拆分字符串以提取子字符串、添加和删除空格和其他字符、更改字符串中字符的大小写以及查找和替换文本。完成后，您将能够将这些方法合并到您自己的程序中。

确定字符串长度

字符串方法 length 返回字符串中的字符数。当您需要强制最小或最大密码长度，或将较大的字符串截断以在特定限制内用作缩写时，此方法很有用。

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

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

Output33

请记住，每个字符，包括字母、数字、空白字符和符号，都将被计算在内，因为它是字符串的一部分。

要检查字符串是否为空，可以检查其长度是否为 0，也可以使用 empty? 方法：

name = ""
name.empty?    # true

name = "Sammy"
name.empty?    # false

name = "     "
name.empty?    # false

让我们看看如何索引字符串并访问字符串的内容。

访问字符串中的字符

要打印或处理字符串中的某些字符，请使用 slice 方法获取您想要的部分。

与 arrays 一样，其中每个元素对应一个索引号，字符串的每个字符也对应一个索引号，从索引号 0 开始。

对于字符串 Sammy，索引细分如下所示：

0	1	2	3	4
S	a	m	m	y

slice 方法可让您抓取单个字符或一系列字符。传递单个整数会返回该索引处的字符。传递两个用逗号分隔的整数，告诉 slice 返回从第一个索引到最后一个索引的所有字符，包括在内。 slice 方法还接受一个范围，例如 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"]

这对于操作或转换字符串中的字符很有用。

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

转换为大写和小写

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

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

name = "Sammy Shark"
print name.upcase

OuputSAMMY SHARK

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

print name.downcase

Ouputsammy shark

upcase 和 downcase 函数通过使大小写始终保持一致，可以更轻松地评估和比较字符串。例如，如果您要求输入用户名并且用户输入的用户名是大写字母，您可以将用户的输入小写并将其与小写的已知值进行比较。

Ruby 字符串也有一个 capitalize 方法，它返回一个第一个字符大写的新字符串：

"sammy".capitalize    # "Sammy"

这是一种方便的方法，但要小心使用它；它仅将第一个字母大写，因此它可能并不总是适合您需要的用例。

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

text = "Sammy"
print text.swapcase

sAMMY

downcase、upcase、captalize 和 swapcase 方法都返回一个新字符串并且保持现有字符串不变。如果您正在做的事情不是立即打印出文本，请务必记住这一点。请看以下示例：

text = "sammy"
text.capitalize

print "Hello, #{text}!"

OutputHello, sammy!

尽管我们在 text 变量上调用了 capitalize，但我们从未捕获 capitalize 返回的值。我们需要像这样重写程序：

text = "sammy"
text = text.capitalize

print "Hello, #{text}!"

OutputHello, Sammy!

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

text = "sammy"
text = text.capitalize!

print "Hello, #{text}!"

不过要小心。改变原始字符串有一些缺点。 Ruby 提供了这两种方法，因此您可以选择适合您需要的一种。

现在让我们在字符串中添加和删除空格。

填充和剥离字符串

如果您正在编写一个必须格式化某些文本的程序，您通常会发现您需要在字符串的前面、后面或周围添加一些空格，以使其与其他数据对齐。有时，您可能希望从字符串的开头或结尾删除不必要的字符，例如额外的空格或特殊字符。

要使用空格包围字符串，请使用 center 方法：

"Sammy",center(21)    # "        Sammy        "

如果你想使用不同的字符，你可以指定一个字符串作为第二个参数：

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

ljust 和 rjust 方法在字符串的左侧或右侧添加空格或字符，其工作方式与 center 方法完全相同：

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

要从字符串中删除前导空格，请使用 rstrip 方法。要删除尾随空格，请使用 lstrip。使用 strip 删除前导和尾随空格：

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

可以使用center!、ljust!、rjust!、lstrip!、rstrip!、strip!方法修改原始字符串。

有时您需要从字符串末尾删除字符。 Ruby 的 chop 方法就是这样做的；它从字符串中删除最后一个字符：

"Sammy".chop     # "Samm"

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

"This string has a newline\n".chop

chop 方法保持原始字符串不变，返回一个新字符串。 chop! 方法修改现有字符串。

chomp 方法可以从字符串末尾删除多个字符：

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

如果您不指定要删除的字符串， chomp 将删除换行符：

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

但是，如果字符串不包含换行符，chomp 只会返回原始字符串：

"Sammy".chomp     # "Sammy"

这使得 chomp 在删除换行符时使用起来比 chop 方法更安全，后者总是删除最后一个字符。

Ruby 有一个 chomp! 方法，它改变原始字符串并在执行替换时返回修改后的字符串。但是，与 chomp 不同的是，如果 chomp! 方法没有改变字符串，它会返回 nil：

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

string = "Hello"
string.chomp!     # nil

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

查找字符和文本

有时您需要确定一个字符串是否包含另一个字符串。

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

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

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 只找到了第一次出现。您必须编写更具体的内容来定位其他事件之一。

例如，您可以将字符串转换为字符数组并使用数组方法遍历结果并选择字符的索引。这是一种方法：

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]

each_with_index 返回一个二维数组，其中包含每个字符的条目及其索引。 select 将其缩减为字符为 a 的条目，并且 map 将二维数组转换为索引的一维数组。

除了在字符串中查找字符外，您还可以使用 start_with? 方法检查字符串是否以字符或子字符串开头：

text = "Sammy has a balloon"
text.start_with?("s")         # true
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? 完全相同：

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

我们已经研究了查找文本的方法，所以让我们看看如何用不同的文本替换该文本。

替换字符串中的文本

文字处理器中的查找和替换功能可让您搜索字符串并将其替换为另一个字符串。您可以在 Ruby 中使用 sub 和 gsub 方法来做到这一点。

sub 方法将字符串的一部分替换为另一个字符串。

Sammy 不再有气球；它飞走了。让我们将子字符串 "has" 更改为 "had"。

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

我们的输出将如下所示：

OuputSammy had a balloon.

sub 方法仅将匹配的第一次出现替换为新文本。让我们使用一个出现两次单词 has 的修改后的字符串：

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

OutputSammy had a balloon. The balloon has a ribbon

只有第一次发生改变。

要全部更改它们，请使用 gsub 方法，该方法执行 global 替换：

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

OutputSammy had a balloon. The balloon had a ribbon

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

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

OutputSammy has a balloon

输出没有显示我们正在寻找的结果，因为虽然我们确实指定了替换，但我们从未将 gsub 的结果分配给新变量。为了得到我们想要的结果，我们可以这样重写程序：

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

或者，您可以改用 sub!，它会修改原始字符串。让我们通过做几个字符串替换来试试这个。我们将“红色气球”更改为“蓝色回旋镖”：

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

OutputSammy has a blue boomerang

您也可以使用 gsub! 方法进行全局替换。

sub 和 gsub 方法接受正则表达式用于搜索模式。让我们用 @ 符号替换字符串中的所有元音：

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

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

替换值不必是字符串。您可以使用散列来指定应如何替换单个字符或片段。让我们将所有出现的字母 a 替换为 @ 并将所有 o 字符替换为零：

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

您可以使用它以更少的代码执行更复杂的替换。

结论

在本教程中，您使用字符串数据类型的一些内置方法处理和操作字符串。您还了解到，许多处理字符串的方法有两种变体：一种保持字符串不变，另一种修改原始字符串。您使用哪一种取决于您的需求。 Ruby 让您可以灵活地选择处理数据的方式。但是，编写不修改现有数据的代码可以更容易在以后进行调试。

请务必查看这些相关教程，以继续探索如何在 Ruby 中处理数据：