字串函式庫教學

wiki

注意：在 Lua 中，字串的索引值從 1 開始，而非 0。此外，索引值可以是負數。負數索引值表示反向順序的索引。例如，「miner」的 -2 是「e」，因此，-1 是 #s（s 為字串）。

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

s:byte([i [, j]])

傳回傳入字串中 s[i] 至 s[j] 的數值代碼（您可以搜尋數值代碼的清單）。

> = string.byte("ABCDE")      -- no index, so the First character
65
> = string.byte(" ") --Whitespace also has its own numerical code
32
> = string.byte("H A I") -- Thus, #s of this string is 5 not 3
> = string.byte("ABCDE",1)    -- indexes start at 1
65
> = string.byte("ABCDE",0)    -- we're not using C
> = string.byte("ABCDE",100)  -- index out of range, no value returned
> = string.byte("ABCDE",3,4)
67      68
> s = "ABCDE"
> = s:byte(3,4)               -- can apply directly to string variable
67      68

string.char(i1, i2, ...)

產生一個代表傳入參數的字元代碼字串。數值代碼在不同平台之間不具可移植性。

> = string.char(65,66,67)
ABC
> = string.char()  -- empty string

string.dump(function)

傳回給定函式的二進位表示，以便稍後對該字串載入 loadstring 後，可傳回函式的副本。函式必須為不具備 upvalue 的 Lua 函式。

string.find(s, pattern [, index [, plain]])

s:find(pattern [, index [, plain]])

在傳入字串中尋找樣式的第一次出現。如果找到樣式的執行個體，則傳回代表字串起點和終點的一組值。若找不到樣式，則傳回 nil。

> = string.find("Hello Lua user", "Lua")
7       9
> = string.find("Hello Lua user", "banana")
nil

> = string.find("Hello Lua user", "Lua", 1)  -- start at first character
7       9
> = string.find("Hello Lua user", "Lua", 8)  -- "Lua" not found again after character 8
nil
> = string.find("Hello Lua user", "e", -5)   -- first "e" 5 characters from the end
13      13

> = string.find("Hello Lua user", "%su")          -- find a space character followed by "u"
10      11
> = string.find("Hello Lua user", "%su", 1, true) -- turn on plain searches, now not found
nil

string.format(s, e1, e2, ...)

s:format(e1, e2, ...)

使用提供的格式和參數建立一個格式化字串。這類似於 C 中的 printf("format",...) 函式。額外的選項 %q 會在字串參數值的外圍加上引號。

• A、a、c、d、E、e、f、G、g、i、o、u、X 和 x 都希望參數是一個數字。
• q 和 s 希望參數是一個字串。

> = string.format("%s %q", "Hello", "Lua user!")   -- string and quoted string
Hello "Lua user!"
> = string.format("%c%c%c", 76, 117, 97)           -- char
Lua
> = string.format("%e, %E", math.pi, math.pi)      -- exponent
3.141593e+000, 3.141593E+000
> = string.format("%f", math.pi)                   -- float
3.141593
> = string.format("%g, %g", math.pi, 10^9)         -- float or exponent
3.14159, 1e+09
> = string.format("%d, %i, %u", -100, -100, -100)  -- signed, signed, unsigned integer
-100, -100, 4294967196
> = string.format("%o, %x, %X", -100, -100, -100)  -- octal, hexadecimal, hexadecimal
37777777634, ffffff9c, FFFFFF9C
> = string.format("%a, %A", 127, 127)              -- hexadecimal with binary exponent (lowercase, uppercase)
0x1.fcp+6, 0X1.FCP+6

選項 A 和 a 可能可以在 Lua 5.2 以後版本中取得。

string.gmatch(s, pattern)

s:gmatch(pattern)

這會傳回一個樣式尋找反覆運算子。反覆運算子會在傳入字串中搜尋您傳入樣式的執行個體。

> for word in string.gmatch("Hello Lua user", "%a+") do print(word) end
Hello
Lua
user

string.gsub(s, pattern, replace [, n])

s:gsub(pattern, replace [,n])

這是一個非常強大的函數，可以用多種方式使用。簡單來說，它可以將提供的樣式的每個實例替換為替換項目。它會傳回一對值，變更過後的字串和已進行的替換次數。可以使用選用的第四個參數 n 來限制替換次數。

> = string.gsub("Hello banana", "banana", "Lua user")
Hello Lua user  1
> = string.gsub("banana", "a", "A", 2)  -- limit substitutions made to 2
bAnAna  2

同樣地，string.find() 可讓我們使用樣式在字串中搜尋。樣式在PatternsTutorial中已做說明。如果使用了擷取，則可以在替換字串中使用表示法%capture_index 參考它，例如：

> = string.gsub("banana", "(an)", "%1-")    -- capture any occurences of "an" and replace
ban-an-a        2
> = string.gsub("banana", "a(n)", "a(%1)")  -- brackets around n's which follow a's
ba(n)a(n)a      2
> = string.gsub("banana", "(a)(n)", "%2%1") -- reverse any "an"s
bnanaa  2

如果替換項目是一個函數（不是字串），傳遞給函數的參數是進行的任何擷取。如果函數傳回一個字串，傳回的值會替換回字串中。

> = string.gsub("Hello Lua user", "(%w+)", print)  -- print any words found
Hello
Lua
user
        3
> = string.gsub("Hello Lua user", "(%w+)", function(w) return string.len(w) end) -- replace with lengths
5 3 4   3
> = string.gsub("banana", "(a)", string.upper)     -- make all "a"s found uppercase
bAnAnA  3
> = string.gsub("banana", "(a)(n)", function(a,b) return b..a end) -- reverse any "an"s
bnanaa  2

樣式擷取：最常見的樣式擷取實例可能是

• "(.-)"，例如 {(. -)} 表示擷取大括弧 {} 之間的任何字元（懶惰比對，也就是盡可能少的字元）
• "(.*)"，例如 {(.*)} 表示擷取大括弧 {} 之間的任何字元（貪婪比對，也就是盡可能多的字元）

> = string.gsub("The big {brown} fox jumped {over} the lazy {dog}.","{(.-)}", function(a)  print(a) end )
brown 
over 
dog

> = string.gsub("The big {brown} fox jumped {over} the lazy {dog}.","{(.*)}", function(a)  print(a) end )
brown} fox jumped {over} the lazy {dog

string.len(s)

s:len()

傳回傳遞字串的長度。

> = string.len("Lua")
3
> = string.len("")
0
> = string.len("Lua\000user")   -- Lua strings are 8 bytes pure so \000 does not terminate
8

string.lower(s)

s:lower()

將大寫字元轉為小寫。

> = string.lower("Hello, Lua user!")
hello, lua user!

string.match (s, pattern [, index])

s:match(pattern [, index])

透過比對樣式擷取子字串。

> = string.match("I have 2 questions for you.", "%d+ %a+")
2 questions

> = string.format("%d, %q", string.match("I have 2 questions for you.", "(%d+) (%a+)"))
2, "questions"

string.rep(s, n)

s:rep(n)

產生一個字串，其中包含傳遞的字串的 n 份副本，且串接在一起。

> = string.rep("Lua ",5)
Lua Lua Lua Lua Lua
> = string.rep("Lua\n",3)
Lua
Lua
Lua

string.reverse(s)

s:reverse()

反轉字串。

> = string.reverse("lua")
aul

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

s:sub(i [,j])

傳回傳遞字串的子字串。子字串從 i 開始。如果未提供第三個參數 j，則子字串將在字串結尾結束。如果提供了第三個參數，則子字串將在 j 結束並包含 j。

> = string.sub("Hello Lua user", 7)      -- from character 7 including 7 until the end
Lua user
> = string.sub("Hello Lua user", 7, 9)   -- from character 7 until and including 9
Lua
> = string.sub("Hello Lua user", -8)     -- 8 from the end until the end
Lua user
> = string.sub("Hello Lua user", -8, 9)  -- 8 from the end until 9 from the start
Lua
> = string.sub("Hello Lua user", -8, -6) -- 8 from the end until 6 from the end
Lua

string.upper(s)

s:upper()

將所有小寫字母轉換成大寫字母。

> = string.upper("Hello, Lua user!")
HELLO, LUA USER!