【导语】下面小编为大家带来详解Lua中的数组概念知识（共7篇），希望能帮助大家!
篇1：详解Lua中的数组概念知识
这篇文章主要介绍了Lua中的数组概念知识,是Lua入门学习中的基础,需要的朋友可以参考下
数组是有序的对象的装置，它可以是包含含有多个行和列的行或多维阵列的集合的单个二维数组，
在Lua中，数组是使用索引表与整数实现的。数组的大小是不固定的，它可以增长基于我们需要受存储器限制。
一维数组
一维数组可以用一个简单的表结构来表示，可以初始化，使用一个简单的for循环读取。如下例子所示。
代码如下:
array = {“Lua”, “Tutorial”}
for i= 0, 2 do
print(array[i])
end
当我们运行上面的代码之后，将得到下面的输出。
代码如下:
nil
Lua
Tutorial
正如在上面的代码中看到，当我们试图访问索引中是不存在的数组中的元素，则返回nil。在Lua索引通常开始于索引1，但有可能在索引0和小于0，以及创建对象。显示使用负索引数组下面我们初始化使用for循环数组。
代码如下:
array = {}
for i= -2, 2 do
array[i] = i *2
end
for i = -2,2 do
print(array[i])
end
当我们运行上面的代码之后，将得到下面的输出。
代码如下:
-4
-2
0
2
4
多维数组
多维数组可以用两种方式来实现。
数组的数组
一维数组通过控制索引
对于3,3多维阵列如下所示使用数组的数组的例子。
代码如下:
-- Initializing the array
array = {}
for i=1,3 do
array[i] = {}
for j=1,3 do
array[i][j] = i*j
end
end
-- Accessing the array
for i=1,3 do
for j=1,3 do
print(array[i][j])
end
end
当我们运行上面的代码之后，将得到下面的输出，
代码如下:
1
2
3
2
4
6
3
6
9
对于3,3多维阵列的例子如下所示使用操作索引。
代码如下:
-- Initializing the array
array = {}
maxRows = 3
maxColumns = 3
for row=1,maxRows do
for col=1,maxColumns do
array[row*maxColumns +col] = row*col
end
end
-- Accessing the array
for row=1,maxRows do
for col=1,maxColumns do
print(array[row*maxColumns +col])
end
end
当我们运行上面的代码之后，将得到下面的输出。
代码如下:
1
2
3
2
4
6
3
6
9
正如在上面的例子中看到的，数据是基于索引储存的。也能够将元素以稀疏的方式，它是一个矩阵的工作方式lua的实现。因为它不保存在Lua零值，就可以节省大量的内存，在Lua中任何特殊的技术相比其他编程语言中使用特殊技术。
篇2：详解Lua中的表的概念及其相关操作方法
这篇文章主要介绍了Lua中的表的概念及其相关操作方法,是Lua入门学习中的基础知识,需要的朋友可以参考下
表格是唯一的数据结构中Lua可以帮助我们创造出不同的类型，如数组和字典， Lua使用关联数组和可不仅数字，但也有不同的零字符串索引。表格都没有固定的大小，并根据需要可以增长。
Lua采用的所有陈述，包括包装的代表性表。当我们访问一个方法的字符串。格式，这意味着，我们正在访问的格式化功能的字符串封装。
表示和用法
表称为对象和它们既不值，也没有变。 Lua使用构造函数表达式{}创建一个空表。它是要知道，有保存表的参考和表本身的变量之间没有固定的关系。
代码如下:
--sample table initialization
mytable = {}
--simple table value assignment
mytable[1]= “Lua”
--removing reference
mytable = nil
-- lua garbage collection will take care of releasing memory
当我们有一个表与集合的元素，如果我们将其指定为b，a和b都指向相同的内存。没有单独的内存单独分配对b。当设置为无，表将仍然可以访问到b。当没有引用表，然后在Lua垃圾收集需要清理过程，使这些未引用的内存再次被重用。
一个例子如下所示用于说明表的上述特征。
代码如下:
-- Simple empty table
mytable = {}
print(“Type of mytable is ”,type(mytable))
mytable[1]= “Lua”
mytable[“wow”] = “Tutorial”
print(“mytable Element at index 1 is ”, mytable[1])
print(“mytable Element at index wow is ”, mytable[“wow”])
-- alternatetable and mytable refers to same table
alternatetable = mytable
print(“alternatetable Element at index 1 is ”, alternatetable[1])
print(“mytable Element at index wow is ”, alternatetable[“wow”])
alternatetable[“wow”] = “I changed it”
print(“mytable Element at index wow is ”, mytable[“wow”])
-- only variable released and and not table
alternatetable = nil
print(“alternatetable is ”, alternatetable)
-- mytable is still accessible
print(“mytable Element at index wow is ”, mytable[“wow”])
mytable = nil
print(“mytable is ”, mytable)
当我们运行上面的程序，会得到下面的输出
代码如下:
Type of mytable is table
mytable Element at index 1 is Lua
mytable Element at index wow is Tutorial
alternatetable Element at index 1 is Lua
mytable Element at index wow is Tutorial
mytable Element at index wow is I changed it
alternatetable is nil
mytable Element at index wow is I changed it
mytable is nil
表操作
在对表操作内置函数和它们被列于下表中，
让我们看看上面的函数一些例子。
表串联
我们可以使用concat函数来连接，如下所示的两个表。
代码如下:
fruits = {“banana”,“orange”,“apple”}
-- returns concatenated string of table
print(“Concatenated string ”,table.concat(fruits))
--concatenate with a character
print(“Concatenated string ”,table.concat(fruits,“, ”))
--concatenate fruits based on index
print(“Concatenated string ”,table.concat(fruits,“, ”, 2,3))
当我们运行上面的程序，会得到下面的输出
代码如下:
Concatenated string bananaorangeapple
Concatenated string banana, orange, apple
Concatenated string orange, apple
插入和删除
插入在表中的项目，并除去最常见于表操纵。它下面的解释。
代码如下:
fruits = {“banana”,“orange”,“apple”}
-- insert a fruit at the end
table.insert(fruits,“mango”)
print(“Fruit at index 4 is ”,fruits[4])
--insert fruit at index 2
table.insert(fruits,2,“grapes”)
print(“Fruit at index 2 is ”,fruits[2])
print(“The maximum elements in table is”,table.maxn(fruits))
print(“The last element is”,fruits[5])
table.remove(fruits)
print(“The previous last element is”,fruits[5])
当我们运行上面的程序，会得到下面的输出
代码如下:
Fruit at index 4 is mango
Fruit at index 2 is grapes
The maximum elements in table is 5
The last element is mango
The previous last element is nil
排序表格
排序表通常需要和排序函数表中的元素按字母顺序排序。下图所示为这方面的一个范例。
代码如下:
fruits = {“banana”,“orange”,“apple”,“grapes”}
for k,v in ipairs(fruits) do
print(k,v)
end
table.sort(fruits)
print(“sorted table”)
for k,v in ipairs(fruits) do
print(k,v)
end
当我们运行上面的程序，会得到下面的输出
代码如下:
1 banana
2 orange
3 apple
4 grapes
sorted table
1 apple
2 banana
3 grapes
4 orange
篇3：房地产基础概念知识详解
房地产：房产和地产的总称，也叫“不动产”。
房地产的形态：1、单纯的土地;2、单纯的房屋;3、土地和房屋的综合体。
房产是房屋及其权利的总称，地产是土地及其权利的总称;
房地产是土地附在土地上不可分割的建筑物，构筑物和其他不可分离的物质及其权利构成的财产。(构筑物是指不能进入的建筑，如：烟筒、树、路等)
房地产按类型分为：1、住宅用(70年);2、生产用(50年);3、经营用(门头等，50年);4、行政用(市政府、法院等，50年);5、其他用(学校，博物馆等)。
房地产业：从事房地产经营管理服务性企业的总称。
房地产产业的主要内容：
1、 土地的开发和再开发;
2、 房屋的开发和建设;
3、 地产的经营(包括土地权的出让、转让、租赁、抵押等);
4、 房地产经营(包括房屋的买卖、租赁、抵押);
5、 房地产中介服务(包括信息、测量、律师、经纪、公证等);
6、 房地产物业管理;
7、 房地产金融(包括信息、保险、金融投资等)。
房地产的特性
1、房地产位置的固定性：土地是自然生成物，位置不可移动，房屋是建筑在土地上的，因此决定房屋不可移动、固定性，使房地产受地理位置的限制;
2、地域差别性：每一个地区或者同一地区不同位置的房地产价值也不相同;
3、房地产的高质耐久性;
4、房地产具有保值、增值性，前提是国家的政局稳定，由土地性质决定，土地有限、不可再生，但人们对土地的需求日益增大、增加，物以稀为贵，房地产作为龙头产业，税收约占国民生产总值的10%。
房地产的前景
1、城市化水平走势稳步提高，形成对房屋越来越高的需求。城市人口达6.1亿，每年需新建住宅3.27亿㎡;
2、人口流动增加形成对住宅的需求;
3、居民消费水平的提高;
4、城市的旧城改造，增加居民对住宅的要求;
5、深化改革与市场发展的促进对住宅的需求。
政府改革深化内需
1、 取消福利分房，实行住宅货币化;
2、 开发二手房市场;
3、 下调存款利率，吸引大批投资性客户;
4、 下调税费，出台法律法规，激励住房需求。
篇4：房地产基础概念知识详解
海外房产基础知识之房屋类型
海外的别墅房屋类型有4种:
1、 独立屋(Singlehouse或Detachedhouse)：只有一户人家居住的房子，类似国内的独栋别墅，一般有地上两层，地下一层(地下室);
2、平房(Bungalow)：与独立屋类似，但只有一层，通常包括前院和后院;
3、 半独立屋(Semi—detachedhouse)：指两户人家连在一起，仅有一墙之隔;
4、 联排别墅(Rowhouse)：指多户人家连在一起的房子，与国内的联体别墅(Townhouse)类似，有一、二、三层三种类型，最常见的是二层结构。
国外的公寓也有两大类，一种是出租公寓(Apartment)，另一种是产权分售公寓(Condominium)。两者的区别是，出租公寓只出租，而不出售;而产权分售公寓只出售而不出租。因此，通常出租公寓的建筑设计标准要比产权分售公寓的要低一点。
海外房产基础知识之产权
与国内一般购房拥有70年产权不同，在海外购房获得的是永久产权。一般，国外房产将土地所有权和房屋所有权捆绑，买房时得到房屋，亦永久拥有了土地所有权。譬如，如果你买的是house，那么，你将永久拥有所在地的土地所有权。
海外房产基础知识之装修
在国内买房后，我们通常还得为新房装修而烦恼。而海外房产通常没有毛胚房的概念，基本所有房子都已经装修完毕。交房时，通常都已配齐地板、家具、电器，收楼后即可入住，省去了不少装修的烦恼。
其实，海外的房子在建造、装修成本上的费用通常比国内的要高出不少，因此大可不必担心海外房产的装修问题。或许，这就是永久产权和国内有限产权的区别。
海外房产基础知识之房产经纪人
与国内房产经纪市场混乱的局面不同，海外的房产经纪相当规范、成熟。众多的与房产经纪相关的法规都异常严厉，一旦违规，就无法再从事本行业。由于进行海外房产投资所涉及到的相关事项众多，所以为保证房产交易的顺利进行，最好还是找一个专业的房产经纪人还是很有必要的。
以上是房屋类型、产权、房产经纪人等最为基础的海外房产基础知识，在海外投资买房时，还会涉及购房贷款、购房利率等更为热门的问题，我们将在下一期的海外房产基础知识里为大家介绍，也欢迎大家登陆专业的国外房产网站——居外网了解更多海外房产投资的最新资讯
篇5：详解Lua中的if语句的使用方法
这篇文章主要介绍了详解Lua中的if语句的使用方法,是Lua入门学习中的基础知识,需要的朋友可以参考下
if语句由一个或多个语句组成一个布尔表达式，
语法
Lua编程语言的if语句语法是：
代码如下:
if(boolean_expression)
then
--[ statement(s) will execute if the boolean expression is true --]
end
如果布尔表达式的计算结果为代码的if语句为true，那么块将被执行。如果if语句的末尾（右大括号后）布尔表达式计算为false，那么第一组代码将被执行。
Lua程序设计语言假定布尔true和非零值的任意组合作为true，以及它是否是布尔假或零，则假定为false值，
但应当注意的是，在Lua零值也会被视为true。
示例:
代码如下:
--[ local variable definition --]
a = 10;
--[ check the boolean condition using if statement --]
if( a < 20 )
then
--[ if condition is true then print the following --]
print(“a is less than 20” );
end
print(“value of a is :”, a);
当建立和运行上面代码，它会产生以下结果。
代码如下:
a is less than 20
value of a is : 10
篇6：Lua中table的遍历详解
这篇文章主要介绍了Lua中table的遍历详解,本文讲解了4种遍历方法,并详细分析了这4种方法的特点、使用环境、相关知识等,需要的朋友可以参考下
当我在工作中使用lua进行开发时，发现在lua中有4种方式遍历一个table，当然，从本质上来说其实都一样，只是形式不同，这四种方式分别是：
代码如下:
for key, value in pairs(tbtest) do
XXX
end
for key, value in ipairs(tbtest) do
XXX
end
for i=1, #(tbtest) do
XXX
end
for i=1, table.maxn(tbtest) do
XXX
end
前两种是泛型遍历，后两种是数值型遍历，当然你还会说lua的table遍历还有很多种方法啊，没错，不过最常见的这些遍历确实有必要弄清楚。
这四种方式各有特点，由于在工作中我几乎每天都会使用遍历table的方法，一开始也非常困惑这些方式的不同，一段时间后才渐渐明白，这里我也是把自己的一点经验告诉大家，对跟我一样的lua初学者也许有些帮助（至少当初我在写的时候在网上就找了很久，不知道是因为大牛们都认为这些很简单，不需要说，还是因为我笨，连这都要问）。
首先要明确一点，就是lua中table并非像是C/C++中的数组一样是顺序存储的，准确来说lua中的table更加像是C++中的map，通过Key对应存储Value，但是并非顺序来保存key-value对，而是使用了hash的方式，这样能够更加快速的访问key对应的value，我们也知道hash表的遍历需要使用所谓的迭代器来进行，同样，lua也有自己的迭代器，就是上面4种遍历方式中的pairs和ipairs遍历。但是lua同时提供了按照key来遍历的方式（另外两种，实质上是一种），正式因为它提供了这种按key的遍历，才造成了我一开始的困惑，我一度认为lua中关于table的遍历是按照我table定义key的顺序来的。
下面依次来讲讲四种遍历方式，首先来看for k,v in pairs(tbtest) do这种方式：
先看效果：
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[3] = 3,
[4] = 4,
}
for key, value in pairs(tbtest) do
print(value)
end
我认为输出应该是1，2，3，4，实际上的输出是1，2，4，3。我因为这个造成了一个bug，这是后话。
也就是说for k,v in pairs(tbtest) do 这样的遍历顺序并非是tbtest中table的排列顺序，而是根据tbtest中key的hash值排列的顺序来遍历的。
当然，同时lua也提供了按照key的大小顺序来遍历的，注意，是大小顺序，仍然不是key定义的顺序，这种遍历方式就是for k,v in ipairs(tbtest) do。
for k,v in ipairs(tbtest) do 这样的循环必须要求tbtest中的key为顺序的，而且必须是从1开始，ipairs只会从1开始按连续的key顺序遍历到key不连续为止。
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[3] = 3,
[5] = 5,
}
for k,v in ipairs(tbtest) do
print(v)
end
只会打印1，2，3。而5则不会显示。
代码如下:
local tbtest = {
[2] = 2,
[3] = 3,
[5] = 5,
}
for k,v in ipairs(tbtest) do
print(v)
end
这样就一个都不会打印。
第三种遍历方式有一种神奇的符号‘#‘，这个符号的作用是是获取table的长度，比如：
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[3] = 3,
}
print(#(tbtest))
打印的就是3
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[6] = 6,
}
print(#(tbtest))
这样打印的就是2，而且和table内的定义顺序没有关系，无论你是否先定义的key为6的值，‘#‘都会查找key为1的值开始。
如果table的定义是这样的：
代码如下:
tbtest = {
[“a”] = 1,
[2] = 2,
[3] = 3,
}
print(#(tbtest))
那么打印的就是0了。因为‘#‘没有找到key为1的值。同样：
代码如下:
tbtest = {
[“a”] = 1,
[“b”] = 2,
[“c”] = 3,
}
print(#(tbtest))
打印的也是0
所以，for i=1, #(tbtest) do这种遍历，只能遍历当tbtest中存在key为1的value时才会出现结果，而且是按照key从1开始依次递增1的顺序来遍历，找到一个递增不是1的时候就结束不再遍历，无论后面是否仍然是顺序的key，比如：
table.maxn获取的只针对整数的key，字符串的key是没办法获取到的，比如：
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[3] = 3,
}
print(table.maxn(tbtest))
tbtest = {
[6] = 6,
[1] = 1,
[2] = 2,
}
print(table.maxn(tbtest))
这样打印的就是3和6，而且和table内的定义顺序没有关系，无论你是否先定义的key为6的值，table.maxn都会获取整数型key中的最大值。
如果table的定义是这样的：
代码如下:
tbtest = {
[“a”] = 1,
[2] = 2,
[3] = 3,
}
print(table.maxn(tbtest))
那么打印的就是3了。如果table是：
代码如下:
tbtest = {
[“a”] = 1,
[“b”] = 2,
[“c”] = 3,
}
print(table.maxn(tbtest))
print(#(tbtest))
那么打印的就全部是0了。
换句话说，事实上因为lua中table的构造表达式非常灵活，在同一个table中，你可以随意定义各种你想要的内容，比如：
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[3] = 3,
[“a”] = 4,
[“b”] = 5,
}
同时由于这个灵活性，你也没有办法获取整个table的长度，其实在coding的过程中，你会发现，你真正想要获取整个table长度的地方几乎没有，你总能采取一种非常巧妙的定义方式，把这种需要获取整个table长度的操作避免掉，比如：
代码如下:
tbtest = {
tbaaa = {
[1] = 1,
[2] = 2,
[3] = 3,
},
[“a”] = 4,
[“b”] = 5,
}
你可能会惊讶，上面这种table该如何遍历呢？
代码如下:
for k, v in pairs(tbtest) do
print(k, v)
end
输出是：a 4 b 5 tbaaa table:XXXXX，
由此你可以看到，其实在table中定义一个table，这个table的名字就是key，对应的内容其实是table的地址。
当然，如果你用
代码如下:
for k, v in ipairs(tbtest) do
print(k,v)
end
来遍历的话，就什么都不会打印，因为没有key为1的值。但当你增加一个key为1的值时，ipairs只会打印那一个值，现在你明白ipairs是如何工作的吧。
既然这里谈到了遍历，就说一下目前看到的几种针对table的遍历方式：
for i=1, #tbtest do --这种方式无法遍历所有的元素，因为‘#‘只会获取tbtest中从key为1开始的key连续的那几个元素，如果没有key为1，那么这个循环将无法进入
for i=1, table.maxn(tbtest) do --这种方式同样无法遍历所有的元素，因为table.maxn只会获取key为整数中最大的那个数，遍历的元素其实是查找tbtest[1]~tbtest[整数key中最大值]，所以，对于string做key的元素不会去查找，而且这么查找的效率低下，因为如果你整数key中定义的最大的key是10000，然而10000以下的key没有几个，那么这么遍历会浪费很多时间，因为会从1开始直到10000每一个元素都会查找一遍，实际上大多数元素都是不存在的，比如：
代码如下:
tbtest = {
[1] = 1,
[10000] = 2,
}
local count = 0
for i=1, table.maxn(tbtest) do
count = count + 1
print(tbtest[i])
end
print(count)
你会看到打印结果是多么的 ，只有1和10000是有意义的，其他的全是nil，而且count是10000。耗时非常久。一般我不这么遍历。但是有一种情况下又必须这么遍历，这个在我的工作中还真的遇到了，这是后话，等讲完了再谈。
代码如下:
for k, v in pairs(tbtest) do
这个是唯一一种可以保证遍历tbtest中每一个元素的方式，别高兴的太早，这种遍历也有它自身的缺点，就是遍历的顺序不是按照tbtest定义的顺序来遍历的，这个前面讲到过，当然，对于不需要顺序遍历的用法，这个是唯一可靠的遍历方式。
代码如下:
for k, v in ipairs(tbtest) do
这个只会遍历tbtest中key为整数，而且必须从1开始的那些连续元素，如果没有1开始的key，那么这个遍历是无效的，我个人认为这种遍历方式完全可以被改造table和for i=1, #(tbtest) do的方式来代替，因为ipairs的效果和‘#‘的效果，在遍历的时候是类似的，都是按照key的递增1顺序来遍历。
好，再来谈谈为什么我需要使用table.maxn这种非常浪费的方式来遍历，在工作中， 我遇到一个问题，就是需要把当前的周序，转换成对应的奖励，简单来说，就是从一个活动开始算起，每周的奖励都不是固定的，比如1~4周给一种奖励，5~8周给另一种奖励，或者是一种排名奖励，1~8名给一种奖励，9~16名给另一种奖励，这种情况下，我根据长久的C语言的习惯，会把table定义成这个样子：
代码如下:
tbtestAward = {
[8] = 1,
[16] = 3,
}
这个代表，1~8给奖励1，9~16给奖励3。这样定义的好处是奖励我只需要写一次（这里的奖励用数字做了简化，实际上奖励也是一个大的table，里面还有非常复杂的结构）。然后我就遇到一个问题，即我需要根据周序数，或者是排名序数来确定给哪一种奖励，比如当前周序数是5，那么我应该给我定义好的key为8的那一档奖励，或者当前周序数是15，那么我应该给奖励3。由此读者看出，其实我定义的key是一个分界，小于这个key而大于上一个key，那么就给这个key的奖励，这就是我判断的条件。逻辑上没有问题，但是lua的遍历方式却把我狠狠地坑了一把。读者可以自己想一想我上面介绍的4种遍历方式，该用哪一种来实现我的这种需求呢？这个函数的大致框架如下：
代码如下:
function GetAward(nSeq)
for 遍历整个奖励表 do
if 满足key的条件 then
return 返回对应奖励的key
end
end
return nil
end
我也不卖关子了，分别来说一说吧，首先因为我的key不是连续的，而且没有key为1的值，所以ipairs和‘#‘遍历是没用的。这种情况下理想的遍历貌似是pairs，因为它会遍历我的每一个元素，但是读者不要忘记了，pairs遍历并非是按照我定义的顺序来遍历，如果我真的使用的条件是：序数nSeq小于这个key而大于上一个key，那么就返回这个key。那么我无法保证程序执行的正确性，因为key的顺序有可能是乱的，也就是有可能先遍历到的是key为16的值，然后才是key为8的值。
这么看来我只剩下table.maxn这么一种方式了，于是我写下了这种代码：
代码如下:
for i=1, table.maxn(tbtestAward) do
if tbtestAward[i] ~= nil then
if nSeq <= i then
return i
end
end
end
这么写效率确实低下，因为实际上还是遍历了从key为1开始直到key为table.maxn中间的每一个值，不过能够满足我上面的要求。当时我是这么实现的，因为这个奖励表会不断的发生变化，这样我每次修改只需要修改这个奖励表就能够满足要求了，后来我想了想，觉得其实我如果自己再定义一个序数转换成对应的奖励数种类的表就可以避免这种 的操作了，不过如果奖励发生修改，我需要统一排查的地方就不止这个奖励表了，权衡再三，我还是没有改，就这么写了。没办法，不断变化的需求已经把我磨练的忘记了程序的最高理想。我甚至愿意牺牲算法的效率而去追求改动的稳定性。在此哀悼程序员的无奈。我这种时间换空间的做法确实不知道好不好。
后来我在《Programming In Lua》中看到了一个神奇的迭代器，使用它就可以达到我想要的这种遍历方式，而且不需要去遍历那些不存在的key。它的方法是把你所需要遍历的table里的key按照遍历顺序放到另一个临时的table中去，这样只需要遍历这个临时的table按顺序取出原table中的key就可以了。如下：
首先定义一个迭代器：
代码如下:
function pairsByKeys(t)
local a = {}
for n in pairs(t) do
a[#a+1] = n
end
table.sort(a)
local i = 0
return function
i = i + 1
return a[i], t[a[i]]
end
end
然后在遍历的时候使用这个迭代器就可以了，table同上，遍历如下：
代码如下:
for key, value in pairsByKeys(tbtestAward) do
if nSeq <= key then
return key
end
end
并且后来我发现有了这个迭代器，我根本不需要先做一步获取是哪一档次的奖励的操作，直接使用这个迭代器进行发奖就可以了。大师就是大师，我怎么就没想到呢！
还有些话我还没有说，比如上面数值型遍历也并非是像看起来那样进行遍历的，比如下面的遍历：
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[3] = 3,
[5] = 5,
}
for i=1, #(tbtest) do
print(tbtest[i])
end
打印的顺序是：1，2，3。不会打印5，因为5已经不在table的数组数据块中了，我估计是被放到了hash数据块中，但是当我修改其中的一些key时，比如：
代码如下:
tbtest = {
[1] = 1,
[2] = 2,
[4] = 4,
[5] = 5,
}
for i=1, #(tbtest) do
print(tbtest[i])
end
打印的内容却是：1，2，nil，4，5。这个地方又遍历到了中间没有的key值，并且还能继续遍历下去。我最近正在看lua源码中table的实现部分，已经明白了是怎么回事，不过我想等我能够更加清晰的阐述lua中table的实现过程了再向大家介绍。用我师傅的话说就是不要使用一些未定义的行为方法，避免在工作中出错，不过工作外，我还是希望能明白未定义的行为中那些必然性，o(幡洇)o 唉！因果论的孩子伤不起。等我下一篇博文分析lua源码中table的实现就能够更加清晰的说明这些了。
篇7：详解Lua中if ... else语句的使用方法
这篇文章主要介绍了详解Lua中if ... else语句的使用方法,是Lua入门学习中的基础知识,需要的朋友可以参考下
if 语句后面可以跟一个可选的else语句，当布尔表达式为假该语句执行，
语法
在Lua编程语言中的if ... else语句的语法是：
代码如下:
if(boolean_expression)
then
--[ statement(s) will execute if the boolean expression is true --]
else
--[ statement(s) will execute if the boolean expression is false --]
end
如果布尔表达式的值为true，那么if代码块将被执行，否则else代码块将被执行。
Lua程序设计语言假定布尔true和非零值的任意组合作为true，以及它是否是布尔假或零，则假定为false值。但应当注意的是，在Lua零值被视为true。
例如：
代码如下:
--[ local variable definition --]
a = 100;
--[ check the boolean condition --]
if( a < 20 )
then
--[ if condition is true then print the following --]
print(“a is less than 20” )
else
--[ if condition is false then print the following --]
print(“a is not less than 20” )
end
print(“value of a is :”, a)
当建立和运行上面的代码，它会产生以下结果。
代码如下:
a is not less than 20
value of a is : 100
if...else if...else 语句
if语句后面可以跟一个可选的else if ... else语句，这是非常有用的使用，以测试各种条件单个if...else if 语句。
当使用if , else if , else语句有几点要记住使用：
if 可以有零或一个 else ，但必须在elseif之前。
if 之后可以有零到很多else if在else之前，
一旦一个else if成功，其它的elseif将不会被测试。
语法
if...else if...else...else语句在Lua编程语言的语法是：
代码如下:
if(boolean_expression 1)
then
--[ Executes when the boolean expression 1 is true --]
else if( boolean_expression 2)
--[ Executes when the boolean expression 2 is true --]
else if( boolean_expression 3)
--[ Executes when the boolean expression 3 is true --]
else
--[ executes when the none of the above condition is true --]
end
例如：
代码如下:
--[ local variable definition --]
a = 100
--[ check the boolean condition --]
if( a == 10 )
then
--[ if condition is true then print the following --]
print(“Value of a is 10” )
elseif( a == 20 )
then
--[ if else if condition is true --]
print(“Value of a is 20” )
elseif( a == 30 )
then
--[ if else if condition is true --]
print(“Value of a is 30” )
else
--[ if none of the conditions is true --]
print(“None of the values is matching” )
end
print(“Exact value of a is: ”, a )
当建立和运行上面的代码，它会产生以下结果。
代码如下:
None of the values is matching
Exact value of a is: 100
★后缀数组
★概念教学
★codeigniter中view通过循环显示数组数据的方法
文档为doc格式
