Lua的简单使用

Lua是一种轻量级的脚本语言，也有面向对象的编程思想，开发起来很方便。

可直接shell调用Lua package中的某个API：

lua -e 'require("path_to_lua_api").api_name("api_parameter")'

如：

lua -e 'require("luci.fs").api_name("api_parameter")'

system arg，传递调用的参数：

arg[n]

其中n为序号，如0， 1，2，通常情况下，0代表调用的脚本本身，1代表第一个参数，2表示第二个，以此类推。

如：

/tmp# cat test_arg.lua 
#!/usr/bin/lua

function main()
    print("arg[0] is ", arg[0])
    print("arg[1] is ", arg[1])
    print("arg[2] is ", arg[2])
end

main()

运行后：

/tmp# lua test_arg.lua first second
arg[0] is       test_arg.lua
arg[1] is       first
arg[2] is       second

并没有argc（arguement count）这个值，所以可以用：

#arg

时间的获取：
- 使用os.time
```
local cur_time = os.time()
print(cur_time)
```
  运行结果为UNIX时间戳，单位是秒：
```
1700638601
```
- 使用os.date
```
 print(os.date())
```
  结果为：
```
Wed Nov 22 15:36:41 2023
```
  os.date还可以传参，控制输出格式，如：
```
os.date("%H:%M:%S")
```
  或者解析时间参数：
```
local time_string = os.date("%Y-%m-%d %H:%M:%S", os.time())
```
  而且Lua已经自动根据机器的时区做了转换，非常方便。
- 使用socket这个package
```
local socket = require "socket"
print("time:", socket.gettime())
```
  得到结果，应该是100微秒的单位级别：
```
time:   1700638361.9353
```

lua的pair和ipair区别在于：ipairs只能遍历数字索引的元素，而pairs可以遍历所有类型的元素。

如：

    local t1 = {"a", "b", "c", "d"}
    print("pairs")
    for k, v in pairs(t1) do
        print("k:", k)
        print("v:", v)
    end

    print("ipairs")
    for k, v in ipairs(t1) do
        print("k:", k)
        print("v:", v)
    end

此时因为是数字的索引，即key值为数字（integer），所以pairs和ipairs的输出无区别：

pairs
k:      1
v:      a
k:      2
v:      b
k:      3
v:      c
k:      4
v:      d
ipairs
k:      1
v:      a
k:      2
v:      b
k:      3
v:      c
k:      4
v:      d

但是，如果索引不是数字：

local t2 = {
        key1 = 1,
        key2 = 2
    }

    print("pairs")
    for k, v in pairs(t2) do
        print("k:", k)
        print("v:", v)
    end

    print("ipairs")
    for k, v in ipairs(t2) do
        print("k:", k)
        print("v:", v)
    end

可以发现ipairs无任何打印输出，即无法遍历tables，输出如下：

pairs
k:      key1
v:      1
k:      key2
v:      2
ipairs

lua的string库，如sub/gsub/match/gmatch

Lua的字符串处理功能非常强大，提供了很多方法来操作字符串。其中，sub、gsub、match和gmatch函数是在Lua的string库中常用的方法，它们的功能和使用方式有一些差异。
- sub 函数
  sub函数用于返回字符串的一个子串。它接受三个参数：字符串、起始位置和结束位置。返回从起始位置到结束位置之间的子串。如果起始位置或结束位置越界，将引发错误。
示例代码：
```
str = "Hello, World!"
sub_str = string.sub(str, 8, 12)  -- 返回 "World"
print(sub_str)  -- 输出 "World"
```
- gsub 函数
  gsub函数用于在字符串中替换指定的子串。它接受三个参数：字符串、替换模式和替换字符串。它将字符串中所有匹配替换模式的地方都替换为指定的替换字符串。
示例代码：
```
str = "Hello, World!"
new_str = string.gsub(str, "World", "Lua")  -- 将 "World" 替换为 "Lua"
print(new_str)  -- 输出 "Hello, Lua!"
```
- match 函数
  match函数用于在字符串中查找匹配的子串，并返回匹配的结果。它接受两个参数：字符串和匹配模式。如果找到了匹配的内容，将返回一个包含匹配结果的表；否则返回nil。
示例代码：
```
str = "Hello, World!"
match_result = string.match(str, "World")  -- 匹配 "World"
if match_result ~= nil then
    print(match_result)  -- 输出 "World"
end
```
- gmatch 函数
  gmatch函数用于在字符串中查找重复匹配的子串，并返回一个迭代器。它接受两个参数：字符串和匹配模式。每次调用迭代器，将返回下一个匹配的结果。如果没有更多的匹配结果，迭代器将返回nil。
示例代码：
```
str = "Hello, World! World!"
gmatch_iter = string.gmatch(str, "World")  -- 创建迭代器
while gmatch_iter() do  -- 迭代所有匹配结果
    print(gmatch_iter())  -- 输出 "World"
end
```
总结：
sub函数用于提取字符串的子串；gsub函数用于替换字符串中的子串；match函数用于查找字符串中的匹配子串；gmatch函数用于迭代字符串中重复匹配的子串。这些函数提供了灵活的字符串操作功能，可以满足不同的字符串处理需求。

随机数

-- 生成1到100之间的随机数  
math.randomseed(os.time())  
number = math.random(1, 100)

读写文件

read

local function read_from_file(file)
    local fp = io.open(file, "r")
    local data = nil
    if fp == nil then
        dbg("error open file failed:" .. file)
    else
        local lines = fp:read("*all")
        fp:close()
        data = json.decode(lines)
    end
	return data
end

write

local function write_to_file(file, data)
    local fp = io.open(file, "w")
    if fp == nil then
        dbg("error open file failed:" .. file)
        return false
    end
    fp:write(json.encode(data))
    fp:close()
    return true
end