由浅入深的理解Lua的数据结构——table

思考一下：如果现在定义了一个table a，将table a赋值给table b，此时它们的内存情况是什么样呢？

成都网站设计、成都网站建设,成都做网站公司-创新互联已向数千家企业提供了,网站设计,网站制作,网络营销等服务!设计与技术结合,多年网站推广经验,合理的价格为您打造企业品质网站。

ab都会指向同一个内存块，如果a设置为nil，b依旧能访问该内存块的元素，直到b设置为nil后，Lua的垃圾回收机制会清理相应的内存。所以当b在更改table内的值后，a再去访问的时候，值也是改变的。

table的for循环写法

先解释一下上面的各个变量

在table中，我们无法对两个table之间进行操作，比如：table a+ table b。为了解决这个问题，就引入了元表的概念，它允许我们 改变table的行为 。

当我们在进行表a+b的时候：

其实逼逼了这么多，我觉得元表和元方法其实就相当于 重载 ，比如_add，我们就是重载了+操作符

也可以将它理解成 事件驱动 ，元表中的键对应着不同的事件名，关联的值是元方法，元方法里就是我们事件对应的操作。

继续接上面的分析

每个Node都是一个键值对 ,里面包含了key和value。tvk是key的值，但是当我们出现hash冲突，此时lua的hash算法比较特殊，一般情况下，我们的hash算法都是根据key算出hash，然后如果有冲突的话，就放在改位置的链表上。而lua不同， 当它出现hash冲突的时候，会在hash表中找到一个空的位置x，来存放key，并且让冲突处的节点的nk.next指向x 。

这意味着什么呢？发生冲突我们无需重新分配空间来存储冲突的key，而是利用hash表上未用过的空白处来存储。刚才我们将key放在了空位置x， 如果此时存在另一个key2，它算出的hash值是空位置x，而我们刚才的key只是因为hash冲突了，占用了其他key的位置，这个时候我们就讲key2放在x上，将key再放到另一个空白处 。

忍不住想总结一波table的实现，和上面我们的Node类型进行对照

lua的table其实由 数组段 和 hash 两部分组成，当你的key值不会过于离散的时候，lua就会将它存储在数组段（也就是下图的array），反正会存储在hash段（也就是下图的node），这个分割线是以数组段的利用率不低于50%为准。hash段采用闭散列的算法，它将有冲突的key存储在空闲槽中，而不额外分配内存。

在我们table结构体中，array和sizearray都是表示数组段。

而lsizenode和node，lastfree是表示hash段。node指向hash表的起始位置，lsizenode是log2(node指向的哈希表的节点数目)， lastfree指向node里面最后一个未使用的节点 （因为我们在hash冲突的时候，是从后往前查找未使用的节点，lastfree存储最后一个未使用节点就可以方便查找）

如果此时hash表中已经没有空格了，那么lua就会resize这个hash表（等会再谈lua的动态扩增）

lua创建新表的时候 先为新表分配内存 Table * t = luaM_new(L, Table)，然后将表 连接到gc 上并设置标志位luaC_link(L, obj2gco(t), LUA_TTABLE)，然后 初始化 一些必要的属性，使用setarrayvector为数组段分配内存，setnodevector为hash部分分配内存，最后返回表指针。

table的查找会根据key进行判断，如果key为空就直接返回空，key为字符串就调用luaH_getstr(t, rawtsvalue(key))，key为数字则根据它是否整数调用luaH_getnum(t, k)，否则，计算出key的位置，遍历table的node节点，找到对应键所在的节点返回。

因为key为数字比较特殊，所以研究一把luaH_getnum函数的实现

如果key大于等于1，小于数组的长度，则从数组中取出对应的键值，否则利用hashnum找到key对应的node位置，遍历node链表，返回对应的值

dummynode是带头结点的指针。

往table中插入新值，先检测 key的主位置 （main position）是否为空，主位置就是key的哈希值在node中的位置。

如果主位置为空，就直接插入，主位置不为空，检查占领该位置的key的主位置是不是在这个地方，如果不在，则将该key移动到其他空闲位置，将要插入的key插入到这个位置中。如果在这个地方，则将要插入的key插入到一个 空槽 中。

如果找不到空闲位置放新键值，就 rehash函数 ，扩增hash表的大小，再找出新位置，再调用luaH_set把要插入的key插入到新的哈希表中，直接返回LuaH_set的结果。

LUA语言入门

LUA脚本语言入门（纯粹转帖，仅供参考）

Lua 程序设计初步

作者： 沐枫 （第二人生成员）

版权所有转载请注明原出处

在这篇文章中，我想向大家介绍如何进行Lua程序设计。我假设大家都学过至少一门编程语言，比如Basic或C，特别是C。因为Lua的最大用途是在宿主程序中作为脚本使用的。

Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。

在Lua中，一切都是变量，除了关键字。请记住这句话。

I. 首先是注释

写一个程序，总是少不了注释的。

在Lua中，你可以使用单行注释和多行注释。

单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。

多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。

II. Lua编程

经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单：

print("Hello world")

在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。

Lua 有好几种程序控制语句，如：

条件控制：if 条件 then … elseif 条件 then … else … end

While循环：while 条件 do … end

Repeat循环：repeat … until 条件

For循环：for 变量 = 初值，终点值，步进 do … end

For循环：for 变量1，变量2，… ，变量N in表或枚举函数 do … end

注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for循环会使用1作为步进值。

你可以用break来中止一个循环。

如果你有程序设计的基础，比如你学过Basic，C之类的，你会觉得Lua也不难。但Lua有几个地方是明显不同于这些程序设计语言的，所以请特别注意。

．语句块

语句块在C++中是用"{"和"}"括起来的，在Lua中，它是用do 和 end 括起来的。比如：

do print("Hello") end

你可以在 函数 中和 语句块 中定局部变量。

．赋值语句

赋值语句在Lua被强化了。它可以同时给多个变量赋值。

例如：

a,b,c,d=1,2,3,4

甚至是：

a,b=b,a -- 多么方便的交换变量功能啊。

在默认情况下，变量总是认为是全局的。假如你要定义局部变量，则在第一次赋值的时候，需要用local说明。比如：

local a,b,c = 1,2,3 -- a,b,c都是局部变量

．数值运算

和C语言一样，支持 +, -, *, /。但Lua还多了一个"^"。这表示指数乘方运算。比如2^3 结果为8, 2^4结果为16。

连接两个字符串，可以用".."运处符。如：

"This a " .. "string." -- 等于 "this a string"

．比较运算

= = == ~=

分别表示 小于，大于，不大于，不小于，相等，不相等

所有这些操作符总是返回true或false。

对于Table，Function和Userdata类型的数据，只有 == 和 ~=可以用。相等表示两个变量引用的是同一个数据。比如：

a={1,2}

b=a

print(a==b, a~=b) -- true, false

a={1,2}

b={1,2}

print(a==b, a~=b) -- false, true

．逻辑运算

and, or, not

其中，and 和 or 与C语言区别特别大。

在这里，请先记住，在Lua中，只有false和nil才计算为false，其它任何数据都计算为true，0也是true！

and 和 or的运算结果不是true和false，而是和它的两个操作数相关。

a and b：如果a为false，则返回a；否则返回b

a or b：如果 a 为true，则返回a；否则返回b

举几个例子：

print(4 and 5) -- 5

print(nil and 13) -- nil

print(false and 13) -- false

print(4 or 5) -- 4

print(false or 5) -- 5

在Lua中这是很有用的特性，也是比较令人混洧的特性。

我们可以模拟C语言中的语句：x = a? b : c，在Lua中，可以写成：x = a and b or c。

最有用的语句是： x = x or v，它相当于：if not x then x = v end 。

．运算符优先级，从高到低顺序如下：

^

not - （一元运算）

* / + -

..（字符串连接）

= = ~= ==

and

or

III. 关键字

关键字是不能做为变量的。Lua的关键字不多，就以下几个：

and break do else elseif

end false for function if

in local nil not or

repeat return then true until while

IV. 变量类型

怎么确定一个变量是什么类型的呢？大家可以用type()函数来检查。Lua支持的类型有以下几种：

Nil 空值，所有没有使用过的变量，都是nil。nil既是值，又是类型。

Boolean 布尔值

Number 数值，在Lua里，数值相当于C语言的double

String 字符串，如果你愿意的话，字符串是可以包含'\0'字符的

Table 关系表类型，这个类型功能比较强大，我们在后面慢慢说。

Function 函数类型，不要怀疑，函数也是一种类型，也就是说，所有的函数，它本身就是一个变量。

Userdata 嗯，这个类型专门用来和Lua的宿主打交道的。宿主通常是用C和C++来编写的，在这种情况下，Userdata可以是宿主的任意数据类型，常用的有Struct和指针。

Thread 线程类型，在Lua中没有真正的线程。Lua中可以将一个函数分成几部份运行。如果感兴趣的话，可以去看看Lua的文档。

V. 变量的定义

所有的语言，都要用到变量。在Lua中，不管你在什么地方使用变量，都不需要声明，并且所有的这些变量总是全局变量，除非，你在前面加上"local"。

这一点要特别注意，因为你可能想在函数里使用局部变量，却忘了用local来说明。

至于变量名字，它是大小写相关的。也就是说，A和a是两个不同的变量。

定义一个变量的方法就是赋值。"＝"操作就是用来赋值的

我们一起来定义几种常用类型的变量吧。

A. Nil

正如前面所说的，没有使用过的变量的值，都是Nil。有时候我们也需要将一个变量清除，这时候，我们可以直接给变量赋以nil值。如：

var1=nil -- 请注意 nil 一定要小写

B. Boolean

布尔值通常是用在进行条件判断的时候。布尔值有两种：true 和 false。在Lua中，只有false和nil才被计算为false，而所有任何其它类型的值，都是true。比如0，空串等等，都是true。不要被 C语言的习惯所误导，0在Lua中的的确确是true。你也可以直接给一个变量赋以Boolean类型的值，如：

varboolean = true

C. Number

在Lua中，是没有整数类型的，也不需要。一般情况下，只要数值不是很大（比如不超过100,000,000,000,000），是不会产生舍入误差的。在很多CPU上，实数的运算并不比整数慢。

实数的表示方法，同C语言类似，如：

4 0.4 4.57e-3 0.3e12 5e+20

D. String

字符串，总是一种非常常用的高级类型。在Lua中，你可以非常方便的定义很长很长的字符串。

字符串在Lua中有几种方法来表示，最通用的方法，是用双引号或单引号来括起一个字符串的，如：

"This is a string."

和C语言相同的，它支持一些转义字符，列表如下：

\a bell

\b back space

\f form feed

\n newline

\r carriage return

\t horizontal tab

\v vertical tab

\\ backslash

\" double quote

\' single quote

\[ left square bracket

\] right square bracket

由于这种字符串只能写在一行中，因此，不可避免的要用到转义字符。加入了转义字符的串，看起来实在是不敢恭维，比如：

"one line\nnext line\n\"in quotes\", 'in quotes'"

一大堆的"\"符号让人看起来很倒胃口。如果你与我有同感，那么，我们在Lua中，可以用另一种表示方法：用"[["和"]]"将多行的字符串括起来，如：

page = [[

HTML

HEAD

TITLEAn HTML Page/TITLE

/HEAD

BODY

A HREF=""Lua/A

[[a text between double brackets]]

/BODY

/HTML

]]

值得注意的是，在这种字符串中，如果含有单独使用的"[["或"]]"就仍然得用"\["或"\]"来避免歧义。当然，这种情况是极少会发生的。

E. Table

关系表类型，这是一个很强大的类型。我们可以把这个类型看作是一个数组。只是C语言的数组，只能用正整数来作索引；在Lua中，你可以用任意类型来作数组的索引，除了nil。同样，在C语言中，数组的内容只允许一种类型；在Lua中，你也可以用任意类型的值来作数组的内容，除了nil。

Table的定义很简单，它的主要特征是用"{"和"}"来括起一系列数据元素的。比如：

T1 = {} -- 定义一个空表

T1[1]=10 -- 然后我们就可以象C语言一样来使用它了。

T1["John"]={Age=27, Gender="Male"}

这一句相当于：

T1["John"]={} -- 必须先定义成一个表，还记得未定义的变量是nil类型吗

T1["John"]["Age"]=27

T1["John"]["Gender"]="Male"

当表的索引是字符串的时候，我们可以简写成：

T1.John={}

T1.John.Age=27

T1.John.Gender="Male"

或

T1.John{Age=27, Gender="Male"}

这是一个很强的特性。

在定义表的时候，我们可以把所有的数据内容一起写在"{"和"}"之间，这样子是非常方便，而且很好看。比如，前面的T1的定义，我们可以这么写：

T1=

{

10, -- 相当于 [1] = 10

[100] = 40,

John= -- 如果你原意，你还可以写成：["John"] =

{

Age=27, -- 如果你原意，你还可以写成：["Age"] =27

Gender=Male -- 如果你原意，你还可以写成：["Gender"] =Male

},

20 -- 相当于 [2] = 20

}

看起来很漂亮，不是吗？我们在写的时候，需要注意三点：

第一，所有元素之间，总是用逗号"，"隔开；

第二，所有索引值都需要用"["和"]"括起来；如果是字符串，还可以去掉引号和中括号；

第三，如果不写索引，则索引就会被认为是数字，并按顺序自动从1往后编；

表类型的构造是如此的方便，以致于常常被人用来代替配置文件。是的，不用怀疑，它比ini文件要漂亮，并且强大的多。

F. Function

函数，在Lua中，函数的定义也很简单。典型的定义如下：

function add(a,b) -- add 是函数名字，a和b是参数名字

return a+b -- return 用来返回函数的运行结果

end

请注意，return语言一定要写在end之前。假如你非要在中间放上一句return，那么请写成：do return end。

还记得前面说过，函数也是变量类型吗？上面的函数定义，其实相当于：

add = function (a,b) return a+b end

当你重新给add赋值时，它就不再表示这个函数了。你甚至可以赋给add任意数据，包括nil （这样，你就清除了add变量）。Function是不是很象C语言的函数指针呢？

和C语言一样，Lua的函数可以接受可变参数个数，它同样是用"…"来定义的，比如：

function sum (a,b,…)

如果想取得…所代表的参数，可以在函数中访问arg局部变量（表类型）得到。

如 sum(1,2,3,4)

则，在函数中，a = 1, b = 2, arg = {3, 4}

更可贵的是，它可以同时返回多个结果，比如：

function s()

return 1,2,3,4

end

a,b,c,d = s() -- 此时，a = 1, b = 2, c = 3, d = 4

前面说过，表类型可以拥有任意类型的值，包括函数！因此，有一个很强大的特性是，拥有函数的表，哦，我想更恰当的应该说是对象吧。Lua可以使用面向对象编程了。不信？那我举例如下：

t =

{

Age = 27

add = function(self, n) self.Age = self.Age+n end

}

print(t.Age) -- 27

t.add(t, 10)

print(t.Age) -- 37

不过，t.add(t,10) 这一句实在是有点土对吧？没关系，在Lua中，你可以简写成：

t:add(10) -- 相当于 t.add(t,10)

G. Userdata 和 Thread

这两个类型的话题，超出了本文的内容，就不打算细说了。

VI. 结束语

就这么结束了吗？当然不是，接下来，需要用Lua解释器，来帮助你理解和实践了。这篇小文只是帮助你大体了解Lua的语法。如果你有编程基础，相信会很快对Lua上手了。

就象C语言一样，Lua提供了相当多的标准函数来增强语言的功能。使用这些标准函数，你可以很方便的操作各种数据类型，并处理输入输出。有关这方面的信息，你可以参考《Programming in Lua 》一书，你可以在网络上直接观看电子版，网址为：

使用例程

1. 函数的使用

以下程序演示了如何在Lua中使用函数, 及局部变量

例e02.lua

-- functions

function pythagorean(a, b)

local c2 = a^2 + b^2

return sqrt(c2)

end

print(pythagorean(3,4))

运行结果

5

程序说明

在Lua中函数的定义格式为:

function 函数名(参数)

...

end

与Pascal语言不同, end不需要与begin配对, 只需要在函数结束后打个end就可以了.

本例函数的作用是已知直角三角形直角边, 求斜边长度. 参数a,b分别表示直角边长,

在函数内定义了local形变量用于存储斜边的平方. 与C语言相同, 定义在函数内的代

码不会被直接执行, 只有主程序调用时才会被执行.

local表示定义一个局部变量, 如果不加local刚表示c2为一个全局变量, local的作用域

是在最里层的end和其配对的关键字之间, 如if ... end, while ... end等。全局变量的

作用域是整个程序。

2. 循环语句

例e03.lua

-- Loops

for i=1,5 do

print("i is now " .. i)

end

运行结果

i is now 1

i is now 2

i is now 3

i is now 4

i is now 5

程序说明

这里偶们用到了for语句

for 变量 = 参数1, 参数2, 参数3 do

循环体

end

变量将以参数3为步长, 由参数1变化到参数2

例如:

for i=1,f(x) do print(i) end

for i=10,1,-1 do print(i) end

这里print("i is now " .. i)中，偶们用到了..，这是用来连接两个字符串的，

偶在(1)的试试看中提到的，不知道你们答对了没有。

虽然这里i是一个整型量，Lua在处理的时候会自动转成字符串型，不需偶们费心。

3. 条件分支语句

例e04.lua

-- Loops and conditionals

for i=1,5 do

print(“i is now “ .. i)

if i 2 then

print(“small”)

elseif i 4 then

print(“medium”)

else

print(“big”)

end

end

运行结果

i is now 1

small

i is now 2

medium

i is now 3

medium

i is now 4

big

i is now 5

big

程序说明

if else用法比较简单, 类似于C语言, 不过此处需要注意的是整个if只需要一个end,

哪怕用了多个elseif, 也是一个end.

例如

if op == "+" then

r = a + b

elseif op == "-" then

r = a - b

elseif op == "*" then

r = a*b

elseif op == "/" then

r = a/b

else

error("invalid operation")

end

数组的使用

1.简介

Lua语言只有一种基本数据结构, 那就是table, 所有其他数据结构如数组啦,

类啦, 都可以由table实现.

2.table的下标

例e05.lua

-- Arrays

myData = {}

myData[0] = “foo”

myData[1] = 42

-- Hash tables

myData[“bar”] = “baz”

-- Iterate through the

-- structure

for key, value in myData do

print(key .. “=“ .. value)

end

输出结果

0=foo

1=42

bar=baz

程序说明

首先定义了一个table myData={}, 然后用数字作为下标赋了两个值给它. 这种

定义方法类似于C中的数组, 但与数组不同的是, 每个数组元素不需要为相同类型,

就像本例中一个为整型, 一个为字符串.

程序第二部分, 以字符串做为下标, 又向table内增加了一个元素. 这种table非常

像STL里面的map. table下标可以为Lua所支持的任意基本类型, 除了nil值以外.

Lua对Table占用内存的处理是自动的, 如下面这段代码

a = {}

a["x"] = 10

b = a -- `b' refers to the same table as `a'

print(b["x"]) -- 10

b["x"] = 20

print(a["x"]) -- 20

a = nil -- now only `b' still refers to the table

b = nil -- now there are no references left to the table

b和a都指向相同的table, 只占用一块内存, 当执行到a = nil时, b仍然指向table,

而当执行到b=nil时, 因为没有指向table的变量了, 所以Lua会自动释放table所占内存

3.Table的嵌套

Table的使用还可以嵌套，如下例

例e06.lua

-- Table ‘constructor’

myPolygon = {

color=“blue”,

thickness=2,

npoints=4;

{x=0, y=0},

{x=-10, y=0},

{x=-5, y=4},

{x=0, y=4}

}

-- Print the color

print(myPolygon[“color”])

-- Print it again using dot

-- notation

print(myPolygon.color)

-- The points are accessible

-- in myPolygon[1] to myPolygon[4]

-- Print the second point’s x

-- coordinate

print(myPolygon[2].x)

程序说明

首先建立一个table, 与上一例不同的是，在table的constructor里面有{x=0,y=0},

这是什么意思呢？ 这其实就是一个小table, 定义在了大table之内, 小table的

table名省略了.

最后一行myPolygon[2].x，就是大table里面小table的访问方式.

Lua能够用来定义数据结构嘛？

lua 内用 table

Monster = {

name = nil,

hp = nil

}

Monster.name = '怪物名称'

Monster.hp = 10000

如果是定义类的话，也是 table ，只是方法有些不一样

TMonster = {

name = nil,

hp = nil

}

TMonster.__index = TMonster

-- 创建类

TMonster.new = function()

local self = {}            

setmetatable(self, TMonster)

self.name = nil

self.hp = nil

return self

end

-- 类函数

TMonster.setSetting = function(self, szName, nHp)

self.name = szName

self.hp = nHp

end

------------------------------

这样就可以使用了

Monster = TMonster.new()

Monster:setSetting('怪物名称', 10000)

扩展语言lua有哪些数据类型呢？

Lua 中有八种基本类型： nil、boolean、number、string、function、userdata、 thread 和 table。 

1.Nil 是值 nil 的类型， 其主要特征就是和其它值区别开；通常用来表示一个有意义的值不存在时的状态。 Boolean 是 false 与 true 两个值的类型。 nil 和 false 都会导致条件判断为假； 而其它任何值都表示为真。 Number 代表了整数和实数（浮点数）。 String 表示一个不可变的字节序列。 Lua 对 8 位是友好的： 字符串可以容纳任意 8 位值， 其中包含零 ('\0') 。 Lua 的字符串与编码无关； 它不关心字符串中具体内容。

2.number 类型有两种内部表现方式， 整数 和 浮点数。 对于何时使用哪种内部形式，Lu a 有明确的规则， 但它也按需作自动转换。 因此，程序员多数情况下可以选择忽略整数与浮点数之间的差异或者假设完全控制每个数字的内部表现方式。 标准 Lua 使用 64 位整数和双精度（64 位）浮点数， 但你也可以把 Lua 编译成使用 32 位整数和单精度（32 位）浮点数。 以 32 位表示数字对小型机器以及嵌入式系统特别合适。

3.Lua 可以调用（以及操作）用 L ua 或 C 编写的函数。 这两种函数有统一类型 function。

userdata 类型允许将 C 中的数据保存在 Lua 变量中。 用户数据类型的值是一个内存块， 有两种用户数据： 完全用户数据 ，指一块由 Lua 管理的内存对应的对象； 轻量用户数据 ，则指一个简单的 C 指针。 用户数据在 Lua 中除了赋值与相等性判断之外没有其他预定义的操作。 通过使用 元表 ，程序员可以给完全用户数据定义一系列的操作 。 你只能通过 C API 而无法在 Lua 代码中创建或者修改用户数据的值， 这保证了数据仅被宿主程序所控制。

4.thread 类型表示了一个独立的执行序列，被用于实现协程 。 L ua 的线程与操作系统的线程毫无关系。 Lu a 为所有的系统，包括那些不支持原生线程的系统，提供了协程支持。

table 是一个关联数组， 也就是说，这个数组不仅仅以数字做索引，除了 nil 和 NaN 之外的所有 Lua 值 都可以做索引。 （Not a Number 是一个特殊的数字，它用于表示未定义或表示不了的运算结果，比如 0/0。） 表可以是 异构 的； 也就是说，表内可以包含任何类型的值（ nil 除外）。 任何键的值若为 nil 就不会被记入表结构内部。 换言之，对于表内不存在的键，都对应着值 nil 。

5.表是 Lua 中唯一的数据结构， 它可被用于表示普通数组、序列、符号表、集合、记录、图、树等等。 对于记录，Lua 使用域名作为索引。 语言提供了 a.name 这样的语法糖来替代 a["name"] 这种写法以方便记录这种结构的使用。 在 Lua 中有多种便利的方式创建表。

大话C与Lua（五） 面向对象的数据结构——userdata

如何实现面向对象？

熟悉Lua的同学都知道！在Lua内部已经实现了面向对象的基本机制(table), 同时也为宿主语言（在这里是C语言）提供了一套接口来实现自定义数据结构（userdata）。在此，我们可以简单的利用metatable与__index的访问机制，为userdata实现一套简单的面向对象的访问方式。

stu.c

main.lua

运行结果：

运行结果很简单。现在，我们简要分析一下具体实现步奏。

首先我们在注册表创建了一个metatable,并且起名"stu"。然后为这个元表添加一个__index元方法，然后将自身作为键值查找域。最后使用setfuncs为元表注入方法。

上述步奏等效于lua中如下操作：

这里需要注意的是：

名称栏目：lua数据结构php,lua数据结构与算法
网站路径：http://pwwzsj.com/article/hoiosc.html