向字符串末尾追加字符

向字符串末尾追加字符时， 使用 String#concat 或 << 运算符(String#<<)

s = 'abc' s.concat('def') p s #=> "abcdef" s = 'abc' s << 'def' p s #=> "abcdef"

<< 运算符还可以有以下的写

s = '' s << 'abc' <<　'def' p s #=> "abcdef"

当然，如果使用 += 运算符也会达到以上的相同效果， 但是 ruby 并不建意使用此方 法。 为什么呢？ 让我们来看看内存是如何工作的。

+= 方法	concat 方法
XXX|	XXX|
XXX| XXX|XXX|	XXX|XXX|
XXX| XXX|XXX| XXX|XXX|XXX|	XXX|XXX|XXX|

+= 方法是先复制原字符串后，在复本字符串尾部追加。 这种方法会吃掉大量的内存。 而 concat 方法是直接在原字符串尾部追加。我们在来测试一下两种方法的速度

# 约 30 秒 box = '' 50000.times{ box += 'xxx|' } # 约 0.05 秒 box = '' 50000.times{ box.concat('xxx|') }

删除行末的换行符或回车符

删除行末的换行符或回车符， 使用 String#chomp

p "line\n".chomp    #=> "line" p "line\r\n".chomp    #=> "line" p "line\r".chomp    #=> "line" p "line \t\n".chomp    #=> "line \t" p "line".chomp    #=> "line"

但是， 有时只想删除 \r\n 并不想删除 独立的 \r 或 \n 时，可以对 String#chomp的 删除模式进行设置

$\ = "\r\n" p "line\n".chomp    #=> "line\n" p "line\r\n".chomp    #=> "line" p "line\r".chomp    #=> "line\r" p "line \t\n".chomp    #=> "line \t\n" p "line".chomp    #=> "line"

还可以为 String#chomp 添加参数， 来实现将在已经设定模式内的某一字符删除

$\ = "\r\n" p "line\n".chomp("\n")    #=> "line" p "line\r\n".chomp("\n")    #=> "line" p "line\r".chomp("\n")    #=> "line" p "line \t\n".chomp("\n")    #=> "line \t" p "line".chomp("\n")    #=> "line"

在对一些文本文件进行处理时， 行末不仅有回车，还会有空格等字符。如果想一并删 除时， 使用 String#rstrip

p "line\n".rstrip    #=> "line" p "line\r\n".rstrip    #=> "line" p "line\r".rstrip    #=> "line" p "line\t \n".rstrip    #=> "line" p "line".rstrip    #=> "line"

字符串分割

使用正则表达则进行字符串分割， Sting#split

p '2003,11,21,字符串,ACB'.split(/,/)     #=> ["2003", "11", "21", "字符串", "ACB"]

设置 Sting#split 的第二参数， 可以设定最大分割的个数

p '2003,11,21,字符串,ACB'.split(/,/， 3)     #=> ["2003", "11", "21，字符串，ACB"]

如果分割符也想原样保留的情况， 可以使用正则表达式的 （）

p '2003,11,21,字符串,ACB'.split(/（,）/)     #=> ["2003", ",", "11", ",", "21", ",", "字符串", ",", "ACB"]

取出字符串中的一部分

在字符串中，从给定的起始位置开始， 任意长度的字符

p 'abcdefghi'[3..3]    #=> "def" (从3开始3byte)

同样也可以使用给定的起始位置和结束位置，来从字符串中取出这一区间的字符

p 'abcdefghi'[3..5]    #=> "def" p 'abcdefghi'[3...6]    #=> "def"

以上的方法都是以byte单位为进行计算的
下面使用正则表达式来实现

# 从 a 开始取出3个字符 p 'abcdefghi'.slice(/a../)    #=> "abc" p 'abcdefghi'.slice(/x../)    #=> nil # 将所有匹配字符取出 p 'static int fact(int n)'.scan(/\w+/)     #=> ["static", "int", "fact", "int", "n"]

字母大小写的转换

将字符串中的所有大写字母转换成小写 String#upcase, 将字符串中的所有小写字母转换成大写 String#downcase

p 'aBcDeFg-->'.upcase    #=> "ABCDEFG-->" p 'aBcDeFg-->'.downcase    #=> "abcdefg-->"

upcase 和 downcase 方法只对字母有效， 其它的字符会原样输出。 如果想将字符串中某一指定字母进行大小写转换时， 使用的方法是String#tr

p 'abcdefghijklmn'.tr('acegikm', 'ACEGIKM')     #=> "AbCdEfGhIjKlMn"

将字符串的首字符转换成大写字母， 使用的方法是String#capitalize

p 'this is a pen'.capitalize    #-> "This is a pen"

大小写字母的相互转换, 使用的方法是String#swapcase

p 'aBcDeFg-->'.swapcase    #-> "AbCdEfG-->"

判断字母的大小写

使用正则表达式 /a-z/ 和 /A-Z/ 来对字母的大小写进行判断

# 小写字母 def lower?(str)     /[a-z]/ =~ str end # 大写字母 def upper?(str)     /[A-Z]/ =~ str end p '小写字母' if lower?('abcdefg')    #=> "小写字母" p '大写字母' if upper?('ABCDEFG')    #=> "大写字母"

lower? 方法是，当字符串含有小写字母时，返回值为true, 否则为false. 如果字符串 中既含大写字母又含小写字母时，以上的写法就不适用了。方法更完善的写法是：

# 小写字母 def lower?(str)     /\A[a-z]\z/ =~ str end # 大写字母 def upper?(str)     /\A[A-Z]\z/ =~ str end str = 'aBcDeFg' if lower?(str)     p '小写字母' elsif upper?(str)     p '大写字母' else     p '无法识别' end #=> "无法识别"

有关 \A 和 \z 的介绍请查看 => 从首字符或尾字符开始的查找

字符串的比较

使用 == 比较两个字符串的意思是否一样。

p '字符串' == '字符串'    #=> true p '字符串' == '字符'    #=> false

大小写字母进行比较时，字母的大小写是有区别的。如果想无区分比较时，可以将两者 同时转化成大写或小写字母后在进行比较。大小写的转化使用 String#downcase

p 'ABC' == 'Abc'    #=> false p 'ABC'.downcase == 'Abc'.downcase    #=> true

也可以不区分大小写对字母进行比较

$= = true p 'ABC' == 'Abc'    #=> false

注:
    $= 这是一种过时的用法了（ruby1.8版本以前）， 意思为除 nil 和 false 之外的任意值。如果一但设置此模式，所有匹配将于大小写无关，字符串比较将忽略大小写，而且字符串的 hash 值也会忽略大小写。（不推荐使用）

不仅如此，使用还可以使用 >, <, >=, <= 对字母的大小进行比较

p 'a' > 'b'    #=> false p 'abc' < 'xyz'    #=> true

ruby的字符型

单行字符串的输出:

str = 'hello the world' p str    #=> "hello the world" puts str    #=> hello the world

多行字符串的输出:

str = <<EOS     This is test.     Ruby, the Object Oriented Script Language. EOS puts str     #=>This is test.           Ruby, the Object Oriented Script Language.

字符串的结合:

str = 'hello' puts str + ' the world'    #=> hello the world

字符串的追加:

str = 'hello' str << ' the world' puts str    #=> hello the world

生成重复的字符串:

str = 'hello ' puts str*3    #=> hello hello hello

大小写字母的变换:

str = 'I Love Ruby' puts str.upcase    #=> I LOVE RUBY puts str.downcase    #=> i love ruby

字符串中的部分字符的取得:

str = "Apple Banana Orange" puts str[0..4]     #=> Apple puts str[6, 6]     #=> Banana

字符串中的部分字符的置换:

str = "Apple Banana Apple Orange" str[0..4] = "Vine"     #=> str = "Vine Banana Apple Orane" str[5, 6] = "Lemon"     #=> str = "Vine Lemon Apple Orange" str.sub("Apple", "Pine")     #=> str = "Pine Banana Apple Orange" str.gsub("Apple", "Pine")     #=> str = "Pine Banana Pine Orange"

字符串中变数的展开:

value = 123 puts "value is #{value}"     #=> value is 123

字符串中方法的展开:

def sub(str)     "Hello, #{str}." end puts "Say #{sub('Tomoya')}"     #=> Say Hello, Tomoya.

削除字符串头和尾的空格:

str = ' Hello, Ruby! ' p s.strip     #=> "Hello, Ruby!"

削除字符串尾部的换行:

str = 'Hello, Ruby!\n' p str.chomp    #=> "Hello, Ruby!" p str.strip    #=> "Hello, Ruby!"

字符型向数值型的转换:

str = '99' i = 1 puts i + str.to_i    #=> 100

数值型向字符型的转换:

str = '99' i = 1 p i.to_s + str    #=> "199"

字符型(数值型)向浮点小数型的转换:

str = '99' puts str.to_f    #=> 99.0

下一个字符串的取得:

p "9".succ    #>= "10" p "a".succ    #>= "b" p "AAA".succ    #>= "AAB" p "A99".succ    #>= "B00" p "A099".succ    #>= "A100"

检查字符串中是否有相同字符出现:

str = "Apple Banana Apple Orange" # 从左则开始查找 puts str.index("Apple")    #=> 0 puts str.index("Banana")    #=> 6 puts str.index("Apple", 6)    #=> 13 # 从右则开始查找 puts str.rindex("Apple")    #=> 13 puts str.rindex("Apple", 6)    #>= 0

字符串的居中,居左和居右:

str = "Ruby" p str.center(10)     #=> " Ruby " p str.ljust(10)    #=> "Ruby " p str.rjust(10)    #=> " Ruby"

单词的检索

查找在某一字符串中是否含有匹配的单词. 如: 当我们想查找单词 spec 而又不想将 specifsction 一起查找出来时, 我们将要用到正则表达式的 \b (要注意是小写字母b).

p /\bspec\b/ =~ "Ruby spec"")    #=> 5 p /\bspec\b/ =~ "Ruby specifsction"")    #=> nil

因为一个汉字由4字节构成, 所以使用正则表达式的 \b 进行单词检索的方法, 只对英 文单词有效.

p /字符\b/ =~ "字符 abc"    #=> nil

单词的查找
说是单词的查找, 但单词的概念却是很模糊的. 如下提供了三种方法:

# 使用 Ruby 的正则表达式 \w 来实现查找 p " This is \ta 2pen.".scan(/\w+/)   #=> ["This", "is", "a", "2pen"]

# 使用 Ruby 的正则表达式 /[a-z]+/i 来实现查找 p " This is \ta 2pen.".scan(/[a-z]+/i)   #=> ["This", "is", "a", "pen"]

# 使用 Ruby 的String#split 方法来实现查找 p " This is \ta 2pen.".split(nil)   #=> ["This", "is", "a", "2pen."]

字符串的查找

查找匹配字符
用正则表达式查找匹配字符时,使用 =~ 运算符.

# 查找含有全角空格和半角空格. p ([\s\t] =~ 'a c')    #=>  1 p ([\s\t] =~ 'abc')    #=>  nil

查找匹配字符最初出现在位置
查找匹配字符最初出现在位置时,使用 String#index

p 'xxxabcabcabcxxx'.index('abc')    #=>  3 p 'xxxabcabcabcxxx'.index('.')     #=>  nil p 'xxx..............xxx'.index('.')     #=>  3

查找匹配字符最后出现在位置
查找匹配字符最后出现在位置时,使用 String#rindex

p 'xxxabcabcabcxxx'.rindex('abc')    #=>  9 p 'xxxabcabcabcxxx'.rindex('.')     #=>  nil p 'xxx..............xxx'.rindex('.')     #=>  16

取得匹配字符外的字符串
取得到匹配字符之后的字符串,使用 Regexp#match

m = /abc/.match('xxxabcabcabcxxx') p m.post_match    #=>  "abcabcxxx" m = 'xxxabcabcabcxxx'.match(/abc/) p m.post_match    #=>  "abcabcxxx"

查找字符串中匹配的所有字符
查找字符串中匹配的所有字符,使用 String#scan

# 查找字符串中的所有字母. str = "abc所\ndef有\nghi字符\n" str.scan(/[a-z]+/){ |s|     p s } #=>  "abc" #=>  "def" #=>  "ghi"

取得含有匹配字符的一行
含有匹配字符的复数行.使用 String#grep (Enumerble#grep)

# 输出含有字母 a 和 g 的一行. str = "abc所\ndef有\nghi字符\n" str.grep(/[ag]/){ |line|     p line } #=>  "abc所\n" #=>  "ghi字符\n"

以下的两种写法同上相同

str.grep(re){ |line|     # 处理内容 }

str.each{ |line|     if re =~ line         # 处理内容     end }

取得字符串的长度

说到取得字符串的长度,就会想到两种情况: byte数和字符数.

取得byte数
字符串byte数的取得将用到 String#lenght 和 String#size 这两种方法.虽然方法名称不同,但意义是相同的.

p "This is a string".length    # 16  p "This is a string".size    # 16

取得字符数
字符数的取得将用到 String#split 方法. 此方法是以字符为单位,将字符串分割成数组再计算组数大小.

p "这是字符串".split(//).length    # 10  p "这是字符串".split(//).size    # 10