lua学习之table类型

关系表类型,这是一个很强大的类型。我们可以把这个类型看作是一个数组。只是 C语言的数组,只能用正整数来作索引; 在Lua中,你可以用任意类型的值来作数组的索引,但这个值不能是&#1

大家好,又见面了,我是全栈君,今天给大家准备了Idea注册码。

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

注意三点: 

    第一,所有元素之间,总是用逗号 “,” 隔开;

    第二,所有索引值都需要用 “[“和”]” 括起来;如果是字符串,还可以去掉引号和中括号; 即如果没有[]括起,则认为是字符串索引

    第三,如果不写索引,则索引就会被认为是数字,并按顺序自动从 1往后编;
 
例如:
tt 
= 
{“hello” 
,33
}
value 
= 4
tab 
= 
{[tt
] 
= “table”
,key 
= value
, 
[“flag” 
] 
= 
nil
, 11
}
 
print
(tab
[tt
])
print
(tab.key
)
print
(tab
[
])

 
以上写法都是对的。http://hovertree.com/hovertreescj/
 
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的易变性
 

= 
{}; b 
= a
;
print
(
== b
)  –> true
 
c
,
= 
{},{};
 
print
(
== 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
) 
< 
string.sub
(b
,
,2
) 
then
          
return 
true
     
else
          
return 
false
     
end
end
 
table.sort
(name
, cmp
)
for k
, v 
in 
ipairs
( name
) 
do
     
print
( 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
=
,#
table 
do
         
print
(i
,
table 
[
])
    
end
end
print
(“before insert:” 
)
printt
(foo
)
table.insert
(foo
,
,“b”
)
print
(“after insert” 
)
printt
(foo
)

 
 
3.  table.concat (table [, sep [, i [, j]]])
 

Given an array where all elements are strings or numbers, returns 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 
= 
{
,2
, 3
,4
,
,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 
= 
{[-
]=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.
function mg1( n)
    
local 
function get 
()
         
return n 
;
    
end
    
local 
function inc 
(
)
        n 
= n 
+
;
    
end
    
return 
{get 
= get
, inc
= inc
}
end
 
object 
= mg1
(50 
)
print
(object.get 
())
print
(object
[“get” 
]())
 
object.inc
(
)
print
(object.get 
())
—————————————-
do
    
local 
function get 
(
)
         
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

= mg3
(50 
)
a
:get
()
a.inc
(a
,
)
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 
, get 
=T.get 
, inc 
=T.inc 
}
    
end
end
 

= mg4
(30 
)
print
(c
:get
())
c
:inc
(
)
print
(c
:get
())
 
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/120420.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • Android反编译apk逆向分析

    Android反编译apk逆向分析

  • 2021.12.13phpstorm激活码【2021免费激活】

    (2021.12.13phpstorm激活码)本文适用于JetBrains家族所有ide,包括IntelliJidea,phpstorm,webstorm,pycharm,datagrip等。IntelliJ2021最新激活注册码,破解教程可免费永久激活,亲测有效,下面是详细链接哦~https://javaforall.cn/100143.html…

  • 06 _使用命令在hadoop的HDFS中存储文件

    06 _使用命令在hadoop的HDFS中存储文件

  • ORA-00607 Internal error occurred while making a change to a data block处理[通俗易懂]

    ORA-00607 Internal error occurred while making a change to a data block处理[通俗易懂]这个问题是我模拟的故障,具体怎么出现的请参考链接https://blog.csdn.net/m15217321304/article/details/105223487–//查看数据库日志RecoveryofOnlineRedoLog:Thread1Group3Seq24Readingmem0Mem#0:/u01/app/oradata/QXY1…

    2022年10月26日
  • 2k21本世代和次世代生涯一样吗_nba2k21次世代价格

    2k21本世代和次世代生涯一样吗_nba2k21次世代价格原题链接对于在中国大学MOOC(http://www.icourse163.org/ )学习“数据结构”课程的学生,想要获得一张合格证书,总评成绩必须达到 60 分及以上,并且有另加福利:总评分在 [G, 100] 区间内者,可以得到 50 元 PAT 代金券;在 [60, G) 区间内者,可以得到 20 元PAT代金券。全国考点通用,一年有效。同时任课老师还会把总评成绩前 K 名的学生列入课程“名人堂”。本题就请你编写程序,帮助老师列出名人堂的学生,并统计一共发出了面值多少元的 PAT 代金券。输入格

  • mysql floor报错注入_mysql报错注入总结[通俗易懂]

    mysql floor报错注入_mysql报错注入总结[通俗易懂]最近又深刻的研究了一下mysql的报错注入,发现很多值得记录的东西,于是写了这篇博客做一个总结,目的是为了更深刻的理解报错注入报错注入原因及分类既然是研究报错注入,那我们先要弄明白为什么我们的注入语句会导致数据库报错,报错的原因我自己总结了一下,有以下几点重复数据报错,这里的重复主要有两个方面,其中之一是基于主键的唯一性:一个表主键必须是唯一的,如果一个表尝试生成两个相同的主键,就会爆出Dupli…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号