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} 在哪?"

以上執行個體輸出運作輸出結果為：

字元串中進行數學運算：

x, y, z = 12, 36, 72

puts "x 的值為 #{ x }"

puts "x + y 的值為 #{ x + y }"

puts "x + y + z 的平均值為 #{ (x + y + z)/3 }"

Ruby 中還支援一種采用 %q 和 %Q 來引導的字元串變量，%q 使用的是單引号引用規則，而 %Q 是雙引号引用規則，後面再接一個 (! [ { 等等的開始界定符和與 } ] ) 等等的末尾界定符。

跟在 q 或 Q 後面的字元是分界符.分界符可以是任意一個非字母數字的單位元組字元.如:[,{,(,<,!等,字元串會一直讀取到發現相比對的結束符為止.

desc1 = %Q{Ruby 的字元串可以使用 '' 和 ""。}

desc2 = %q|Ruby 的字元串可以使用 '' 和 ""。|

puts desc1

puts desc2

下标列出了可使用反斜杠符号轉義的轉義字元或非列印字元。

注意：在一個雙引号括起的字元串内，轉義字元會被解析。在一個單引号括起的字元串内，轉義字元不會被解析，原樣輸出。

反斜杠符号

十六進制字元

描述

0x07

報警符

0x08

倒退鍵

\cx

Control-x

\C-x

0x1b

轉義符

0x0c

換頁符

\M-\C-x

Meta-Control-x

0x0a

換行符

\nnn

八進制表示法，其中 n 的範圍為 0.7

0x0d

回車符

0x20

空格符

0x09

制表符

0x0b

垂直制表符

字元 x

\xnn

十六進制表示法，其中 n 的範圍為 0.9、 a.f 或 A.F

Ruby 的預設字元集是 ASCII，字元可用單個位元組表示。如果您使用 UTF-8 或其他現代的字元集，字元可能是用一個到四個位元組表示。

您可以在程式開頭使用 $KCODE 改變字元集，如下所示：

下面是 $KCODE 可能的值。

編碼

ASCII （與 none 相同）。這是預設的。

EUC。

None （與 ASCII 相同）。

UTF-8。

我們需要有一個 String 對象的執行個體來調用 String 方法。下面是建立 String 對象執行個體的方式：

new [String.new(str="")]

這将傳回一個包含 str 副本的新的字元串對象。現在，使用 str 對象，我們可以調用任意可用的執行個體方法。例如：

myStr = String.new("THIS IS TEST")

foo = myStr.downcase

puts "#{foo}"

這将産生以下結果：

下面是公共的字元串方法（假設 str 是一個 String 對象）：

序号

方法 & 描述

str % arg

使用格式規範格式化字元串。如果 arg 包含一個以上的替代，那麼 arg 必須是一個數組。如需了解更多格式規範的資訊，請檢視"核心子產品"下的 sprintf。

str * integer

傳回一個包含 integer 個 str 的新的字元串。換句話說，str 被重複了 integer 次。

str + other_str

連接配接 other_str 到 str。

str << obj

連接配接一個對象到字元串。如果對象是範圍為 0.255 之間的固定數字 Fixnum，則它會被轉換為一個字元。把它與 concat 進行比較。

str <=> other_str

把 str 與 other_str 進行比較，傳回 -1（小于）、0（等于）或 1（大于）。比較是區分大小寫的。

str == obj

檢查 str 和 obj 的相等性。如果 obj 不是字元串，則傳回 false，如果 str <=> obj，則傳回 true，傳回 0。

str =~ obj

根據正規表達式模式 obj 比對 str。傳回比對開始的位置，否則傳回 false。

str[position] # 注意傳回的是ASCII碼而不是字元

str[start, length]

str[start..end]

str[start...end]

使用索引截取子串

str.capitalize

把字元串轉換為大寫字母顯示。

str.capitalize!

與 capitalize 相同，但是 str 會發生變化并傳回。

str.casecmp

不區分大小寫的字元串比較。

str.center

居中字元串。

str.chomp

從字元串末尾移除記錄分隔符（$/），通常是 \n。如果沒有記錄分隔符，則不進行任何操作。

str.chomp!

與 chomp 相同，但是 str 會發生變化并傳回。

str.chop

移除 str 中的最後一個字元。

str.chop!

與 chop 相同，但是 str 會發生變化并傳回。

str.concat(other_str)

str.count(str, ...)

給一個或多個字元集計數。如果有多個字元集，則給這些集合的交集計數。

str.crypt(other_str)

對 str 應用單向加密哈希。參數是兩個字元長的字元串，每個字元的範圍為 a.z、 A.Z、 0.9、 . 或 /。

str.delete(other_str, ...)

傳回 str 的副本，參數交集中的所有字元會被删除。

str.delete!(other_str, ...)

與 delete 相同，但是 str 會發生變化并傳回。

str.downcase

傳回 str 的副本，所有的大寫字母會被替換為小寫字母。

str.downcase!

與 downcase 相同，但是 str 會發生變化并傳回。

str.dump

傳回 str 的版本，所有的非列印字元被替換為 \nnn 符号，所有的特殊字元被轉義。

str.each(separator=$/) { |substr| block }

使用參數作為記錄分隔符（預設是 $/）分隔 str，傳遞每個子字元串給被提供的塊。

str.each_byte { |fixnum| block }

傳遞 str 的每個位元組給 block，以位元組的十進制表示法傳回每個位元組。

str.each_line(separator=$/) { |substr| block }

使用參數作為記錄分隔符（預設是 $/）分隔 str，傳遞每個子字元串給被提供的 block。

str.empty?

如果 str 為空（即長度為 0），則傳回 true。

str.eql?(other)

如果兩個字元串有相同的長度和内容，則這兩個字元串相等。

str.gsub(pattern, replacement) [or]

str.gsub(pattern) { |match| block }

傳回 str 的副本，pattern 的所有出現都替換為 replacement 或 block 的值。pattern 通常是一個正規表達式 Regexp；如果是一個字元串 String，則沒有正規表達式元字元被解釋（即，/\d/ 将比對一個數字，但 '\d' 将比對一個反斜杠後跟一個 'd'）。

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 開始。

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! 同義。

str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match| block }

執行 String#gsub 的替換，傳回 str，如果沒有替換被執行則傳回 nil。

str.hash

傳回一個基于字元串長度和内容的哈希。

str.hex

把 str 的前導字元當作十六進制數字的字元串（一個可選的符号和一個可選的 0x），并傳回相對應的數字。如果錯誤則傳回零。

str.include? other_str [or] str.include? fixnum

如果 str 包含給定的字元串或字元，則傳回 true。

str.index(substring [, offset]) [or]

str.index(fixnum [, offset]) [or]

str.index(regexp [, offset])

傳回給定子字元串、字元（fixnum）或模式（regexp）在 str 中第一次出現的索引。如果未找到則傳回 nil。如果提供了第二個參數，則指定在字元串中開始搜尋的位置。

str.insert(index, other_str)

在給定索引的字元前插入 other_str，修改 str。負值索引從字元串的末尾開始計數，并在給定字元後插入。其意圖是在給定的索引處開始插入一個字元串。

str.inspect

傳回 str 的可列印版本，帶有轉義的特殊字元。

str.intern [or] str.to_sym

傳回與 str 相對應的符号，如果之前不存在，則建立符号。

str.length

傳回 str 的長度。把它與 size 進行比較。

str.ljust(integer, padstr=' ')

如果 integer 大于 str 的長度，則傳回長度為 integer 的新字元串，新字元串以 str 左對齊，并以 padstr 作為填充。否則，傳回 str。

str.lstrip

傳回 str 的副本，移除了前導的空格。

str.lstrip!

從 str 中移除前導的空格，如果沒有變化則傳回 nil。

str.match(pattern)

如果 pattern 不是正規表達式，則把 pattern 轉換為正規表達式 Regexp，然後在 str 上調用它的比對方法。

str.oct

把 str 的前導字元當作十進制數字的字元串（一個可選的符号），并傳回相對應的數字。如果轉換失敗，則傳回 0。

str.replace(other_str)

把 str 中的内容替換為 other_str 中的相對應的值。

str.reverse

傳回一個新字元串，新字元串是 str 的倒序。

str.reverse!

逆轉 str，str 會發生變化并傳回。

str.rindex(substring [, fixnum]) [or]

str.rindex(fixnum [, fixnum]) [or]

str.rindex(regexp [, fixnum])

傳回給定子字元串、字元（fixnum）或模式（regexp）在 str 中最後一次出現的索引。如果未找到則傳回 nil。如果提供了第二個參數，則指定在字元串中結束搜尋的位置。超出該點的字元将不被考慮。

str.rjust(integer, padstr=' ')

如果 integer 大于 str 的長度，則傳回長度為 integer 的新字元串，新字元串以 str 右對齊，并以 padstr 作為填充。否則，傳回 str。

str.rstrip

傳回 str 的副本，移除了尾随的空格。

str.rstrip!

從 str 中移除尾随的空格，如果沒有變化則傳回 nil。

str.scan(pattern) [or]

str.scan(pattern) { |match, ...| block }

兩種形式比對 pattern（可以是一個正規表達式 Regexp 或一個字元串 String）周遊 str。針對每個比對，會生成一個結果，結果會添加到結果數組中或傳遞給 block。如果 pattern 不包含分組，則每個獨立的結果由比對的字元串、$& 組成。如果 pattern 包含分組，每個獨立的結果是一個包含每個分組入口的數組。

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 的形式，将忽略執行動作。

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 字段。

str.squeeze([other_str]*)

使用為 String#count 描述的程式從 other_str 參數建立一系列字元。傳回一個新的字元串，其中集合中出現的相同的字元會被替換為單個字元。如果沒有給出參數，則所有相同的字元都被替換為單個字元。

str.squeeze!([other_str]*)

與 squeeze 相同，但是 str 會發生變化并傳回，如果沒有變化則傳回 nil。

str.strip

傳回 str 的副本，移除了前導的空格和尾随的空格。

str.strip!

從 str 中移除前導的空格和尾随的空格，如果沒有變化則傳回 nil。

str.sub(pattern, replacement) [or]

str.sub(pattern) { |match| block }

傳回 str 的副本，pattern 的第一次出現會被替換為 replacement 或 block 的值。pattern 通常是一個正規表達式 Regexp；如果是一個字元串 String，則沒有正規表達式元字元被解釋。

str.sub!(pattern, replacement) [or]

str.sub!(pattern) { |match| block }

執行 String#sub 替換，并傳回 str，如果沒有替換執行，則傳回 nil。

str.succ [or] str.next

傳回 str 的繼承。

str.succ! [or] str.next!

相當于 String#succ，但是 str 會發生變化并傳回。

str.sum(n=16)

傳回 str 中字元的 n-bit 校驗和，其中 n 是可選的 Fixnum 參數，預設為 16。結果是簡單地把 str 中每個字元的二進制值的總和，以 2n - 1 為模。這不是一個特别好的校驗和。

str.swapcase

傳回 str 的副本，所有的大寫字母轉換為小寫字母，所有的小寫字母轉換為大寫字母。

str.swapcase!

相當于 String#swapcase，但是 str 會發生變化并傳回，如果沒有變化則傳回 nil。

str.to_f

傳回把 str 中的前導字元解釋為浮點數的結果。超出有效數字的末尾的多餘字元會被忽略。如果在 str 的開頭沒有有效數字，則傳回 0.0。該方法不會生成異常。

str.to_i(base=10)

傳回把 str 中的前導字元解釋為整數基數（基數為 2、 8、 10 或 16）的結果。超出有效數字的末尾的多餘字元會被忽略。如果在 str 的開頭沒有有效數字，則傳回 0。該方法不會生成異常。

str.to_s [or] str.to_str

傳回接收的值。

str.tr(from_str, to_str)

傳回 str 的副本，把 from_str 中的字元替換為 to_str 中相對應的字元。如果 to_str 比 from_str 短，那麼它會以最後一個字元進行填充。兩個字元串都可以使用 c1.c2 符号表示字元的範圍。如果 from_str 以 ^ 開頭，則表示除了所列出的字元以外的所有字元。

str.tr!(from_str, to_str)

相當于 String#tr，但是 str 會發生變化并傳回，如果沒有變化則傳回 nil。

str.tr_s(from_str, to_str)

把 str 按照 String#tr 描述的規則進行處理，然後移除會影響翻譯的重複字元。

str.tr_s!(from_str, to_str)

相當于 String#tr_s，但是 str 會發生變化并傳回，如果沒有變化則傳回 nil。

str.unpack(format)

根據 format 字元串解碼 str（可能包含二進制資料），傳回被提取的每個值的數組。format 字元由一系列單字元指令組成。每個指令後可以跟着一個數字，表示重複該指令的次數。星号（*）将使用所有剩餘的元素。指令 sSiIlL 每個後可能都跟着一個下劃線（_），為指定類型使用底層平台的本地尺寸大小，否則使用獨立于平台的一緻的尺寸大小。format 字元串中的空格會被忽略。

str.upcase

傳回 str 的副本，所有的小寫字母會被替換為大寫字母。操作是環境不敏感的，隻有字元 a 到 z 會受影響。

str.upcase!

改變 str 的内容為大寫，如果沒有變化則傳回 nil。

str.upto(other_str) { |s| block }

周遊連續值，以 str 開始，以 other_str 結束（包含），輪流傳遞每個值給 block。String#succ 方法用于生成每個值。

下表列出了方法 String#unpack 的解壓指令。

指令

傳回

String

移除尾随的 null 和空格。

字元串。

從每個字元中提取位（首先是最高有效位）。

從每個字元中提取位（首先是最低有效位）。

Fixnum

提取一個字元作為無符号整數。

提取一個字元作為整數。

D, d

Float

把 sizeof(double) 長度的字元當作原生的 double。

把 sizeof(double) 長度的字元當作 littleendian 位元組順序的 double。

把 sizeof(float) 長度的字元當作 littleendian 位元組順序的 float。

F, f

把 sizeof(float) 長度的字元當作原生的 float。

把 sizeof(double) 長度的字元當作 network 位元組順序的 double。

把 sizeof(float) 長度的字元當作 network 位元組順序的 float。

從每個字元中提取十六進制（首先是最高有效位）。

從每個字元中提取十六進制（首先是最低有效位）。

Integer

把 sizeof(int) 長度（通過 _ 修改）的連續字元當作原生的 integer。

把 sizeof(int) 長度（通過 _ 修改）的連續字元當作有符号的原生的 integer。

把四個（通過 _ 修改）連續字元當作無符号的原生的 long integer。

把四個（通過 _ 修改）連續字元當作有符号的原生的 long integer。

引用可列印的。

Base64 編碼。

把四個字元當作 network 位元組順序的無符号的 long。

把兩個字元當作 network 位元組順序的無符号的 short。

把 sizeof(char *) 長度的字元當作指針，并從引用的位置傳回 \emph{len} 字元。

把 sizeof(char *) 長度的字元當作一個空結束字元的指針。

把八個字元當作無符号的 quad word（64 位）。

把八個字元當作有符号的 quad word（64 位）。

把兩個（如果使用 _ 則不同）連續字元當作 native 位元組順序的無符号的 short。

把兩個（如果使用 _ 則不同）連續字元當作 native 位元組順序的有符号的 short。

UTF-8 字元，作為無符号整數。

UU 編碼。

把四個字元當作 little-endian 位元組順序的無符号的 long。

把兩個字元當作 little-endian 位元組順序的無符号的 short。

BER 壓縮的整數。

向後跳過一個字元。

向前跳過一個字元。

和 * 一起使用，移除尾随的 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"]