类 String

String 对象具有任意的字节序列，通常表示文本或二进制数据。可以使用 String::new 或作为字面量来创建 String 对象。

String 对象与 Symbol 对象不同，Symbol 对象设计为用作标识符，而不是文本或数据。

您可以使用以下方式显式创建一个 String 对象：

您可以使用以下方式将某些对象转换为字符串：

一些 String 方法会修改 self。通常，名称以 ! 结尾的方法会修改 self 并返回 self；通常，类似命名的方法（没有 !）会返回一个新的字符串。

一般来说，如果一个方法同时存在带感叹号和不带感叹号的版本，那么带感叹号的方法会改变自身，而不带感叹号的方法则不会。然而，没有感叹号的方法也可能会改变自身，例如 String#replace。

替换方法 ↑

这些方法执行替换操作

这些方法中的每一个都接受：

本节中的示例主要使用 String#sub 和 String#gsub 方法；所说明的原则适用于所有四种替换方法。

参数 pattern

参数 pattern 通常是一个正则表达式

s = 'hello'
s.sub(/[aeiou]/, '*') # => "h*llo"
s.gsub(/[aeiou]/, '*') # => "h*ll*"
s.gsub(/[aeiou]/, '')  # => "hll"
s.sub(/ell/, 'al')     # => "halo"
s.gsub(/xyzzy/, '*')   # => "hello"
'THX1138'.gsub(/\d+/, '00') # => "THX00"

当 pattern 是一个字符串时，它的所有字符都被视为普通字符（而不是 Regexp 特殊字符）

'THX1138'.gsub('\d+', '00') # => "THX1138"

String replacement

如果 replacement 是一个字符串，则该字符串确定替换匹配文本的替换字符串。

上面的每个示例都使用一个简单的字符串作为替换字符串。

String replacement 可能包含对模式捕获的反向引用

有关详细信息，请参见 Regexp。

请注意，在字符串 replacement 中，诸如 $& 之类的字符组合被视为普通文本，而不是特殊的匹配变量。但是，您可以使用以下组合引用一些特殊的匹配变量：

有关详细信息，请参见 Regexp。

请注意，\\ 被解释为转义符，即单个反斜杠。

还要注意，字符串字面量会消耗反斜杠。有关字符串字面量的详细信息，请参见 字符串字面量。

反向引用通常前面会有一个额外的反斜杠。例如，如果您想在双引号字符串字面量中使用 replacement 写入反向引用 \&，则需要写入 "..\\&.."。

如果您想在 replacement 中写入非反向引用字符串 \&，则需要首先转义反斜杠，以防止此方法将其解释为反向引用，然后您需要再次转义反斜杠，以防止字符串字面量消耗它们："..\\\\&.."。

您可能希望使用块形式来避免过多的反斜杠。

哈希 replacement

如果参数 replacement 是一个哈希，并且 pattern 匹配其键之一，则替换字符串是该键的值

h = {'foo' => 'bar', 'baz' => 'bat'}
'food'.sub('foo', h) # => "bard"

请注意，符号键不匹配

h = {foo: 'bar', baz: 'bat'}
'food'.sub('foo', h) # => "d"

块

在块形式中，当前匹配的字符串被传递给该块；该块的返回值将成为替换字符串

s = '@'
'1234'.gsub(/\d/) { |match| s.succ! } # => "ABCD"

特殊匹配变量（如 $1、$2、$`、$& 和 $'）会被正确设置。

字符串中的空白 ↑

在 String 类中，空白 被定义为由以下任何字符混合组成的连续字符序列：

空白与以下方法相关：

String 切片 ↑

字符串的切片是通过某些标准选择的子字符串。

以下实例方法使用切片：

上述每个方法都接受用于确定要复制或替换的切片的参数。

参数有多种形式。对于字符串 string，形式为：

string[index]

当给定一个非负整数参数 index 时，切片是 self 中字符偏移量 index 处的 1 个字符的子字符串

'bar'[0]      # => "b"
'bar'[2]      # => "r"
'bar'[20]     # => nil
'тест'[2]     # => "с"
'こんにちは'[4] # => "は"

当给定一个负整数 index 时，切片从 self 末尾向后计数给定的偏移量处开始

'bar'[-3]      # => "b"
'bar'[-1]      # => "r"
'bar'[-20]     # => nil

string[start, length]

当给定非负整数参数 start 和 length 时，如果存在，则切片从字符偏移量 start 处开始，并持续 length 个字符（如果可用）

'foo'[0, 2]      # => "fo"
'тест'[1, 2]     # => "ес"
'こんにちは'[2, 2] # => "にち"
# Zero length.
'foo'[2, 0]      # => ""
# Length not entirely available.
'foo'[1, 200]    # => "oo"
# Start out of range.
'foo'[4, 2]      # => nil

特殊情况：如果 start 等于 self 的长度，则切片是一个新的空字符串

'foo'[3, 2]    # => ""
'foo'[3, 200]  # => ""

当给定负数 start 和非负数 length 时，切片从 self 末尾向后计数开始，并持续 length 个字符（如果可用）

'foo'[-2, 2]     # => "oo"
'foo'[-2, 200]   # => "oo"
# Start out of range.
'foo'[-4, 2]     # => nil

当给定负数 length 时，不存在切片

'foo'[1, -1]   # => nil
'foo'[-2, -1]  # => nil

string[range]

当给定 Range 参数 range 时，它使用 range 中的索引创建 string 的子字符串。然后如上所述确定切片

'foo'[0..1]     # => "fo"
'foo'[0, 2]     # => "fo"

'foo'[2...2]    # => ""
'foo'[2, 0]     # => ""

'foo'[1..200]   # => "oo"
'foo'[1, 200]   # => "oo"

'foo'[4..5]     # => nil
'foo'[4, 2]     # => nil

'foo'[-4..-3]   # => nil
'foo'[-4, 2]    # => nil

'foo'[3..4]     # => ""
'foo'[3, 2]     # => ""

'foo'[-2..-1]   # => "oo"
'foo'[-2, 2]    # => "oo"

'foo'[-2..197]  # => "oo"
'foo'[-2, 200]  # => "oo"

string[regexp, capture = 0]

当给定 Regexp 参数 regexp 且 capture 参数为 0 时，切片是 self 中找到的第一个匹配子字符串

'foo'[/o/]                # => "o"
'foo'[/x/]                # => nil
s = 'hello there'
s[/[aeiou](.)\1/]        # => "ell"
s[/[aeiou](.)\1/, 0]     # => "ell"

如果提供参数 capture 且不为 0，则它应该是捕获组索引（整数）或捕获组名称（String 或 Symbol）；切片是指定的捕获（参见 Regexp 的组和捕获）

s = 'hello there'
s[/[aeiou](.)\1/, 1] # => "l"
s[/(?<vowel>[aeiou])(?<non_vowel>[^aeiou])/, "non_vowel"] # => "l"
s[/(?<vowel>[aeiou])(?<non_vowel>[^aeiou])/, :vowel]      # => "e"

如果给定无效的捕获组索引，则不存在切片。如果给定无效的捕获组名称，则会引发 IndexError。

string[substring]

当给定单个 String 参数 substring 时，如果找到，则返回 self 的子字符串，否则返回 nil

'foo'['oo'] # => "oo"
'foo'['xx'] # => nil

本页内容 ↑

首先，看看其他地方。类 String

在这里，类 String 提供了以下方面的实用方法：

用于创建 String 的方法 ↑

用于冻结/未冻结 String 的方法 ↑

用于查询的方法 ↑

计数

子字符串

编码

其他

用于比较的方法 ↑

用于修改 String 的方法 ↑

这些方法中的每一个都会修改 self。

插入

替换

大小写

编码

删除

用于转换为新 String 的方法 ↑

这些方法中的每一个都会返回一个基于 self 的新 String，通常只是 self 的修改副本。

扩展

编码

替换

大小写

删除

复制

转换为非-String 的方法 ↑

这些方法中的每一个都将 self 的内容转换为非 String。

字符、字节和集群

拆分

匹配

数值

字符串和符号

用于迭代的方法 ↑