下面讲解lua变量声明以及条件判断语句

local a = 0				-- 局部变量，number类型 
b = false				-- 全局变量，bool类型 
c = "Hello"				-- string类型 
d, e, f = 0, 1.1		-- d=0,e=1.1,f=nil
g = 1 .. 2				-- g=12, ..会拼接前后的字符串

if a == 0 and b ~= 0 then       -- lua中false不等于0
    print("1") 
elseif c >= 0 or not d then 
    print("2") 
else 
    print("3") 
end

输出结果：1

函数大致分为：局部函数，全局函数和成员函数。函数前加local就是局部函数，只能在本文件中被调用；不加local就是全局函数，可以在其他文件调用该函数；成员函数是定义在table里的函数，需要通过table调用。

local function hello()           -- 局部函数，只允许在本文件内调用
    print("Hello world")
end
hello()                          -- 调用函数

输出结果：
Hello world

function average(...)            -- 全局函数，...表示可变参数
   result = 0
   local arg={...}              -- arg为一个表，局部变量，里面存放的是入参
   for i, var in ipairs(arg) do
       result = result + var    -- 入参累加
   end
   print("形参个数：" .. #arg .. " 个")
   return result/#arg
end

print("平均值为："..average(10,5,3,4,5,6)) -- 调用求平均值函数average()

输出结果：
形参个数：6 个
平均值为：5.5

People = {age = 20}               -- 声明一个类(table)

function People.sayHi(self, name) -- 类的成员函数
    print(name, self.age)
end

People.sayHi(People, "Zhangsan")  -- 直接调用类的成员函数
People:sayHi("Lisi")              -- 将People自身作为实参传入函数，效果同上

输出结果：
Zhangsan 20
Lisi 20

table可以看作是C++里的类，里面可以放变量也可以放函数，可以在任意时候往table里增加变量或函数。

People = {hello="Hello lua", world="World"}   -- 初始化table
People.num = 100                              -- 添加元素并赋值
People["name"] = "ZhangSan"                   -- 添加元素并赋值

print(People.num)                             -- 打印num元素的值
print(People["world"])                        -- 打印world元素的值

for key, var in pairs(People) do              -- 遍历数组
    print(key, var)                           -- 打印索引和值，索引从1开始
end

输出结果：
100
World
num 100
name ZhangSan
world World
hello Hello lua

lua不支持原生的面向对象和多态，但可以通过一些方法事项。以下两段代码需要放在两个文件里：module.lua和test.lua。module可以看作一个类的封装，运行时只调用test.lua。

-- module.lua文件，文件名就是module名
module = {}                        -- 定义一个名为module的模块
module.publiclVar = "公共成员变量"  -- 类成员变量
local privateVar =  "私有成员变量"  -- 局部变量，只能本文件访问

function module.publicFun()        -- public公共函数，可以在外部访问
    io.write("这是一个公有函数!\n")  -- 等同于print() 
end 

local function privateFun()        -- private私有函数，只能在本文件内访问
    print("这是一个私有函数!")
end

return module

-- test.lua文件
require("module")         -- 执行require 后会返回一个由模块常量或函数组成的table，并且还会定义一个包含该table的全局变量。
print(module.publiclVar)  -- 访问module里的成员变量publiclVar，require()函数已经声明了module，可以直接访问 
module.publicFun()        -- 调用module里的成员函数publicFun()，如果调用私有函数privateFun()就会报错

输出结果：（调用test.lua）
公共成员变量
这是一个公有函数！

同样，lua也不支持原生的多态，但可以自己实现new函数达到相同的效果。父类在new方法里将所有属性和方法都拷贝给子类，子类在new方法里调用父类的new函数获取父类所有属性和方法，然后再增加自己特有的属性和方法，以此来实现多态，示例代码如下：

Father = {name = "Zhangsan", age = 50}  -- 父类成员变量声明和初始化
Father.hello = function()               -- 父类成员函数
    print("Hello world!")
end

function Father.new(iName) -- 父类new方法
    local ins = {}
    for key, var in pairs(Father) do
        ins[key] = var    -- 将父类所有方法和属性都拷贝给子类
    end
    ins.name = iName
    return ins	-- 返回实例化的父类对象，子类负责接受
end

Son = {}  -- 子类
function Son.new()                 -- 子类new方法
    local ins = Father.new("Lisi") -- 继承父类的所有属性和方法
    ins.sports = "Basketball"      -- 添加子类特有属性或方法
    return ins                     -- 返回实例化的子类对象
end

-- 开始测试
child = Son.new()    -- 实例化子类
child.hello()        -- 调用父类成员函数
print(child.sports)  -- 访问子类属性或方法

输出结果：
Hello world!
Basketball

使用goto语句模拟continue

for key, var in pairs(People) do    -- 遍历数组
    if key == 0 then
    	goto continue
    end
    print(key, val)
    ::continue::
end