关系表类型，这是一个很强大的类型。我们可以把这个类型看作是一个数组。只是
C
语言的数组，只能用正整数来作索引； 在
Lua
中，你可以用任意类型的值来作数组的索引，但这个值不能是
nil
。同样，在
C
语言中，数组的内容只允许一种类型；在
Lua
中，你也可以用任意类型的值来作数组的内容，
nil也可以
。
基本介绍
Sorts table elements in a given order, in-place,from
Given an array where all elements are strings or numbers,returns
注意三点：
第一，所有元素之间，总是用逗号 "，" 隔开；
第二，所有索引值都需要用 "["和"]" 括起来；如果是字符串，还可以去掉引号和中括号； 即如果没有[]括起，则认为是字符串索引
第三，如果不写索引，则索引就会被认为是数字，并按顺序自动从 1往后编；
第一，所有元素之间，总是用逗号 "，" 隔开；
第二，所有索引值都需要用 "["和"]" 括起来；如果是字符串，还可以去掉引号和中括号； 即如果没有[]括起，则认为是字符串索引
第三，如果不写索引，则索引就会被认为是数字，并按顺序自动从 1往后编；
例如：
tt
=
{
"hello"
,
33
}
value
=
4
tab
=
{[
tt
]
=
"table"
,
key
=
value
,
[
"flag"
]
=
nil
,
11
}
print
(
tab
[
tt
])
print
(
tab.key
)
print
(
tab
[
1
])
以上写法都是对的。
look = {[www] = "ok"}这样是不对的，www没有赋值，所以默认为nil因此出错table index is nil
---
temp = 1
tab = {[temp] = 1,11}
print(tab[temp]) --此时的结果是11，因为11没有显式对应的key，因此从1开始，如果前面定义了，则覆盖其value
temp = 2
tab = {[temp] = 1,11}
temp = 1
print(tab[temp]) -- 结果是11，虽然定义时[temp] = 1,但是后来我们改变了temp的值，所以指向另外的key了
以上可知：
1.对于字符串，在｛｝定义时，可以
key = value,也可以["flag"] = nil，索引都是string类型，对于非nil类型
变量（包括字符串）
，都可以[variable]=value的方式
2.使用table时，对于字符串，可以通过.的方式访问，也可以通过[]方式访问。tab[a]，tab[b]，只要a==b那么tab[a]可以访问到tab[b]的值
3.不管定义索引时用的是常量还是变量，最终table中value的索引key是常量，不会随变量的改变而变化该value的key
嵌套
tb11= {tb12 = {bool = true}} -- simple,it's a table IN a table :)
-- Call magic!
print
(
tb11.tb12.bool
)
-- works fine,since it's calling the key and value correctly.
print
(
tab11
[
"tb12"
].
bool
)
--same as line 33
print
(
tab11.tb12
[
"bool"
])
--same as line 33
print
(
tab11
[
"tb12"
][
"bool"
])
--same as line 33
修改table的value
--Altering a table's content. Basically manipulating the values of the keys.
lucky
=
{
john
=
"chips"
,
jane
=
"lemonade"
,
jolene
=
"egg salad"
}
lucky.jolene
=
"fruit salad"
--changed the value to "fruit salad" instead of "egg salad"
lucky.jerry
=
"fagaso food"
-- adding a new key-value pair to the container lucky.
lucky.john
=
nil
-- remove john from giving anything or from being a key.
table的易变性
a = {}; b = a;
print(a == b) --> true
c,d = {},{};
print(c == d) -->false
table库函数使用
-----------------------------------------------------------
1. table.sort (table [,comp])
Sorts table elements in a given order, in-place,from table[1] to table[n],where n is the length of the table. If comp is given,then it must be a function that receives two table elements,and returns true when the first is less than the second (so that not comp(a[i+1],a[i]) will be true after the sort). If comp is not given,then the standard Lua operator < is used instead.
The sort algorithm is not stable; that is,elements considered equal by the given order may have their relative positions changed by the sort.
name = {"you" ,"me", "him","bill" }
--table.sort - only works with arrays!
table.sort(name)
for k, v in ipairs( name) do
print( k,v)
end
--table.sort uses callbacks. a function that is writtent to be called by a library function.
function cmp( a, b)
if string.sub(a,2 ,2) < string.sub(b,2) then
return true
else
return false
end
end
table.sort(name, cmp)
for k,v)
end
2. table.insert (table,[pos,] value)
Inserts element
value at position pos in table,shifting up other elements to open space,if necessary. The default value for pos is n+1,where n is the length of the table so that a call table.insert(t,x) inserts x at the end of table t.
--table.insert --an easy to copy a table to another table or adding elements to an array.!
foo
=
{
"a"
,
"c"
,
"d"
}
bar
=
{}
function
printt
(
table
)
for
i
=
1
,#
table
do
print
(
i
,
table
[
i
])
end
end
print
(
"before insert:"
)
printt
(
foo
)
table.insert
(
foo
,
2
,
"b"
)
print
(
"after insert"
)
printt
(
foo
)
table[i]..sep..table[i+1] ··· sep..table[j]. The default value for sep is the empty string,the default for i is 1,and the default for j is the length of the table. If i is greater than j,returns the empty string.
--table.concat does what it implies. Takes an array and concates to one string.
num
=
{
1
,
2
,
3
,
4
,
5
,
6
}
print
(
table.concat
(
num
,
"<"
))
4. table.remove (table [,pos])
Removes from table the element at position pos,shifting down other elements to close the space,if necessary. Returns the value of the removed element. The default value for pos is n,where n is the length of the table,so that a call table.remove(t) removes the last element of table t.
abc = {"a" ,"b", "c"}
print
(
table.remove
(
abc
,
2
))
print
(
"abc length = "
..
#
abc
)
5. table.maxn (table)
Returns the largest positive numerical index of the given table,or zero if the table has no positive numerical indices. (To do its job this function does a linear traversal of the whole table.)
--table.maxn
apple = {"a" ,"p",[ 5]="e"}
print
(
table.maxn
(
apple
))
-- 5
duck
=
{[-
2
]=
3
,[-
1
]=
0
}
print
(
table.maxn
(
duck
))
-- 0
面向对象编程
--note for a object to work,it needs a closure(inner function with an upvalue(a local value from a higher scope))
--note: the more closures made,the slower the program would run.
--note: the more closures made,the slower the program would run.
function mg1( n)
local
function
get
()
return
n
;
end
local
function
inc
(
m
)
n
=
n
+
m
;
end
return
{
get
=
get
,
inc
=
inc
}
end
object
=
mg1
(
50
)
print
(
object.get
())
print
(
object
[
"get"
]())
object.inc
(
2
)
print
(
object.get
())
----------------------------------------
do
local
function
get
(
o
)
return
o.one
end
local
function
inc
(
self
,
two
)
self.one
=
self.one
+
two
end
function
mg3
(
one
)
return
{
one
=
one
,
get
=
get
,
inc
=
inc
}
end
end
a
=
mg3
(
50
)
a
:
get
()
a.inc
(
a
,
2
)
print
(
a
:
get
())
----------------------------------------
do
local
T
=
{};
function
T
:
get
()
return
self.n
;
end
function
T
:
inc
(
m
)
self.n
=
self.n
+
m
;
end
function
mg4
(
n
)
return
{
n
=
n
,
get
=
T.get
,
inc
=
T.inc
}
end
end
c
=
mg4
(
30
)
print
(
c
:
get
())
c
:
inc
(
4
)
print
(
c
:
get
())
——本文对您有帮助的话，那就小额打赏1元呗——
——收到您的打赏，我会很开心——
（完）
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
