String

字符串的类。可以处理任意长度的字节串。详细参看 Sprintf 格式。

超类

• Object

包含的模块

• Comparable

方法

self + other

返回连接起来的新字符串。

self * times

生成并返回一个重复字符串内容 times 次的新字符串。

self <=> other

将 self 与 other 依照 ASCII 码顺序进行比较，若是 self 大于 other 则返回正整数、若是 self 等于 other 则返回 0、若是 self 小于 other 则返回负整数。

self == other

判断字符串是否相等。

self[nth, len]

返回从第 nth 位开始， len 位长度的子字符串。当 nth 是负值时，从字符串尾部开始算起。

若 nth 超出范围，返回 nil。

self[regexp]

返回第一个匹配 regexp 的子字符串。匹配信息储存于内建变量 $~ 中。

若是 regexp 匹配失败，返回 nil。

p "foobar"[/bar/]   # => "bar"

self[nth, len]=val

将从第 nth 位开始计算 len 位长度的子字符串替换为 val 字符串。当 nth 是负值时，从字符串尾部开始算起。

返回 val 。

self[regexp]=val

将第一个匹配 regexp 的子字符串替换为 val 字符串。

若匹配失败，抛出 IndexError 异常。

返回 val。

clone

dup

返回与原字符串相同内容的新字符串。对冻结的字符串使用 clone 返回相同的冻结字符串，而 dup 返回相同内容的非冻结字符串。

concat(other)

将 other 和 self 的内容连接起来并返回 self。

downcase

downcase!

将所有的大写字母替换成小写字母。

downcase 生成并返回新修改的字符串，而 downcase! 修改并返回 self，但是若没有替换任何字符，返回 nil。

参考 upcase。

each_line {|line| ... }

迭代字符串中的每一行。

返回 self。

each_byte {|byte| ... }

迭代字符串中的每一字节。返回 self。

empty?

若字符串为空（长度为 0）则返回 true。

gsub(pattern) {|matched| .... }

gsub!(pattern) {|matched| .... }

以区块的计算结果替换所有匹配 pattern 的子字符串。匹配成功的子字符串会传递给区块作为参数。内建变量 $<digits> 可以在区块内引用。

p 'abcabc'.gsub(/b/) {|s| s.upcase }    # => "aBcaBc"
p 'abcabc'.gsub(/b/) { $&.upcase }      # => "aBcaBc"
p 'abbbcd'.gsub(/a(b+)/) { $1 }         # => "bbbcd"

gsub 生成并返回替换后的字符串。gsub! 修改并返回 self，但是若没有发生替换，返回 nil。

参考 sub。

include?(substr)

若字符串文字包含子字符串 substr 则返回 true。

index(pattern[, pos])

从左至右寻找子字符串，返回所找到字符串左端的位置。若找不到字符串，返回 nil 。

pattern 参数使用字符串或正则表达式指定所寻找的子字符串。

若指定了 pos ，则从该位置开始寻找，省略时默认值为 0。

insert(nth, other)

将字符串 other 插入在第 nth 位的字符的前面。返回 self。

p "foobaz".insert(3, "bar")         # => "foobarbaz"

to_sym

返回对应字符串的符号值（Symbol）。

使用 Symbol#id2name 获取对应符号的字符串。

p "foo".to_sym                      # => :foo
p "foo".to_sym.to_s == "foo"        # => true

length

size

返回字符串的字符数。

scan(re)

scan(re) {|s| ... }

重复将 self 与正则表达式 re 进行匹配，并返回匹配成功的子字符串的数组。

p "foobarbazfoobarbaz".scan(/ba./)
# => ["bar", "baz", "bar", "baz"]

p "abcde".scan(/./)
# => ["a", "b", "c", "d", "e"]

当指定区块时，匹配成功的子字符串成为区块的参数（若包含括号时，区块的参数是匹配括号部分的字符串数组）。指定区块时，返回 self。

"foobarbazfoobarbaz".scan(/ba./) {|s| p s}
# => "bar"
   "baz"
   "bar"
   "baz"

slice(nth, len)

slice(regexp)

与 self[] 相同。

slice!(nth, len)

slice!(regexp)

移除并返回字符串中指定范围（参考 self[]）的子字符串。

若参数超出范围，返回 nil。

sub(pattern) {|matched| ... }

sub!(pattern) {|matched| ... }

以区块的计算结果替换第一个匹配 pattern 的子字符串。匹配成功的子字符串会传递给区块作为参数。

sub 生成并返回替换后的字符串。sub! 修改并返回 self，但是若没有发生替换，返回 nil。

与 gsub 相同，但是 sub 只会匹配一次。

to_f

将字符串视为 10 进制的表达式并转换成浮点数（Float）。

to_i([base])

将字符串视为数值表达式并转换成整数。

默认为十进制。若指定了 base，可以进行 2～36 进制的转换。

upcase

upcase!

将所有的小写字母替换成大写字母。

upcase 生成并返回新修改的字符串。upcase! 修改并返回 self，但是若没有替换任何字符，返回 nil。

参考 downcase。