ruby way之string之三

21 在字符串中插入表达式

#{}做的就是这个,在{}中的所有表达式，都会自动计算，看下面的例子：

temp_f="ff"
temp_c="cc"
b=2
a=1
c=3
word="cdafr"
puts "#{temp_f} Fahrenheit is #{temp_c} Celsius"  #ff Fahrenheit is cc Celsius
puts "The discriminant has the value #{b*b - 4*a*c}."#The discriminant has the value -8.
puts "#{word} is #{word.reverse} spelled backward." #cdafr is rfadc spelled backward.

完整的语句也可以放在{}里面，语句中最后一个计算的表达式将会被返回：

puts  str = "The answer is #{ def factorial(n)
                          n==0 ? 1 : n*factorial(n-1)
                        end

                        answer = factorial(3) * 7}, of course."
# The answer is 42, of course.

在全局变量，类变量和实例变量中，我们可以省略中括号。

class Test
  def initialize()
    @name="bobo"
    $style="jackjones"
    @@address="xiamen"
  end
  def to_s
    "$style= #$style,@name= #@name,@@address=#@@address"
  end
end
tt=Test.new
puts tt
#$style= jackjones,@name= bobo,@@address=xiamen

单引号不支持#{}.
22 延迟插入字符串

有时我们需要延迟插入一些值到一个字符串，我们这时可以使用block：

str = proc {|x,y,z| "The numbers are #{x}, #{y}, and #{z}" }

puts s1 = str.call(3,4,5)   # The numbers are 3, 4, and 5
puts s2 = str.call(7,8,9)   # The numbers are 7, 8, and 9

还有一种更重量级的方法，那就是保存为单引号，然后用双引号包起来，再执行它。

str = '#{name} is my name, and #{nation} is my nation'
name, nation = "Stephen Dedalus", "Ireland"
puts s1  = eval('"' + str + '"')
# Stephen Dedalus is my name, and Ireland is my nation.

我们还可以使用另一种两个参数的eval方法：

bind = proc do
  name,nation = "Gulliver Foyle", "Terra"
  binding
end.call   # 返回block上下文的绑定
puts s2 = eval('"' + str + '"',bind)
# Gulliver Foyle is my name, and Terra is my nation.

23 解析逗号分隔的数据
逗号分隔的数据在我们平时的计算中非常常见，假设我们这边有一个混合着字符串和数字的数据，这个不就是ruby中的数组类型吗，所以我们只需要把这些数据构造转换为数组就可以了..

name="bobo"
address="xiamen"
age=24
string = "name,address,age"
puts data = eval("[" + string + "]")   # 转换为一个数组
data.each {|x| puts "Value = #{x}"}

24 转换字符串到数字

一般有两种方法转换一个字符串到数字，Kernel的方法Integer 和float，或者string的方法to_i和to_f

puts x = "123".to_i          # 123
puts y = Integer("123")      # 123
puts x = "junk".to_i         # 0
puts y = Integer("junk")     # 出错

#to_i方法转换字符串时如果遇到非数字的字符(包括空格)会立即停止转换，而integer会报错
puts x = "123junk123".to_i      # 123
puts y = Integer("123junk")  # error


#两个方法都会去除掉前置和后置空格
puts x = " 12 3 ".to_i        # 123
puts y = Integer(" 123 ")    # 123

#浮点数的转换是一样的
puts x = "3.1416".to_f      # 3.1416
puts y = Float("2.718")     # 2.718

#科学计数法的话，两个方法的结果略有不同
puts x = Float("6.02e23")   # 6.02e23
puts y = "2.9979246e5".to_f # 299792.46(这边会把科学计数法变为原始的数字)

to_i and Integer 表示不同进制时，得到的结果也略有不同。默认的话当然是十进制了，可是我们也可以工作在其他的进制下。

puts x = Integer("0b111")     # binary      - returns 7
puts y = Integer("0111")      # octal       - returns 73
puts z = Integer("0x111")     # hexadecimal - returns 273
#而to_i的话，就要加上参数，才能知道所要转换的字符串的进制:
puts x = "111".to_i(2)        # 7
puts y = "111".to_i(8)        # octal       - returns 73
puts z = "111".to_i(16)       # hexadecimal - returns 273

#这边还有要注意的，就是 比如你想把一个字符串转成8进制，可是你的字符串里包含大于8的字符，这样的话两个方法所得到的结果也不一样。

puts x = "12389".to_i(8)      # 123的八进制也就是83    (8 is ignored)
puts y = Integer("012389")    # 出错  (8 is illegal)

#尽管有很多限制，可是我们还可以使用其他进制的转换，比如5进制或者36进制
puts x = "123".to_i(5)        # 38(123的五进制表示)
puts y = "ruby".to_i(36)      # 1299022

#还可以使用scanf方法来对字符串进行转换,不过scanf方法不是core lib,所以我们必须require它(详细看这里：http://readlist.com/lists/ruby-lang.org/ruby-talk/17/88039.html)：

require 'scanf'
str = "234 234 234"
puts x, y, z = str.scanf("%d %o %x")    # 234, 156, 564

25 编码和解码rot13文本

rot13或许是最简单的加密算法，历史上它只是简单地用于防止人们意外地读取文本,这个编码只是简单的替换，如果调用第二次，它会把密文进行解码.

class String
  def rot13
    self.tr("A-Ma-mN-Zn-z","N-Zn-zA-Ma-m")
  end

end

joke = "Y2K bug"
puts joke13 = joke.rot13    # "L2X oht"
puts joke13.rot13  #Y2K bug

episode2 = "Fcbvyre: Naanxva qbrfa'g trg xvyyrq."
puts episode2.rot13

26 字符串加密

我们可以使用crypt 来进行加密，crypt 方法使用的加密算法是DES-encrypt ，它接受一个salt为参数然后与接受字符串进行加密。

coded = "ddg/KJyT4gPYc"

puts "Speak, friend, and enter!"

print "Password: "
password = gets.chop
if password.crypt("dd") == coded
  puts "Welcome!"
else
  puts "What are you, an orc?"
end

27压缩字符串
Zlib 库提供压缩和解压缩字符串和文件的方法.
为什么我们要压缩字符串呢，可能是使数据库io更快，或者优化网络，甚至含混的存储字符串以使他们更难被读取。

Deflate and Inflate 类有类方法叫做deflate and inflate，deflate 有一个扩展的参数说明了压缩的类型，这个类型权衡压缩的质量和速度，BEST_COMPRESSION 压缩的质量最好，可是速度比较慢，BEST_SPEED压缩的速度比较快，可是质量不那么好。默认的DEFAULT_COMPRESSION，是平衡这两点。

发下牢骚，windows下的ruby真是郁闷，总是缺者少那的，俺的ubuntu就没出过什么问题，这次又找不到zlib.dll了，真是郁闷,不过http://www.dll-files.com/dllindex/dll-files.shtml?zlib 这边可以下载。

不过下了个还是不能用，没办法，等晚上回家，我切到我的ubuntu下再试这段代码。

require 'zlib'
include Zlib

long_string = ("abcde"*71 + "defghi"*79 + "ghijkl"*113)*371
# long_string has 559097 characters

s1 = Deflate.deflate(long_string,BEST_SPEED)        # 4188 chars
puts s1.size
s2 = Deflate.deflate(long_string)                   # 3568 chars
puts s2.size
s3= Deflate.deflate(long_string,BEST_COMPRESSION)  # 2120 chars
puts s3.size

压缩的速度和压缩率都依赖于字符串的内容和机器的硬件.

28计算字符串中某个字符的个数

可以使用cunt方法：

s1 = "abracadabra"
puts a  = s1.count("c")      # 1
puts b  = s1.count("bdr")    # 5
#当字符前面有^符号时，代表非的意思。

puts c = s1.count("^a")      # 6
puts d = s1.count("^bdr")    # 6
#参数还可以是一个区间：
puts e = s1.count("a-d")     # 9
puts f = s1.count("^a-d")    # 2

29翻转一个字符串

我们可以简单的使用reverse 方法，来进行翻转.

puts s1 = "Star Trek"
puts s2 = s1.reverse         # "kerT ratS"
puts s1.reverse!             # s1 is now "kerT ratS"

如果你想将一个字符串按照单词进行反转，那么你就会用到split方法和，数组的reverse方法：

phrase = "Now here's a sentence"
puts phrase.split(" ").reverse.join(" ")
# "sentence a here's Now"

30移除重复的字符

我们可以使用squeeze 方法来一处重复的字符

s1 = "bookkeeper"
puts s2 = s1.squeeze         # "bokeper"
s3 = "Hello..."
puts s4 = s3.squeeze         # "Helo."
#If a parameter is specified, only those characters will be squeezed.
puts s5 = s3.squeeze(".")    # "Hello."

squeeze 方法的参数的使用是和上面的cunt的参数是一样的..