lua中的字符串操作(模式匹配)

agile Posted on Jan 10 2020

**(一). 模式匹配函数**
在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)      
这是一个返回迭代器的函数. 实际的用例如下:

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

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

```lua
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个成功配对的成员进行操作.

以下是几个例子:

```lua
> 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.

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

string.reverse(str)

返回一个字符串的倒序排列

```lua
string.reverse("abcde")
->edcba
```

string.dump(function)
返回指定函数的二进制代码(函数必须是一个Lua函数，并且没有上值)
string.find(str, pattern, init, plain) 
string.find的基本应用就是用来在目标串（subject string）内搜索匹配指定的模式的串。函数如果找到匹配的串返回他的位置，否则返回nil.最简单的模式就是一个单词，仅仅匹配单词本身。比如，模式'hello'仅仅匹配目标串中的"hello"。当查找到模式的时候，函数返回两个值：匹配串开始索引和结束索引。

```lua
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函数第三个参数是可选的：标示目标串中搜索的起始位置。当我们想查找目标串中所有匹配的子串的时候，这个选项非常有用。我们可以不断的循环搜索，每一次从前一次匹配的结束位置开始。下面看一个例子，下面的代码用一个字符串中所有的新行构造一个表：

```lua
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返回的值截取匹配的子串。
对简单模式而言，匹配的就是其本身

```lua
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函数有三个参数：目标串，模式串，替换串。

```lua
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
```

第四个参数是可选的，用来限制替换的范围：

```lua
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格式的日期：

```lua
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'非字母的字符

```lua
print(string.gsub("hello, up-down!", "%A", "."))
    --> hello..up.down. 4
```

（数字4不是字符串结果的一部分，他是gsub返回的第二个结果，代表发生替换的次数。下面其他的关于打印gsub结果的例子中将会忽略这个数值。）在模式匹配中有一些特殊字符，他们有特殊的意义，Lua中的特殊字符如下：

( ) . % + - * ? [ ^ $

'%' 用作特殊字符的转义字符，因此 '%.' 匹配点；'%%' 匹配字符 '%'。转义字符 '%'不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。当对一个字符有疑问的时候，为安全起见请使用转义字符转义。
　　对Lua而言，模式串就是普通的字符串。他们和其他的字符串没有区别，也不会受到特殊对待。只有他们被用作模式串用于函数的时候，'%' 才作为转义字符。所以，如果你需要在一个模式串内放置引号的话，你必须使用在其他的字符串中放置引号的方法来处理，使用 '\' 转义引号，'\' 是Lua的转义符。你可以使用方括号将字符类或者字符括起来创建自己的字符类（译者：Lua称之为char-set，就是指传统正则表达式概念中的括号表达式）。比如，'[%w_]' 将匹配字母数字和下划线，'[01]' 匹配二进制数字，'[%[%]]' 匹配一对方括号。下面的例子统计文本中元音字母出现的次数：

```lua
_, 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+' 匹配一个或多个字母或者一个单词：

```lua
print(string.gsub("one, and two; and three", "%a+", "word"))
    --> word, word word; word word
```

'%d+' 匹配一个或多个数字（整数）：

```lua
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程序中的注释，很多人可能使用 '/%*.*%*/'（也就是说 "/*" 后面跟着任意多个字符，然后跟着 "*/" ）。然而，由于 '.*' 进行的是最长匹配，这个模式将匹配程序中第一个 "/*" 和**最后一个 "*/"** 之间所有部分：

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

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

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

'?' 匹配一个字符0次或1次。举个例子，假定我们想在一段文本内查找一个整数，整数可能带有正负号。模式 '[+-]?%d+' 符合我们的要求，它可以匹配像 "-12"、"23" 和 "+1009" 等数字。'[+-]' 是一个匹配 '+' 或者 '-' 的字符类；接下来的 '?' 意思是匹配前面的字符类0次或者1次。

与其他系统的模式不同的是，Lua中的修饰符不能用字符类；不能将模式分组然后使用修饰符作用这个分组。比如，没有一个模式可以匹配一个可选的单词（除非这个单词只有一个字母）。下面我将看到，通常你可以使用一些高级技术绕开这个限制。
以 '^' 开头的模式只匹配目标串的开始部分，相似的，以 '$' 结尾的模式只匹配目标串的结尾部分。这不仅可以用来限制你要查找的模式，还可以定位（anchor）模式。比如：

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

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

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

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

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

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

--lua中字符串索引从前往后是1,2,……，从后往前是-1，-2……。

--string库中所有的function都不会直接操作字符串，只返回一个结果。

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

**【基本函数】**
<table style="width: 580px; height: 400px;" border="0" cellspacing="0" cellpadding="0">
    <colgroup>
        <col width="54">
            <col width="183">
                <col width="230">
                    <col width="95">
    </colgroup>
    <tbody>
        <tr>
            <td width="54" height="22">函数</td>
            <td width="183">描述</td>
            <td width="230">示例</td>
            <td width="95">结果</td>
        </tr>
        <tr>
            <td height="22">len</td>
            <td width="183">计算字符串长度</td>
            <td>string.len("abcd")</td>
            <td>4</td>
        </tr>
        <tr>
            <td height="22"><span style="color: #ff0000;">rep</span>
            </td>
            <td width="183">返回字符串s的n个拷贝</td>
            <td>string.rep("abcd",2)</td>
            <td>abcdabcd</td>
        </tr>
        <tr>
            <td height="22">lower</td>
            <td width="183">返回字符串全部字母大写</td>
            <td>string.lower("AbcD")</td>
            <td>abcd</td>
        </tr>
        <tr>
            <td height="22">upper</td>
            <td width="183">返回字符串全部字母小写</td>
            <td>string.upper("AbcD")</td>
            <td>ABCD</td>
        </tr>
        <tr>
            <td height="22"><span style="color: #ff0000;">format</span>
            </td>
            <td width="183">返回一个类似printf的格式化字符串(format的各种格式化控制字符在本博文附录中介绍)</td>
            <td>string.format("the value is:%d",4)</td>
            <td>the value is:4</td>
        </tr>
        <tr>
            <td rowspan="4" height="88">sub</td>
            <td rowspan="4" width="183">returns substring from index i to j of s</td>
            <td>string.sub("abcd",2)</td>
            <td>bcd</td>
        </tr>
        <tr>
            <td height="22">string.sub("abcd",-2)</td>
            <td>cd</td>
        </tr>
        <tr>
            <td height="22">string.sub("abcd",2,-2)</td>
            <td>bc</td>
        </tr>
        <tr>
            <td height="22">string.sub("abcd",2,3)</td>
            <td>bc</td>
        </tr>
        <tr>
            <td rowspan="3" height="66">find</td>
            <td rowspan="3" width="183">在字符串中查找</td>
            <td>string.find("cdcdcdcd","ab")</td>
            <td>nil</td>
        </tr>
        <tr>
            <td height="22">string.find("cdcdcdcd","cd")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">string.find("cdcdcdcd","cd",7)</td>
            <td>7    8</td>
        </tr>
        <tr>
            <td rowspan="2" height="44"><span style="color: #ff0000;">gsub</span>
            </td>
            <td rowspan="2" width="183">在字符串中替换</td>
            <td>string.gsub("abcdabcd","a","z");</td>
            <td>zbcdzbcd    2</td>
        </tr>
        <tr>
            <td height="22">string.gsub("aaaa","a","z",3);</td>
            <td>zzza    3</td>
        </tr>
        <tr>
            <td height="22"><span style="color: #ff0000;">byte</span>
            </td>
            <td width="183">返回字符的整数形式</td>
            <td>string.byte("ABCD",4)</td>
            <td>68(D的ASCII码)</td>
        </tr>
        <tr>
            <td height="22">char</td>
            <td width="183">将整型数字转成字符并连接</td>
            <td>string.char(97,98,99,100)</td>
            <td>abcd</td>
        </tr>
    </tbody>
</table>

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

**【基本模式串】**

<table style="width: 562px;" border="0" cellspacing="0" cellpadding="0">
    <colgroup>
        <col width="54">
            <col width="183">
                <col width="230">
                    <col width="95">
    </colgroup>
    <tbody>
        <tr>
            <td width="54" height="22">字符类</td>
            <td width="183">描述</td>
            <td width="230">示例</td>
            <td width="95">结果</td>
        </tr>
        <tr>
            <td height="22">.</td>
            <td>任意字符</td>
            <td>string.find("",".")</td>
            <td>nil</td>
        </tr>
        <tr>
            <td height="22">%s</td>
            <td>空白符</td>
            <td>string.find("ab  cd","%s%s")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%S</td>
            <td>非空白符</td>
            <td>string.find("ab  cd","%S%S")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">%p</td>
            <td>标点字符</td>
            <td>string.find("ab,.cd","%p%p")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%P</td>
            <td>非标点字符</td>
            <td>string.find("ab,.cd","%P%P")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">%c</td>
            <td>控制字符</td>
            <td>string.find("abcd\t\n","%c%c")</td>
            <td>5    6</td>
        </tr>
        <tr>
            <td height="22">%C</td>
            <td>非控制字符</td>
            <td>string.find("\t\nabcd","%C%C")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%d</td>
            <td>数字</td>
            <td>string.find("abcd12","%d%d")</td>
            <td>5    6</td>
        </tr>
        <tr>
            <td height="22">%D</td>
            <td>非数字</td>
            <td>string.find("12abcd","%D%D")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%x</td>
            <td>十六进制数字</td>
            <td>string.find("efgh","%x%x")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">%X</td>
            <td>非十六进制数字</td>
            <td>string.find("efgh","%X%X")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%a</td>
            <td>字母</td>
            <td>string.find("AB12","%a%a")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">%A</td>
            <td>非字母</td>
            <td>string.find("AB12","%A%A")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%l</td>
            <td>小写字母</td>
            <td>string.find("ABab","%l%l")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%L</td>
            <td>大写字母</td>
            <td>string.find("ABab","%L%L")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">%u</td>
            <td>大写字母</td>
            <td>string.find("ABab","%u%u")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">%U</td>
            <td>非大写字母</td>
            <td>string.find("ABab","%U%U")</td>
            <td>3    4</td>
        </tr>
        <tr>
            <td height="22">%w</td>
            <td>字母和数字</td>
            <td>string.find("a1()","%w%w")</td>
            <td>1    2</td>
        </tr>
        <tr>
            <td height="22">%W</td>
            <td>非字母非数字</td>
            <td>string.find("a1()","%W%W")</td>
            <td>3    4</td>
        </tr>
    </tbody>
</table>

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

**【转义字符%】**

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

【用[]创建字符集，"-"为连字符，"^"表示字符集的补集】

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

**【用"()"进行捕获】**

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

【模式修饰符】

string函数库的一些使用例子：

![1578627043755_2.png](https://tools.nxcloud.club:12500/images/2020/01/10/1578627043755_2.png)

附录1：

Lua提供了string.format()函数来生成具有特定格式的字符串, 函数的第一个参数是格式(formatstring), 之后是对应格式中每个代号的各种数据. 由于格式字符串的存在, 使得产生的长字符串可读性大大提高了. 这个函数的格式很像C语言中的printf().函数string.format在用来对字符串进行格式化的时候，特别是字符串输出，是功能强大的工具。这个函数有两个参数，你完全可以照C语言的printf来使用这个函数。第一个参数为格式化串：由指示符和控制格式的字符组成。指示符后的控制格式的字符可以为：十进制'd'；十六进制'x'；八进制'o'；浮点数'f'；字符串's'。在指示符'%'和控制格式字符之间还可以有其他的选项：用来控制更详细的格式，比如一个浮点数的小数的位数：

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

```lua
%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, ...).

```lua
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</%s>", tag, title, tag))
        --> <h1>a title</h1>

-----------------------------------------------
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
```

附录2

string.char函数和string.byte函数用来将字符在字符和数字之间转换。string.char获取0个或多个整数，将每一个数字转换成字符，然后返回一个所有这些字符连接起来的字符串。string.byte(s, i)将字符串s的第i个字符的转换成整数；第二个参数是可选的，缺省情况下i=1。下面的例子中，我们假定字符用ASCII表示：

```lua
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_reference]http://www.lua.org/manual/5.3/