-- 赋值是改变一个变量的值和改变表域的最基本的方法。
a = "hello" .. "world"
t.n = t.n + 1

-- Lua 可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。
a, b = 10, 2*x       <-->       a=10; b=2*x

-- 遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作，所以我们可以这样进行交换变量的值：
x, y = y, x                     -- swap 'x' for 'y'
a[i], a[j] = a[j], a[i]         -- swap 'a[i]' for 'a[j]'

--[[
当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：
a. 变量个数 > 值的个数             按变量个数补足nil
b. 变量个数 < 值的个数             多余的值会被忽略
]]

a, b, c = 0, 1
print(a,b,c)             --> 0   1   nil

a, b = a+1, b+1, b+2     -- value of b+2 is ignored
print(a,b)               --> 1   2

a, b, c = 0
print(a,b,c)             --> 0   nil   nil

-- 多值赋值经常用来交换变量，或将函数调用返回给变量：
a, b = f()

--[[
应该尽可能的使用局部变量，有两个好处：

1. 避免命名冲突。
2. 访问局部变量的速度比全局变量更快。
]]

-- 对 table 的索引使用方括号 []。Lua 也提供了 . 操作。
t[i]
t.i                 -- 当索引为字符串类型时的一种简化写法
gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用

--[[
while循环

while(condition)
do
   statements
end
]]

a=10
while( a < 20 )
do
   print("a 的值为:", a)
   a = a+1
end

--[[
repeat...until循环

当condition为true时，结束statements
repeat
   statements
until( condition )
]]

a = 10
repeat
   print("a的值为:", a)
   a = a + 1
until( a > 15 )

--[[
if( 布尔表达式 1) then
   --[ 在布尔表达式 1 为 true 时执行该语句块 --]
   if(布尔表达式 2) then
      --[ 布尔表达式 2 为 true 时执行该语句块 --]
   end
elseif( 布尔表达式 2) then
   --[ 在布尔表达式 2 为 true 时执行该语句块 --]

elseif( 布尔表达式 3) then
   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
else 
   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end
]]

--[[
optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
    function_body
    return result_params_comma_separated
end

* optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。
* function_name: 指定函数名称。
* argument1, argument2, argument3..., argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。
* function_body: 函数体，函数中需要执行的代码语句块。
* result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。
]]

--[[
将函数作为参数传递给函数
]]
myprint = function(param)
   print("这是打印函数 -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   -- 调用传递的函数参数
   functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)

--[[
多返回值

Lua函数可以返回多个结果值，比如string.find，其返回匹配串"开始和结束的下标"（如果不存在匹配串返回nil）。
]]
function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    for i,val in ipairs(a) do
       if val > m then
           mi = i
           m = val
       end
    end
    return m, mi
end

print(maximum({8,10,23,12,5}))

--[[
可变参数

Lua 函数可以接受可变数目的参数，和 C 语言类似，在函数参数列表中使用三点 ... 表示函数有可变的参数。

通常在遍历变长参数的时候只需要使用 {…}，然而变长参数可能会包含一些 nil，那么就可以用 select 函数来访问变长参数了：select('#', …) 或者 select(n, …)

* select('#', …) 返回可变参数的长度。
* select(n, …) 用于返回从起点 n 开始到结束位置的所有参数列表。
]]
function add(...)  
local s = 0  
  for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组  
    s = s + v  
  end  
  return s  
end  
print(add(3,4,5,6,7))  --->25

-- 大小写转换
string.upper(string
string.lower(string)

-- 替换
string.gsub(mainString,findString,replaceString,num)

-- 查找
string.find(string)

-- 反转
string.reverse(string)

-- 格式化，类似java中的String.format
string.format(templateString, params)

-- 整型与字符之间的转换
string.byte("A") --> 65
string.byte("ABCD", 4) --> 68
string.char(65, 66, 67, 68) --> "ABCD"

-- 字符串长度
string.len("123") -- 3

-- 字符串拷贝
string.rep("a", 2) --> "aa"

-- 连接多个字符串
print("123".."456") --> "123456"

--[[
返回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。
如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。
]]
for word in string.gmatch("Hello Lua user", "%a+") do print(word) end
--[[
Hello
Lua
user
]]

--[[
string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。
在成功配对时, 函数将返回配对表达式中的所有捕获结果; 
如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。
]]
string.match("I have 2 questions for you.", "%d+ %a+") --> 2 questions
string.format("%d, %q", string.match("I have 2 questions for you.", "(%d+) (%a+)")) --> 2, "questions"

--[[
字符串截取使用 sub() 方法。

用于截取字符串，原型为：
string.sub(s, i [, j])

s：要截取的字符串。
i：截取开始位置。
j：截取结束位置，默认为 -1，最后一个字符。
]]

string.sub("1234", 2, 3) --> 23
string.sub("1234", 2, 2) --> 2
string.sub("1234", -2) --> 34
string.sub("1234", -10) --> 1234

-- 一维数组: 默认索引以1开始，可以为0和负数指定value
array = {"Lua", "Tutorial"}

-- 多维数组: 即数组中包含数组或一维数组的索引键对应一个数组。
array = {}
for i=1,3 do
   array[i] = {}
      for j=1,3 do
         array[i][j] = i*j
      end
end

array = {}
maxRows = 3
maxColumns = 3
for row=1,maxRows do
   for col=1,maxColumns do
      array[row*maxColumns +col] = row*col
   end
end

-- 初始化表
mytable = {}

-- 指定值
mytable[1]= "Lua"

-- 移除引用
mytable = nil
-- lua 垃圾回收会释放内存

fruits = {"banana","orange","apple"}
-- 返回 table 连接后的字符串
print("连接后的字符串 ",table.concat(fruits))

-- 指定连接字符
print("连接后的字符串 ",table.concat(fruits,", "))

-- 指定索引来连接 table
print("连接后的字符串 ",table.concat(fruits,", ", 2,3))

fruits = {"banana","orange","apple"}

-- 在末尾插入
table.insert(fruits,"mango")
print("索引为 4 的元素为 ",fruits[4])

-- 在索引为 2 的键处插入
table.insert(fruits,2,"grapes")
print("索引为 2 的元素为 ",fruits[2])

print("最后一个元素为 ",fruits[5])
table.remove(fruits)
print("移除后最后一个元素为 ",fruits[5])

fruits = {"banana","orange","apple","grapes"}
print("排序前")
for k,v in ipairs(fruits) do print(k,v) end

table.sort(fruits)
print("排序后")
for k,v in ipairs(fruits) do print(k,v) end

function split(s, delimiter)
    result = {};
    for match in (s..delimiter):gmatch("(.-)"..delimiter) do
        table.insert(result, match);
    end
    return result;
end

-- 文件名为 module.lua
-- 定义一个名为 module 的模块
module = {}
 
-- 定义一个常量
module.constant = "这是一个常量"
 
-- 定义一个函数
function module.func1()
    io.write("这是一个公有函数！\n")
end
 
local function func2()
    print("这是一个私有函数！")
end
 
function module.func3()
    func2()
end
 
return module

require("<模块名>")
-- OR
require "<模块名>"

-- test_module.lua 文件
-- module 模块为上文提到到 module.lua
require("module")
 
print(module.constant) --> 这是一个常量
module.func3() --> 这是一个私有函数！

-- test_module2.lua 文件
-- module 模块为上文提到到 module.lua
-- 别名变量 m
local m = require("module")
 
print(m.constant) --> 这是一个常量
m.func3() --> 这是一个私有函数！

local path = "/usr/local/lua/lib/libluasocket.so"
local f = loadlib(path, "luaopen_socket")

local path = "/usr/local/lua/lib/libluasocket.so"
-- 或者 path = "C:\\windows\\luasocket.dll"，这是 Window 平台下
local f = assert(loadlib(path, "luaopen_socket"))
f()  -- 真正打开库

file = io.open (filename [, mode])

-- 以只读方式打开文件*
file = io.open("test.lua", "r")

-- 设置默认输入文件为 test.lua*
io.input(file)

-- 输出文件第一行*
print(io.read())

-- 关闭打开的文件*
io.close(file)

-- 以附加的方式打开只写文件*
file = io.open("test.lua", "a")

-- 设置默认输出文件为 test.lua*
io.output(file)

-- 在文件最后一行添加 Lua 注释*
io.write("--  test.lua 文件末尾注释")

-- 关闭打开的文件*
io.close(file)

-- test.lua 文件

-- 以只读方式打开文件*
file = io.open("test.lua", "r")

-- 输出文件第一行*
print(file:read())

-- 关闭打开的文件*
file:close()

-- 以附加的方式打开只写文件*
file = io.open("test.lua", "a")

-- 在文件最后一行添加 Lua 注释*
file:write("--test")

-- 关闭打开的文件*
file:close()

-- test.lua 文件

-- 以只读方式打开文件*
file = io.open("test.lua", "r")

file:seek("end",-25)
print(file:read("*a"))

-- 关闭打开的文件*
file:close()