本文主要是介绍新文章 - Lua中的ipair 和 pair的区别 / table，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
参考博客: https://blog.csdn.net/W_han__/article/details/51376615 (https://blog.csdn.net/heyuchang666/article/details/51003492)
参考博客: https://www.jianshu.com/p/4db84cf0d61a(初探 lua 的唯一数据结构 table)
----------------------------------------------------------------------------------------------------
原来，pairs会遍历table的所有键值对。table是键值对的数据结构。
而ipairs就是固定地从key值1开始，下次key累加1进行遍历，如果key对应的value不存在，就停止遍历。顺便说下，记忆也很简单，带i的就是根据integer key值从1开始遍历的。
请看个例子：
tb = {"oh", [3] = "god", "my", [5] = "hello", [6] = "world"}
for k,v in ipairs(tb) do
print(k, v)
end
输出结果就是：
1 oh
2 my
3 god
因为tb不存在tb[4]，所以遍历到此为止了。
for k,v in pairs(tb) do
print(k, v)
end
输出结果：
1 oh
2 my
3 god
6 world
5 hello
我们都能猜到，将输出所有的内容。然而你发现输出的顺序跟你tb中的顺序不同。
如果我们要按顺序输出怎么办？办法之一是：
for i = 1, #tb do
if tb[i] then
print(tb[i])
else
end
当然，仅仅是个数组的话，ipairs也没问题。
————————————————————————————————————————————————————————
在lua的世界中是只有一种数据结构的，那就是table。
而 table 做了在其他语言中，高级特性该做的所有事情。
table 中的数组和hash
这个是比较诡异的一种操作。没错，hash和数组在一起。举个例子
local color = {first="red","blue",third="green","yellow"}
print(color["first"]) -- red
print(color[1]) -- blue
print(color[2]) -- yellow
print(color) -- table: 0x41d99d48
当取下标时，只取出数组部分，当取键时，就是去取hash部分。
而table本身如果打印的话，他只是一个地址。
lua 的数组下标是从1开始的，这点需要注意了。
而遍历他们，lua又提供了两个方法，就是ipair和pair。
local color = {first="red","blue",third="green","yellow"}
for k,v in ipairs(color) do print(k,v)
end
-- 1 blue
-- 2 yellowfor k,v in pairs(color) do print(k,v)
end-- 1 blue
-- 2 yellow
-- third green
-- first red
table 的库函数
- table.getn 获得table的长度
对于一个序列，其元素个数是getn或者一元操作符 # 。其取的长度都是数组的。
且其操作是O(N)的，所以尽量在长度很长的情况下避免使用。
local color = {first="red","blue",third="green","yellow","black"}
print(table.getn(color)) -- 3
print(#color) -- 3
- table.remove 删除指定元素
删除元素，只是说删除 数组部分，也就是使用下标去删除的。
local color = {first="red","blue",third="green","yellow","black"}
table.remove(color,1)
for k,v in pairs(color) do print(k,v)
end
-- 1 yellow
-- 2 black
-- third green
-- first red
如果是删除 hash 部分的话就是 将指定的 元素设置成nil。同时，这样也是对内存的释放。
local color = {first="red","blue",third="green","yellow","black"}
table.remove(color,1)
color.first = nil
for k,v in pairs(color) do print(k,v)
end
-- 1 yellow
-- 2 black
-- third green
- table.concat 元素拼接
按照此方式，把table中的元素拼接起来，同样的，还是针对的是一个table中的数组部分。
local color = {first="red","blue",third="green","yellow","black"}
print(table.concat(color,","))
-- blue,yellow,black
print(table.concat(color,",",2))
-- yellow,black
中间的“，”是指将 数组中的元素以什么为分割符分割。如果最后还跟着数字，则指的是取该数字以后的元素。
- table.insert 插入一个元素
同样，这是对数组操作的了。但是insert的插入性能不乐观，如果不是指定下标去插入元素的话，那么每次需要调用Luajit的 lj_table_len 来获取数组的长度。以便插入队尾。
所以在热代码处减少对insert的使用
local color = {first="red","blue",third="green","yellow","black"}
table.insert(color,1,"orange")
for k,v in pairs(color) doprint(k,v)
end
- table.new 新建一个table
这是luajit的table扩展函数。用来新建table。这个函数会预先分配好指定数组和hash的空间大小。而不是在插入元素时自增长
table.new(narray,nhash) 正是这个含义。
因为自增长是一个代价非常高的操作。，会涉及到空间分配，resize和rehash等。
因为是扩展出来的，所以使用的时候需要require一下。
local new_tab = require "table.new" -- 需要luajit-2.1.0-beta3local t = new_tab(10,5)
for i = 1,10 dot[i] = i
end
- table.clear 清空table
这个同样是函数 table.clear() 里面的函数，用来清空某个table里面的所有数据。但并不会释放数组和hash所占用的内存。
所以，在循环利用lua table时比较有效。可以避免反复的创建和销毁。
local clear_tab = require "table.clear" -- 需要luajit-2.1.0-beta3local color = {first = "red", "blue", third = "green", "yellow"}
clear_tab(color)
for k,v in pairs(color) do print(k,v)
end
元表
元表（metatable）。元表是Lua中独有的概念，在实际的项目中，就是靠元表来对lua作面向对象编程的，在几乎所有的lua-resty-* 库中，都有他的身影。
最重要的函数辅助元表的处理。
- setmetatable(table,metatable): 对指定表设置元表，如果元表中存在 _metatable 键值，setmetatable会失败。
- getmetatable(table)，用于获取table的元素。
类似python中的魔术方法，lua在这方面也有类似的做法。
- __index 元方法
__index 是元表中最常用的键值。当通过键访问表时，如果这个键没有值，则会寻找该元表的__index值。
local v = { bar = 1 }
t = setmetatable({}, { __index = v})
print(t.bar)
-- 1
- __newindex 元方法
该方法对表进行更新，_index 用来对表访问，当给表一个不存在的索引的时候，解释器会查找__newindex 元方法。
local t = {}
myt = setmetatable({k1 = "v1"}, {__newindex = t})print(myt.k1)
-- v1myt.k2 = "v2"
print(myt.k2,t.k2)
-- nil v2myt.k1 = "new_v1"
print(myt.k1,t.k1)
-- new_v1 nil
- __tostring 元方法
__tostring 元方法是用来改变一个表的输出行为。
比如
local t = { major = 5,minor = 3,patch = 102
}
myt = setmetatable(t, {__index = { name = "lua" },__tostring = function (t)return string.format( "%s version is %d.%d.%d",t.name,t.major,t.minor,t.patch )end
})print(tostring(myt))
- lua version is 5.3.102
- __call 元方法
可以让表像方法一样被调用。
local version = { name = "lua",major = 5,minor = 3,patch = 102
}local function print_version(t)print(string.format( "%s version is %d.%d.%d",t.name,t.major,t.minor,t.patch ))
endversion = setmetatable( version, { __call = print_version })version()
面向对象
面向对象是众多编程语言的所支持的。
其主要特点有：
- 封装：能把一个实体的信息，功能装入一个变量或对象里。
- 继承：在不改动原有方法的基础上，对其进行扩充。
- 多态：在同一操作作用于不同的对象时。可以有不同的解释。
- 抽象： 简化复杂现实问题的解决。
-- Meta class
Rectangle = {area = 0,length = 0,breadth = 0,
}function Rectangle:new ( o,length,breadth )o = o or {}setmetatable(o, self)self.__index = selfself.length = length or 0self.breadth = breadth or 0self.area = length * breadthreturn o
endfunction Rectangle:printArea()print("矩形面积为 ",self.area)
end-- 创建对象
r = Rectangle:new(nil,10,20)-- 访问属性
print("矩形的长为",r.length)
-- 矩形的长为 10-- 访问成员函数
r:printArea() -- 或者写成 r.printArea(r) 用 ：号表示是一个语法糖
-- 矩形面积为 200
这篇关于新文章 - Lua中的ipair 和 pair的区别 / table的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
