Ruby - 字符串

Ruby 中的 String 对象保存和操作一个或多个字节的任意序列，通常表示代表人类语言的字符。

最简单的字符串文字用单引号（撇号字符）括起来。引号内的文本是字符串的值 −

'This is a simple Ruby string literal'

如果您需要在单引号字符串文字中放置一个撇号，请在其前面加上一个反斜杠，这样 Ruby 解释器就不会认为它终止了该字符串 −

'Won\'t you read O\'Reilly\'s book?'

反斜杠还可以转义另一个反斜杠，因此第二个反斜杠本身不会被解释为转义字符。

以下是 Ruby 中与字符串相关的特性。

表达式替换

表达式替换是一种使用 #{ 和 } 将任何 Ruby 表达式的值嵌入到字符串中的方法 −

#!/usr/bin/ruby

x, y, z = 12, 36, 72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."

这将产生以下结果 −

The value of x is 12.
The sum of x and y is 48.
The average was 40.

通用分隔字符串

使用一般的分隔字符串，您可以在一对匹配的任意分隔符中创建字符串，例如，!、(、{、< 等，前面有一个百分号字符 (%)。Q、q 和 x 有特殊含义。一般的分隔字符串可以是 −

%{Ruby is fun.}  equivalent to "Ruby is fun."
%Q{ Ruby is fun. } equivalent to " Ruby is fun. "
%q[Ruby is fun.]  equivalent to a single-quoted string
%x!ls! equivalent to back tick command output `ls`

转义字符

下表是可以用反斜杠表示法表示的转义字符或不可打印字符的列表。

反斜杠符号	十六进制字符	说明
\a	0x07	响铃或警报
\b	0x08	退格
\cx		Control-x
\C-x		Control-x
\e	0x1b	Escape
\f	0x0c	换页
\M-\C-x		Meta-Control-x
\n	0x0a	换行符
\nnn		八进制表示法，其中 n 在 0.7 范围内
\r	0x0d	回车
\s	0x20	Space
\t	0x09	Tab
\v	0x0b	Vertical tab
\x		Character x
\xnn		十六进制表示法，其中 n 在 0.9、a.f 或 A.F 范围内

字符编码

Ruby 的默认字符集是 ASCII，其字符可以用单个字节表示。如果您使用 UTF-8 或其他现代字符集，则字符可能用一到四个字节表示。

您可以在程序开始时使用 $KCODE 更改字符集，如下所示 −

$KCODE = 'u'

以下是 $KCODE 的可能值。

序号	Code & 描述
1	a ASCII（与无相同）。这是默认设置。
2	e EUC.
3	n None (same as ASCII).
4	u UTF-8.

字符串内置方法

我们需要有一个 String 对象的实例来调用 String 方法。以下是创建 String 对象实例的方法 −

new [String.new(str = "")]

这将返回一个包含 str 副本的新字符串对象。现在，使用 str 对象，我们都可以使用任何可用的实例方法。例如 −

#!/usr/bin/ruby

myStr = String.new("THIS IS TEST")
foo = myStr.downcase

puts "#{foo}"

这将产生以下结果 −

this is test

以下是公共字符串方法（假设 str 是一个字符串对象） −

序号	方法 & 描述
1	str % arg 使用格式规范格式化字符串。如果 arg 包含多个替换，则它必须是一个数组。有关格式规范的信息，请参阅"内核模块"下的 sprintf。
2	*str integer** 返回一个包含整数倍 str 的新字符串。换句话说，str 是重复的整数次。
3	str + other_str 将 other_str 连接到 str。
4	str << obj 将一个对象连接到 str。如果对象是 0.255 范围内的 Fixnum，则将其转换为字符。将其与 concat 进行比较。
5	str <=> other_str 将 str 与 other_str 进行比较，返回 -1（小于）、0（等于）或 1（大于）。比较区分大小写。
6	str == obj 测试 str 和 obj 是否相等。如果 obj 不是字符串，则返回 false；如果 str <=> obj 返回 0，则返回 true。
7	str =~ obj 将 str 与正则表达式模式 obj 匹配。返回匹配开始的位置；否则为假。
8	str.capitalize 将字符串大写。
9	str.capitalize! 与大写相同，但进行了适当的更改。
10	str.casecmp 对字符串进行不区分大小写的比较。
11	str.center 使字符串居中。
12	str.chomp 从字符串末尾删除记录分隔符 ($/)，通常为 \n。如果不存在记录分隔符，则不执行任何操作。
13	str.chomp! 与 chomp 相同，但已进行了适当的更改。
14	str.chop 删除 str 中的最后一个字符。
15	str.chop! 与chop相同，但已进行了适当的更改。
16	str.concat(other_str) 将 other_str 连接到 str。
17	str.count(str, ...) 计算一组或多组字符。如果有多个字符集，则计算这些集的交集
18	str.crypt(other_str) 将单向加密哈希应用于 str。参数是盐字符串，它应该是两个字符长，每个字符在 a.z, A.Z, 0.9, 范围内。或者 /。
19	str.delete(other_str, ...) 返回 str 的副本，其中删除了其参数交集中的所有字符。
20	str.delete!(other_str, ...) 与删除相同，但更改已就地进行。
21	str.downcase 返回 str 的副本，其中所有大写字母都替换为小写。
22	str.downcase! 与小写相同，但已进行了更改。
23	str.dump 返回一个版本的 str ，其中所有非打印字符都被 \nnn 表示法替换，并且所有特殊字符都被转义了。
24	str.each(separator = $/) { \|substr\| block } 使用参数作为记录分隔符（默认为 $/）拆分 str，将每个子字符串传递给提供的块。
25	str.each_byte { \|fixnum\| block } 将每个字节从 str 传递到块，将每个字节作为字节的十进制表示形式返回。
26	str.each_line(separator=$/) { \|substr\| block } 使用参数作为记录分隔符（默认为 $/）拆分 str，将每个子字符串传递给提供的块。
27	str.empty? 如果 str 为空（长度为零），则返回 true。
28	str.eql?(other) 如果两个字符串具有相同的长度和内容，则它们是相等的。
29	str.gsub(pattern, replacement) [or] str.gsub(pattern) { \|match\| block } 返回 str 的副本，其中所有出现的模式替换为替换或块的值。该模式通常是一个正则表达式；如果是字符串，则不会解释正则表达式元字符（即 /\d/ 将匹配一个数字，但 '\d' 将匹配一个反斜杠后跟一个 'd'）
30	str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str] 引用 str，使用以下参数：一个 Fixnum，在 fixnum 处返回一个字符代码；两个 Fixnum，返回从偏移量（第一个 fixnum）到长度（第二个 fixnum）的子字符串； range，返回范围内的子字符串；正则表达式返回匹配字符串的一部分；带有 fixnum 的正则表达式，返回 fixnum 处的匹配数据； other_str 返回匹配 other_str 的子字符串。负的 Fixnum 以 -1 开头。
31	str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ] 替换（分配）全部或部分字符串。切片的同义词！。
32	str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { \|match\|block } 就地执行 String#gsub 的替换，如果没有执行替换，则返回 str 或 nil。
33	str.hash 根据字符串的长度和内容返回一个哈希值。
34	str.hex 将 str 中的前导字符视为十六进制数字字符串（带有可选的符号和可选的 0x）并返回相应的数字。出错时返回零。
35	str.include? other_str [or] str.include? fixnum 如果 str 包含给定的字符串或字符，则返回 true。
36	str.index(substring [, offset]) [or] str.index(fixnum [, offset]) [or] str.index(regexp [, offset]) 返回给定子字符串、字符 (fixnum) 或模式 (regexp) 在 str 中第一次出现的索引。如果没有找到则返回 nil。如果存在第二个参数，它指定字符串中开始搜索的位置。
37	str.insert(index, other_str) 在给定索引处的字符之前插入 other_str，修改 str。负索引从字符串末尾开始计数，并插入给定字符之后。目的是插入一个字符串，以便它从给定的索引开始。
38	str.inspect 返回 str 的可打印版本，特殊字符已转义。
39	str.intern [or] str.to_sym 返回与 str 对应的符号，如果符号以前不存在，则创建该符号。
40	str.length 返回 str 的长度。比较大小。
41	str.ljust(integer, padstr = ' ') 如果整数大于 str 的长度，则返回一个长度为整数的新字符串，其中 str 左对齐并用 padstr 填充；否则，返回 str。
42	str.lstrip 返回删除前导空格的 str 副本。
43	str.lstrip! 从 str 中删除前导空格，如果没有进行任何更改，则返回 nil。
44	str.match(pattern) 将模式转换为正则表达式（如果还不是），然后在 str 上调用其匹配方法。
45	str.oct 将 str 的前导字符视为八进制数字字符串（带有可选符号）并返回相应的数字。如果转换失败，则返回 0。
46	str.replace(other_str) 将 str 的内容和污点替换为 other_str 中的相应值。
47	str.reverse 以相反的顺序返回一个新字符串，其中包含 str 中的字符。
48	str.reverse! 将 str 反转到位。
49	str.rindex(substring [, fixnum]) [or] str.rindex(fixnum [, fixnum]) [or] str.rindex(regexp [, fixnum]) 返回 str 中给定子字符串、字符 (fixnum) 或模式 (regexp) 的最后一次出现的索引。如果没有找到则返回 nil。如果存在第二个参数，它指定字符串中结束搜索的位置。超出此点的字符将不被考虑。
50.	str.rjust(integer, padstr = ' ') 如果 integer 大于 str 的长度，则返回一个长度为 integer 的新 String，str 右对齐并用 padstr 填充；否则，返回 str。
51	str.rstrip 返回删除尾随空格的 str 副本。
52	str.rstrip! 从 str 中删除尾随空格，如果没有进行任何更改，则返回 nil。
53	str.scan(pattern) [or] str.scan(pattern) { \|match, ...\| block } 两种形式都遍历 str，匹配模式（可能是正则表达式或字符串）。对于每个匹配，都会生成一个结果并将其添加到结果数组或传递给块。如果模式不包含任何组，则每个单独的结果都包含匹配的字符串 $&。如果模式包含组，则每个单独的结果本身就是一个数组，每个组包含一个条目。
54	str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or] str.slice(range) [or] str.slice(regexp) [or] str.slice(regexp, fixnum) [or] str.slice(other_str) See str[fixnum], etc. str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str) 从 str 中删除指定部分，并返回已删除的部分。如果值超出范围，采用 Fixnum 的表单将引发 IndexError； Range 表单将引发 RangeError，而 Regexp 和 String 表单将默默地忽略分配。
55	str.split(pattern = $, [limit]) 根据分隔符将 str 划分为子字符串，返回这些子字符串的数组。如果pattern是一个String，那么它的内容在分割str时作为分隔符。如果 pattern 是单个空格，则 str 在空格上拆分，忽略前导空格和连续空格字符的运行。如果 pattern 是一个正则表达式，str 在模式匹配的地方被分割。每当模式与零长度字符串匹配时，str 就会被拆分为单个字符。如果pattern被省略，$的值；用来。如果 $; 为 nil（这是默认值），str 在空格上拆分，就像指定了 ` `。如果省略 limit 参数，则禁止尾随空字段。如果 limit 是一个正数，最多将返回该数量的字段（如果 limit 为 1，则整个字符串作为数组中的唯一条目返回）。如果为负数，则返回的字段数没有限制，并且不抑制尾随的空字段。
56	*str.squeeze([other_str])** 使用针对 String#count 描述的过程从 other_str 参数构建一组字符。返回一个新字符串，其中出现在此集中的相同字符的运行被单个字符替换。如果没有给出参数，则所有相同字符的运行都将替换为单个字符。
57	*str.squeeze!([other_str])** 将 str 压缩到位，如果未进行任何更改，则返回 str 或 nil。
58	str.strip 返回删除前导和尾随空格的 str 副本。
59	str.strip! 从 str 中删除前导和尾随空格。如果 str 未更改，则返回 nil。
60	str.sub(pattern, replacement) [or] str.sub(pattern) { \|match\| block } 返回 str 的副本，其中第一次出现的模式替换为替换或块的值。该模式通常是一个正则表达式；如果它是字符串，则不会解释正则表达式元字符。
61	str.sub!(pattern, replacement) [or] str.sub!(pattern) { \|match\| block } 就地执行 String#sub 的替换，如果没有执行替换，则返回 str 或 nil。
62	str.succ [or] str.next 返回 str 的后继者。
63	str.succ! [or] str.next! 等效于 String#succ，但在适当的位置修改接收器。
64	str.sum(n = 16) 返回 str 中字符的基本 n 位校验和，其中 n 是可选的 Fixnum 参数，默认为 16。结果只是 str 中每个字符的二进制值的总和，模 2n - 1。好的校验和。
65	str.swapcase 返回 str 的副本，其中大写字母字符转换为小写，小写字符转换为大写。
66	str.swapcase! 等效于 String#swapcase，但在适当的位置修改接收器，返回 str，如果未进行任何更改，则返回 nil。
67	str.to_f >返回将 str 中的前导字符解释为浮点数的结果。超过有效数字末尾的无关字符将被忽略。如果 str 的开头没有有效数字，则返回 0.0。此方法从不引发异常。
68	str.to_i(base = 10) 返回将 str 中的前导字符解释为整数基数（基数为 2、8、10 或 16）的结果。超过有效数字末尾的无关字符将被忽略。如果 str 的开头没有有效数字，则返回 0。此方法从不引发异常。
69	str.to_s [or] str.to_str 返回接收器。
70	str.tr(from_str, to_str) 返回 str 的副本，其中 from_str 中的字符被 to_str 中的相应字符替换。如果 to_str 比 from_str 短，则用最后一个字符填充。两个字符串都可以使用 c1.c2 表示法来表示字符范围，并且 from_str 可以以 ^ 开头，表示除列出的字符之外的所有字符。
71	str.tr!(from_str, to_str) 使用与 String#tr 相同的规则，就地翻译 str。返回 str，如果没有进行任何更改，则返回 nil。
72	str.tr_s(from_str, to_str) 按照 String#tr 中的说明处理 str 的副本，然后删除受翻译影响的区域中的重复字符。
73	str.tr_s!(from_str, to_str) 就地对 str 执行 String#tr_s 处理，返回 str，如果未进行任何更改，则返回 nil。
74	str.unpack(format) >根据格式字符串解码 str（可能包含二进制数据），返回提取的每个值的数组。格式字符串由一系列单字符指令组成，总结在表 18 中。每个指令后面可以跟一个数字，表示使用该指令重复的次数。星号 (*) 将用完所有剩余元素。指令 sSiIlL 每个都可以后跟一个下划线 (_) 以使用指定类型的底层平台的本机大小；否则，它使用与平台无关的一致大小。格式字符串中的空格被忽略。
75	str.upcase 返回 str 的副本，其中所有小写字母都替换为对应的大写字母。该操作对区域设置不敏感。只有字符 a 到 z 受到影响。
76	str.upcase! 将 str 的内容更改为大写，如果没有更改则返回 nil。
77	str.upto(other_str) { \|s\| block } 遍历连续的值，从 str 开始，到 other_str 结束，依次将每个值传递给块。 String#succ 方法用于生成每个值。

字符串解包指令

下表列出了方法 String#unpack 的解包指令。

指令	返回	说明
A	String	W删除了尾随的空值和空格。
a	String	字符串。
B	String	从每个字符中提取位（首先是最高有效位）。
b	String	从每个字符中提取位（首先是最低有效位）。
C	Fixnum	将字符提取为无符号整数。
c	Fixnum	将字符提取为整数。
D, d	Float	将 sizeof(double) 字符视为本机双精度。
E	Float	将 sizeof(double) 字符视为 littleendian 字节顺序中的 double。
e	Float	将 sizeof(float) 字符视为 littleendian 字节顺序的浮点数。
F, f	Float	将 sizeof(float) 字符视为本机浮点数。
G	Float	将 sizeof(double) 字符视为网络字节顺序中的双精度。
g	String	将 sizeof(float) 字符视为网络字节顺序中的浮点数。
H	String	从每个字符中提取十六进制半字节（首先是最高有效位）
h	String	从每个字符中提取十六进制半字节（最低有效位在前）。
I	Integer	将 sizeof(int)（由 _ 修改）连续字符视为无符号本机整数。
i	Integer	将 sizeof(int)（由 _ 修改）连续字符视为有符号本机整数。
L	Integer	将四个（由 _ 修改）连续字符视为无符号本机长整数。
l	Integer	将四个（由 _ 修改）连续字符视为有符号本机长整数。
M	String	引用可打印。
m	String	Base64 编码。
N	Integer	将四个字符视为网络字节顺序中的无符号长整数。
n	Fixnum	将两个字符视为网络字节顺序中的无符号短整数。
P	String	将 sizeof(char *) 字符视为指针，并从引用位置返回 \emph{len} 字符。
p	String	将 sizeof(char *) 字符视为指向以空字符结尾的字符串的指针。
Q	Integer	将八个字符视为无符号四字（64 位）。
q	Integer	将八个字符视为有符号四字（64 位）。
S	Fixnum	将两个（如果使用 _ 则不同）连续字符视为本机字节顺序的无符号短整数。
s	Fixnum	将两个（如果使用 _ 则不同）连续字符视为原生字节顺序的有符号短字符。
U	Integer	UTF-8 字符作为无符号整数。
u	String	UU 编码。
V	Fixnum	将四个字符视为小端字节序中的无符号长整数。
v	Fixnum	将两个字符视为 little-endian 字节顺序的无符号 short。
w	Integer	BER 压缩整数。
X		向后跳过一个字符。
x		向前跳过一个字符。
Z	String	使用 * 删除尾随空值，直到第一个空值。
@		跳到由长度参数给出的偏移量。

示例

尝试以下示例来解压缩各种数据。

"abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c')               #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
"now = 20is".unpack('M*')           #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]

Ruby 基础知识

Ruby 高级

Scala 其他

Ruby - 字符串

表达式替换

通用分隔字符串

转义字符

字符编码

字符串内置方法

字符串解包指令

示例

颜色选择器

读后有收获微信请站长喝咖啡

错误报告

您的建议:

感谢您的帮助！