字符串库教程

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 返回函数的副本。函数必须是没有任何上值的 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!