ruby-string 字符串的学习

String

来自：http://www.kuqin.com/rubycndocument/man/built-in-class/class_object_string.html

 

字符串类。可处理任意长度的字节串。

在该类的众多方法中，那些方法名尾部是！的方法将会直接修改字符串的内容。此时，使用不带！的同名方法是比较安全的。例如，在下例中就会出现这样的问题。

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

---

原文由 webmaster[at]ruby-lang.org 所著
稀亿网络软件(北京) 进行翻译

评论

1 楼 lzyfn123 2012-06-11  

http://www.iteye.com/images/smiles/icon_biggrin.gif