Ruby 字串（String）
Ruby 中的 String 對象用於存儲或操作一個或多個位元組的序列。
Ruby 字串分為單引號字串（'）和雙引號字串（"），區別在於雙引號字串能夠支持更多的轉義字元。
單引號字串
最簡單的字串是單引號字串，即在單引號記憶體放字串：
'這是一個 Ruby 程式的字串'
如果您需要在單引號字串內使用單引號字元，那麼需要在單引號字串使用反斜杠(\)，這樣 Ruby 解釋器就不會認為這個單引號字元是字串的終止符號：
'Won\'t you read O\'Reilly\'s book?'
反斜杠也能轉義另一個反斜杠，這樣第二個反斜杠本身不會解釋為轉義字元。
以下是 Ruby 中字串相關的特性。
雙引號字串
在雙引號字串中我們可以使用 #{} 井號和大括弧來計算運算式的值：
字串中嵌入變數：
實例
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
name1 = "Joe"
name2 = "Mary"
puts "你好 #{name1}, #{name2} 在哪?"
以上實例輸出運行輸出結果為：
你好 Joe, Mary 在哪?
字串中進行數學運算：
實例
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
x, y, z = 12, 36, 72
puts "x 的值為 #{ x }"
puts "x + y 的值為 #{ x + y }"
puts "x + y + z 的平均值為 #{ (x + y + z)/3 }"
以上實例輸出運行輸出結果為：
x 的值為 12 x + y 的值為 48 x + y + z 的平均值為 40
Ruby 中還支持一種採用 %q 和 %Q 來引導的字串變數，%q 使用的是單引號引用規則，而 %Q 是雙引號引用規則，後面再接一個 (! [ { 等等的開始界定符和與 } ] ) 等等的末尾界定符。
跟在 q 或 Q 後面的字元是分界符.分界符可以是任意一個非字母數字的單字節字元.如:[,{,(,<,!等,字串會一直讀取到發現相匹配的結束符為止.
實例
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
desc1 = %Q{Ruby 的字串可以使用 '' 和 ""。}
desc2 = %q|Ruby 的字串可以使用 '' 和 ""。|
puts desc1
puts desc2
以上實例輸出運行輸出結果為：
Ruby 的字串可以使用 '' 和 ""。 Ruby 的字串可以使用 '' 和 ""。
轉義字元
下標列出了可使用反斜杠符號轉義的轉義字元或非列印字元。
注意：在一個雙引號括起的字串內，轉義字元會被解析。在一個單引號括起的字串內，轉義字元不會被解析，原樣輸出。
| 反斜杠符號 | 十六進制字元 | 描述 |
|---|---|---|
| \a | 0x07 | 報警符 |
| \b | 0x08 | 退格鍵 |
| \cx | Control-x | |
| \C-x | Control-x | |
| \e | 0x1b | 轉義符 |
| \f | 0x0c | 換頁符 |
| \M-\C-x | Meta-Control-x | |
| \n | 0x0a | 換行符 |
| \nnn | 八進製錶示法，其中 n 的範圍為 0.7 | |
| \r | 0x0d | 回車符 |
| \s | 0x20 | 空白字元 |
| \t | 0x09 | 跳位字元 |
| \v | 0x0b | 垂直跳位字元 |
| \x | 字元 x | |
| \xnn | 十六進製錶示法，其中 n 的範圍為 0.9、 a.f 或 A.F |
字元編碼
Ruby 的默認字元集是 ASCII，字元可用單個位元組表示。如果您使用 UTF-8 或其他現代的字元集，字元可能是用一個到四個位元組表示。
您可以在程式開頭使用 $KCODE 改變字元集，如下所示：
$KCODE = 'u'
下麵是 $KCODE 可能的值。
| 編碼 | 描述 |
|---|---|
| a | ASCII （與 none 相同）。這是默認的。 |
| e | EUC。 |
| n | None （與 ASCII 相同）。 |
| u | UTF-8。 |
字串內建方法
我們需要有一個 String 對象的實例來調用 String 方法。下麵是創建 String 對象實例的方式：
new [String.new(str="")]
這將返回一個包含 str 副本的新的字串對象。現在，使用 str 對象，我們可以調用任意可用的實例方法。例如：
實例
#!/usr/bin/ruby
myStr = String.new("THIS IS TEST")
foo = myStr.downcase
puts "#{foo}"
這將產生以下結果：
this is test
下麵是公共的字串方法（假設 str 是一個 String 對象）：
| 序號 | 方法 & 描述 |
|---|---|
| 1 | str % arg 使用格式規範格式化字串。如果 arg 包含一個以上的替代，那麼 arg 必須是一個數組。如需瞭解更多格式規範的資訊，請查看"內核模組"下的 sprintf。 |
| 2 | str * integer 返回一個包含 integer 個 str 的新的字串。換句話說，str 被重複了 integer 次。 |
| 3 | str + other_str 連接 other_str 到 str。 |
| 4 | str << obj 連接一個對象到字串。如果對象是範圍為 0.255 之間的固定數字 Fixnum，則它會被轉換為一個字元。把它與 concat 進行比較。 |
| 5 | str <=> other_str 把 str 與 other_str 進行比較，返回 -1（小於）、0（等於）或 1（大於）。比較是區分大小寫的。 |
| 6 | str == obj 檢查 str 和 obj 的相等性。如果 obj 不是字串，則返回 false，如果 str <=> obj，則返回 true，返回 0。 |
| 7 | str =~ obj 根據正則運算式模式 obj 匹配 str。返回匹配開始的位置，否則返回 false。 |
| 8 | str[position] # 注意返回的是ASCII碼而不是字元 str[start, length] str[start..end] str[start...end] 使用索引截取子串 |
| 9 | str.capitalize 把字串轉換為大寫字母顯示。 |
| 10 | str.capitalize! 與 capitalize 相同，但是 str 會發生變化並返回。 |
| 11 | str.casecmp 不區分大小寫的字串比較。 |
| 12 | str.center 居中字串。 |
| 13 | str.chomp 從字串末尾移除記錄分隔符號（$/），通常是 \n。如果沒有記錄分隔符號，則不進行任何操作。 |
| 14 | str.chomp! 與 chomp 相同，但是 str 會發生變化並返回。 |
| 15 | str.chop 移除 str 中的最後一個字元。 |
| 16 | str.chop! 與 chop 相同，但是 str 會發生變化並返回。 |
| 17 | str.concat(other_str) 連接 other_str 到 str。 |
| 18 | str.count(str, ...) 給一個或多個字元集計數。如果有多個字元集，則給這些集合的交集計數。 |
| 19 | str.crypt(other_str) 對 str 應用單向加密哈希。參數是兩個字元長的字串，每個字元的範圍為 a.z、 A.Z、 0.9、 . 或 /。 |
| 20 | str.delete(other_str, ...) 返回 str 的副本，參數交集中的所有字元會被刪除。 |
| 21 | str.delete!(other_str, ...) 與 delete 相同，但是 str 會發生變化並返回。 |
| 22 | str.downcase 返回 str 的副本，所有的大寫字母會被替換為小寫字母。 |
| 23 | str.downcase! 與 downcase 相同，但是 str 會發生變化並返回。 |
| 24 | str.dump 返回 str 的版本，所有的非列印字元被替換為 \nnn 符號，所有的特殊字元被轉義。 |
| 25 | str.each(separator=$/) { |substr| block } 使用參數作為記錄分隔符號（默認是 $/）分隔 str，傳遞每個子字串給被提供的塊。 |
| 26 | str.each_byte { |fixnum| block } 傳遞 str 的每個位元組給 block，以位元組的十進位表示法返回每個位元組。 |
| 27 | str.each_line(separator=$/) { |substr| block } 使用參數作為記錄分隔符號（默認是 $/）分隔 str，傳遞每個子字串給被提供的 block。 |
| 28 | str.empty? 如果 str 為空（即長度為 0），則返回 true。 |
| 29 | str.eql?(other) 如果兩個字串有相同的長度和內容，則這兩個字串相等。 |
| 30 | str.gsub(pattern, replacement) [or] str.gsub(pattern) { |match| block } 返回 str 的副本，pattern 的所有出現都替換為 replacement 或 block 的值。pattern 通常是一個正則運算式 Regexp；如果是一個字串 String，則沒有正則運算式元字元被解釋（即，/\d/ 將匹配一個數字，但 '\d' 將匹配一個反斜杠後跟一個 'd'）。 |
| 31 | str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str] 使用下列的參數引用 str：參數為一個 Fixnum，則返回 fixnum 的字元編碼；參數為兩個 Fixnum，則返回一個從偏移（第一個 fixnum）開始截至到長度（第二個 fixnum）為止的子字串；參數為 range，則返回該範圍內的一個子字串；參數為 regexp，則返回匹配字串的部分；參數為帶有 fixnum 的 regexp，則返回 fixnum 位置的匹配數據；參數為 other_str，則返回匹配 other_str 的子字串。一個負數的 Fixnum 從字串的末尾 -1 開始。 |
| 32 | str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or]
str[regexp] =new_str [or] str[regexp, fixnum] =new_str [or] str[other_str] = new_str ] 替換整個字串或部分字串。與 slice! 同義。 |
| 33 | str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match| block } 執行 String#gsub 的替換，返回 str，如果沒有替換被執行則返回 nil。 |
| 34 | str.hash 返回一個基於字串長度和內容的哈希。 |
| 35 | str.hex 把 str 的前導字元當作十六進制數字的字串（一個可選的符號和一個可選的 0x），並返回相對應的數字。如果錯誤則返回零。 |
| 36 | str.include? other_str [or] str.include? fixnum 如果 str 包含給定的字串或字元，則返回 true。 |
| 37 | str.index(substring [, offset]) [or] str.index(fixnum [, offset]) [or] str.index(regexp [, offset]) 返回給定子字串、字元（fixnum）或模式（regexp）在 str 中第一次出現的索引。如果未找到則返回 nil。如果提供了第二個參數，則指定在字串中開始搜索的位置。 |
| 38 | str.insert(index, other_str) 在給定索引的字元前插入 other_str，修改 str。負值索引從字串的末尾開始計數，並在給定字元後插入。其意圖是在給定的索引處開始插入一個字串。 |
| 39 | str.inspect 返回 str 的可列印版本，帶有轉義的特殊字元。 |
| 40 | str.intern [or] str.to_sym 返回與 str 相對應的符號，如果之前不存在，則創建符號。 |
| 41 | str.length 返回 str 的長度。把它與 size 進行比較。 |
| 42 | str.ljust(integer, padstr=' ') 如果 integer 大於 str 的長度，則返回長度為 integer 的新字串，新字串以 str 左對齊，並以 padstr 作為填充。否則，返回 str。 |
| 43 | str.lstrip 返回 str 的副本，移除了前導的空格。 |
| 44 | str.lstrip! 從 str 中移除前導的空格，如果沒有變化則返回 nil。 |
| 45 | str.match(pattern) 如果 pattern 不是正則運算式，則把 pattern 轉換為正則運算式 Regexp，然後在 str 上調用它的匹配方法。 |
| 46 | str.oct 把 str 的前導字元當作十進位數字的字串（一個可選的符號），並返回相對應的數字。如果轉換失敗，則返回 0。 |
| 47 | str.replace(other_str) 把 str 中的內容替換為 other_str 中的相對應的值。 |
| 48 | str.reverse 返回一個新字串，新字串是 str 的倒序。 |
| 49 | str.reverse! 逆轉 str，str 會發生變化並返回。 |
| 50 | str.rindex(substring [, fixnum]) [or] str.rindex(fixnum [, fixnum]) [or] str.rindex(regexp [, fixnum]) 返回給定子字串、字元（fixnum）或模式（regexp）在 str 中最後一次出現的索引。如果未找到則返回 nil。如果提供了第二個參數，則指定在字串中結束搜索的位置。超出該點的字元將不被考慮。 |
| 51 | str.rjust(integer, padstr=' ') 如果 integer 大於 str 的長度，則返回長度為 integer 的新字串，新字串以 str 右對齊，並以 padstr 作為填充。否則，返回 str。 |
| 52 | str.rstrip 返回 str 的副本，移除了尾隨的空格。 |
| 53 | str.rstrip! 從 str 中移除尾隨的空格，如果沒有變化則返回 nil。 |
| 54 | str.scan(pattern) [or] str.scan(pattern) { |match, ...| block } 兩種形式匹配 pattern（可以是一個正則運算式 Regexp 或一個字串 String）遍曆 str。針對每個匹配，會生成一個結果，結果會添加到結果數組中或傳遞給 block。如果 pattern 不包含分組，則每個獨立的結果由匹配的字串、$& 組成。如果 pattern 包含分組，每個獨立的結果是一個包含每個分組入口的數組。 |
| 55 | str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or] str.slice(range) [or] str.slice(regexp) [or] str.slice(regexp, fixnum) [or] str.slice(other_str) See str[fixnum], etc. str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str) 從 str 中刪除指定的部分，並返回刪除的部分。如果值超出範圍，參數帶有 Fixnum 的形式，將生成一個 IndexError。參數為 range 的形式，將生成一個 RangeError，參數為 Regexp 和 String 的形式，將忽略執行動作。 |
| 56 | str.split(pattern=$;, [limit]) 基於分隔符號，把 str 分成子字串，並返回這些子字串的數組。 如果 pattern 是一個字串 String，那麼在分割 str 時，它將作為分隔符號使用。如果 pattern 是一個單一的空格，那麼 str 是基於空格進行分割，會忽略前導空格和連續空格字元。 如果 pattern 是一個正則運算式 Regexp，則 str 在 pattern 匹配的地方被分割。當 pattern 匹配一個零長度的字串時，str 被分割成單個字元。 如果省略了 pattern 參數，則使用 $; 的值。如果 $; 為 nil（默認的），str 基於空格進行分割，就像是指定了 ` ` 作為分隔符號一樣。 如果省略了 limit 參數，會抑制尾隨的 null 字段。如果 limit 是一個正數，則最多返回該數量的字段（如果 limit 為 1，則返回整個字串作為數組中的唯一入口）。如果 limit 是一個負數，則返回的字段數量不限制，且不抑制尾隨的 null 字段。 |
| 57 | str.squeeze([other_str]*) 使用為 String#count 描述的程式從 other_str 參數建立一系列字元。返回一個新的字串，其中集合中出現的相同的字元會被替換為單個字元。如果沒有給出參數，則所有相同的字元都被替換為單個字元。 |
| 58 | str.squeeze!([other_str]*) 與 squeeze 相同，但是 str 會發生變化並返回，如果沒有變化則返回 nil。 |
| 59 | str.strip 返回 str 的副本，移除了前導的空格和尾隨的空格。 |
| 60 | str.strip! 從 str 中移除前導的空格和尾隨的空格，如果沒有變化則返回 nil。 |
| 61 | str.sub(pattern, replacement) [or] str.sub(pattern) { |match| block } 返回 str 的副本，pattern 的第一次出現會被替換為 replacement 或 block 的值。pattern 通常是一個正則運算式 Regexp；如果是一個字串 String，則沒有正則運算式元字元被解釋。 |
| 62 | str.sub!(pattern, replacement) [or] str.sub!(pattern) { |match| block } 執行 String#sub 替換，並返回 str，如果沒有替換執行，則返回 nil。 |
| 63 | str.succ [or] str.next 返回 str 的繼承。 |
| 64 | str.succ! [or] str.next! 相當於 String#succ，但是 str 會發生變化並返回。 |
| 65 | str.sum(n=16) 返回 str 中字元的 n-bit 校驗和，其中 n 是可選的 Fixnum 參數，默認為 16。結果是簡單地把 str 中每個字元的二進位值的總和，以 2n - 1 為模。這不是一個特別好的校驗和。 |
| 66 | str.swapcase 返回 str 的副本，所有的大寫字母轉換為小寫字母，所有的小寫字母轉換為大寫字母。 |
| 67 | str.swapcase! 相當於 String#swapcase，但是 str 會發生變化並返回，如果沒有變化則返回 nil。 |
| 68 | str.to_f 返回把 str 中的前導字元解釋為浮點數的結果。超出有效數字的末尾的多餘字元會被忽略。如果在 str 的開頭沒有有效數字，則返回 0.0。該方法不會生成異常。 |
| 69 | str.to_i(base=10) 返回把 str 中的前導字元解釋為整數基數（基數為 2、 8、 10 或 16）的結果。超出有效數字的末尾的多餘字元會被忽略。如果在 str 的開頭沒有有效數字，則返回 0。該方法不會生成異常。 |
| 70 | str.to_s [or] str.to_str 返回接收的值。 |
| 71 | str.tr(from_str, to_str) 返回 str 的副本，把 from_str 中的字元替換為 to_str 中相對應的字元。如果 to_str 比 from_str 短，那麼它會以最後一個字元進行填充。兩個字串都可以使用 c1.c2 符號表示字元的範圍。如果 from_str 以 ^ 開頭，則表示除了所列出的字元以外的所有字元。 |
| 72 | str.tr!(from_str, to_str) 相當於 String#tr，但是 str 會發生變化並返回，如果沒有變化則返回 nil。 |
| 73 | str.tr_s(from_str, to_str) 把 str 按照 String#tr 描述的規則進行處理，然後移除會影響翻譯的重複字元。 |
| 74 | str.tr_s!(from_str, to_str) 相當於 String#tr_s，但是 str 會發生變化並返回，如果沒有變化則返回 nil。 |
| 75 | str.unpack(format) 根據 format 字串解碼 str（可能包含二進位數據），返回被提取的每個值的數組。format 字元由一系列單字符指令組成。每個指令後可以跟著一個數字，表示重複該指令的次數。星號（*）將使用所有剩餘的元素。指令 sSiIlL 每個後可能都跟著一個下劃線（_），為指定類型使用底層平臺的本地尺寸大小，否則使用獨立於平臺的一致的尺寸大小。format 字串中的空格會被忽略。 |
| 76 | str.upcase 返回 str 的副本，所有的小寫字母會被替換為大寫字母。操作是環境不敏感的，只有字元 a 到 z 會受影響。 |
| 77 | str.upcase! 改變 str 的內容為大寫，如果沒有變化則返回 nil。 |
| 78 | str.upto(other_str) { |s| block } 遍曆連續值，以 str 開始，以 other_str 結束（包含），輪流傳遞每個值給 block。String#succ 方法用於生成每個值。 |
字串 unpack 指令
下表列出了方法 String#unpack 的解壓指令。
| 指令 | 返回 | 描述 |
|---|---|---|
| A | String | 移除尾隨的 null 和空格。 |
| a | String | 字串。 |
| B | String | 從每個字元中提取位（首先是最高有效位）。 |
| b | String | 從每個字元中提取位（首先是最低有效位）。 |
| C | Fixnum | 提取一個字元作為無符號整數。 |
| c | Fixnum | 提取一個字元作為整數。 |
| D, d | Float | 把 sizeof(double) 長度的字元當作原生的 double。 |
| E | Float | 把 sizeof(double) 長度的字元當作 littleendian 位元組順序的 double。 |
| e | Float | 把 sizeof(float) 長度的字元當作 littleendian 位元組順序的 float。 |
| F, f | Float | 把 sizeof(float) 長度的字元當作原生的 float。 |
| G | Float | 把 sizeof(double) 長度的字元當作 network 位元組順序的 double。 |
| g | Float | 把 sizeof(float) 長度的字元當作 network 位元組順序的 float。 |
| H | String | 從每個字元中提取十六進制（首先是最高有效位）。 |
| h | String | 從每個字元中提取十六進制（首先是最低有效位）。 |
| I | Integer | 把 sizeof(int) 長度（通過 _ 修改）的連續字元當作原生的 integer。 |
| i | Integer | 把 sizeof(int) 長度（通過 _ 修改）的連續字元當作有符號的原生的 integer。 |
| L | Integer | 把四個（通過 _ 修改）連續字元當作無符號的原生的 long integer。 |
| l | Integer | 把四個（通過 _ 修改）連續字元當作有符號的原生的 long integer。 |
| M | String | 引用可列印的。 |
| m | String | Base64 編碼。 |
| N | Integer | 把四個字元當作 network 位元組順序的無符號的 long。 |
| n | Fixnum | 把兩個字元當作 network 位元組順序的無符號的 short。 |
| P | String | 把 sizeof(char *) 長度的字元當作指針，並從引用的位置返回 \emph{len} 字元。 |
| p | String | 把 sizeof(char *) 長度的字元當作一個空結束字元的指針。 |
| Q | Integer | 把八個字元當作無符號的 quad word（64 位）。 |
| q | Integer | 把八個字元當作有符號的 quad word（64 位）。 |
| S | Fixnum | 把兩個（如果使用 _ 則不同）連續字元當作 native 位元組順序的無符號的 short。 |
| s | Fixnum | 把兩個（如果使用 _ 則不同）連續字元當作 native 位元組順序的有符號的 short。 |
| U | Integer | UTF-8 字元，作為無符號整數。 |
| u | String | UU 編碼。 |
| V | Fixnum | 把四個字元當作 little-endian 位元組順序的無符號的 long。 |
| v | Fixnum | 把兩個字元當作 little-endian 位元組順序的無符號的 short。 |
| w | Integer | BER 壓縮的整數。 |
| X | 向後跳過一個字元。 | |
| x | 向前跳過一個字元。 | |
| Z | String | 和 * 一起使用，移除尾隨的 null 直到第一個 null。 |
| @ | 跳過 length 參數給定的偏移量。 |
實例
嘗試下麵的實例，解壓各種數據。
"abc \0\0abc \0\0".unpack('A6Z6') #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*') #=> ["abc ", "abc "]
"aa".unpack('b8B8') #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c') #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') #=> [-2, 65534]
"now=20is".unpack('M*') #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a') #=> ["h", "e", "l", "l", "o"]