Ruby教程

Ruby - 字符串

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

最简单的字符串文字用单引号括起来(撇号(撇号).引号内的文本是字符串的值 :

'This is a simple Ruby string literal'

如果你需要在一个单引号的字符串文字中放置一个撇号，在它前面加一个反斜杠，这样Ruby解释器就不会认为它终止字符串 :

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

反斜杠也可用于转义另一个反斜杠，因此第二个反斜杠本身不会被解释为转义字符.

以下是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	Backspace
\ cx		Control-x
\ Cx		Control-x
\ e	0x1b	Escape
\f	0x0c	Formfeed
\ M-\C -x		Meta-Control-x
\ n	0x0a	Newline
\ nnn	&nbsp ;	八进制表示法，其中n在0.7
\ r	0x0d	回车
\s	0x20	空格
\t	0x09	Tab
\v	0x0b	垂直选项卡
\ x		字符x
\ xnnn		十六进制表示法，其中n在0.9，af或AF范围内

字符编码

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

您可以在程序开头使用$ KCODE更改字符集，喜欢这个 :

$KCODE = 'u'

Sr.No.	Code&说明
1	a ASCII(与无相同).这是默认值.
2	e EUC.
3	n 无(与ASCII相同) ).
4	u UTF-8.

字符串内置方法

我们需要一个String对象实例来调用String方法.以下是创建String对象&minus的实例的方法;

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

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

#!/usr/bin/ruby

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

puts "#{foo}"

将产生以下结果 :

this is test

Sr.No.	方法&说明
1	str％arg 使用格式规范格式化字符串.如果arg包含多个替换，则它必须是数组.有关格式规范的信息，请参阅"内核模块"下的sprintf.
2	*str integer** 返回包含整数倍str的新字符串.换句话说，str是重复整数imes.
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不是String，则返回false;如果str< =>则返回true obj返回0.
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！与印章相同，但进行了更改到位.
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 = &dollar;/) { \|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？(其他) 如果两个字符串具有相同的长度和内容，则它们是相等的.
29	str.gsub(pattern, replacement) [or] str.gsub(pattern) { \|match\| block } 返回str的副本，其中所有出现的模式都替换为替换或块的值.该模式通常是Regexp;如果是String，则不会解释正则表达式元字符(即/\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返回一个字符代码;两个Fixnums，返回从偏移量(第一个fixnum)到length(第二个fixnum)开始的子字符串; range，返回范围内的子字符串; regexp返回匹配字符串的一部分;带有fixnum的regexp，在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 [或] str.include？ fixnum 如果str包含给定的字符串或字符，则返回true.
36	str.index(substring [, offset]) [or] str.index(fixnum [, offset]) [or] str.index(regexp [, offset]) 返回str中给定子字符串，字符(fixnum)或模式(regexp)的第一次出现的索引.如果找不到则返回nil.如果存在第二个参数，则它指定字符串中开始搜索的位置.
37	str.insert(index，other_str) 在字符前插入other_str在给定的索引处，修改str.负索引从字符串的末尾开始计数，并在给定字符后插入.目的是插入一个字符串，使其从给定的索引开始.
38	str.inspect 返回str的可打印版本，并转义特殊字符.
39	str.intern [或] str.to_sym 返回与str对应的符号，如果以前不存在则创建符号.
40	str.length 返回str的长度.比较大小.
41	str.ljust(integer，padstr ='') 如果整数大于str的长度，则返回一个长度为整数的新String str左对齐并用padtr填充;否则，返回str.
42	str.lstrip 返回删除前导空格的str副本.
43	str.lstrip！从str中删除前导空格，如果没有更改则返回nil.
44	str.match(pattern) 将模式转换为a Regexp(如果它不是一个)，然后在str上调用它的匹配方法.
45	str.oct 将str的前导字符视为八进制字符串数字(带有可选符号)并返回相应的数字.如果转换失败，则返回0.
46	str.replace(other_str) 用other_str中的相应值替换str的内容和污点.
47	str.反转以相反的顺序返回一个带有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 ='') 如果整数大于str的长度，则返回一个长度为整数的新String，其中str右对齐并用padstr填充;否则，返回str.
51	str.rstrip 返回删除了尾部空格的str副本.
52	str.rstrip！从str中删除尾随空格，如果没有更改则返回nil.
53	str.scan(pattern) [or] str.scan(pattern) { \|match, ...\| block } 两种形式都通过str迭代，匹配模式(可能是Regexp或String).对于每个匹配，生成结果并将其添加到结果数组或传递给块.如果模式不包含组，则每个单独的结果由匹配的字符串$&组成.如果模式包含组，则每个单独的结果本身就是一个包含每个组一个条目的数组.
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 =&dollar;，[limit]) 将str分为基于分隔符的子串，返回这些子串的数组. 如果 pattern 是一个String，那么其内容将用作分隔符分裂str.如果pattern是单个空格，则str在空格上拆分，前导空格和连续空格字符的运行被忽略. 如果 pattern 是Regexp，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的副本，第一次出现的pattern替换为替换或块的值.该模式通常是Regexp;如果是String，则不会解释正则表达式元字符.
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 modulo 2n - 1.这不是一个特别好的校验和.
65	str.swapcase 返回str的副本，其中大写字母字符转换为小写和小写字符转换为大写.
66	str.swapcase！等效于String＃swapcase，但修改了接收器，返回str，如果没有进行任何更改则返回nil.
67	str.to_f > R. eturns将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下的描述处理str的副本#tr，然后删除受翻译影响的区域中的重复字符.
73	str.tr_s！(from_str，to_str) 执行字符串＃如果没有进行任何更改，tr_s处理str，返回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 Directives

$b$ b$b$ b

指令	返回	描述
A	字符串	删除尾随空格和空格.
a	String	字符串.
B	String	从每个字符中提取位(最高位).
String	从每个字符中提取位(首先是最低位).
C	Fixnum	提取一个角色作为无符号整数.
c	Fixnum	将一个字符提取为整数.
D ，d	Float	将sizeof(双)字符视为原生双精度.
E	Float	对待sizeof( double)字符作为littleendian字节顺序的double.
e	Float	将sizeof(float)字符视为以littleendian字节顺序浮动.
F，f	Float	对待sizeof( float)将字符作为本机浮点数.
G	Float	将sizeof(双)字符视为网络字节顺序的双精度.
g	String	将sizeof(float)字符视为网络字节顺序中的浮点数.
H	String	从每个字符中提取十六进制半字节(最重要的位首先)
h	String	从每个字符中提取十六进制半字节(首先是最低有效位).
I	Integer	对待sizeof(int) (由_修改)连续字符作为无符号原生整数.
i	Integer	将sizeof(int)(由_修改)连续字符视为已签名的本机inte ger.
L	Integer	Treats four (modified by _) successive characters as an unsigned native long integer.
l	Integer	Treats four (modified by _) successive characters as a signed native long integer.
M	String	Quoted-printable.
m	String	Base64-encoded.
N	Integer	Treats four characters as an unsigned long in network byte order.
n	Fixnum	Treats two characters as an unsigned short in network byte order.
P	String	Treat s sizeof(char *) characters as a pointer, and return \emph{len} characters from the referenced location.
p	String	Treats sizeof(char *) characters as a pointer to a null-terminated string.
Q	Integer	Treats eight characters as an unsigned quad word (64 bits).
q	Integer	Treats eight characters as a signed quad word (64 bits).
S	Fixnum	Treats two (different if _ used) successive characters as an unsigned short in native byte order.
s	Fixnum	Treats two (different if _ used) successive characters as a signed short in native byte order.
U	Integer	UTF-8 characters as unsigned integers.
u	String	UU-encoded.
V	Fixnum	Treats four characters as an unsigned long in little-endian byte order.
v	Fixnum	Treats two characters as an unsigned short in little-endian byte order.
w	Integer	BER-compressed integer.
X		Skips backward one character.
x		Skips forward one character.
Z	String	With trailing nulls rem oved up to first null with *.
@		Skips to the offset given by the length argument.

Example

Try the following example to unpack various data.

"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"]