Lua字符串库(整理)

Lua字符串库小集

1. 基础字符串函数：
    字符串库中有一些函数非常简单，如：
    1). string.len(s) 返回字符串s的长度；
    2). string.rep(s,n) 返回字符串s重复n次的结果；
    3). string.lower(s) 返回s的副本，其中所有的大写都被转换为了小写形式，其他字符不变；
    4). string.upper(s) 和lower相反，将小写转换为大写；
    5). string.sub(s,i,j) 提取字符串s的第i个到第j个字符。Lua中，第一个字符的索引值为1，最后一个为-1，以此类推，如：
    print(string.sub("[hello world]",2,-2))      --输出hello world
    6). string.format(s,...) 返回格式化后的字符串，其格式化规则等同于C语言中printf函数，如：
    print(string.format("pi = %.4f",math.pi)) --输出pi = 3.1416
    7). string.char(...) 参数为0到多个整数，并将每个整数转换为对应的字符。然后返回一个由这些字符连接而成的字符串，如：
    print(string.char(97,98,99)) --输出abc
    8). string.byte(s,i) 返回字符串s的第i个字符的Ascii值，如果没有第二个参数，缺省返回第一个字符的Ascii值。
    print(string.byte("abc"))      --输出97
    print(string.byte("abc",-1))  --输出99
    由于字符串类型的变量都是不可变类型的变量，因此在所有和string相关的函数中，都无法改变参数中的字符串值，而是生成一个新值返回。

2. 模式匹配函数：
    Lua的字符串库提供了一组强大的模式匹配函数，如find、match、gsub和gmatch。
    1). string.find函数：
    在目标字符串中搜索一个模式，如果找到，则返回匹配的起始索引和结束索引，否则返回nil。如：

 s = "hello world"
 i, j = string.find(s,"hello")
 print(i, j)        --输出1  5
 i, j = string.find(s,"l")
 print(i, j)        --输出3  3
 print(string.find(s,"lll"))  --输出nil

string.find函数还有一个可选参数，它是一个索引，用于告诉函数从目标字符串的哪个位置开始搜索。主要用于搜索目标字符串中所有匹配的子字符串，且每次搜索都从上一次找到的位置开始。如：

local t = {}
local i =
while true do
    i = string.find(s,"\n",i+)
    if i == nil then
        break
    end
    t[#t + ] = i
end

2). string.match函数：
    该函数返回目标字符串中和模式字符串匹配的部分。如：

 date = "Today is 2012-01-01"
 d = string.match(date,"%d+\-%d+\-%d+")
 print(d)  --输出2012-01-01

3). string.gsub函数：
    该函数有3个参数，目标字符串、模式和替换字符串。基本用法是将目标字符串中所有出现模式的地方替换为替换字符串。如：
    print(string.gsub("Lua is cute","cute","great"))  --输出Lua is great

　 该函数还有可选的第4个参数，即实际替换的次数。
    print(string.gsub("all lii","l","x",1))  --输出axl lii
    print(string.gsub("all lii","l","x",2))  --输出axx lii

函数string.gsub 返回还有另一个结果，即实际替换的次数。
    count = select(2, string.gsub(str," "," "))  --输出str中空格的数量

　 还能根据这个函数来实现一些其他的功能，譬如 split string：

string.split = function(s, p)
    local rt= {}
    string.gsub(s, '[^'..p..']+', function(w) table.insert(rt, w) end )
    return rt
end
 
-- 测试代码如下：
local str = "abc,123,hello,ok"
local list = string.split(str, ',')
for _, s in ipairs(list) do
    print(tostring(s))
end
-- 输出结果如下 ：
abc
123
hello
ok

　另外观看 云风的这篇文章，发现string.gsub函数 还可以这样用：

local str = "#qwe&qwe&qwe&##qwe&qwe&qwe&##qwe&qwe&qwe&##qwe&qwe&qwe&#"
str = str.rep(str , )
 
str = string.gsub(str , '&', '&')
str = string.gsub(str , '#', '@@@')
str = string.gsub(str , 'q', 'Q')
str = string.gsub(str , '#', 'B-B')
print(str)

上述的实现也可写成这样 来写~如下：

local escapeAttrib = {
    ['&'] = '&';
    ['#'] = '@@@';
    ['q'] = 'Q';
    ['e'] = 'B-B';
}
 
local str = "#qwe&qwe&qwe&##qwe&qwe&qwe&##qwe&qwe&qwe&##qwe&qwe&qwe&#"
str = str.rep(str , )
str = string.gsub(str , '[&#qe]', escapeAttrib)
print(str)

　　使用lua自带的SciTe 跑了多次，目测 前者表现会稍好一点；

　　4). string.gmatch函数：
    返回一个函数，通过这个返回的函数可以遍历到一个字符串中所有出现指定模式的地方。如：

words = {}
s = "hello world"
for w in string.gmatch(s,"%a+") do                                                                                                                                            print("----")
    print(w)
    words[#words + ] = w
end
--输出结果为： 
----
hello　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　----world

3. 模式：
    下面的列表给出了Lua目前支持的模式元字符；

模式元字符	描述
.	所有字符
%a	字母
%c	控制字符
%d	数字
%l	小写字母
%p	标点符号
%s	空白字符
%u	大写字母
%w	字母和数字字符
%x	十六进制数字
%z	内部表示为0的字符

这些元字符的大写形式表示它们的补集，如%A，表示所有非字母字符。
    print(string.gsub("hello, up-down!","%S","."))   --输出hello..up.down. 4
    上例中的4表示替换的次数。
    除了上述元字符之外，Lua还提供了另外几个关键字符。如：( ) . % + - * ? [ ] ^ $
    其中%表示转义字符，如%.表示点(.)，%%表示百分号(%)。
    方括号[]表示将不同的字符分类，即可创建出属于自己的字符分类，如[%w_]表示匹配字符、数字和下划线。
    横线(-)表示连接一个范围，比如[0-9A-Z]
    如果^字符在方括号内 ，如[^\n]，表示除\n之外的所有字符，即表示方括号中的分类的补集。如果^不在方括号内，则表示以后面的字符开头，$和它正好相反，表示以前面的字符结束。如：^Hello%d$，匹配的字符串可能为Hello1、Hello2等。
    在Lua中还提供了4种用来修饰模式中的重复部分，如：+(重复1次或多次)、*(重复0次或多次)、-(重复0次或多次)和?(出现0或1次)。如：
    print(string.gsub("one, and two; and three","%a+","word")) --输出word, word word; word word
    print(string.match("the number 1298 is even","%d+")) --输出1298
    星号(*)和横线(-)的主要差别是，星号总是试图匹配更多的字符，而横线则总是试图匹配最少的字符。

格式字符串可能包含以下的转义码:

%c - 接受一个数字, 并将其转化为ASCII码表中对应的字符
%d, %i - 接受一个数字并将其转化为有符号的整数格式
%o - 接受一个数字并将其转化为八进制数格式
%u - 接受一个数字并将其转化为无符号整数格式
%x - 接受一个数字并将其转化为十六进制数格式, 使用小写字母
%X - 接受一个数字并将其转化为十六进制数格式, 使用大写字母
%e - 接受一个数字并将其转化为科学记数法格式, 使用小写字母e
%E - 接受一个数字并将其转化为科学记数法格式, 使用大写字母E
%f - 接受一个数字并将其转化为浮点数格式
%g(%G) - 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式
%q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式（即将该string添加了""）
%s - 接受一个字符串并按照给定的参数格式化该字符串

为进一步细化格式, 可以在%号后添加参数. 参数将以如下的顺序读入:

(1) 符号: 一个+号表示其后的数字转义符将让正数显示正号. 默认情况下只有负数显示符号.
(2) 占位符: 一个0, 在后面指定了字串宽度时占位用. 不填时的默认占位符是空格.
(3) 对齐标识: 在指定了字串宽度时, 默认为右对齐, 增加-号可以改为左对齐.
(4) 宽度数值 
(5) 小数位数/字串裁切: 在宽度数值后增加的小数部分n, 若后接f(浮点数转义符, 如%6.3f)则设定该浮点数的小数只保留n位, 若后接s(字符串转义符, 如%5.3s)则设定该字符串只显示前n位.

4. 捕获(capture)：
    捕获功能可根据一个模式从目标字符串中抽出匹配于该模式的内容。在指定捕获是，应将模式中需要捕获的部分写到一对圆括号内。对于具有捕获的模式，函数string.match会将所有捕获到的值作为单独的结果返回。即它会将目标字符串切成多个捕获到的部分。如：

pair = "name = Anna"
key,value = string.match(pair,"(%a+)%s*=%s*(%a+)")
print(key,value)  --输出name anna
 
date = "Today is 2012-01-02"
y,m,d = string.match(date,"(%d+)\-(%d+)\-(%d+)")
print(y,m,d)      --输出2012    01      02

还可以对模式本身使用捕获。即%1表示第一个捕获，以此类推，%0表示整个匹配，如：

 print(string.gsub("hello Lua","(.)(.)","%2%1"))  --将相邻的两个字符对调，输出为ehll ouLa
 print(string.gsub("hello Lua!","%a","%0-%0"))    --输出为h-he-el-ll-lo-o L-Lu-ua-a!

5. 替换：
    string.gsub函数的第三个参数不仅可以是字符串，也可以是函数或table，如果是函数，string.gsub会在每次找到匹配时调用该函 数，调用时的参数就是捕获到的内容，而该函数的返回值则作为要替换的字符串。当用一个table来调用时，string.gsub会用每次捕获到的内容作 为key，在table中查找，并将对应的value作为要替换的字符串。如果table中不包含这个key，那么string.gsub不改变这个匹 配。如：

function expand(s)
    return (string.gsub(s,"$(%w+)",_G))
end
 
name = "Lua"; status = "great"
print(expand("$name is $status, isn't it?"))  --输出 Lua is great, isn't it?
print(expand("$othername is $status, isn't it?"))  --输出 $othername is great, isn't it?
 
function expand2(s)
    return (string.gsub(s,"$(%w+)",function(n) return tostring(_G[n]) end))
end
 
print(expand2("print = $print; a = $a")) --输出 print = function: 002B77C0; a = nil

另外：附上网路上关于Lua的table和String相互转化的方法如下：

-- 序列化tablle表--將表轉化成string
function serialize(obj)
    local lua = ""
    local t = type(obj)
    if t == "number" then
        lua = lua .. obj
    elseif t == "boolean" then
        lua = lua .. tostring(obj)
    elseif t == "string" then
        lua = lua .. string.format("%q", obj)
    elseif t == "table" then
        lua = lua .. "{\n"
    for k, v in pairs(obj) do
        lua = lua .. "[" .. serialize(k) .. "]=" .. serialize(v) .. ",\n"
    end
    local metatable = getmetatable(obj)
        if metatable ~= nil and type(metatable.__index) == "table" then
        for k, v in pairs(metatable.__index) do
            lua = lua .. "[" .. serialize(k) .. "]=" .. serialize(v) .. ",\n"
        end
    end
        lua = lua .. "}"
    elseif t == "nil" then
        return nil
    else
        return "-nil-"
        --error("can not serialize a " .. t .. " type.")
    end
    return lua
end
 
-- 反序列化tablle表--將string轉化成table
function unserialize(lua)
    local t = type(lua)
    if t == "nil" or lua == "" then
        return nil
    elseif t == "number" or t == "string" or t == "boolean" then
        lua = tostring(lua)
    else
        error("can not unserialize a " .. t .. " type.")
    end
    lua = "return " .. lua
    local func = loadstring(lua)
    if func == nil then
        return nil
    end
    return func()
end

未完带整理；阅参考文章 请Click ：Here