Alex学Ruby[最重要的数据类型‘字符串’]

1.   我最早学的语言是大一学的C语言，现在忘的差不多了

，但我还记得C语言里的字符串是以空字符结束的，但 Ruby不是，所以， Ruby的字符串里可以包含空字符。

2.   Ruby里的字符串分为两种，其中最简单的一种是用单引号括起的字符串，表示的完全是字面意义，唯一支持的转义序列是 单引号和反斜杠
      >> str = 'i m \'ok\', a u ok\? \\xie \\'
      => "i m 'ok', a u ok\\? \\xie \\"
      >> str = 'i m \'ok\', a u ok\? \\xie \''
      => "i m 'ok', a u ok\\? \\xie '"
      另外一种就是双引号括起来的字符串，常用的。

3.   我们也可以用其他方法表示字符串，%q和%Q,  后面只需要把字符串包含到一对分隔符之间就行了，你可以用中括号，小括号，大括号。up to u
      >> str = %q[\?xxx]
      => "\\?xxx"
      >> str = %Q[\?xxx]
      => "?xxx"
      >> str = %Q(\?xxx)
      => "?xxx"
      同样，你也可以使用非成对分隔符来表示（字母数字空格除外）：
      >> str = %Q* \? yyy \? *
      => "? yyy ?"
      由此可见，小q代表单引号，大q代表双引号。 一般这种字符串写法是有那种需要包含大量元字符的需求下要使用。

4.    我们需要把字符串多行表示，但又不想把缩进也作为字符串的一部分，那么就可以用here文档。 关于here文档，我之前只知道其形式：
       语法符号<<后面加一对开始结束标记，标记之间放你想要的内容即可。
       str = <<EOF
                i m ok
                a u ok?
       EOF
       但是，今天，我知道了其需要注意的几个地方；
        1） 结束标记末尾不能有空格。
           >> str = <<EOF
                           sdfsd
                       EOF          ＃这行结束标记前后都有空格，所以 ruby不识别
           EOF
           => "sdfsd\n  EOF\n"
         2)  但是你可以消除结束标记前面的空格，只需要要用<<- 语法符合：
            >> str = <<-EOF
                        sfdsf
                          EOF      ＃前面有空格，后面没有空格， ruby可以识别，但是后面有空格就不行了。
            => "sfdsf\n"

         2)   默认的here文档相当于双引号字符串。但是你可以改变其为单引号模式：
            >> str = <<'EOF'
                       \? xx
            EOF
            => "  \\? xx\n"

5.   读取文件的时候，可以将读取出来的文件存储到字符串里，字符串里就包含了换行符，默认的each方法是按行处理的：
      >> str = "tell you a  truth \nlong time ago...\nThe end"
      => "tell you a  truth \nlong time ago...\nThe end"
      >> num = 0
      => 0
      >> str.each do |s|
     ?>      num += 1
     ?>      print "LINE #{num} : #{s}"
      >> end
      LINE 1 : #LINE 1 : tell you a  truth
      LINE 2 : #LINE 2 : long time ago...
      LINE 3 : #LINE 3 : The end

6.   字符串转成字符数组：
      >> str = "ABC"
      => "ABC"
      >> chars = str.scan(/./)
      => ["A", "B", "C"]


7.  一般的字符串之间比较通常是比较首字母ASCII码值的大小：
    >> ?s         => 115
    >> ?u         => 117
    >> str1 = "sbu"
    => "sbu"
   >> str2 = "usb"
   => "usb"
   >> str1 < str2
   => true
   >> str1 > str2
   => false
   但我们如果想忽略字符串首字母来比较呢？ 我们可以重写ufo比较符（<=>）:
   class String
       alias old_compare <=>
       def <=>(other)
           a = self.dup
           b = other.dup
           a.gsub!(/^./i,"")
           b.gsub!(/^./i,"")
           a.strip!
           b.strip!
           a.old_compare(b)
       end
   end

   >> s1 = "ss"            => "ss"
   >> s2 = "ub"           => "ub"
   >> s1 < s2              => false
   >> ?s                       => 115
   >> ?u                       => 117
   >> ?b                       => 98

   注意的是，＝＝运算符并不会调用<=>方法，如果我们要自定义的方式来判断字符是否相等，需要我们重写== 方法。

8.  有时候我们需要分解字符串：
    >> str = "foo, bar, foobar, , "               => "foo, bar, foobar, , "
    >> l1 = str.split                                     => ["foo,", "bar,", "foobar,", ","]
    >> l1 = str.split(",")                               => ["foo", " bar", " foobar", " ", " "]
    >> l1 = str.split(",",2)                            => ["foo", " bar, foobar, , "]
   >> l1 = str.split(",",4)                             => ["foo", " bar", " foobar", " , "]
   >> l1 = str.split(",",6)                             => ["foo", " bar", " foobar", " ", " "]
   >> l1 = str.split(",",8)                             => ["foo", " bar", " foobar", " ", " "]
   >> l1 = str.split(",",10)                           => ["foo", " bar", " foobar", " ", " "]
   >> l1 = str.split(",",-1)                            => ["foo", " bar", " foobar", " ", " "]
   >> l1 = str.split(",",-2)                            => ["foo", " bar", " foobar", " ", " "]

9. >> str = "a A b C d D xx"   => "a A b C d D xx"
   >> str.downcase                 => "a a b c d d xx"
   >> str.upcase                      => "A A B C D D XX"
   >> str.capitalize                  => "A a b c d d xx"
   >> str.swapcase                 => "A a B c D d XX"

   casecmp方法和<=>类似，但是忽略大小写：
     >> "AAA".casecmp("aaa")           => 0

10.  to_s 和 to_str有什么区别：
     原则上任何对象都可以转换为某种字符串表示，这也是几乎每个核心类都有to_s方法的原因。这是一种强制转换，但几乎核心类都没有实现to_str方法。to_str被认为是一种隐式转换, 隐式转换的结果应为对象的真正字符串值。 puts方法调用对象的to_s方法以获取其字符串表示，这属于对显示转换的隐式调用。
      class Haha
         def to_s
             "ha"
         end

         def to_str
              "haha"
         end
      end

      h = Haha.new
      puts h
      >>        puts "H is " + h
              H is haha
      >>        puts  "H is " << h
              H is haha
      >>        puts  "H is #{h}"
              H is ha

     假如我们有个方法，需要接受一个字符串为参数，但是如果传个非字符串进来会出问题的，我们如何解决这个问题？
      1. 可以显示的调用to_s方法把参数转成字符串表示，或者检查是否为String类型，也可以只管往下执行，但是肯定会报错。
       2.我们可以这么做：  param = param.to_str rescure param.to_s rescure param

11. #{} 对于全局变量，类变量和实例变量可以省略大括号。

12.  其他的一些String自带的操作字符串方法。。。