• 标准库
    • String
      • (1) pattern 模式
      • (2) capture 捕获
      • (3) string.find 字符串查找
      • (4) string.gmatch 全局字符串查找
      • (5) string.gsub 全局字符串替换
      • (6) string.sub, string.byte, string.format
    • Table
      • (1) table.getn
      • (2) table.insert, table.remove
      • (3) table.sort
    • Coroutine
    • Math
    • IO
    • OS
    • File
    • Debug
    • 导航

    标准库

    String

    1. string.byte
    2. string.char
    3. string.dump
    4. string.find
    5. string.format
    6. string.gmatch
    7. string.gsub
    8. string.len
    9. string.lower
    10. string.match
    11. string.rep
    12. string.reverse
    13. string.sub
    14. string.upper

    在string库中功能最强大的函数是：string.find（字符串查找），string.gsub（全局字符串替换），and string.gfind（全局字符串查找）。这些函数都是基于模式匹配的。

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

    (1) pattern 模式

    下面的表列出了Lua支持的所有字符类：

    1. .      任意字符
    2. %a     字母
    3. %c     控制字符
    4. %d     数字
    5. %l     小写字母
    6. %p     标点字符
    7. %s     空白符
    8. %u     大写字母
    9. %w     字母和数字
    10. %x     十六进制数字
    11. %z     代表0的字符

    可以使用修饰符来修饰模式增强模式的表达能力，Lua中的模式修饰符有四个：

    1. +      匹配前一字符1次或多次
    2. *      匹配前一字符0次或多次
    3. -      匹配前一字符0次或多次
    4. ?      匹配前一字符0次或1次

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

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

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

    (2) capture 捕获

    Capture是这样一种机制：可以使用模式串的一部分匹配目标串的一部分。将你想捕获的模式用圆括号括起来，就指定了一个capture。

    1. pair = "name = Anna"
    2. _, _, key, value = string.find(pair, "(%a+)%s*=%s*(%a+)")
    3. print(key, value)    --> name   Anna

    (3) string.find 字符串查找

    string.find 的基本应用就是用来在目标串（subject string）内搜索匹配指定的模式的串，函数返回两个值：匹配串开始索引和结束索引。

    1. s = "hello world"
    2. i, j = string.find(s, "hello")
    3. print(i, j)                        --> 1    5
    4. print(string.sub(s, i, j))         --> hello
    5. print(string.find(s, "world"))     --> 7    11
    6. i, j = string.find(s, "l")
    7. print(i, j)                        --> 3    3
    8. print(string.find(s, "lll"))       --> nil

    string.find函数第三个参数是可选的：标示目标串中搜索的起始位置。

    在string.find使用captures的时候，函数会返回捕获的值作为额外的结果：

    1. pair = "name = Anna"
    2. _, _, key, value = string.find(pair, "(%a+)%s*=%s*(%a+)")
    3. print(key, value)    --> name   Anna

    看个例子，假定你想查找一个字符串中单引号或者双引号引起来的子串，你可能使用模式 ‘[“‘].-[“‘]’，但是这个模式对处理类似字符串 “it’s all right” 会出问题。为了解决这个问题，可以使用向前引用，使用捕获的第一个引号来表示第二个引号：

    1. s = [[then he said: "it's all right"!]]
    2. a, b, c, quotedPart = string.find(s, "(["'])(.-)%1")
    3. print(quotedPart)    --> it's all right
    4. print(c)             --> "

    (4) string.gmatch 全局字符串查找

    string.gfind 函数比较适合用于范性 for 循环。他可以遍历一个字符串内所有匹配模式的子串。

    1. words = {}
    2. for w in string.gmatch("nick takes a stroll", "%a+") do
    3.     table.insert(words, w)
    4. end

    URL解码

    1. function unescape(s)
    2.     s = string.gsub(s, "+", " ")
    3.     s = string.gsub(s, "%%(%x%x)", function(h)
    4.         return string.char(tonumber(h, 16))
    5.     end)
    6.     return s
    7. end
    9. print(unescape("a%2Bb+%3D+c")) -- a+b = c

    对于name=value对，我们使用gfind解码，因为names和values都不能包含 ‘&’ 和 ‘=’我们可以用模式 ‘[^&=]+’ 匹配他们：

    1. cgi = {}
    2. function decode (s)
    3.     for name, value in string.gmatch(s, "([^&=]+)=([^&=]+)") do
    4.        name = unescape(name)
    5.        value = unescape(value)
    6.        cgi[name] = value
    7.     end
    8. end

    URL编码

    这个函数将所有的特殊字符转换成 ‘%’ 后跟字符对应的ASCII码转换成两位的16进制数字（不足两位，前面补0），然后将空白转换为 ‘+’：

    1. function escape(s)
    2.     s = string.gsub(s, "([&=+%c])", function(c)
    3.         return string.format("%%%02X", string.byte(c))
    4.     end)
    5.     s = string.gsub(s, " ", "+")
    6.     return s
    7. end
    9. function encode(t)
    10.     local s = ""
    11.     for k, v in pairs(t) do
    12.         s = s .. "&" .. escape(k) .. "=" .. escape(v)
    13.     end
    14.     return string.sub(s, 2) -- remove first '&'
    15. end
    16. t = {name = "al", query = "a+b = c", q = "yes or no"}
    18. print(encode(t)) --> q=yes+or+no&query=a%2Bb+%3D+c&name=al

    (5) string.gsub 全局字符串替换

    string.gsub 函数有三个参数：目标串，模式串，替换串，第四个参数是可选的，用来限制替换的数量。

    1. print(string.gsub("nck eats fish", "fish", "chips")) --> nick eats chips 1

    string.gsub 的第二个返回值表示他进行替换操作的次数：

    1. print(string.gsub("fish eats fish", "fish", "chips")) --> chips eats chips 2

    使用模式：

    1. print(string.gsub("nick eats fish", "[AEIOUaeiou]", ".")) --> n.ck ..ts f.sh 4

    使用捕获：

    1. print(string.gsub("nick eats fish", "([AEIOUaeiou])", "(%1)")) --> n(i)ck (e)(a)ts f(i)sh 4

    使用替换函数：

    1. function f(s)
    2.     print("found " .. s)
    3. end
    5. string.gsub("Nick is taking a walk today", "%a+", f)
    7. 输出：
    8. found Nick
    9. found is
    10. found taking
    11. found a
    12. found walk
    13. found today

    (6) string.sub, string.byte, string.format

    1. s = "[in brackets]"
    2. print(string.sub(s, 2, -2))     --> in brackets

    string.char 函数和 string.byte 函数用来将字符在字符和数字之间转换，string.char 获取0个或多个整数，将每一个数字转换成字符，然后返回一个所有这些字符连接起来的字符串。string.byte(s, i) 将字符串s的第i个字符的转换成整数。

    1. print(string.char(97))                    --> a
    2. i = 99; print(string.char(i, i+1, i+2))   --> cde
    3. print(string.byte("abc"))                 --> 97
    4. print(string.byte("abc", 2))              --> 98
    5. print(string.byte("abc", -1))             --> 99

    string.format 和 C 语言的 printf 函数几乎一模一样，你完全可以照 C 语言的 printf 来使用这个函数，第一个参数为格式化串：由指示符和控制格式的字符组成。指示符后的控制格式的字符可以为：十进制’d’；十六进制’x’；八进制’o’；浮点数’f’；字符串’s’。

    1. print(string.format("pi = %.4f", PI)) --> pi = 3.1416
    2. d = 5; m = 11; y = 1990
    3. print(string.format("%02d/%02d/%04d", d, m, y)) --> 05/11/1990
    4. tag, title = "h1", "a title"
    5. print(string.format("<%s>%s</%s>", tag, title, tag)) --> <h1>a title</h1>

    Table

    1. table.concat
    2. table.insert
    3. table.maxn
    4. table.remove
    5. table.sort

    (1) table.getn

    1. print(table.getn{10,2,4})          --> 3
    2. print(table.getn{10,2,nil})        --> 2
    3. print(table.getn{10,2,nil; n=3})   --> 3
    4. print(table.getn{n=1000})          --> 1000
    6. a = {}
    7. print(table.getn(a))               --> 0
    8. table.setn(a, 10000)
    9. print(table.getn(a))               --> 10000
    11. a = {n=10}
    12. print(table.getn(a))               --> 10
    13. table.setn(a, 10000)
    14. print(table.getn(a))               --> 10000

    (2) table.insert, table.remove

    1. table.isnert(table, value, position)
    2. table.remove(table, position)

    table库提供了从一个list的任意位置插入和删除元素的函数。table.insert函数在array指定位置插入一个元素，并将后面所有其他的元素后移。

    1. a = {}
    2. for line in io.lines() do
    3.     table.insert(a, line)
    4. end
    5. print(table.getn(a))        --> (number of lines read)

    table.remove 函数删除数组中指定位置的元素，并返回这个元素，所有后面的元素前移，并且数组的大小改变。不带位置参数调用的时候，他删除array的最后一个元素。

    (3) table.sort

    table.sort 有两个参数，存放元素的array和排序函数，排序函数有两个参数并且如果在array中排序后第一个参数在第二个参数前面，排序函数必须返回true。如果未提供排序函数，sort使用默认的小于操作符进行比较。

    1. lines = {
    2.     luaH_set = 10,
    3.     luaH_get = 24,
    4.     luaH_present = 48,
    5. }
    7. function pairsByKeys (t, f)
    8.     local a = {}
    9.     for n in pairs(t) do table.insert(a, n) end
    10.     table.sort(a, f)
    11.     local i = 0                 -- iterator variable
    12.     local iter = function ()    -- iterator function
    13.        i = i + 1
    14.        if a[i] == nil then return nil
    15.        else return a[i], t[a[i]]
    16.        end
    17.     end
    18.     return iter
    19. end
    21. for name, line in pairsByKeys(lines) do
    22.     print(name, line)
    23. end

    打印结果：

    1. luaH_get          24
    2. luaH_present      48
    3. luaH_set          10

    Coroutine

    1. coroutine.create
    2. coroutine.resume
    3. coroutine.running
    4. coroutine.status
    5. coroutine.wrap
    6. coroutine.yield

    Math

    1. math.abs
    2. math.acos
    3. math.asin
    4. math.atan
    5. math.atan2
    6. math.ceil
    7. math.cos
    8. math.cosh
    9. math.deg
    10. math.exp
    11. math.floor
    12. math.fmod
    13. math.frexp
    14. math.huge
    15. math.ldexp
    16. math.log
    17. math.log10
    18. math.max
    19. math.min
    20. math.modf
    21. math.pi
    22. math.pow
    23. math.rad
    24. math.random
    25. math.randomseed
    26. math.sin
    27. math.sinh
    28. math.sqrt
    29. math.tan
    30. math.tanh

    IO

    1. io.close
    2. io.flush
    3. io.input
    4. io.lines
    5. io.open
    6. io.output
    7. io.popen
    8. io.read
    9. io.stderr
    10. io.stdin
    11. io.stdout
    12. io.tmpfile
    13. io.type
    14. io.write

    OS

    1. os.clock
    2. os.date
    3. os.difftime
    4. os.execute
    5. os.exit
    6. os.getenv
    7. os.remove
    8. os.rename
    9. os.setlocale
    10. os.time
    11. os.tmpname

    File

    1. file:close
    2. file:flush
    3. file:lines
    4. file:read
    5. file:seek
    6. file:setvbuf
    7. file:write

    Debug

    1. debug.debug
    2. debug.getfenv
    3. debug.gethook
    4. debug.getinfo
    5. debug.getlocal
    6. debug.getmetatable
    7. debug.getregistry
    8. debug.getupvalue
    9. debug.setfenv
    10. debug.sethook
    11. debug.setlocal
    12. debug.setmetatable
    13. debug.setupvalue
    14. debug.traceback

    导航

    • 目录
    • 上一章：函数与面向对象
    • 下一章：协程 Coroutine