用的上的Lua函数-贴给自己看

lzkd

找了一点Lua函数资料,是给自己看的,有兴趣的朋友也一起看哈

------------

这个清掉了,看4楼的吧.排版有够差的

[ 本帖最后由 lzkd 于 2009-12-11 02:10 PM 编辑 ]

jason

lua的字符串能力还是稍微弱了一点，要是python就完美了

lzkd

一部分的table函数只对其数组部分产生影响, 而另一部分则对整个table均产生影响. 下面会分开说明.


table.concat(table, sep,  start, end)

concat是concatenate(连锁, 连接)的缩写. table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。除了table外, 其他的参数都不是必须的, 分隔符的默认值是空字符, start的默认值是1, end的默认值是数组部分的总长.

sep, start, end这三个参数是顺序读入的, 所以虽然它们都不是必须参数, 但如果要指定靠后的参数, 必须同时指定前面的参数.

> tbl = {"alpha", "beta", "gamma"}
> print(table.concat(tbl, ":"))
alpha:beta:gamma
> print(table.concat(tbl, nil, 1, 2))
alphabeta
> print(table.concat(tbl, "\n", 2, 3))
beta
gamma

table.insert(table, pos, value)

table.insert()函数在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.

> tbl = {"alpha", "beta", "gamma"}
> table.insert(tbl, "delta")
> table.insert(tbl, "epsilon")
> print(table.concat(tbl, ", ")
alpha, beta, gamma, delta, epsilon
> table.insert(tbl, 3, "zeta")
> print(table.concat(tbl, ", ")
alpha, beta, zeta, gamma, delta, epsilon


table.maxn(table)

table.maxn()函数返回指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0. 此函数不限于table的数组部分.

> tbl = {[1] = "a", [2] = "b", [3] = "c", [26] = "z"}
> print(#tbl)
3               -- 因为26和之前的数字不连续, 所以不算在数组部分内
> print(table.maxn(tbl))
26
> tbl[91.32] = true
> print(table.maxn(tbl))
91.32


table.remove(table, pos)

table.remove()函数删除并返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起.


table.sort(table, comp)

table.sort()函数对给定的table进行升序排序.

> tbl = {"alpha", "beta", "gamma", "delta"}
> table.sort(tbl)
> print(table.concat(tbl, ", "))
alpha, beta, delta, gamma

comp是一个可选的参数, 此参数是一个外部函数, 可以用来自定义sort函数的排序标准.

此函数应满足以下条件: 接受两个参数(依次为a, b), 并返回一个布尔型的值, 当a应该排在b前面时, 返回true, 反之返回false.

例如, 当我们需要降序排序时, 可以这样写:

> sortFunc = function(a, b) return b < a end
> table.sort(tbl, sortFunc)
> print(table.concat(tbl, ", "))
gamma, delta, beta, alpha

用类似的原理还可以写出更加复杂的排序函数. 例如, 有一个table存有工会三名成员的姓名及等级信息:

guild = {}

table.insert(guild, {
　name = "Cladhaire",
　class = "Rogue",
　level = 70,
})

table.insert(guild, {
　name = "Sagart",
　class = "Priest",
　level = 70,
})

table.insert(guild, {
　name = "Mallaithe",
　class = "Warlock",
　level = 40,
})


对这个table进行排序时, 应用以下的规则: 按等级升序排序, 在等级相同时, 按姓名升序排序.

可以写出这样的排序函数:

function sortLevelNameAsc(a, b)
　if a.level == b.level then
　　return a.name < b.name
　else
　　return a.level < b.level
　end
end

测试功能如下:

> table.sort(guild, sortLevelNameAsc)
> for idx, value in ipairs(guild) do print(idx, value.name) end
1, Mallaithe
2, Cladhaire
3, Sagart

table.foreachi(table, function(i, v))
会期望一个从 1（数字 1）开始的连续整数范围，遍历table中的key和value逐对进行function(i, v)操作

t1 = {2, 4, 6, language="Lua", version="5", 8, 10, 12, web="hello lua"};
table.foreachi(t1, function(i, v) print (i, v) end) ; --等价于foreachi(t1, print)

输出结果：
1 2
2 4
3 6
4 8
5 10
6 12

table.foreach(table, function(i, v))
与foreachi不同的是，foreach会对整个表进行迭代

t1 = {2, 4, 6, language="Lua", version="5", 8, 10, 12, web="hello lua"};
table.foreach(t1, function(i, v) print (i, v) end) ;

输出结果：
1 2
2 4
3 6
4 8
5 10
6 12
web hello lua
language Lua
version 5

table.getn(table)
返回table中元素的个数

t1 = {1, 2, 3, 5};
print(getn(t1))
->4

table.setn(table, nSize)
设置table中的元素个数

lzkd

5.4 - 字符串操作

该库为字符串操作提供常规函数，例如查找和抽取子串以及模式匹配。在Lua中索引字符串时，第一个字符在位置1（不像C是在0处）。索引允许为负数，被解释为从字符串末尾往回索引。因此，最后一个字符在-1位置，依此类推。

字符串库在表string内提供所有函数。它也给字符串设置元表，其中的__index字段指向string表。因此，你可以使用面向对象风格的字符串函数。例如，string.byte(s, i)可写为s:byte(i)。

string.byte (s [, i [, j]])
返回字符s, s[i+1], ···, s[j]的内部数字代码。i缺省为1；j缺省为i。

注意数字代码不一定是跨平台可移植的。

string.char (···)
接受0获多个整数。返回一个字符串，其长度等于参数个数，其中的每个字符的内部数字代码等于相应的参数。

注意数字代码不一定是跨平台可移植的。

string.dump (function)

返回给定函数的二进制表示的字符串，之后在其上应用loadstring返回函数的拷贝。function必须是不带upvalueLua函数。

string.find (s, pattern [, init [, plain]])
在字符串s中查找pattern的第一个匹配。如果找到则返回它开始和结束处在s中的索引；否则，返回nil。可选的第三参数init是数字，指定从哪儿开始搜索；其缺省值是1并且可为负数。如果真值作为可选的第四参数plain，则关闭模式匹配设备，所以函数执行无格式的“查找子串”操作，pattern中的字符并不被认为是“魔术的（magic）”。注意，如果给出了plain，则init也必须给出。

如果模式具有捕获（capture），则在成功的匹配中被捕获的值也在两个索引后面返回。

string.format (formatstring, ···)
Returns a formatted version of its variable number of arguments following the description given in its first argument (which must be a string). 格式字符串遵循同printf族标准C函数同样的规则。仅有的区别是不支持*、l、L、n、p和h等选项/修饰符，而且有个额外选项q。q选项以可安全地为Lua解释器读取的适当形式格式化字符串：字符串被写在双引号之间，而且字符串中的所有双引号、换行、内嵌的0和反斜杠被恰当地转义。例如，调用

     string.format('%q', 'a string with "quotes" and \n new line')

产生字符串：

     "a string with \"quotes\" and \
      new line"

选项c、d、E、e、f, g、G、i、o、u、X和x都预期得到数字作为参数，然而q和s期望得到字符串。

该函数不接受含有内嵌的0的字符串值，除了作为q选项的参数。

string.gmatch (s, pattern)
返回一个迭代器函数，每次调用返回来自pattern的下一个捕获，从字符串s开头直到结尾。如果pattern没指定捕获则每次调用产生整个匹配。

作为例子，下面的循环

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

将迭代来自字符串s的所有单词，每行打印一个。下一个例子从给定的字符串收集所有的键=值对放在表中：

     t = {}
     s = "from=world, to=Lua"
     for k, v in string.gmatch(s, "^(%w+)=(%w+)") do
       t[k] = v
     end

对于该函数，模式起始处的‘^’不能作为锚点，因为这会阻止迭代。

string.gsub (s, pattern, repl [, n])
返回s的拷贝，其中出现的所有（或前n个，如果指定）pattern被替换为repl——可以是字符串、表或函数，指定的替换串。gsub也返回出现的匹配的总数作为第二个值。

如果repl是字符串，它的值被用作替换式。字符%用作转义字符：repl中的任何形如%n的序列代表第n个捕获的子串（见下面），其中n在1和9之间。序列%0代表整个匹配。序列%%代表单个%。

如果repl是表，则对于每个匹配，用第一个捕获作为键查询表；如果模式未指定捕获，则整个匹配被用作键。

如果repl是函数，则每次匹配发生时都按顺序传入所有捕获的子串作为参数调用该函数；如果模式没指定捕获，则整个匹配作为单个参数传入。

如果表查询或函数调用返回的结果是个字符串或数字，则被用作替换串；否则，如果是false或nil，则不发生替换（即原始匹配被保持在字符串中）。

这里有一些例子：

     x = string.gsub("hello world", "(%w+)", "%1 %1")
     --> x="hello hello world world"
     
     x = string.gsub("hello world", "%w+", "%0 %0", 1)
     --> x="hello hello world"
     
     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
     --> x="world hello Lua from"
     
     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
     --> x="home = /home/roberto, user = roberto"
     
     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
           return loadstring(s)()
         end)
     --> x="4+5 = 9"
     
     local t = {name="lua", version="5.1"}
     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
     --> x="lua-5.1.tar.gz"

string.len (s)
接受字符串并返回其长度。空串""长度为0。内嵌的0被计算在内，所以"a\000bc\000"长度为5。

string.lower (s)
接受字符串并返回其所有大写字母变为小写的拷贝。所有其他字符不变。大写字母的定义依赖于但前locale。

string.match (s, pattern [, init])
在字符串s中查找pattern的首次匹配。如果找到一个，则返回来自模式的捕获；否则返回nil。如果pattern未指定捕获则返回整个匹配。可选的第三个参数init是数字，指定从哪儿开始搜索；其缺省值是1并且可为负。

string.rep (s, n)
返回字符串s的n个拷贝拼接字符串。

string.reverse (s)
返回字符串s的颠倒的字符串。

string.sub (s, i [, j])
返回s的子串，它起始于i并延续到j；i和j可为负数。如果省略j，则它被假定为-1（同字符串长度一样）。特别地，调用string.sub(s,1,j)返回s长为j的前缀，而且string.sub(s, -i)返回s长为i的后缀。

string.upper (s)
接受字符串并返回其所有小写字母变为大写的拷贝。所有其他字符不变。小写字母的定义依赖于但前locale。
5.4.1 - 模式
字符类（Character Class）：

一个字符类被用于表示一组字符。允许用下面的组合描述字符类：

    * x: （此处x不是魔术字符^$()%.[]*+-?中的一个）表示字符x本身。
    * .: （一个点）表示所有字符。
    * %a: 表示所有字母。
    * %c: 表示所有控制字符。
    * %d: 表示所有十进制数字。
    * %l: 表示所有小写字母。
    * %p: 表示所有标点符号。
    * %s: 表示所有空白字符。
    * %u: 表示所有大写字母。
    * %w: 表示所有字母数字字符。
    * %x: 表示所有十六进制数字。
    * %z: 表示0值字符。
    * %x: （此处x是任何非字母数字字符）表示字符x。这是转义魔术字符的标准方式。当被用于在模式中表示自身时，任何标点符号（甚至非魔术的）都能前缀一个‘%’。
    * [set]: 表示set中的所有字符的联合构成的分类。通过用‘-’分隔截止字符可以指定某个范围的字符。上面描述的所有种类的%x都可用作set的部件。set中的所有其他字符表示它们自身。例如[%w_]（或[_%w]）表示所有字母数字字符和下划线，[0-7]表示八进制数字，[0-7%l%-]表示八进制数字和小写字母以及‘-’字符。

      字符范围和字符类之间的相互作用是未定义的。因此类似[%a-z]或[a-%%]的模式没有意义。
    * [^set]: 表示set的补集，其中的set在上面解释了。

所有单字母表示的字符类（%a、%c，等等），相应的大写字母表示该字符类的补集。例如，%S表示所有非空白符。

字母、空白和其他字符组合的定义依赖于当前locale。特别地，字符类[a-z]可能不等于%l。
模式项（Pattern Item）:

模式项可能为

    * 单个字符类，它匹配该类中的任意单个字符；
    * 后跟‘*’的单个字符类，它匹配该类中的0或多个字符。这些重复项将总是匹配最长的可能序列；
    * 后跟‘+’的单个字符类，它匹配该类中的1或多个字符。这些重复项将总是匹配最长的可能序列；
    * 后跟‘-’的单个字符类，它也匹配该类中的0或多个字符。与‘*’不同，这些重复项将总是匹配最短的可能序列；
    * 后跟‘?’的单个字符类，它匹配出现0或1次该类中的字符；
    * %n，其中n在1和9之间；这种项匹配一个等价于捕获的字符串的第n个子串（见下面）；
    * %bxy其中x和y是两个不同的字符；这种项匹配始于x终于y的字符串，并且x和y是对称的。这表示，如果一个人从左到右读字符串，对x计数为+1，对y计数为-1，结尾的y是第一个遇到计数为0的y 。例如，项%b()匹配带有平衡的圆括号的表达式。

模式（Pattern）:

模式是一系列的模式项。在模式开头的‘^’将匹配固定在源串的开头。 在模式结尾的‘$’将匹配固定在源串的结尾。在其他位置上，‘^’和‘$’没有特殊含义，表示它们自身。
捕获（Captures）:

模式可以含有括在圆括号内的子模式；它们描述捕获。当成功进行一个匹配，源串中匹配捕获的子串被存储（捕获）以便将来使用。捕获根据它们的左圆括号进行编号。例如，在模式"(a*(.)%w(%s*))"中，字符串的匹配"a*(.)%w(%s*)"的部分作为第一个捕获被存储（因此被编号为1）；匹配“.”的字符被捕获并编号为2，匹配“%s*”的部分被编号为3。

作为一种特殊情况，空捕获()捕获当前字符串位置（一个数字）。例如，如果我们把模式"()aa()"用于字符串"flaaap"，将有两个捕获：3和5。

模式不能含有内嵌的0。使用%z代替。

jason

table是lua的精华。也有人认为是滥用，哈哈

lzkd

原帖由 jason 于 2009-12-11 02:00 PM 发表
lua的字符串能力还是稍微弱了一点，要是python就完美了

jason你吓我一大跳.....
lua字符能力不好,正则能力不好,数据库能力没试,估计也强不了哪里去(毕竟,设计理念摆在那里)
唯一的优点是跟mush结合的非常好,不容易出错,我用php老是报错退出,米办法.

lzkd

原帖由 jason 于 2009-12-11 02:04 PM 发表
table是lua的精华。也有人认为是滥用，哈哈

table是精华,我这么认为.
当然,不能否认的一点是,table用起来,有点太随心所欲了...呃..也许,性格严谨的人不会喜欢.
从武学角度上来讲,软剑一般要比硬剑来的难使

lzkd

模式匹配函数

在string库中功能最强大的函数是：

string.find（字符串查找）
string.gsub（全局字符串替换）
string.gfind（全局字符串查找）
string.gmatch(返回查找到字符串的迭代器)

这些函数都是基于模式匹配的。与其他脚本语言不同的是，Lua并不使用POSIX规范的正则表达式[4]（也写作regexp）来进行模式匹配。主要的原因出于程序大小方面的考虑：实现一个典型的符合POSIX标准的regexp大概需要4000行代码，这比整个Lua标准库加在一起都大。权衡之下，Lua中的模式匹配的实现只用了 500行代码，当然这意味着不可能实现POSIX所规范的所有更能。然而，Lua中的模式匹配功能是很强大的，并且包含了一些使用标准POSIX模式匹配不容易实现的功能。

string.gmatch(str, pattern)      

这是一个返回迭代器的函数. 实际的用例如下:

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

这里是一个捕获并将配对字符分别存到不同变量的例子:

t = {}
s = "from=world, to=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
　t[k]=v
end
for k, v in pairs(t) do
　print(k, v)
end

string.gsub(str, pattern, repl, n)

string.gsub()函数根据给定的配对表达式对源字符串str进行配对, 同时返回源字符串的一个副本, 该副本中成功配对的所有子字符串都将被替换. 函数还将返回成功配对的次数.实际的替换行为由repl参数的类型决定:

当repl为字符串时, 所有成功配对的子字符串均会被替换成指定的repl字串.
当repl为table时, 对每个成功配对的子字符串, 函数均会试图寻找以其为key值的table中的元素, 并返回该元素. 如果该配对包含任何捕获信息, 则以编号为1号的捕获作为key值进行查找.
当repl为函数时, 每个成功配对的子字符串均会作为参数被传入到该函数中去.
在repl是table或函数时, 如果该table或函数返回了字串或数字的值, 这个值依然会被用于替换副本字串中的配对子字串. 如果该table/函数返回的值为空, 将不发生替换.

n参数可选, 当它被指定时, string.gsub()函数只对源字符串中的前n个成功配对的成员进行操作.

以下是几个例子:

> print(string.gsub("hello world", "(%w+)", "%1 %1"))
hello hello world world 2

> print(string.gsub("hello Lua", "(%w+)%s*(%w+)", "%2 %1"))
Lua hello 1

> string.gsub("hello world", "%w+", print)
hello world 2

> lookupTable = {["hello"] = "hola", ["world"] = "mundo"}
> print(string.gsub("hello world", "(%w+)", lookupTable))
hola mundo 2


string.match(str, pattern, init)

string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1.

在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil.


string.match("abcdaef", "a")
-> a

string.reverse(str)
返回一个字符串的倒序排列
string.reverse("abcde")
->edcba

string.dump(function)
返回指定函数的二进制代码(函数必须是一个Lua函数，并且没有上值)


string.find(str, pattern, init, plain)
string.find 的基本应用就是用来在目标串（subject string）内搜索匹配指定的模式的串。函数如果找到匹配的串返回他的位置，否则返回nil.最简单的模式就是一个单词，仅仅匹配单词本身。比如，模式 'hello'仅仅匹配目标串中的"hello"。当查找到模式的时候，函数返回两个值：匹配串开始索引和结束索引。
s = "hello world"
string.find(s, "hello")    --> 1    5
string.find(s, "world")    --> 7    11
string.find(s, "l")        --> 3    3
string.find(s, "lll")      --> nil
string.find函数第三个参数是可选的：标示目标串中搜索的起始位置。当我们想查找目标串中所有匹配的子串的时候，这个选项非常有用。我们可以不断的循环搜索，每一次从前一次匹配的结束位置开始。下面看一个例子，下面的代码用一个字符串中所有的新行构造一个表：
local t = {}      -- 存放回车符的位置
local i = 0
while true do
    i = string.find(s, "\n", i+1)  -- 查找下一行
    if i == nil then break end
    table.insert(t, i)
end

string.sub(str,sPos,ePos)
string.gsub的功能是截取字符串，他从指定起始位置截取一个字符串。string.sub可以利用string.find返回的值截取匹配的子串。
对简单模式而言，匹配的就是其本身
s = "hello world"
local i, j = string.find(s, "hello")    --> 1    5
string.sub(s, i, j)        --> hello

string.gsub(str, sourcestr, desstr)
string.gsub的基本作用是用来查找匹配模式的串，并将使用替换串其替换掉：
string.gsub函数有三个参数：目标串，模式串，替换串。
s = string.gsub("Lua is cute", "cute", "great")
print(s)      --> Lua is great
s = string.gsub("all lii", "l", "x")
print(s)      --> axx xii
s = string.gsub("Lua is great", "perl", "tcl")
print(s)      --> Lua is great
第四个参数是可选的，用来限制替换的范围：
s = string.gsub("all lii", "l", "x", 1)
print(s)          --> axl lii
s = string.gsub("all lii", "l", "x", 2)
print(s)          --> axx lii
string.gsub的第二个返回值表示他进行替换操作的次数。例如，下面代码涌来计算一个字符串中空格出现的次数：
_, count = string.gsub(str, " ", " ")
（注意，_ 只是一个哑元变量）


模式

你还可以在模式串中使用字符类。字符类指可以匹配一个特定字符集合内任何字符的模式项。比如，字符类%d匹配任意数字。所以你可以使用模式串'%d%d/%d%d/%d%d%d%d'搜索dd/mm/yyyy格式的日期：
s = "Deadline is 30/05/1999, firm"
date = "%d%d/%d%d/%d%d%d%d"
print(string.sub(s, string.find(s, date)))    --> 30/05/1999
下面的表列出了Lua支持的所有字符类：

单个字符(除^$()%.[]*+-?外): 与该字符自身配对
.(点): 与任何字符配对
%a: 与任何字母配对
%c: 与任何控制符配对(例如\n)
%d: 与任何数字配对
%l: 与任何小写字母配对
%p: 与任何标点(punctuation)配对
%s: 与空白字符配对
%u: 与任何大写字母配对
%w: 与任何字母/数字配对
%x: 与任何十六进制数配对
%z: 与任何代表0的字符配对
%x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*+-?)的配对问题, 例如%%与%配对
[数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
[^数个字符类]: 与任何不包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对

当上述的字符类用大写书写时, 表示与非此字符类的任何字符配对. 例如, %S表示与任何非空白字符配对.例如，'%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.gsub(test, "/%*.*%*/", ""))
    --> int x;

然而模式 '.-' 进行的是最短匹配，她会匹配 "/*" 开始到第一个 "*/" 之前的部分：

test = "int x; /* x */ int y; /* y */"
print(string.gsub(test, "/%*.-%*/", ""))
    --> int x; int y;

'?' 匹配一个字符0次或1次。举个例子，假定我们想在一段文本内查找一个整数，整数可能带有正负号。模式 '[+-]?%d+' 符合我们的要求，它可以匹配像 "-12"、"23" 和 "+1009" 等数字。'[+-]' 是一个匹配 '+' 或者 '-' 的字符类；接下来的 '?' 意思是匹配前面的字符类0次或者1次。
与其他系统的模式不同的是，Lua中的修饰符不能用字符类；不能将模式分组然后使用修饰符作用这个分组。比如，没有一个模式可以匹配一个可选的单词（除非这个单词只有一个字母）。下面我将看到，通常你可以使用一些高级技术绕开这个限制。
以 '^' 开头的模式只匹配目标串的开始部分，相似的，以 '$' 结尾的模式只匹配目标串的结尾部分。这不仅可以用来限制你要查找的模式，还可以定位（anchor）模式。比如：

if string.find(s, "^%d") then ...

检查字符串s是否以数字开头，而

if string.find(s, "^[+-]?%d+$") then ...

检查字符串s是否是一个整数。
'%b' 用来匹配对称的字符。常写为 '%bxy' ，x和y是任意两个不同的字符；x作为匹配的开始，y作为匹配的结束。比如，'%b()' 匹配以 '(' 开始，以 ')' 结束的字符串：

print(string.gsub("a (enclosed (in) parentheses) line", "%b()", ""))
--> a line

常用的这种模式有：'%b()' ，'%b[]'，'%b%{%}' 和 '%b<>'。你也可以使用任何字符作为分隔符。

lzkd

Lua解释器对字符串的支持很有限。一个程序可以创建字符串并连接字符串，但不能截取子串，检查字符串的大小，检测字符串的内容。在Lua中操纵字符串的功能基本来自于string库。

字符串库中的一些函数是非常简单的：

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", tag, title, tag))
        -->

a title

第一个例子，%.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

ddid

原帖由 jason 于 2009-12-11 14:00 发表
lua的字符串能力还是稍微弱了一点，要是python就完美了

Jason指的是iconv吧？我已经把iconv的库转成MUSH能调用的了。