Lua 字符串处理(string)

基于Lua5.3

注意一下两点：

①Lua string库的所有操作不会影响原字符串，只会返回结果

②加[,]的表示缺省，可有可无

 

目录

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

string.char (···)

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

string.format (formatstring, ···)

string.gmatch (s, pattern)

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

string.len (s)

string.lower (s)

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

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

string.reverse (s)

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

string.upper (s)

---

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

返回字符 s[i]， s[i+1]， ... ，s[j] 的内部数字编码。 i 的默认值是 1 ； j 的默认值是 i

string.byte("abcABC", 1, 6)   -- 返回:97 98 99 65 66 67

 

string.char (···)

接收零或更多的整数。 返回和参数数量相同长度的字符串。 其中每个字符的内部编码值等于对应的参数值。

string.char(97, 98, 99)     -- 返回:abc

 

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

查找第一个字符串 s 中匹配到的 pattern 。

如果找到一个匹配，find 会返回 s 中关于它起始及终点位置的索引； 否则，返回 nil。

第三个可选数字参数 init 指明从哪里开始搜索； 默认值为 1 ，同时可以是负值。

第四个可选参数 plain 为 true 时， 关闭模式匹配机制。 此时函数仅做直接的 “查找子串”的操作， 而 pattern 中没有字符被看作魔法字符。 注意，如果给定了 plain ，就必须写上 init 。 如果在模式中定义了捕获，捕获到的若干值也会在两个索引之后返回。

string.find("8Abc%a23", "bc")               -- 返回:3 4
string.find("8Abc%a23", "%a")               -- 返回:2 2
string.find("8Abc%a23", "(%a)")             -- 返回:2 2 A
string.find("8Abc%a23", "(%a)", 4)          -- 返回:4 4 c
string.find("8Abc%a23", "%a", 1, true)      -- 返回:5 6

 

string.format (formatstring, ···)

返回不定数量参数的格式化版本， 格式化串为第一个参数（必须是一个字符串）

常用转义符：

%s - 接受一个字符串并按照给定的参数格式化该字符串

%q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式

%d, %i - 接受一个数字并将其转化为有符号的整数格式(十进制数格式)

%u - 接受一个数字并将其转化为无符号整数格式

%f - 接受一个数字并将其转化为浮点数格式


%c - 接受一个数字,并将其转化为ASCII码表中对应的字符

%o - 接受一个数字并将其转化为八进制数格式

%x - 接受一个数字并将其转化为十六进制数格式,使用小写字母

%X - 接受一个数字并将其转化为十六进制数格式,使用大写字母

%e - 接受一个数字并将其转化为科学记数法格式,使用小写字母e

%E - 接受一个数字并将其转化为科学记数法格式,使用大写字母E

%g(%G) - 接受一个数字并将其转化为%e(%E,对应%G)及%f中较短的一种格式

print(string.format("1:%04d-%02d-%02d", 2017, 01, 12))
print(string.format("2:%s %q", "Hello", "Lua!"))
print(string.format("3:%%c:%c", 97))
print(string.format("4:%+04d", 11.2))
print(string.format("5:%f/%0.2f/%.2f/%6.2f/%06.2f", 12, 12, 12, 12, 12))
print(string.format("6:%e, %E", math.pi, math.pi))
print(string.format("7:%d, %i, %u", -10, -10, -10))
print(string.format("8:%o, %x, %X", -10, -10, -10))
print(string.format("9:%c", 83))
print(string.format("10:%+04d", 11.2))

输出如下：

print("默认右对齐:\n" .. string.format("%6d\n%+06d\n%06d", 10, 20, 30))
print("改为左对齐:\n" .. string.format("%-6d\n%-+6d\n%-+06d", 10, 20, 30))

 输出如下

 

string.gmatch (s, pattern)

返回一个迭代器函数。
每次调用这个函数都会继续以 pattern 对 s 做匹配，并返回所有捕获到的值。
如果 pattern 中没有指定捕获，则每次捕获整个 pattern。

local s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do
  print(w)
end

输出如下：

 

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

将字符串 s 中，所有的（或是在 n 给出时的前 n 个） pattern 都替换成 repl ，并返回其副本。
repl 可以是字符串、表、或函数。
gsub 还会在第二个返回值返回一共发生了多少次匹配。
如果 repl 是一个字符串，那么把这个字符串作为替换品。 字符 % 是一个转义符： repl 中的所有形式为 %d 的串表示 第 d 个捕获到的子串，d 可以是 1 到 9 。 串 %0 表示整个匹配。 串 %% 表示单个 %。
如果 repl 是张表，每次匹配时都会用第一个捕获物作为键去查这张表。
如果 repl 是个函数，则在每次匹配发生时都会调用这个函数。 所有捕获到的子串依次作为参数传入。
任何情况下，模板中没有设定捕获都看成是捕获整个模板。
如果表的查询结果或函数的返回结果是一个字符串或是个数字， 都将其作为替换用串； 而在返回 false 或 nil　时不作替换 （即保留匹配前的原始串）。
 

string.gsub("hello1 world2", "(%a+)", "%1 %1")
-- 理解:(%a+)会捕获到hello1中的hello,赋值给%1,此时"%1 %1"即成了"hello hello",
-- 替换过去就成了"hello hello1",后面字符同样理解,共匹配2次
-- 所以结果返回:hello hello1 world world2 2

-- 下面请自行理解,有益健康, 更多祥情,请看 "强大的匹配模式"
 1. string.gsub("hello world", "%w+", "%0 %0", 1)
 2. string.gsub("hello world", "%a+", "%0 %0", 1)
 3. string.gsub("hello world from Lua", "(%a+)%s*(%a+)", "%2 %1")
 4. string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s) return load(s)() end)
    local t = {name="lua", version="5.3"}
 5. string.gsub("$name-$version.tar.gz", "%$(%w+)", t)

 

string.len (s)

接收一个字符串，返回其长度。 空串 “” 的长度为 0 。 内嵌零也统计在内

string.len("abc")          -- 返回:3
string.len("a\000bc\000")  -- 返回:5

 

string.lower (s)

大写转小写

string.lower("ABc")         -- 返回:abc

 

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

在字符串 s 中找到第一个能用 pattern 匹配到的部分。 如果能找到，match 返回其中的捕获物；
否则返回 nil 。
如果 pattern 中未指定捕获， 返回整个 pattern 捕获到的串。
第三个可选数字参数 init 指明从哪里开始搜索； 它默认为 1 且可以是负数。
 

string.match("abc123ABC456", "%a+%d+")          -- 返回:abc123
string.match("abc123ABC456", "(%a+)%d+")        -- 返回:abc
string.match("abc123ABC456", "(%a+)%d+", -5)    -- 返回:BC

 

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

返回 n 个字符串 s 以字符串 sep 为分割符连在一起的字符串。 默认的 sep 值为空字符串（即没有分割符）。 如果 n 不是正数则返回空串

string.rep("wzz", 3, ",")   -- 返回:wzz,wzz,wzz

 

string.reverse (s)

返回字符串 s 的翻转串。

string.reverse("abc")      -- 返回:"cba"

 

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

返回 s 的子串， 该子串从 i 开始到 j 为止； i 和 j 都可以为负数。负数，取从字符串后面算起， 如果开始位置在结束位置的后面，则返回空串

string.sub("abcABC", 1, -2)     -- 返回:abcAB
string.sub("abcABC", -3)        -- 返回:ABC

 

string.upper (s)

小写转大写

string.upper("ABc")         -- 返回:ABC