0-1認識Lua （二）--Lua Table 的構造

1.Lua Table 的構造

 

//初始化表
//1
mytable = {}
//2
_mytable = {a=100,b="123"}

//使用.號賦值
_mytable.a = 110
//使用索引賦值
_mytable["c"]=139
//創建多級表
local _mytable = {}
for i=1,5 do
    _mytable[i] = {a=100,b="123"}
end
//創建多級表2
  local _mytable = {}
  _mytable['a'] = {a=100,b="123"}
  _mytable['b'] = {a=100,b="321"}
  local _mytable2 = {'a','b'}
  dump(_mytable[_mytable2[1]])

Lua表的構造過程 

1.定義一個table a 此時內存情況爲

 

(如果要刪除這個表，只需將a == nil ，Lua的垃圾回收機制將會清理掉相應的內存)

2.如果此時定義一個 table b == a ，此時b會直接指向內存，而不是a，此時a和b對這個表是一樣的權限，都能讀寫，所以在這是即使將a==nil，b依然能控制這個表，只有將b==nil 才能將這個表完全刪除

表的使用

//增加  table.insert()
//其用法如下 table.insert（數組，鍵，值）
//下面添加 鍵爲2的值，如果原來數組中有鍵爲2的值依次向後從新排列。
//如果我們省略了鍵，只填入數組名 和 值，就會默認把新添加的值放入數組的最後一位。
table.insert（array，2，"aa"）

//刪除 table.remove()
//從數組中刪除元素 table.remove(數組名，鍵)
//table.remove(數組名) 默認刪除最後一個元素
bm = {"aa","bb","cc"}
table.remove(bm,3)
print(#bm) -- 2

//排序 table.sort()
// table.sort(數組，排序規則） 但是遇到相等的會亂序
am = {1,4,7,2,6}
func = function(a,b)
 return a>b
end
table.sort(am,func)

//創建表函數
//創建自己函數的表來作爲自己的函數庫
myfunc = {} --創建一個空表
myfunc.func = function()
    print("111111111")
end
myfunc.func2 = function()
    print("22222222222")
end
myfunc.func()
myfunc.func2()

//得到表的長度
print(table.getn(表))
print(#表)
//table.getn(表) 獲取表的長度 也可以用 #表 來獲取表的長度 
//注意：以上2種獲得 表長的方法必須要求 該table的key必須是有序的，索引是從1開始的。
//因爲下面的table的key值是無序的，所以 table.getn(),#table 無法得到該table 表的長度
//在循環中，當我們獲取 table 的長度的時候無論是使用 # 還是 table.getn 其都會在索引中斷的地方停止計數，而導致無法正確取得 table 的長度。

//表庫
//table.concat(表，分隔符，開始下標，結束下標)
//作用：返回參數中表內從開始下標到結束下標中所有數組部分，並用分隔符分開。後三個參數爲可選參數
a = {55,66,88}
print(table.concat(a,",",2,3))

//table.maxn(表)
//返回表中多有正數鍵值中最大鍵，如果不存在鍵爲正數的鍵，則返回0

lua表的冒泡排序

-- 有一個數組包含10個元素，sa = {54,25,66,87,47,89,34,45,63,101}利用循環判斷語句將數組內的值從大到小從新排序
-- 交換兩個變量的值可以寫成 a,b = b,a 
-- 冒泡排序法 (升序排序)從第一個元素開始，對數組中兩兩相鄰的元素比較，將值較小的元素放在最前面，值較大的元素放在後面，一輪比較完畢
--一個最大的數沉底成爲數組的最後一個元素，一個較小的數如同氣泡一樣上浮一個位置。n個數，經過n-1輪比較後完成排序
--按升序進行排列
sa = {54,25,66,87,47,89,34,45,63,101}
i = 1
j = 1
while i<(#sa) do --i<10
while j<=((#sa)-i) do --j<=9
if sa[j]>sa[j+1] then --如果想從大到小進行排序 sa[j]<sa[j+1]
sa[j],sa[j+1] =sa[j+1],sa[j]
end
j = j+1
end
j = 1
i = i+1
end
for k,v in pairs(sa) do 
print(k.."鍵的值爲"..v)
end
--[[1鍵的值爲25
2鍵的值爲34
3鍵的值爲45
4鍵的值爲47
5鍵的值爲54
6鍵的值爲63
7鍵的值爲66
8鍵的值爲87
9鍵的值爲89
10鍵的值爲101--]]

--冒泡排序法的另外一種寫法
function bubble_sort(arr)
local tmp = 0
for i = 1,#arr-1 do
for j = 1,#arr-i do
if arr[j]>arr[j+1] then --從小到大排列 arr[j]<arr[j+1]
tmp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = tmp
end
end
end
end
function main(...)
local arr = {54,25,66,45,555,666,321,88,665,89}
bubble_sort(arr)
for i,v in pairs (arr) do
print(i.."鍵的值是："..v)
end
end
main()
--結果和上面一樣

2.lua 的Table的源代碼

對一門新知識在做到會用之後還得了解下源碼，字符串大家都屬性，但如果定義string類卻是讓人一時難以下手。不會寫可以先看，看多了自然就通了

typedef struct Table {
  CommonHeader;    //爲所有可回收資源提供標記頭
  lu_byte flags;  /* 1<<p means tagmethod(p) is not present 其實是 typedef unsigned char lu_byte，lu_byte flags用於表示表中提供了哪些元方法*/ 
  lu_byte lsizenode;  /* 以2的lsizenode次方作爲哈希表長度  它的值就是表的長度，但是散列表大小的擴增一定是2的冪，如果散列桶數組要擴展的話，也是每次在原大小的基礎上乘以2的形式擴展*/
  struct Table *metatable /* 元表 */;
  TValue *array;  /* 數組 */
  Node *node; /* 哈希表 */
  Node *lastfree;  /* 指向最後一個爲閒置的鏈表空間 */
  GCObject *gclist;
  int sizearray;  /* 數組的大小 */
} Table;

太難了，未完待續