字符串类。可处理任意长度的字节串。
在该类的众多方法中，那些方法名尾部是！的方法将会直接修改字符串的内容。此时，使用不带！的同名方法是比较安全的。例如，在下例中就会出现这样的问题。
def foo(arg)
arg.sub!(/good/, 'bad')
arg
end
s = 'verygoodname'
p foo(s) # => 'verybadname'
p s # => 'verybadname'
为了正确处理日语字符串，还必须根据字符的编码情况来设定内部变量$KCODE的值。String类将自身当作字节串来处理。例如，不管str的内容是什么，str[1]都会返回第2字节的字符代码。若想以字符(而非字节)为单位来处理日语字符串的话，请使用jcode.rb。
超类:
* Object
包含的模块:
* Comparable
* Enumerable
类方法:
String.new(string)
生成并返回一个与string内容完全相同的新字符串。
ruby 1.7 特性：省略参数时将生成并返回一个空字符串。
方法:
self + other
将字符串连接起来之后，返回得到的新字符串。
例:
p 'abc' + 'def' #=> 'abcdef'
self * times
将字符串的内容重复times次之后，返回新字符串。
例:
p "abc" * 4 #=> "abcabcabcabc"
self % args
字符串的格式化。按照格式化字符串(self)的要求对参数进行格式化之后将其返回。
若args是数组，则等同于
sprintf(self, *args)
除此之外，则等同于
sprintf(self, args)
详情请参考sprintf格式化。
p "%#x" % 10 # => "0xa"
p "%#x,%#o" % [10, 10] # => "0xa,012"
self == other
self > other
self >= other
self < other
self <= other
字符串的比较。若变量$=的值为真，则比较时会忽略字符大小写的区别。($=变量将被废弃。请参考obsolete)
self << other
concat(other)
将other字符串的内容连接到self之后。若other是0到255之间的Fixnum时，将把它的1个字节添加到末尾。
返回self。
self =~ other
与正则表达式other进行匹配操作。若匹配成功则返回匹配位置的索引，若失败则返回nil。
与匹配相关的信息被存入内部变量$~中。
若other既非正则表达式又非字符串时，将作如下处理
other =~ self
ruby 1.8 特性: 在以前的版本中，若other是字符串的话，就把它编译为正则表达式，然后与self进行匹配操作。在1.8以后的版本中，若将other设为字符串时，会引发TypeError异常。
~ self
ruby 1.8 特性: 该方法已被删除。请使用Regexp#~即可替代该方法。
将self编译为正则表达式，然后与内部变量$_进行匹配操作，并返回匹配成功的位置的索引。这与$_ =~ Regexp.compile(self)是一样的。
若$_不是字符串就返回nil。
ruby 1.7 特性: 该方法等同于
$_ =~ Regexp.compile(Regexp.quote(self))
self[nth]
以整数形式(字符代码)返回第nth字节的内容(相反地，若想从字符代码变为字符串时，请使用Integer#chr)。若nth为负值，则从字符串尾部算起。
若nth超出范围则返回nil。
例:
p 'bar'[2] # => 114
p 'bar'[2] == ?r # => true
p 'bar'[-1] # => 114
p 'bar'[3] # => nil
p 'bar'[-4] # => nil
self[nth, len]
返回从第nth字节算起的长度为len字节的子字符串。若nth为负数则从字符串尾部算起。
若nth超出范围则返回nil。
self[substr]
若self当中包含substr，则生成并返回一致的字符串。若不包含substr的话，就返回nil。
substr = "bar"
result = "foobar"[substr]
p result # => "bar"
p substr.equal? result # => true (ruby 1.7 特性:1.7.2 以后为 false)
self[regexp]
self[regexp, nth] ((<ruby 1.7 特性>))
返回最初那个与regexp相匹配的子字符串。与匹配操作相关的信息被存入内部变量$~中。
若与regexp的匹配失败则返回nil。
p "foobar"[/bar/] # => "bar"
p $~.begin(0) # => 3
ruby 1.7 特性：若使用了nth参数，则返回最初那个与regexp中第nth个括号相匹配的子字符串。若nth为0，则返回整个匹配的字符串。若匹配失败或没有与nth相对应的括号时，返回nil。
p "foobar"[/bar/] # => "bar"
p $~.begin(0) # => 3
p "def getcnt(line)"[ /def\s*(\w+)/, 1 ] # => "getcnt"
self[first..last]
生成并返回一个包含从索引first到索引last之间所有内容的字符串。
.
0 1 2 3 4 5 (索引)
-6 -5 -4 -3 -2 -1 (负的索引)
| a | b | c | d | e | f |
|<--------->| 'abcdef'[0..2] # => 'abc'
|<----->| 'abcdef'[4..5] # => 'ef'
|<--------->| 'abcdef'[2..4] # => 'cde'
当last超过字符串长度时，就认为它的值等于(字符串长度-1)。
当first小于0或大于字符串长度，或者first > last + 1时返回nil。但是，若first和last中的一个或者两个都为负数时，将会补足字符串的长度然后再次执行。
例:
'abcd'[ 2 .. 1] # => ""
'abcd'[ 2 .. 2] # => "c"
'abcd'[ 2 .. 3] # => "cd"
'abcd'[ 2 .. 4] # => "cd"
'abcd'[ 2 .. -1] # => "cd" # str[f..-1] 是一种惯用写法，它表示
'abcd'[ 2 .. -2] # => "c" # “从第f个字符开始到该字符串的最后”
'abcd'[ 1 .. 2] # => "bc"
'abcd'[ 2 .. 2] # => "c"
'abcd'[ 3 .. 2] # => ""
'abcd'[ 4 .. 2] # => nil
'abcd'[-3 .. 2] # => "bc"
'abcd'[-4 .. 2] # => "abc"
'abcd'[-5 .. 2] # => nil
self[first...last]
将字符串的头部看作第0个缝隙，将字符串的末尾看作第self.length个缝隙，然后生成并返回一个包含从第first个缝隙到第last个缝隙之间的所有内容的字符串。
字符串和“缝隙”的示意图
0 1 2 3 4 5 6 (缝隙编号)
-6 -5 -4 -3 -2 -1 (负的缝隙编号)
| a | b | c | d | e | f |
|<--------->| 'abcdef'[0...3] # => 'abc'
|<----->| 'abcdef'[4...6] # => 'ef'
|<--------->| 'abcdef'[2...5] # => 'cde'
当last大于字符串长度时，就认为它的值等于字符串的长度。
当first小于0或大于字符串长度，或者first > last时返回nil。但是，若first和last中的一个或者两个都为负数时，将会补足字符串的长度然后再次执行。
例:
'abcd'[ 2 ... 3] # => "c"
'abcd'[ 2 ... 4] # => "cd"
'abcd'[ 2 ... 5] # => "cd"
'abcd'[ 1 ... 2] # => "b"
'abcd'[ 2 ... 2] # => ""
'abcd'[ 3 ... 2] # => nil
'abcd'[-3 ... 2] # => "b"
'abcd'[-4 ... 2] # => "ab"
'abcd'[-5 ... 2] # => nil
self[nth]=val
以val来替换第nth字节的内容。若val是0到255之间的整数时，就把它看作是字符代码，并以该代码所对应的字符来进行替换操作。
返回val。
self[nth, len]=val
以val来替换从第nth字节起长度为len字节的子字符串。若nth为负数则从尾部算起。
返回val。
self[substr]=val
以val来替换字符串中第一个与substr相对应的子字符串。
若self中不包含substr时，将引发IndexError异常。
返回val。
self[regexp]=val
self[regexp, nth]=val ((<ruby 1.7 特性>))
以val来替换第一个与正则表达式regexp相匹配的子字符串。
若正则表达式的匹配失败则引发IndexError异常。
返回val。
ruby 1.7 特性: 若使用了参数nth时，则以val替换第一个与正则表达式regexp中的第nth个括号相匹配的子字符串。若nth为0时，则以val来替换整个匹配部分。
若正则表达式匹配失败或没有与nth相对应的括号时，将引发IndexError异常。
self[first..last]=val
self[first...last]=val
以val来替换从first到last之间的内容。
返回val。
self <=> other
以ASCII代码的顺序来比较self和other。若self较大时返回正整数，相等时返回0，较小时返回负整数。
若常数$=的值为真，则在比较的过程中忽略字母的大小写差别。($=变量将被废弃，请参考obsolete)
ruby 1.8 特性:
当other不是字符串时，若定义了other.to_str以及other.<=>的话，就返回0 - (other <=> self)的结果。否则返回nil。
capitalize
capitalize!
将首字符(若为字母的话)改为大写字母，其余的改为小写字母。
capitalize生成并返回修改后的字符串。而capitalize!会修改self本身并返回结果，若未作修改时返回nil。
p "foobar".capitalize # => "Foobar"
若未正确设置$KCODE的话，部分汉字代码也会被篡改(在ShiftJIS编码下会发生这种情况)。相反地，即使设定了$KCODE也不会对多字节字符的字母进行处理。
# -*- Coding: shift_jis -*-
$KCODE ='n'
puts "帰".capitalize # => 蟻
请参考upcase, downcase, swapcase。
casecmp(other) ((<ruby 1.7 特性>))
该方法与String#<=>一样，是用来比较字符串的顺序的。 它将忽略字母的大小写。
该方法的运作不受$=的影响。
p 'a' <=> 'A' #=> 1
p 'a'.casecmp('A') #=> 0
center(width)
ljust(width)
rjust(width)
center(width[, padding]) ((<ruby 1.8 特性>))
ljust(width[, padding]) ((<ruby 1.8 特性>))
rjust(width[, padding]) ((<ruby 1.8 特性>))
分别返回居中、靠左、靠右的字符串。
p "foo".center(10) # => " foo "
p "foo".ljust(10) # => "foo "
p "foo".rjust(10) # => " foo"
当字符串长度超过width时，将返回原字符串的拷贝。
s = "foo"
p s.center(1).id == s.id # => false
ruby 1.8 特性: 若使用了第二参数padding的话，将使用padding来填充空白。
p "foo".center(10,"*") # => "***foo****"
p "foo".ljust(10,"*") # => "foo*******"
p "foo".rjust(10,"*") # => "*******foo"
chomp([rs])
chomp!([rs])
删除字符串尾部的行切分符，该切分符由rs指定。rs的默认值取自变量$/的值。
若rs的取值是nil的话，将不作任何动作。若rs是空字符串(段落模式)的话，将删除字符串尾部的所有的连续换行符。
chomp生成并返回修改后的字符串。而chomp!会修改self本身并返回结果，若没作修改时返回nil。
ruby 1.7 特性: 当rs的值为"\n"(默认值)时，将会把"\r"、"\r\n"和"\n"全部看作行切分符并加以删除。
p "foo\r".chomp # => "foo"
p "foo\r\n".chomp # => "foo"
p "foo\n".chomp # => "foo"
p "foo\n\r".chomp # => "foo\n"
chop
chop!
删除字符串末尾的字符(若字符串末尾是"\r\n"的话,就删除2个字符).
chop会生成并返回修改后的字符串. 而chop!会修改self本身然后返回结果,若没作修改则返回nil.
clone
dup
返回一个与原字符串内容相同的新字符串. 对被冻结的字符串使用clone会得到一个同样被冻结的字符串,而使用dup就会得到一个内容相同但未被冻结的字符串.
count(str[, str2[, ... ]])
返回在该字符串中str所含字符出现的次数.
str的形式与tr(1)相同.也就是说,`a-c'表示从a到c,而像"^0-9"这样,当`^'出现在头部时表示"取反".
只有当`-'出现在字符串内部,而非两端时才表示指定一个范围.同样地,只有当`^'出现在字符串头部时才表示"取反".另外,可以使用反斜线(`\')来对`-', `^', `\'进行转义操作.
若给出多个参数,则意味着会使用所有参数的交集.
p 'abcdefg'.count('c') # => 1
p '123456789'.count('2378') # => 4
p '123456789'.count('2-8', '^4-6') # => 4
以下是该方法的典型应用, 它返回文件的行数(但文件尾部要有换行符).
n_lines = File.open("foo").read.count("\n")
crypt(salt)
生成并返回一个由self和salt加密而成的字符串. salt是一个由字母或数字、点(.)和斜线(/)构成的2字节以上的字符串.
如下所示,salt应尽量选择随机的字符组合.
salt = [rand(64),rand(64)].pack("C*").tr("\x00-\x3f","A-Za-z0-9./")
passwd.crypt(salt)
一般来说,很难利用加密后的字符串求出原始字符串(self),所以只有知道原始字符串的人才能生成一模一样的加密字符串. 由此可以验证某人是否知道(self).
例如,UNIX密码的验证过程如下. (此例中假定可以用 Etc.getpwnam 得到加密字符串).
require 'etc'
user = "foo"
passwd = "bar"
ent = Etc.getpwnam(user)
p passwd.crypt(ent.passwd) == ent.passwd
注意:
* crypt的运行需要crypt(3)的支持. 请参考系统中的crypt(3)等来了解crypt处理内容的详情以及设定 salt 的方法.
* 当系统环境发生变化时,crypt的结果往往会出现不同. 因此,若在不同的系统环境中使用crypt的结果时,请充分注意这些差异.
* 在使用了DES的典型的crypt(3)中,只使用self的最初的8字节和salt的最初的2字节.
delete(str[, str2[, ... ]])
delete!(str[, str2[, ... ]])
从该字符串中删除str所包含的字符.
str的形式与tr(1)相同.也就是说,`a-c'表示从a到c,而像"^0-9"这样,当`^'出现在头部时表示"取反".
只有当`-'出现在字符串内部,而非两端时才表示指定一个范围.同样地,只有当`^'出现在字符串头部时才表示"取反".另外,可以使用反斜线(`\')来对`-', `^', `\'进行转义操作.
若给出多个参数,则意味着会使用所有参数的交集.
p "123456789".delete("2-8", "^4-6") #=> "14569"
p "123456789".delete("2378") #=> "14569"
delete会生成并返回修改后的字符串. 而delete!会修改self本身并返回结果,若没作修改时返回nil.
downcase
downcase!
将字符串中的大写字母都改为小写字母.
downcase生成并返回修改后的字符串.而downcase!则会修改self本身并返回结果,若没有作修改,则返回nil.
若没有正确设置$KCODE时,部分汉字代码也会被修改(在ShiftJIS编码中就会发生这种情况).相反,即使设置了$KCODE,也不会修改多字节字符的字母.
# -*- Coding: shift_jis -*-
$KCODE ='n'
puts "帰".downcase # => 蟻
请参考upcase, swapcase, capitalize.
dump
使用反斜线表示法替换字符串中的非显示字符,并返回修改后的字符串.它保证了str == eval(str.dump).
puts "abc\r\n\f\x00\b10\\\"".dump #=> "abc\r\n\f\000\01010\\\""
each([rs]) {|line| ... }
each_line([rs]) {|line| ... }
对字符串中的各行进行迭代操作. 此时,rs中的字符串将成为行切分符,行切分符的默认值取自变量$/的值.各line中包含用作切分符的字符串.
若将rs设为nil时,则意味着不作行的切分. 若设为空字符串""则将连续的换行当做行切分符(段落模式).
返回self.
each_byte {|byte| ... }
对字符串中的各个字节进行迭代操作.
返回self.
请参考unpack.使用unpack('C*')可以得到以字节为单位的数组.
empty?
若字符串为空(也就是说其长度为0),则返回真.
gsub(pattern, replace)
gsub!(pattern, replace)
gsub(pattern) {|matched| .... }
gsub!(pattern) {|matched| .... }
以replace来替换字符串中所有与pattern相匹配的部分. replace中的\&和\0被替换为匹配的子字符串,而\1 ... \9被替换为第n个括号的内容.在替换字符串replace中,还可以使用\`、\'或\+. 它们分别对应于$`、$'、$+.
p 'abcabc'.gsub(/b/, '(\&)') #=> "a(b)ca(b)c"
省略replace参数时,该方法就相当于一个迭代器,它以块的计算结果进行替换. 匹配的子字符串被当做参数传递给块.与没带块时不同的是, 可以在块中调用内部变量$.
p 'abcabc'.gsub(/b/) {|s| s.upcase } #=> "aBcaBc"
p 'abcabc'.gsub(/b/) { $&.upcase } #=> "aBcaBc"
gsub生成并返回替换之后的字符串.而gsub!会修改self本身并返回结果,若没有进行置换时返回nil.
p 'abcdefg'.gsub(/cd/, 'CD') #=> "abCDefg"
str = 'abcdefg'
str.gsub!(/cd/, 'CD')
p str #=> "abCDefg"
p 'abbbxabx'.gsub(/a(b+)/, '\1') #=> "bbbxbx"
注意: 不能在replace中使用$.这是因为在对该字符串进行计算时,尚未进行匹配操作所致. 另外,在replace中必需对\进行2重转义(请参考trap::\的影响).
# 使用第二参数时常见的错误
p 'abbbcd'.gsub(/a(b+)/, "#{$1}") # 错误
p 'abbbcd'.gsub(/a(b+)/, "\1") # 错误
p 'abbbcd'.gsub(/a(b+)/, "\\1") # 正确
p 'abbbcd'.gsub(/a(b+)/, '\1') # 正确
p 'abbbcd'.gsub(/a(b+)/, '\\1') # 正确(更安全)
p 'abbbcd'.gsub(/a(b+)/) { $1 } # 正确(最安全)
请参考sub.
ruby 1.7 特性:在1.6版之前,若pattern是字符串时,会把该字符串编译为正则表达式.在1.7以后的版本中,该字符串本身将成为匹配模型(pattern).
hex
把字符串看做是16进制数形式,并将其变为整数.
p "10".hex # => 16
p "ff".hex # => 255
p "0x10".hex # => 16
p "-0x10".hex # => -16
"0x"和"0X"前缀将被忽略. 若遇到[_0-9a-fA-F]之外的字符时,就只转换它前面的部分.若变换对象是空字符串,则返回0.
p "xyz".hex # => 0
p "10z".hex # => 16
p "1_0".hex # => 16
请参考oct, to_i, to_f,Integer,Float.
如果想把数值变为字符串时,请使用sprintf,%,Integer#to_s.
include?(substr)
若字符串中包含substr子字符串的话,就返回真.
若substr是从0到255之间的Fixnum时,将把它看做是字符代码,若包含该代码所对应的字符,就返回真.
index(pattern[, pos])
按照从左到右的顺序搜索子字符串,并返回搜索到的子字符串的左侧位置. 若没有搜索到则返回nil.
在参数pattern中,可以使用字符串,0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.
若给出了pos时, 则从相应位置开始搜索.省略pos时其默认值为 0.
p "astrochemistry".index("str") # => 1
p "character".index(?c) # => 0
p "regexpindex".index(/e.*x/, 2) # => 3
若pos为负,则从字符串尾部找到相应位置后开始搜索.
p "foobarfoobar".index("bar", 6) # => 9
p "foobarfoobar".index("bar", -6) # => 9
请参考rindex.
insert(nth, other) ((<ruby 1.7 特性>))
在第nth个字符的前面插入other字符串. (除了返回值以外)它等同于
self[nth, 0] = other
返回self.
str = "foobaz"
p str.insert(3, "bar")
# => "foobarbaz"
intern
to_sym ((<ruby 1.7 特性>))
返回与字符串相对应的符号值(Symbol). 不能对包含空字符('\0')的字符串进行intern(会引发ArgumentError异常).
若想得到与某符号相对应的字符串时,请使用Symbol#to_s(或Symbol#id2name).
p "foo".intern
=> :foo
p "foo".intern.to_s == "foo"
=> true
length
size
返回字符串的字节数.
match(regexp) ((<ruby 1.7 特性>))
match(regexp[, pos]) ((<ruby 1.9 特性>))
与regexp.match(self[, pos])相同(请参考Regexp#match). 若regexp是字符串,则将其编译为正则表达式.
next
next!
succ
succ!
返回下一个字符串. 所谓"下一个"是指,按照26个字母顺序或10进制数的顺序继续向下数时得到的结果.这里不考虑负号的问题.请参考下例.
p "aa".succ # => "ab"
p "99".succ # => "100"
p "a9".succ # => "b0"
p "Az".succ # => "Ba"
p "zz".succ # => "aaa"
p "-9".succ # => "-10"
p "9".succ # => "10"
p "09".succ # => "10"
若字符串中包含字母或数字的话,则其他字符将保持不变.
p "1.9.9".succ # => # "2.0.0"
相反地,若不包含字母或数字的话,就返回下一个ASCII字符.
p "/".succ #=> "0"
p "\0".succ #=> "\001"
p "\377".succ #=> "\001\000"
"".succ 会返回 "".如果遇到多字节字符串的话,则只把它当做普通的字节串来处理. 另外,没有与succ动作相反的方法.
succ!和next!会强行修改字符串的内容.
oct
将字符串看做是8进制字符串,并将其变为整数.
p "10".oct # => 8
p "010".oct # => 8
p "8".oct # => 0
oct可根据字符串的前缀("0", "0b", "0B", "0x", "0X")来进行8进制以外的相关处理.
p "0b10".oct # => 2
p "10".oct # => 8
p "010".oct # => 8
p "0x10".oct # => 16
若遇到不能看做整数的字符时,就只变换此前的内容.若变换对象为空字符串,则返回0.
p "1_0_1x".oct # => 65
请参考hex, to_i, to_f,Integer, Float.
若想把数值变为字符串时,请使用sprintf,%,Integer#to_s.
replace(other)
以other的内容来替换字符串的内容.
s = "foo"
id = s.id
s.replace "bar"
p s # => "bar"
p id == s.id # => true
返回self.
reverse
reverse!
对字符串进行反转.
p "foobar".reverse # => "raboof"
reverse生成并返回修改后的字符串.而reverse!会修改self本身并返回结果.
rindex(pattern[, pos])
按照从右到左的顺序来搜索子字符串,并返回找到的子字符串的左侧的位置. 若搜索失败则返回nil.
在参数pattern中,可以使用字符串,从0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.
若给出了pos时,就从相应位置开始搜索. 省略pos时,其值为self.size (右端).
p "astrochemistry".rindex("str") # => 10
p "character".rindex(?c) # => 5
p "regexprindex".rindex(/e.*x/, 2) # => 1
若pos为负,则从尾部找到相对应的位置后开始搜索.
p "foobarfoobar".rindex("bar", 6) # => 3
p "foobarfoobar".rindex("bar", -6) # => 3
该方法的运作情况并非与index完全相反. 开始搜索时,起始位置当然是从右向左移动,但是对比子字符串时还是从左向右进行的. 请参考下例.
# 使用String#index时
p "foobar".index("bar", 2) # => 3
# bar <- 从这里开始搜索
# bar <- 向右挪动一步后之后对比成功
# 使用String#rindex时
p "foobar".rindex("bar", -2) # => 3
# bar <- 并不是从这里(从尾部算起到子字符串右端正好是第2个)开始搜索的
# bar <- 而是从这里开始搜索(从尾部算起到子字符串的左端正好是第2个)
# bar <- 向左挪动一步之后对比成功
scan(re)
scan(re) {|s| ... }
使用正则表达式re反复对self进行匹配操作,并以数组的形式返回匹配成功的子字符串.
p "foobar".scan(/./)
# => ["f", "o", "o", "b", "a", "r"]
p "foobarbazfoobarbaz".scan(/ba./)
# => ["bar", "baz", "bar", "baz"]
若正则表达式中包含括号,则返回与括号内的pattern匹配成功的子字符串的数组的数组.
p "foobar".scan(/(.)/)
# => [["f"], ["o"], ["o"], ["b"], ["a"], ["r"]]
p "foobarbazfoobarbaz".scan(/(ba)(.)/)
# => [["ba", "r"], ["ba", "z"], ["ba", "r"], ["ba", "z"]]
若带块调用的话,匹配成功的子字符串(若包含括号时,则是与括号内的pattern匹配成功的字符串的数组)将成为块的形参. 带块调用时返回self.
"foobarbazfoobarbaz".scan(/ba./) {|s| p s}
# => "bar"
"baz"
"bar"
"baz"
"foobarbazfoobarbaz".scan(/(ba)(.)/) {|s| p s}
# => ["ba", "r"]
["ba", "z"]
["ba", "r"]
["ba", "z"]
ruby 1.7 特性: 在1.6之前的版本中,若re是字符串的话,则把该字符串编译为正则表达式. 在1,7以后的版本中,该字符串本身将成为pattern.
slice(nth[, len])
slice(substr)
slice(first..last)
slice(first...last)
slice(regexp[, nth])
与self[ ]相同.
ruby 1.7 特性: 在1.7以后的版本中,可以使用slice(regexp, nth).
slice!(nth[, len])
slice!(substr)
slice!(first..last)
slice!(first...last)
slice!(regexp[, nth])
从字符串中删除指定的范围(请参考self[ ]),然后返回删除的子字符串.
若参数超出范围则返回nil.
ruby 1.7 特性: 在1.7以后的版本中,可以使用slice!(regexp, nth).
split([sep[, limit]])
使用sep指定的pattern来分割字符串,并将分割结果存入数组.
sep可以是下列之一
* 正则表达式: 把正则表达式的匹配结果当作切分符来切分字符串。如果使用了括号群组的话，与群组相匹配的字符串也会出现在最后的数组中(后文详述)。
* 1字节的字符串：把该字符当作切分符来进行切分(ruby 1.6)。
* 2字节以上的字符串：把与Regexp.new(sep)相匹配的字符串当作切分符来进行切分(ruby 1.6)。
* 省略 或 nil：把$;的值当作切分符来进行切分。
* 1字节的空白' ' 或 使用了$;且其值为nil时：除了头部的空白之外，使用空白进行切分。
* 空字符串'' 或 与空字符串相匹配的正则表达式：以单个字符为单位进行切分。可识别多字节字符。
ruby 1.7 特性: 在1.7之后的版本中，若sep是字符串的话，不管它的长度如何，都将使用与Regexp.new(Regexp.quote(sep))相匹配的字符串(即该字符串本身)来作为切分符。
例: awk split
p " a \t b \n c".split(/\s+/) # => ["", "a", "b", "c"]
p " a \t b \n c".split # => ["a", "b", "c"] ($;的默认值是nil)
p " a \t b \n c".split(' ') # => ["a", "b", "c"]
若sep中的pattern与空字符串相匹配的话，将以单个字符为单位对字符串进行切分(若正确设置了$KCODE的话，就会自动识别出汉字并进行适当的切分)。例如：
例:以字符为单位进行切分
p 'hi there'.split(/ */).join(':')
# => "h:i:t:h:e:r:e"
p 'hi there'.split(//).join(':')
# => "h:i: :t:h:e:r:e"
$KCODE = 'e'
p '文字列'.split(//).join(':')
# => "文:字:列"
若sep中的pattern包含括号，则数组中还会出现各括号的匹配结果。若括号不止一个时，则数组中就只剩下匹配结果了。例如：
例:
p '1-10,20'.split(/([-,])/) # => ["1", "-", "10", ",", "20"]
p '1-10,20'.split(/(-)|(,)/) # => ["1", "-", "10", ",", "20"]
limit可以是下列之一。
* 省略 或 0: 删除数组尾部的空字符串。
* limit > 0: 为数组分配至多limit个元素。
* limit < 0: 相当于指定limit的值为正无穷。
例: limit 的例子
# 省略limit的话，就如同把它指定为0一样。这将删除数组尾部的空字符串
p "a,b,c,,,".split(/,/) # => ["a", "b", "c"]
p "a,b,c,,,".split(/,/, 0) # => ["a", "b", "c"]
# 若limit不够大，则将剩余部分全部塞入数组的最后一个元素中
p "a,b,c,,,".split(/,/, 3) # => ["a", "b", "c,,,"]
# 若limit的值为-1或超过分割块数时，其值将被自动修改为分割块数
p "a,b,c,,,".split(/,/, 6) # => ["a", "b", "c", "", "", ""]
p "a,b,c,,,".split(/,/, -1) # => ["a", "b", "c", "", "", ""]
p "a,b,c,,,".split(/,/, 100) # => ["a", "b", "c", "", "", ""]
squeeze([str[,str2[, ... ]]])
squeeze!([str[,str2[, ... ]]])
压缩由str所含字符构成的重复字符串。
str的形式与tr(1)相同.也就是说,`a-c'表示从a到c,而像"^0-9"这样,当`^'出现在头部时表示"取反".
只有当`-'出现在字符串内部,而非两端时才表示指定一个范围.同样地,只有当`^'出现在字符串头部时才表示"取反".另外,可以使用反斜线(`\')来对`-', `^', `\'进行转义操作.
若给出多个参数,则意味着会使用所有参数的交集进行压缩.
p "112233445566778899".squeeze
=>"123456789"
p "112233445566778899".squeeze("2-8")
=>"11234567899"
p "112233445566778899".squeeze("2-8", "^4-6")
=>"11234455667899"
p "112233445566778899".squeeze("2378")
=>"11234455667899"
squeeze会生成并返回修改后的字符串。而squeeze!会修改self本身并返回结果。若没作修改则返回nil。
strip
strip!
删除头部和尾部的所有空白字符。空白字符是指" \t\r\n\f\v"。
strip生成并返回修改后的字符串。
strip!会修改self本身并返回结果。若没有进行删除动作，则返回nil。
p " abc \r\n".strip #=> "abc"
p "abc\n".strip #=> "abc"
p " abc".strip #=> "abc"
p "abc".strip #=> "abc"
str = "\tabc\n"
p str.strip #=> "abc"
p str #=> "\tabc\n" (无变化)
str = " abc\r\n"
p str.strip! #=> "abc"
p str #=> "abc" (有变化)
str = "abc"
p str.strip! #=> nil
p str #=> "abc"
ruby 1.8 特性: 与rstrip一样，它会删除右侧的空白字符和"\0"，但不会对左侧的"\0"进行特殊处理。
str = " \0 abc \0"
p str.strip # => "\000 abc"
lstrip ((<ruby 1.7 特性>))
lstrip! ((<ruby 1.7 特性>))
删除字符串头部的所有空白字符。空白字符是指" \t\r\n\f\v"。
lstrip会生成并返回加工后的字符串。
lstrip!会修改self本身并返回结果。如果没有删除空白字符，则返回nil。
p " abc\n".lstrip #=> "abc\n"
p "\t abc\n".lstrip #=> "abc\n"
p "abc\n".lstrip #=> "abc\n"
str = "\nabc"
p str.lstrip #=> "abc"
p str #=> "\nabc" (无变化)
str = " abc"
p str.lstrip! #=> "abc"
p str #=> "abc" (有变化)
str = "abc"
p str.lstrip! #=> nil
p str #=> "abc"
rstrip ((<ruby 1.7 特性>))
rstrip! ((<ruby 1.7 特性>))
删除字符串尾部的所有空白字符。空白字符是指" \t\r\n\f\v"。
rstrip会生成并返回加工后的字符串。
rstrip!会修改self本身并返回结果。如果没有删除空白字符，则返回nil。
p " abc\n".rstrip #=> " abc"
p " abc \t\r\n".rstrip #=> " abc"
p " abc".rstrip #=> " abc"
str = "abc\n"
p str.rstrip #=> "abc"
p str #=> "abc\n" (无变化)
str = "abc "
p str.rstrip! #=> "abc"
p str #=> "abc" (有变化)
str = "abc"
p str.rstrip! #=> nil
p str #=> "abc"
ruby 1.8 特性: 删除空白类和 "\0"。而lstrip则不会删除"\0"。
str = "abc \0"
p str.rstrip # => "abc"
sub(pattern, replace)
sub!(pattern, replace)
sub(pattern) {|matched| ... }
sub!(pattern) {|matched| ... }
用replace来替换首次匹配pattern的部分。
若带块调用的话，就以块的计算值来替换首次匹配的部分。
sub生成并返回替换后的字符串。而sub!会修改self本身并返回结果。若没有进行替换时返回nil。
除去只进行一次匹配这个特点以外，它与gsub是相同的。
注意: 在介绍gsub时，我们提到了使用 sub/gsub 时应该注意的问题。请参考gsub。
ruby 1.7 特性: 在1.6之前的版本中，若pattern是字符串，则将其编译为正则表达式。在1.7以后的版本中，该字符串本身将成为pattern。
sum([bits=16])
计算字符串的bits位的校验和。它等同于
sum = 0
str.each_byte {|c| sum += c}
sum = sum & ((1 << bits) - 1) if bits != 0
例如，可以使用如下代码来得到与System V 的 sum(1)命令相同的值。
sum = 0
while gets
sum += $_.sum
end
sum %= 65536
swapcase
swapcase!
将所有的大写字母改为小写字母，小写字母改为大写字母。
swapcase生成并返回修改后的字符串。而swapcase!则会修改self本身并返回结果,若没有作修改,则返回nil。
若没有正确设置$KCODE时,部分汉字代码也会被修改(在ShiftJIS编码中就会发生这种情况)。相反,即使设置了$KCODE,也不会修改多字节字符的字母.
# -*- Coding: shift_jis -*-
$KCODE ='n'
puts "蟻".swapcase # => 帰
请参考upcase, downcase, capitalize。
to_f
将字符串看作是10进制数形式，并将其变为浮点数Float。
p "10".to_f # => 10.0
p "10e2".to_f # => 1000.0
p "1e-2".to_f # => 0.01
p ".1".to_f # => 0.1
p "nan".to_f # => NaN (ruby 1.7 特性: => 0.0)
p "INF".to_f # => Infinity (ruby 1.7 特性: => 0.0)
p "-Inf".to_f # => -Infinity (ruby 1.7 特性: => -0.0)
p (("10" * 1000).to_f) # => Infinity (ruby 1.7 特性: => out of range (ArgumentError)
p "0xa.a".to_f # => 10.625 # 16 进制也可以(取决系统环境)
# (ruby 1.7 特性: => 0.0)
p " \n10".to_f # => 10.0 # 头部的空白被忽略
p "1_0_0".to_f # => 1.0 # `_' 不能被看作是数值元素
# (ruby 1.7 特性: => 100.0)
p "".to_f # => 0.0
将不能被看作浮点数的那个部分之前的内容变为浮点数。若变换对象是空字符串则返回 0.0 。
请参考hex, oct, to_i, Integer, Float 。
若想把数值变为字符串时，请使用sprintf、%、Integer#to_s。
to_i
to_i(base) ((<ruby 1.7 特性>))
将字符串看作是10进制数形式，并将其变为整数。
p " 10".to_i # => 10
p "010".to_i # => 10
p "-010".to_i # => -10
若遇到不能变为整数的字符，就将它前面的内容变为整数。若变换对象为空字符串，则返回0。
p "0x11".to_i # => 0
请参考hex, oct, to_f, Integer, Float 。
若想把数值变为字符串时，请使用sprintf、%、Integer#to_s。
ruby 1.7 特性: 通过指定不同的基数，还可以进行2～36进制的转换。若指定为0时，则通过 prefix 来判断基数(相反地，只有将其指定为0时，才会识别prefix)。若使用了0、2～36之外的参数时，会引发ArgumentError异常。
p "0b10".to_i(0) # => 2
p "0o10".to_i(0) # => 8
p "010".to_i(0) # => 8
p "0d10".to_i(0) # => 10
p "0x10".to_i(0) # => 16
to_s
to_str
返回self。
tr(search, replace)
tr!(search, replace)
若字符串中包含search字符串中的字符时，就将其替换为replace字符串中相应的字符。
search的形式与tr(1)相同。也就是说,`a-c'表示从a到c,而像"^0-9"这样,当`^'出现在头部时表示"取反"。
replace中也可以使用`-'来指定范围。例如，用tr来改写String#upcase的话，就是
p "foo".tr('a-z', 'A-Z')
=> "FOO"
这样。
只有当`-'出现在字符串内部,而非两端时才表示指定一个范围。同样地,只有当`^'出现在字符串头部时才表示"取反"。另外,可以使用反斜线(`\')来对`-', `^', `\'进行转义操作。
若replace所指定的范围比search的范围小的话，则认为replace的最后一个字符会一直重复出现下去。
tr生成并返回替换后的字符串。而tr!会修改self本身并返回结果，若没有进行替换操作则返回nil。
tr_s(search, replace)
tr_s!(search, replace)
若字符串中包含search字符串中的字符时，就将其替换为replace字符串中相应的字符。同时，若替换部分中出现重复字符串时，就将其压缩为1个字符。
search的形式与tr(1)相同。也就是说,`a-c'表示从a到c,而像"^0-9"这样,当`^'出现在头部时表示"取反"。
replace中也可以使用`-'来指定范围。
p "foo".tr_s('a-z', 'A-Z')
=> "FO"
只有当`-'出现在字符串内部,而非两端时才表示指定一个范围。同样地,只有当`^'出现在字符串头部时才表示"取反"。另外,可以使用反斜线(`\')来对`-', `^', `\'进行转义操作。
若replace所指定的范围比search的范围小的话，则认为replace的最后一个字符会一直重复出现下去。
tr_s生成并返回替换后的字符串。而tr_s!会修改self本身并返回结果，若没有进行替换操作则返回nil。
注意: 该方法的运作方式与tr(search, replace).squeeze(replace)并不相同。tr与squeeze连用时，会把整个替换后的字符串当作squeeze的对象来处理，而tr_s只把被替换的部分当作squeeze的对象来处理。
p "foo".tr_s("o", "f") # => "ff"
p "foo".tr("o", "f").squeeze("f") # => "f"
unpack(template)
按照template字符串的规则，把被pack起来(可能是由Array#pack生成)的字符串unpack开来，并以数组的形式返回其结果。请参考pack template字符串来了解template字符串的格式。
upcase
upcase!
在ASCII字符串的范围内，将所有字母都变为大写形式。
upcase生成并返回修改后的字符串。而upcase!会修改self本身并返回结果，若没有进行转换操作则返回nil。
若没有正确设置$KCODE时,部分汉字代码也会被修改(在ShiftJIS编码中就会发生这种情况)。相反,即使设置了$KCODE,也不会修改多字节字符的字母.
# -*- Coding: shift_jis -*-
$KCODE ='n'
puts "蟻".upcase # => 帰
请参考downcase, swapcase, capitalize。
upto(max) {|s| ... }
在从self到max的范围内，依次取出“下一个字符串”后将其传给块，进行迭代操作。关于“下一个”的定义，请参考String#succ。
该方法被用在字符串的Range内部。
例如，下面的代码会输出a, b, c, ... z,aa, ... az, ..., za。
("a" .. "za").each do |str|
puts str
end
