空间管理您的位置: 51Testing软件测试网 » 龙族守护神 » 日志

Ruby语言入门（22）- 内部类 -String

上一篇 / 下一篇 2013-02-06 16:01:37 / 个人分类：语言

查看( 436 ) / 评论( 0 ) / 评分( 0 / 0 )

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

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

类方法

String.new(string)

生成并返回一个与string内容完全相同的新字符串。

String.new("test")

=>"test"

实例方法

self + other

将字符串连接起来之后，返回得到的新字符串。

"test1"+"test2"

=>"test1test2"

self * times

将字符串的内容重复times次之后，返回新字符串

"test1"*3

=>"test1test1test1"

self % args

字符串的格式化。按照格式化字符串(self)的要求对参数进行格式化之后将其返回。

若args是数组，则等同于sprintf(self, *args),除此之外，则等同于sprintf(self, args)

"%#x"%10

=> "0xa"

"%#x"%8

=> "0x8"

self = = other

self > other

self >= other

self < other

self <= other

字符串的比较。

self << other

concat(other)

将other字符串的内容连接到self之后。

“123”<<"a"

=>"123a"

“123”<<1

=>"123\x01"

self =~ other

与正则表达式other进行匹配操作。若匹配成功则返回匹配位置的索引，若失败则返回nil

"test"=~/./

=>0

=>#<Matchdata "t">

self[nth]

以整数形式(字符代码)返回第nth字节的内容(相反地，若想从字符代码变为字符串时，请使用Integer#chr)。若nth为负值，则从字符串尾部算起。若nth超出范围则返回nil。

"abcd"[0]

=>"a"

"abcd"[-2]

=>"c"

self[nth, len]

返回从第nth字节算起的长度为len字节的子字符串。若nth为负数则从字符串尾部算起。若nth超出范围则返回nil。

"abcd"[-2,2]

=>"cd"

self[regexp]

self[regexp, nth]

返回最初那个与regexp相匹配的子字符串。与匹配操作相关的信息被存入内部变量$~中。

若使用了nth参数，则返回最初那个与regexp中第nth个括号相匹配的子字符串。若nth为0，则返回整个匹配的字符串。若匹配失败或没有与nth相对应的括号时，返回nil。

"test"[/te/]

=>"te"

"test"[/te/,0]

=>"te"

self[first..last]

生成并返回一个包含从索引first到索引last之间所有内容的字符串。

"abcd"[1..2]

=>"bc"

self[first...last]

将字符串的头部看作第0个缝隙，将字符串的末尾看作第self.length个缝隙，然后生成并返回一个包含从第first个缝隙到第last个缝隙之间的所有内容的字符串。

"abcd"[1...2]

=>"b"

self[nth]=val

以val来替换第nth字节的内容。若val是0到255之间的整数时，就把它看作是字符代码，并以该代码所对应的字符来进行替换操作。

s1="abcd"

s1[1]="f"

=>"afcd"

self[nth, len]=val

以val来替换从第nth字节起长度为len字节的子字符串。若nth为负数则从尾部算起。

s1="abcd"

s1[1,2]="f"

=>"afd"

self[substr]=val

以val来替换字符串中第一个与substr相对应的子字符串。

s1="abcd"

s1["bc"]="ff"

=>"affd"

self[regexp]=val

self[regexp, nth]=val

以val来替换第一个与正则表达式regexp相匹配的子字符串。若使用了参数nth时，则以val替换第一个与正则表达式regexp中的第nth个括号相匹配的子字符串。若nth为0时，则以val来替换整个匹配部分。

s1="test"

s1[/es/]="ff"

=>"affd"

self[first..last]=val

self[first...last]=val

以val来替换从first到last之间的内容。

s1="abcd"

s1[1..2]="ff"

=>"affd"

s1[1...2]="d"

=>"adfd"

self <=> other

以ASCII代码的顺序来比较self和other。若self较大时返回正整数，相等时返回0，较小时返回负整数。

capitalize

capitalize!

将首字符(若为字母的话)改为大写字母，其余的改为小写字母。

"test".capitalize

=>"Test"

"TEST".capitalize

=>"Test"

casecmp(other)

该方法与String#<=>一样，是用来比较字符串的顺序的。它将忽略字母的大小写。

center(width)

ljust(width)

rjust(width)

center(width[, padding])

ljust(width[, padding])

rjust(width[, padding])

分别返回居中、靠左、靠右的字符串。第二参数padding的话，将使用padding来填充空白.

"test".rjust(10,"*")

=>"******test"

chomp([rs])

chomp!([rs])

删除字符串尾部的行切分符，该切分符由rs指定。rs的默认值取自变量$/的值。

"test\n".chomp

=> "test"

chop

chop!

删除字符串末尾的字符(若字符串末尾是"\r\n"的话,就删除2个字符).

"test".chop

=>"tes"

clone

dup

返回一个与原字符串内容相同的新字符串. 对被冻结的字符串使用clone会得到一个同样被冻结的字符串,而使用dup就会得到一个内容相同但未被冻结的字符串.

count(str[, str2[, ... ]])

返回在该字符串中str所含字符出现的次数.若给出多个参数,则意味着会使用所有参数的交集.

"testtesttest".count("s")

=>3 (count for "s")

"testtesttest".count("st")

=>9 (count for "s"+"t")

"123456789".count('2-8', '3-4')

=>2

crypt(salt)

生成并返回一个由self和salt加密而成的字符串. salt是一个由字母或数字、点(.)和斜线(/)构成的2字节以上的字符串.

"test".crypt("123")

=>"126D8rSh5sjUE"

delete(str[, str2[, ... ]])

delete!(str[, str2[, ... ]])

从该字符串中删除str所包含的字符.若给出多个参数,则意味着会使用所有参数的交集.

"123456789".delete("2-8", "4-6")

=> "123789"

"123456789".delete("2378")

=> "14569"

downcase

downcase!

将字符串中的大写字母都改为小写字母.

dump

使用反斜线表示法替换字符串中的非显示字符,并返回修改后的字符串

"test".dump

=>"\"test\""

each([rs]) {|line| ... } (each 报错）

each_line([rs]) {|line| ... }

对字符串中的各行进行迭代操作. 此时,rs中的字符串将成为行切分符,行切分符的默认值取自变量$/的值.各line中包含用作切分符的字符串.若将rs设为nil时,则意味着不作行的切分. 若设为空字符串""则将连续的换行当做行切分符(段落模式).

a="1\n2\n3\n"

a.each_line {|n| puts n}

=>"1\n2\n3\n"

each_byte {|byte| ... }

对字符串中的各个字节进行迭代操作.

a="1\n2\n3\n"

a.each_byte {|n| puts n}

=>"1\n2\n3\n"

empty?

若字符串为空(也就是说其长度为0),则返回真.

gsub(pattern, replace)

gsub!(pattern, replace)

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

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

以replace来替换字符串中所有与pattern相匹配的部分. replace中的\&和\0被替换为匹配的子字符串,而\1 ... \9被替换为第n个括号的内容.在替换字符串replace中,还可以使用\`、\'或\+. 它们分别对应于$`、$'、$+.

a="test"

a.gsub!("es","se")

=>"tset"

hex

把字符串看做是16进制数形式,并将其变为整数.

"123".hex

=>10

include?(substr)

若字符串中包含substr子字符串的话,就返回真.若substr是从0到255之间的Fixnum时,将把它看做是字符代码,若包含该代码所对应的字符,就返回真.

"test".include?("e")

=>true

index(pattern[, pos])

按照从左到右的顺序搜索子字符串,并返回搜索到的子字符串的左侧位置. 若没有搜索到则返回nil.在参数pattern中,可以使用字符串,0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.若给出了pos时, 则从相应位置开始搜索.省略pos时其默认值为 0.

"test".index("es")

=>1

"test".index("es",3)

=>nil

insert(nth, other)

在第nth个字符的前面插入other字符串.

"test".insert(2,"ooo")

=>"teooost"

intern

to_sym

返回与字符串相对应的符号值(Symbol).

"test".intern

=>:test

length

size

返回字符串的字节数.

"test".size

=>4

match(regexp)

match(regexp[, pos])

与regexp.match(self[, pos])相同

"test".match(/./)

=> #<MatchData "t">

next

next!

succ

succ!

返回下一个字符串. 所谓"下一个"是指,按照26个字母顺序或10进制数的顺序继续向下数时得到的结果.

"abc".next

=>"abd"

"123".succ

=>"124"

oct

将字符串看做是8进制字符串,并将其变为整数.

"123".oct

=>83

replace(other)

以other的内容来替换字符串的内容.

"test".replace("123")

=>"123"

reverse

reverse!

对字符串进行反转.

"123".reverse

=>"321"

rindex(pattern[, pos])

按照从右到左的顺序来搜索子字符串,并返回找到的子字符串的左侧的位置. 若搜索失败则返回nil.在参数pattern中,可以使用字符串,从0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.若给出了pos时,就从相应位置开始搜索. 省略pos时,其值为self.size (右端).

"character".rindex("c")

=>5

"character".rindex("c",0)

=>0

scan(re)

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

使用正则表达式re反复对self进行匹配操作,并以数组的形式返回匹配成功的子字符串.

"test".scan(/./)

=>["t","e","s","t"]

slice(nth[, len])

slice(substr)

slice(first..last)

slice(first...last)

slice(regexp[, nth])

与self[ ]相同.

slice!(nth[, len])

slice!(substr)

slice!(first..last)

slice!(first...last)

slice!(regexp[, nth])

从字符串中删除指定的范围(请参考self[ ]),然后返回删除的子字符串.

a="test"

a.slice(1)

=>"e"

a.slice!(1)

=>"tst"

split([sep[, limit]])

使用sep指定的pattern来分割字符串,并将分割结果存入数组.

sep可以是下列之一:

正则表达式: 把正则表达式的匹配结果当作切分符来切分字符串。如果使用了括号群组的话，与群组相匹配的字符串也会出现在最后的数组中。
1字节的字符串：把该字符当作切分符来进行切分
2字节以上的字符串：把与Regexp.new(sep)相匹配的字符串当作切分符来进行切分。
省略或 nil：把$;的值当作切分符来进行切分。
1字节的空白' ' 或使用了$;且其值为nil时：除了头部的空白之外，使用空白进行切分。
空字符串'' 或与空字符串相匹配的正则表达式：以单个字符为单位进行切分。可识别多字节字符。

a="test"

a.split

=>["test"]

a.split("")

=>["t","e","s","t"]

squeeze([str[,str2[, ... ]]])

squeeze!([str[,str2[, ... ]]])

压缩由str所含字符构成的重复字符串。

"111222333".squeeze

=>"123"

"111222333".squeeze("222")

=>"1112333"

strip

strip!

删除头部和尾部的所有空白字符。空白字符是指" \t\r\n\f\v"。strip生成并返回修改后的字符串。strip!会修改self本身并返回结果。若没有进行删除动作，则返回nil。

" test ".strip

=>"test"

lstrip

lstrip!

删除字符串头部的所有空白字符。空白字符是指" \t\r\n\f\v"。lstrip会生成并返回加工后的字符串。lstrip!会修改self本身并返回结果。如果没有删除空白字符，则返回nil。

" test ".lstrip

=>"test "

rstrip

rstrip!

删除字符串尾部的所有空白字符。空白字符是指" \t\r\n\f\v"。rstrip会生成并返回加工后的字符串。rstrip!会修改self本身并返回结果。如果没有删除空白字符，则返回nil。

" test ".rstrip

=>" test"

sub(pattern, replace)

sub!(pattern, replace)

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

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

用replace来替换首次匹配pattern的部分。若带块调用的话，就以块的计算值来替换首次匹配的部分。sub生成并返回替换后的字符串。而sub!会修改self本身并返回结果。若没有进行替换时返回nil。

除去只进行一次匹配这个特点以外，它与gsub是相同的。

"test".sub("es","ttt")

="ttttt"

sum([bits=16])

计算字符串的bits位的校验和。

"test".sum

=448

swapcase

swapcase!

将所有的大写字母改为小写字母，小写字母改为大写字母。

"TesT".swapcase

=>"tESt"

to_f

将字符串看作是10进制数形式，并将其变为浮点数Float。

"123".to_f

=>123.0

to_i

to_i(base)

将字符串看作是10进制数形式，并将其变为整数。

"123".to_i

=>123

to_s

to_str

返回self。

tr(search, replace)

tr!(search, replace)

若字符串中包含search字符串中的字符时，就将其替换为replace字符串中相应的字符。

"test".tr("es","aa")

=>"taat"

unpack(template)

按照template字符串的规则，把被pack起来的字符串unpack开来，并以数组的形式返回其结果.

"test".unpack("a")

=>["t"]

upcase

upcase!

在ASCII字符串的范围内，将所有字母都变为大写形式。

upto(max) {|s| ... }

在从self到max的范围内，依次取出“下一个字符串”后将其传给块，进行迭代操作。

"a".upto("e") {|s| puts s}

=>"a"

收藏举报

TAG:

查看全部评论

gigobin

用户菜单

我的栏目

标题搜索

日历

数据统计

访问量: 149942
日志数: 185
文件数: 6
建立时间: 2007-08-06
更新时间: 2015-01-06

Ruby语言入门（22）- 内部类 -String

用户菜单

我的栏目

标题搜索

日历

我的存档

数据统计

RSS订阅