希望能帮助到那些lua的初学者，更好的理解和使用lua这门语言
lua作为一个使用寄存器虚拟机的语言，他需要实现如下几个部分：
1. 将源代码编译程虚拟机可识别执行的字节码
2. 为函数准备调用栈
3. 内部维持一个IP（指令指针）来保存下一个将执行的指令地址
4. 模拟一个cpu的运行，循环拿出ip指向的字节码，根据字节码进行解码，然后执行字节码
虚拟机有两种不同的实现方式，基于栈的虚拟机和基于寄存器的虚拟机，lua是第一个基于寄存器的虚拟机，那么我会讲一下这两种虚拟机的不同，并做一下分析
基于栈的虚拟机：
在基于栈的虚拟机中，字节码的操作数在栈顶弹出，在执行完成之后再压入栈顶的，在我们的内存中，栈作为一个独立的内存区域，我们去计算一个数据的时候，基于栈的虚拟机，会首先把需要的数据压入栈顶，在计算完结果后，把之前压入栈顶的数据push掉后，把结果在压入栈顶，这个过程在计算一个类似1+2=3的方法时，实际需要如下四个步骤：
1. Pop 1
2. Pop 2
3. ADD 1,2，result
4. Push result
可以看到，执行一条假发需要四条字节码，前面几条指令用来准备数据，将数据压入栈，这就是设计上的缺陷。但优点是，指令中不需要关心操作数的地址，在执行操作数据已经把数据放在栈顶了
基于寄存器的虚拟机
与基于栈的虚拟机不同，在基于寄存器的指令中，操作数是放在“cpu寄存器”中，这个并不是物理意义上的寄存器，因此同样操作不再需要push，pop指令，取而代之的是在字节码中带上具体操作数所在的寄存器地址，对比基于栈的虚拟机，由四条指令降低为一条，但缺点是程序需要关注操作数所在的位置
之所以讲lua虚拟机一些基础原理，是为了接下来有助于帮助我们在使用lua时候有更深刻的理解
我从15年入行，17年才接触lua，从经验来说，只能算个新兵，同时这是我第一篇博客，我希望以一个新兵的视角给大家在学习lua带来帮助
Lua语法篇：
lua有很多数据结构
Lua 数据类型
Lua是动态类型语言，变量不要类型定义,只需要为变量赋值。值可以存储在变量中，作为参数传递或结果返回。
Lua中有8个基本类型分别为：nil、boolean、number、string、userdata、function、thread和table。
数据类型 |
描述 |
nil |
这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。 |
boolean |
包含两个值：false和true。 |
number |
表示双精度类型的实浮点数 |
string |
字符串由一对双引号或单引号来表示 |
function |
由 C 或 Lua 编写的函数 |
userdata |
表示任意存储在变量中的C数据结构 |
thread |
表示执行的独立线路，用于执行协同程序 |
table |
Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。 |
以上是
https://www.runoob.com/lua/lua-data-types.html 摘抄的引用
这里的userdata，你可以理解为一个内存地址，实际上对于lua虚拟机，table实际上也是一块内存地址，那么我谈一谈table这种数据结构吧，table里面的key有两种类型，一种是int类型，一种是其他类型，这篇博客会讲述实现原理：
https://blog.csdn.net/zr339361504/article/details/52432163
理解完lua table的实现，我们聊一聊我们常见的：和.这两个标识符，我引用网上一篇博客做解释
1. 原文地址https://www.cnblogs.com/xzxdm/p/6980267.html
lua的语法很简单，太简单了，所以lua就复杂了
两个点与一个点有什么区别呢？
一个点用来定义和取得一个变量，这个变量可能是个函数
两个点用来定义和调用一个函数，两个点会自动传入“调用者”这个table自身
先看简单的：
c = {a = 1, b = 2}
function c:foo()
print(self.a,self.b)
end
这里，c这个table定义了一个foo函数，用两个点定义的，在foo函数第一个参数的地方自动传入了c自身，然后调用一下
c:foo()
输出1 2
也可以这样，一个点调用函数，手动传入table：c.foo(c)
输出也是一样的
下面看复杂一点的：
两个点会自动传入调用者本身，但是他仅仅只会传入调用者本身，他没有一个点灵活，这个怎么理解？看代码
c = {a = 1, b = 2}
c.foo = function(c) print(c.a,c.b) end
d = {}
d.foo2 = c.foo
d:foo2()
输出为：nil nil
解释下上面的代码：
首先创建一个table，然后定义一个函数foo，这个函数访问了table中的a和b两个变量
然后创建了另一个table，b
在b中定义一个变量foo2，赋值为c这个table中的foo函数
然后调用d这个table中的foo2函数，输出为nil nil
因为d是两个点调用的foo2，那么会自动吧d本身传入函数的第一个参数，那么函数的运行就是这样的：
function (d)
print(d.a,d.b)
end
d这个table没有定义a和b两个变量，输入当然就是nil
像这种情况就只能一个点调用，显示的传入c这个table
d:foo2()改为d.foo2(c) 这样就可以了
输出1 2
上面的例子还可以这么写：
c = {a=1,b=2}
function c:foo()
print(self.a,self.b)
end
d = {}
d.foo2 = c.foo
d.foo2(c)
self类似于c#的this，但并不一样，因为c#的this指的是这个类对象，但是table的self确实使用table或者说传入table对象自身，也就是可以把当前使用的table当做一个对象，如果是：的方法和参数self都是可以缺省的，因为是默认传入，self的目的是为了方便我们使用“调用者自身”，而.就是直接拿到这个表对象的一个方法或数值，所以对比一下，：能帮助我们实现类似衍生对象的方法，接下来我会阐述
Lua 元表(Metatable)
这个是一个非常重要的概念，我们是否能灵活使用lua，元表非常重要
原文地址：https://www.runoob.com/lua/lua-metatables.html
在 Lua table 中我们可以访问对应的key来得到value值，但是却无法对两个 table 进行操作。
因此 Lua 提供了元表(Metatable)，允许我们改变table的行为，每个行为关联了对应的元方法。
例如，使用元表我们可以定义Lua如何计算两个table的相加操作a+b。
当Lua试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫"__add"的字段，若找到，则调用对应的值。"__add"等即时字段，其对应的值（往往是一个函数或是table）就是"元方法"。
有两个很重要的函数来处理元表：
· setmetatable(table,metatable): 对指定table设置元表(metatable)，如果元表(metatable)中存在__metatable键值，setmetatable会失败。
· getmetatable(table): 返回对象的元表(metatable)。
以下实例演示了如何对指定的表设置元表：
mytable = {} -- 普通表
mymetatable = {} -- 元表
setmetatable(mytable,mymetatable) -- 把 mymetatable 设为 mytable 的元表
以上代码也可以直接写成一行：
mytable = setmetatable({},{})
以下为返回对象元表：
getmetatable(mytable) -- 这回返回mymetatable
__index 元方法
这是 metatable 最常用的键。
当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。如果__index包含一个表格，Lua会在表格中查找相应的键。
我们可以在使用 lua 命令进入交互模式查看：
$ lua
Lua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio
> other = { foo = 3 }
> t = setmetatable({}, { __index = other })
> t.foo
3
> t.bar
nil
如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。
__index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。
mytable = setmetatable({key1 = "value1"}, {
__index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
return nil
end
end
})
print(mytable.key1,mytable.key2)
实例输出结果为：
value1 metatablevalue
实例解析：
· mytable 表赋值为 {key1 = "value1"}。
· mytable 设置了元表，元方法为 __index。
· 在mytable表中查找 key1，如果找到，返回该元素，找不到则继续。
· 在mytable表中查找 key2，如果找到，返回 metatablevalue，找不到则继续。
· 判断元表有没有__index方法，如果__index方法是一个函数，则调用该函数。
· 元方法中查看是否传入 "key2" 键的参数（mytable.key2已设置），如果传入 "key2" 参数返回 "metatablevalue"，否则返回 mytable 对应的键值。
我们可以将以上代码简单写成：
mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)
总结
Lua查找一个表元素时的规则，其实就是如下3个步骤:
· 1.在表中查找，如果找到，返回该元素，找不到则继续
· 2.判断该表是否有元表，如果没有元表，返回nil，有元表则继续。
· 3.判断元表有没有__index方法，如果__index方法为nil，则返回nil；如果__index方法是一个表，则重复1、2、3；如果__index方法是一个函数，则返回该函数的返回值。
__newindex 元方法
__newindex 元方法用来对表更新，__index则用来对表访问。
当你给表的一个缺少的索引赋值，解释器就会查找__newindex 元方法：如果存在则调用这个函数而不进行赋值操作。
以下实例演示了 __newindex 元方法的应用：
mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })
print(mytable.key1)
mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey)
mytable.key1 = "新值1"
print(mytable.key1,mymetatable.key1)
以上实例执行输出结果为：
value1
nil 新值2
新值1 nil
以上实例中表设置了元方法 __newindex，在对新索引键（newkey）赋值时（mytable.newkey = "新值2"），会调用元方法，而不进行赋值。而如果对已存在的索引键（key1），则会进行赋值，而不调用元方法 __newindex。
以下实例使用了 rawset 函数来更新表：
mytable = setmetatable({key1 = "value1"}, {
__newindex = function(mytable, key, value)
rawset(mytable, key, "\""..value.."\"")
end
})
mytable.key1 = "new value"
mytable.key2 = 4
print(mytable.key1,mytable.key2)
以上实例执行输出结果为：
new value "4"
为表添加操作符
以下实例演示了两表相加操作：
-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数
function table_maxn(t)
local mn = 0
for k, v in pairs(t) do
if mn < k then
mn = k
end
end
return mn
end
-- 两表相加操作
mytable = setmetatable({ 1, 2, 3 }, {
__add = function(mytable, newtable)
for i = 1, table_maxn(newtable) do
table.insert(mytable, table_maxn(mytable)+1,newtable[i])
end
return mytable
end
})
secondtable = {4,5,6}
mytable = mytable + secondtable
for k,v in ipairs(mytable) do
print(k,v)
end
以上实例执行输出结果为：
1 1
2 2
3 3
4 4
5 5
6 6
__add 键包含在元表中，并进行相加操作。表中对应的操作列表如下：(注意：__是两个下划线)
模式 |
描述 |
__add |
对应的运算符 '+'. |
__sub |
对应的运算符 '-'. |
__mul |
对应的运算符 '*'. |
__div |
对应的运算符 '/'. |
__mod |
对应的运算符 '%'. |
__unm |
对应的运算符 '-'. |
__concat |
对应的运算符 '..'. |
__eq |
对应的运算符 '=='. |
__lt |
对应的运算符 '<'. |
__le |
对应的运算符 '<='. |
__call 元方法
__call 元方法在 Lua 调用一个值时调用。以下实例演示了计算表中元素的和：
-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数
function table_maxn(t)
local mn = 0
for k, v in pairs(t) do
if mn < k then
mn = k
end
end
return mn
end
-- 定义元方法__call
mytable = setmetatable({10}, {
__call = function(mytable, newtable)
sum = 0
for i = 1, table_maxn(mytable) do
sum = sum + mytable[i]
end
for i = 1, table_maxn(newtable) do
sum = sum + newtable[i]
end
return sum
end
})
newtable = {10,20,30}
print(mytable(newtable))
以上实例执行输出结果为：
70
__tostring 元方法
__tostring 元方法用于修改表的输出行为。以下实例我们自定义了表的输出内容：
mytable = setmetatable({ 10, 20, 30 }, {
__tostring = function(mytable)
sum = 0
for k, v in pairs(mytable) do
sum = sum + v
end
return "表所有元素的和为 " .. sum
end
})
print(mytable)
以上实例执行输出结果为：
表所有元素的和为 60
从本文中我们可以知道元表可以很好的简化我们的代码功能，所以了解 Lua 的元表，可以让我们写出更加简单优秀的 Lua 代码。
我们使用lua的table，可以用来存储和操作数据，同时可以编写方法，给lua虚拟机以调用，在 Lua table 中我们可以访问对应的key来得到value值，但是却无法对两个 table 进行操作。
因此 Lua 提供了元表(Metatable)，允许我们改变table的行为，每个行为关联了对应的元方法，这就是lua元表的设计初衷，但是由于有了元表，我们可以实现面向对象编程，后面我会分享一篇博客，但请循序渐进的往下看，有助于你的理解
这里面的__index和__newIndex，如果觉得是一个很新奇的东西，你可以理解为c#的get和set，而那个__call的原方法可以理解为在__index这个get方法里面添加了一个方法进去，同时被调用，这样是不是很好理解了呢
接下来，让我们实现lua的面向对象
首先让我们来实现一个类似模板的方法
INew.lua
INew = {} --分配一个内存地址
function INew:new(o)
o = o or {} --表存在则用以前存在的表（那么会用之前的数据，如果没有则构建新表）
o.super = self --设置super（父类）对象为调用者自身
setmetatable(o,self) --设置元表为调用者自身
self.__index = self --设置元表key值为调用者自身
return o --返回这个table
end
Test = INew:new(
Info1= {}, --重新赋值为{}会清理掉之前数据
num=2
)
Test = INew:Clear() --把这个table理解为一个模板，这个方法是为了清空之前使用的数据
Info1= nil,
num= 0
end
function Test:Update()
print(self.num+1) --调用方法
end
调用：
local List = {} --在另一个table里创建一个名字为list的table
local test = Test:new() --构建一个模板
test:Clear() --清楚之前数据
test:Update() --结果为3
table.insert(List，test) 或者List[1] = test
--这里面把这个模板数据插入其他的table，其他的table就会为这个table分配k值，而且数据会被拷贝到新的table数据内，这样我们可以实现通过模板方法插入一个table不同数据对象的方法
后续会分享一些实现面向对象的文章，上述只是为了帮助大家理解table和元表的妙用