lua string 庫函數

Lua 最強大的特性之一就是它的字符串處理能力，它支持字符格式化輸出，具有可擴展的模式匹配查找功能，以及一些實用的字符操作，例如查詢、截取、替換和刪除等字符串操作，這些字符串操作函數都封裝在一個名爲 string 的模塊裏。

Lua 裏的字符索引是從 1 開始，索引值也可以是負數，這種情況將被解釋成向後索引，從字符串末尾開始算起。

下面是 Lua 5.2 提供的字符串操作函數：

byte

函數 string.byte 把字符串裏的第 i 個字符轉爲 ASCII 編碼，默認是輸出第一個字符的編碼（只有一個參數的話），用法：

1	string.byte(s [, i [, j]])

例子：

1	print(string.byte("abc"))

1	print(string.byte("abc", 2))

char

函數 string.char 是把一個 ASCII 編碼轉換爲對應的字符，用法：

1	string.char(asc1, ...)

例子：

1	print(string.char(97))

1	print(string.char(99, 100, 101))

dump

函數 string.dump 返回一個函數二進制形式的字符串，用法：

1	string.dump(function)

參數 function 是一個 Lua 函數：

1 2 3 4

functiontest()     print("just a test") end print(string.dump(test))

函數 string.dump 實現了函數的序列化，函數可以很輕鬆的傳遞，並在其他作用域調用。函數 string.dump 出來的二進制字符串，可以用 load 函數反序列回來直接調用。

1 2 3 4 5 6 7 8

functiontest()     print("just a test") end localsd = string.dump(test) print(sd) localls = load(sd) print(ls) ls()

find

函數 string.find 查找字符串 s 裏第一個符合查找字符 pattern 的位置，用法：

1	string.find(s, pattern [, init [, plain]])

如果找到了目標字符 pattern，則返回它的開始和結束位置：

1 2	start, end= string.find("just a test", "st") print(start, end)

如果沒有找到，則返回 nil：

1	print(string.find("just a test", "dhq.me"))

. 任意字符
%a 字母
%c 控制字符
%d 數字
%l 小寫字母
%p 標點字符
%s 空白符
%u 大寫字母
%w 字母和數字
%x 十六進制數字
%z 代表0的字符
上面字符類的大寫形式表示小寫所代表的集合的補集。例如，'%A'非字母的字符：
print(string.gsub("hello, up-down!", "%A", "."))
--> hello..up.down. 4
（數字4不是字符串結果的一部分，他是gsub返回的第二個結果，代表發生替換的次數。下面其他的關於打印gsub結果的例子中將會忽略這個數值。）在模式匹配中有一些特殊字符，他們有特殊的意義，Lua中的特殊字符如下：
( ) . % + - * ? [ ^ $
'%' 用作特殊字符的轉義字符，因此 '%.' 匹配點；'%%' 匹配字符 '%'。轉義字符 '%'不僅可以用來轉義特殊字符，還可以用於所有的非字母的字符。當對一個字符有疑問的時候，爲安全起見請使用轉義字符轉義他。
對 Lua而言，模式串就是普通的字符串。他們和其他的字符串沒有區別，也不會受到特殊對待。只有他們被用作模式串用於函數的時候，'%' 才作爲轉義字符。所以，如果你需要在一個模式串內放置引號的話，你必須使用在其他的字符串中放置引號的方法來處理，使用 '\' 轉義引號，'\' 是Lua的轉義符。你可以使用方括號將字符類或者字符括起來創建自己的字符類（譯者：Lua稱之爲char-set，就是指傳統正則表達式概念中的括號表達式）。比如，'[%w_]' 將匹配字母數字和下劃線，'[01]' 匹配二進制數字，'[%[%]]' 匹配一對方括號。下面的例子統計文本中元音字母出現的次數：
_, nvow = string.gsub(text, "[AEIOUaeiou]", "")
在 char-set中可以使用範圍表示字符的集合，第一個字符和最後一個字符之間用連字符連接表示這兩個字符之間範圍內的字符集合。大部分的常用字符範圍都已經預定義好了，所以一般你不需要自己定義字符的集合。比如，'%d' 表示 '[0-9]'；'%x' 表示 '[0-9a-fA-F]'。然而，如果你想查找八進制數，你可能更喜歡使用 '[0-7]' 而不是 '[01234567]'。你可以在字符集(char-set)的開始處使用 '^' 表示其補集：'[^0-7]' 匹配任何不是八進制數字的字符；'[^\n]' 匹配任何非換行符戶的字符。記住，可以使用大寫的字符類表示其補集：'%S' 比 '[^%s]' 要簡短些。
Lua的字符類依賴於本地環境，所以 '[a-z]' 可能與 '%l' 表示的字符集不同。在一般情況下，後者包括 'ç' 和 'ã'，而前者沒有。應該儘可能的使用後者來表示字母，除非出於某些特殊考慮，因爲後者更簡單、方便、更高效。
可以使用修飾符來修飾模式增強模式的表達能力，Lua中的模式修飾符有四個：
+ 匹配前一字符1次或多次
* 匹配前一字符0次或多次
- 匹配前一字符0次或多次
? 匹配前一字符0次或1次
'+'，匹配一個或多個字符，總是進行最長的匹配。比如，模式串 '%a+' 匹配一個或多個字母或者一個單詞：
print(string.gsub("one, and two; and three", "%a+", "word"))
--> word, word word; word word
'%d+' 匹配一個或多個數字（整數）：
i, j = string.find("the number 1298 is even", "%d+")
print(i,j) --> 12 15
'*' 與 '+' 類似，但是他匹配一個字符0次或多次出現.一個典型的應用是匹配空白。比如，爲了匹配一對圓括號()或者括號之間的空白，可以使用 '%(%s*%)'。（ '%s*' 用來匹配0個或多個空白。由於圓括號在模式中有特殊的含義，所以我們必須使用 '%' 轉義他。）再看一個例子，'[_%a][_%w]*' 匹配Lua程序中的標示符：字母或者下劃線開頭的字母下劃線數字序列。
'-' 與 '*' 一樣，都匹配一個字符的0次或多次出現，但是他進行的是最短匹配。某些時候這兩個用起來沒有區別，但有些時候結果將截然不同。比如，如果你使用模式 '[_%a][_%w]-' 來查找標示符，你將只能找到第一個字母，因爲 '[_%w]-' 永遠匹配空。另一方面，假定你想查找C程序中的註釋，很多人可能使用 '/%*.*%*/'（也就是說 "/*" 後面跟着任意多個字符，然後跟着 "*/" ）。然而，由於 '.*' 進行的是最長匹配，這個模式將匹配程序中第一個 "/*" 和最後一個 "*/" 之間所有部分：
test = "int x; /* x */ int y; /* y */"
print(string.find(test, "(/%*.*%*/)"))

format

函數 string.format 用於把字符串格式化輸出，用法：

1	string.format(formatstring, ···)

string.format 函數的第一個參數是用來指定字符串的格式，例如：

1	print(string.format("%s is %d", "ten", 10))

上面例子裏的 %s 表示字符串，%d 表示數字，它們是 Lua 的格式化輸出符號。

string.format 函數的用法跟 C 語言裏的 printf 函數類似，例如它可以像 printf 那樣輸出指定位數的數字：

1 2	Pi = 3.1415926 print(string.format("Pi is %.2f", Pi))

Lua 的字符格式化輸出符號列表：

1 2 3 4 5 6 7 8 9 10 11 12

.           所有字符 %a          字母 %c          控制符 %d          數字 %D          非數字 %l          小寫字母 %p          標點符號 %s          字符串 %u          大寫字母 %w          字母數字 %x          十六進制數 %z          用 0 表示的字符

gmatch

函數 string.gmatch 會返回一個迭代函數，尅通過該函數遍歷到一個字符串 s 中所有出現指定匹配模式 pattern 的地方，用法：

1	string.gmatch(s, pattern)

例如下面是找出字符串 s 裏的所有單詞：

1 2 3 4

s = "just a test" for w in string.gmatch(s, "%a+") do     print(w) end

gsub

函數 string.gsub 用於全局字符串替換，字符串 s 裏滿足匹配模式 pattern 格式的字符都會被替換成 repl 參數的值，用法：

1	string.gsub(s, pattern, repl [, n])

例如：

1	print(string.gsub("just a test", "st", "*"))

匹配模式 pattern 可以是一個正則：

1 2	s = "num is 1234567890" print(string.gsub(s, "%d", "*"))

可在函數的最後加上一個可選參數 n，表示指定要替換的次數：

1 2	s = "sethook, setlocal, setmetatable, setupvalue, setuservalue" print(string.gsub(s, "s%a+", "S", 2))

len

函數 string.len 用於返回字符串 s 的長度，用法：

1	string.len(s)

例子：

1	print(string.len("abcdefg"))

lower

函數 string.lower 用於把字符串 s 裏的字母轉爲小寫，用法：

1	string.lower(s)

例如：

1	print(string.lower("AbCdEfG"))

match

函數 string.match 用於查找字符串 s 裏第一個匹配對模式 pattern 的值，並返回匹配值，用法：

1	string.match(s, pattern [, init])

上面參數 init 是可選, 表示查找過程的起點, 默認從 1 開始：

1	print(string.match("just a test", "test"))

參數 patter 可以是一個正則模式：

1 2	t = "today is 2003-5-31" print(string.match(t, "%d+-%d+-%d+"))

如果 pattern 爲空，則返回整個字符串；如果沒匹配成功，則返回 nil。

1	print(string.match("abcdabcd", "a"))

rep

函數 string.rep 返回一個由分隔符 sep 隔開的重複（repeat）n 次字符 s 的字符串，用法：

1	string.rep(s, n [, sep])

默認的分隔符 sep 是空字符。

1	print(string.rep("repeat", 3))

reverse

函數 string.reverse 用於倒轉一個字符串 s 的排序，用法：

1	string.reverse(s)

例如：

1	print(string.reverse("reverse"))

sub

函數 string.sub 用於從字符串 s 裏截取一個從第 i 個字符到第 j 個字符間的子字符串，用法：

1	string.sub(s, i [, j])

例如：

1	print(string.sub("abcdefg", 2, 5))

參數 i 可以是負數，這種情況下，子串的位置從字符串 s 的最後開始算起：

1	print(string.sub("abcdefg", -4, -2))

參數 end 省略的話，則會返回從 i 到字符串末尾的子字符串：

1	print(string.sub("abcdefg", 3))

upper

函數 string.upper 用於把字符串 s 裏的字母轉爲大寫，用法：

1	string.upper(s)

例如：

1	print(string.upper("AbCdEfG"))

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

其他參考

字符串庫中的一些函數是非常簡單的：

string.len(s)          返回字符串s的長度；
string.rep(s, n)      返回重複n次字符串s的串；你使用string.rep("a", 2^20)可以創建一個1M bytes的字符串（比如，爲了測試需要）；
string.lower(s)       將s中的大寫字母轉換成小寫（string.upper將小寫轉換成大寫）。如果你想不關心大小寫對一個數組進行排序的話，你可以這樣：
                             table.sort(a, function (a, b) return string.lower(a) < string.lower(b) end)
string.upper(s)       將s中的小寫字母轉換成大寫
                            string.upper和string.lower都依賴於本地環境變量。所以，如果你在 European Latin-1環境下，表達式：
                            string.upper("a??o")    --> "A??O"
string.sub(s,i,j)      函數截取字符串s的從第i個字符到第j個字符之間的串。Lua中，字符串的第一個字符索引從1開始。你也可以使用負索引，負索引從字符串的結尾向前計數：-1指向最後一個字符，-2指向倒數第二個，以此類推。所以， string.sub(s, 1, j)返回字符串s的長度爲j的前綴；string.sub(s, j, -1)返回從第j個字符開始的後綴。如果不提供第3個參數，默認爲-1，因此我們將最後一個調用寫爲string.sub(s, j)；string.sub(s, 2, -2)返回去除第一個和最後一個字符後的子串。
s = "[in brackets]"
print(string.sub(s, 2, -2)) --> in brackets
記住：Lua中的字符串是恆定不變的。string.sub函數以及Lua中其他的字符串操作函數都不會改變字符串的值，而是返回一個新的字符串。一個常見的錯誤是：
string.sub(s, 2, -2)
認爲上面的這個函數會改變字符串s的值。如果你想修改一個字符串變量的值，你必須將變量賦給一個新的字符串：
s = string.sub(s, 2, -2)
string.char函數和string.byte函數用來將字符在字符和數字之間轉換。string.char獲取0個或多個整數，將每一個數字轉換成字符，然後返回一個所有這些字符連接起來的字符串。string.byte(s, i)將字符串s的第i個字符的轉換成整數；第二個參數是可選的，缺省情況下i=1。下面的例子中，我們假定字符用ASCII表示：

print(string.char(97)) --> a
i = 99; print(string.char(i, i+1, i+2)) --> cde
print(string.byte("abc")) --> 97
print(string.byte("abc", 2)) --> 98
print(string.byte("abc", -1)) --> 99 

上面最後一行，我們使用負數索引訪問字符串的最後一個字符。

Lua提供了string.format()函數來生成具有特定格式的字符串, 函數的第一個參數是格式(formatstring), 之後是對應格式中每個代號的各種數據. 由於格式字符串的存在, 使得產生的長字符串可讀性大大提高了. 這個函數的格式很像C語言中的printf().函數string.format在用來對字符串進行格式化的時候，特別是字符串輸出，是功能強大的工具。這個函數有兩個參數，你完全可以照C語言的printf來使用這個函數。第一個參數爲格式化串：由指示符和控制格式的字符組成。指示符後的控制格式的字符可以爲：十進制'd'；十六進制'x'；八進制'o'；浮點數'f'；字符串's'。在指示符'%'和控制格式字符之間還可以有其他的選項：用來控制更詳細的格式，比如一個浮點數的小數的位數：

格式字符串可能包含以下的轉義碼:

%c - 接受一個數字, 並將其轉化爲ASCII碼錶中對應的字符
%d, %i - 接受一個數字並將其轉化爲有符號的整數格式
%o - 接受一個數字並將其轉化爲八進制數格式
%u - 接受一個數字並將其轉化爲無符號整數格式
%x - 接受一個數字並將其轉化爲十六進制數格式, 使用小寫字母
%X - 接受一個數字並將其轉化爲十六進制數格式, 使用大寫字母
%e - 接受一個數字並將其轉化爲科學記數法格式, 使用小寫字母e
%E - 接受一個數字並將其轉化爲科學記數法格式, 使用大寫字母E
%f - 接受一個數字並將其轉化爲浮點數格式
%g(%G) - 接受一個數字並將其轉化爲%e(%E, 對應%G)及%f中較短的一種格式
%q - 接受一個字符串並將其轉化爲可安全被Lua編譯器讀入的格式
%s - 接受一個字符串並按照給定的參數格式化該字符串

爲進一步細化格式, 可以在%號後添加參數. 參數將以如下的順序讀入:

(1) 符號: 一個+號表示其後的數字轉義符將讓正數顯示正號. 默認情況下只有負數顯示符號.
(2) 佔位符: 一個0, 在後面指定了字串寬度時佔位用. 不填時的默認佔位符是空格.
(3) 對齊標識: 在指定了字串寬度時, 默認爲右對齊, 增加-號可以改爲左對齊.
(4) 寬度數值
(5) 小數位數/字串裁切: 在寬度數值後增加的小數部分n, 若後接f(浮點數轉義符, 如%6.3f)則設定該浮點數的小數只保留n位, 若後接s(字符串轉義符, 如%5.3s)則設定該字符串只顯示前n位.

在這些參數的後面則是上述所列的轉義碼類型(c, d, i, f, ...).

print(string.format("pi = %.4f", PI))
      --> pi = 3.1416
d = 5; m = 11; y = 1990
print(string.format("%02d/%02d/%04d", d, m, y))
        --> 05/11/1990
tag, title = "h1", "a title"
print(string.format("<%s>%s</%s>", tag, title, tag))
        --> <h1>a title</h1>

第一個例子，%.4f代表小數點後面有4位小數的浮點數。第二個例子%02d代表以固定的兩位顯示十進制數，不足的前面補0。而%2d前面沒有指定0，不足兩位時會以空白補足。對於格式串部分指示符得詳細描述清參考lua手冊，或者參考C手冊，因爲Lua調用標準C的printf函數來實現最終的功能。

以下是一些例子:

string.format("%%c: %c", 83)            輸出S
string.format("%+d", 17.0)              輸出+17
string.format("%05d", 17)               輸出00017
string.format("%o", 17)                 輸出21
string.format("%u", 3.14)               輸出3
string.format("%x", 13)                 輸出d
string.format("%X", 13)                 輸出D
string.format("%e", 1000)               輸出1.000000e+03
string.format("%E", 1000)               輸出1.000000E+03
string.format("%6.3f", 13)              輸出13.000
string.format("%q", "One\nTwo")         輸出"One\
                                        　　Two"
string.format("%s", "monkey")           輸出monkey
string.format("%10s", "monkey")         輸出    monkey
string.format("%5.3s", "monkey")        輸出  mon