字符串比大小

uby-1.9.2-p0 > "product"<=>"gifts"

 => 1 

ruby-1.9.2-p0 > "jue"<=>"des"

 => 1 

ruby-1.9.2-p0 > "jue"<=>"gift"

 => 1 

ruby-1.9.2-p0 > "jue"<=>"k"

 => -1 

ruby-1.9.2-p0 > "jue"<=>"juf"

 => -1 

ruby-1.9.2-p0 > "jue"<=>"jue"

 => 0 

ruby-1.9.2-p0 > "jue"<=>"jud"

 => 1 

ruby-1.9.2-p0 > 

ruby way之string之二

接着昨天的。 

11 控制字符串的大小写 。 

downcase 方法可以转换一个字符串为小写,upcase可以转换一个字符串为大写.capitalize 方法强迫字符串第一个字符为大写，其他的字符为小写。 

s1 = "Boston Tea Party"
puts s2 = s1.downcase             # "boston tea party"
puts s3 = s2.upcase
puts s1.capitalize  #Boston tea party

swapcase 方法可以将一个字符串中的大小写进行翻转，而casecmp方法则是实现了和<=>相同的功能，只不过忽略了大小写. 

puts s1.swapcase #bOSTON tEA pARTY
n4 = "ABC".casecmp("abc")  #0

我们还可以通过downcase!或者upcase!方法来判断一个字符串是否含有大写或者小写字母. 

str="asdas"
str2="ASDF"
puts str.downcase! ==nil
puts str2.upcase! ==nil

12 得到和设置子字符串 

在ruby中得到子字符串有很多不同的方法，经常使用的是中括号,中括号里面可以是数字，一个区间，一个正则表达式，或者一个string. 
如果指定了一对数字的话，两个数字各代表偏移和长度： 

str = "Humpty Dumpty"
puts sub1 = str[7,4]         # "Dump"
puts sub2 = str[7,99]        # "Dumpty" (长度超长也可以)
puts sub3 = str[10,-4]       # nil (长度是负数)

虽然长度不能是负数，可是这边我们的偏移可以是负数，如果是负数的话偏移是从字符串左边算起的，并且起始位置是-1而不是0. 

str1 = "Alice"
puts sub1 = str1[-3,3]   # "ice"
puts str2 = "Through the Looking-Glass"
puts sub3 = str2[-13,4]  # "Look"

中括号里面也可以放区间，在这里区间也就是所要处理的string的起始位置和结束位置。区间的第一个数字可以为负数，可是第一个数字必须得比第二个数字小，如果不符合这个的话将会返回nil. 

str = "Winston Churchill"
puts sub1 = str[8..13]    # "Church"
puts sub2 = str[-4..-1]   # "hill"
puts sub3 = str[-1..-4]   # nil
puts sub4 = str[25..30]   # nil

正则表达式也可以放.这个将会返回正则表达式所匹配的字符串. 

str = "Alistair Cooke"
puts sub1 = str[/l..t/]   # "list"
puts sub2 = str[/s.*r/]   # "stair"
puts sub3 = str[/foo/]    # nil

一个string也可以放进中括号，如果它是所处理的string的子字符串的话，方法将会返回它自己，否则将返回nil 

str = "theater"
puts sub1 = str["heat"]  # "heat"
puts sub2 = str["eat"]   # "eat"
puts sub3 = str["ate"]   # "ate"
puts sub4 = str["beat"]  # nil
puts sub5 = str["cheat"] # nil

最终，中括号里还可以放进一个数字，这个数字代表了从左往右第几个字符: 

str = "Aaron Burr"
puts ch1 = str[0]     # A
puts ch1 = str[1]     # a
puts ch3 = str[99]    # nil

13 在一个string中进行替换. 

我们可以使用sub或者gsub方法来进行替换，他们两个方法第一个参数都是接受正则表达式。其中，sub方法替换掉第一个匹配的地方，而gsub方法替换掉左右匹配的地方： 

s1 = "spam, spam, and eggs"
s2 = s1.sub(/spam/,"bacon")               # "bacon, spam, and eggs"

s3 = s2.sub(/(\w+), (\w+),/,'\2, \1,')    # "spam, bacon, and eggs"

s4 = "Don't forget the spam."
s5 = s4.sub(/spam/) { |m| m.reverse }
s5 = "alfalfa abracadabra"
s6 = s5.gsub(/a[bl]/,"xx")     # "xxfxxfa xxracadxxra"
s5.gsub(/[lfdbr]/) { |m| m.upcase + "-" }
# s5 is now "aL-F-aL-F-a aB-R-acaD-aB-R-a"

14 搜索一个字符串 

index方法返回指定的子字符串，正则表达式或者字符的起始位置(如果有多个匹配的只返回第一个匹配的起始位置)，没有发现的话返回nil： 

str = "Albert Einstein"
puts pos1 = str.index(?E)        # 7
puts pos1 = str.index(69)        # 7
puts pos2 = str.index("bert")    # 2
puts pos3 = str.index(/in/)      # 8
puts pos4 = str.index(?e)        # nil
puts pos5 = str.index("bart")    # nil
puts pos6 = str.index(/wein/)    # nil

而rindex则是从string的右边(也就是结束处)开始查找，不过返回的值却是从左边数起的： 

str = "Albert Einstein"
puts pos1 = str.rindex(?E)       # 7
puts pos2 = str.rindex("bert")   # 2
puts pos3 = str.rindex(/in/)     # 13 (finds rightmost match)
puts pos4 = str.rindex(?W)       # nil
puts pos5 = str.rindex("bart")   # nil
puts pos6 = str.rindex(/wein/)   # nil

而include?方法只是简单的返回是否指定的子字符串属于所处理的字符串. 

str1 = "mathematics"
puts flag1 = str1.include? ?e         # true
puts flag2 = str1.include? "math"     # true
puts str2 = "Daylight Saving Time"
puts flag3 = str2.include? ?s         # false
puts flag4 = str2.include? "Savings"  # false

scan方法遍历一遍整个字符串查找出符合指定模式的字符串并组成一个数组或者将每次匹配的结果传递给block(注意，这边只是传递) 

str1 = "abracadabra"
puts sub1 = str1.scan(/a./)
puts sub1 = str4.scan(/a./){|w| puts w} #ab ac ad

看下面的代码： 

str4 = "abracadabra"
sub1 = str4.scan(/a./){|w| w.upcase}
puts sub1

这边不仅没有转换为大写字母，而且直接把原始的字符串打印出来了，这边的原因就是我前面所提到的，如果是block形式的话，它仅仅只是把每次匹配的结果传递给block.. 

15一个字符和asc之间的转换。 

我们可以使用<<符号或者chr来把一个asc转换为字符串: 

puts  "a"<<111
puts  111.chr

而要将一个字符转换为一个asc码的话我们可以使用unpack方法： 

puts  "E".unpack("c")#69

16 隐式转换和显式转换(也就是转换为字符串) 

在ruby中，to_s和to_str让人很混淆.他们都是转换一个对象为string，可是他们有什么不同呢？ 

在ruby的核心类中基本都实现了to_s，而to_str却不是. 
在这边to_s是显式转换，to_str是隐式转换, 

to_s方法返回真正的string对象，而隐式转换则是一个强迫的转换，有点像java中的强制转型。 

我们可以看下面的例子： 

class Helium
  def to_s
    "He"
  end
  def to_str
    "helium"
  end
end

e = Helium.new
print "Element is "
puts e                    # Element is He
puts "Element is " + e    # Element is helium
puts "Element is #{e}"    # Element is He

这边的加号会将e强制转型为string因此会调用to_str,再看下面的代码 

class Fixnum
  def to_str
    self.to_s
  end
end

puts str = "The number is " + 345     # The number is 345

这边会将345强制转型为string,因此就会调用to_str方法. 

17字符串尾部添加元素. 

我们能使用<<操作符. 

str = "A"
str << [1,2,3].to_s << " " << (3.14).to_s
#如果一个数字在0..255 之间，将会把他转为一个字符
str = "Marlow"
str << 101 << ", Christopher"
# str is now "Marlowe, Christopher"

18 移除换行符和其他字符 

chop方法将会删除最后一个字符，返回新的string。如果字符是以\r\n结束，则两个字符都会被删除. 

str = "abcxyz"
s1 = str.chop           # "abcxy"
str2="abc\r\n"
s2=str2.chop  #abc

而chomp方法则会默认删除回车换行符，如果有参数的话，将会删除参数所代表的字符串 

str = "abcxyz"
puts s1 = str.chomp #abcxyz
str2 = "123\n"
puts s2=str2.chomp   #123
str1 = "abcxyz"
str2 = "abcxyz"
puts s1 = str1.chomp("yz")   # "abcx"
puts s2 = str2.chomp("x")    # "abcxyz"

19 删除空格符 
strip将会删除掉字符串的开头和结尾的空格 

sss="a d c "
puts sss.strip

如果你只想从字符串的开头或者结尾的空格，那么可以使用lstrip或者rstrip 

str = "  abc  "
s2 = str.lstrip       # "abc  "
s3 = str.rstrip       # "  abc"

20 重复字符串 

我们可以使用*来操作重复字符串： 

puts etc = "Etc. "*3 # "Etc. Etc. Etc. "