Lua: table

 

1. 一维数组 模拟 二维数组
   

   array = {}
   rows = 3
   cols = 4
   
   for row = 1, rows do
       for col = 1, cols do
           array[(row - 1) * cols + col] = row * col
       end
   end
   
   
   
   for row = 1, rows do
       for col = 1, cols do
           io.write(string.format("%d\t", array[(row-1)*cols+col]))
       end
       print()
   end

    

2. 构造数组型的table

   a = {}
   a[1] = "Perl"
   a[2] = "PHP"
   a[3] = "Ruby"
   a[4] = "Lua"
   
   -- 直接构造
   a1 = {"Perl", "PHP", "Ruby", "Lua"}
   print(a1[1])   --> Perl
   
   -- key/value方式构造
   a2 = {[1] = "Perl", [2] = "PHP", [3] = "Ruby", [4] = "Lua"}
   print(a2[1])   --> Perl

   

    

    

    

     

   

     

   tbl1 = {}
   tbl1[0] = 00
   tbl1[1] = 11
   tbl1[2] = nil
   tbl1[3] = 33
   
   print('#######################################################')
   print('tbl1 count:', #tbl1)
   
   for k, v in ipairs(tbl1) do
       print(k .. ': ' .. v)
   end
   print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
   for k,v in pairs(tbl1) do
       print(k..': '..v)
   end
   
   tbl2 = { [0] = 00, [1] = 11, [2] = nil, [3] = 33 }
   
   print('#######################################################')
   print('tbl2 count:', #tbl2)
   
   for k, v in ipairs(tbl2) do
       print(k .. ': ' .. v)
   end
   print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
   for k,v in pairs(tbl2) do
       print(k..': '..v)
   end
   
   tbl3 = { 1, nil, 2 }
   
   print('#######################################################')
   print('tbl3 count:', #tbl3)
   
   for k, v in ipairs(tbl3) do
       print(k .. ': ' .. v)
   end
   print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
   for k,v in pairs(tbl3) do
       print(k..': '..v)
   end

   

    

    

3. 移除数组的所有间隙，将所有数组元素重组成一个序列

   tbl = { "perl", "php", "shell", "lua", "python" }
   tbl[10] = "java"
   tbl[11] = "javascript"
   tbl[33] = "c"
   tbl[44] = "go"
   tbl[45] = "sql"
   
   local function recompose(tbl)
       tbl.idx = {}
       for i in pairs(tbl) do
           if type(i) == 'number' then
               tbl.idx[#tbl.idx + 1] = i
           end
       end
       -- 1, 2, 3, 4, 5, 44, 10, 11, 33, 45
       print(table.concat(tbl.idx, ', '))
   
       table.sort(tbl.idx)
       -- 1, 2, 3, 4, 5, 10, 11, 33, 44, 45
       print(table.concat(tbl.idx, ', '))
   
       local cnt
       for _, index in ipairs(tbl.idx) do
           cnt = (cnt or 0) + 1
           tbl[cnt] = tbl[index]
           if cnt ~= index then
               tbl[index] = nil
           end
       end
   
       tbl.idx = nil
   
   end
   
   recompose(tbl)
   
   print(table.concat(tbl, ', '))

    

4. Double-ended queue
   
   

   function queue()
       return { head = 1, tail = 0 }
   end
   
   function push(q, v)
       q[q.tail + 1] = v
       q.tail = q.tail + 1
   end
   
   function unshift(q, v)
       q[q.head - 1] = v
       q.head = q.head - 1
   end
   
   function pop(q)
       if q.tail < q.head then
           error('empty queue')
       end
       local v = q[q.tail]
       q[q.tail] = nil
       q.tail = q.tail - 1
       return v
   end
   
   function shift(q)
       if q.tail < q.head then
           error('empty queue')
       end
       local v = q[q.head]
       q[q.head] = nil
       q.head = q.head + 1
       return v
   end
   
   q = queue()
   
   for b = 0, 4 do
       push(q, utf8.char(0x41 + b))
   end
   
   for b = 0, 4 do
       print(pop(q))
   end
   print('~~~~~~~~~~~~~~~~~~~~~~~~~~~')
   for b = 0, 4 do
       unshift(q, utf8.char(0x30 + b))
   end
   
   for b = 0, 4 do
       print(shift(q))
   end