持久化

写一个文件容易，读一个文件难。健壮的程序应该能正确读取文件，还能处理坏文件。
数据描述是Lua的主要应用之一，从Lua发明以来，我们花了很多心血使他能够更快的编译和运行大的chunks。也即是说lua文件即可存储数据。

  1. --使用lua文件作为数据数据，并进行管理的例子。
  3. -------------- 数据文件data.lua
  4. Entry{
  5. author = "Donald E. Knuth",
  6. title = "Literate Programming",
  7. publisher = "CSLI",
  8. year = 1992
  9. }
  10. Entry{
  11. author = "Jon Bentley",
  12. title = "More Programming Pearls",
  13. publisher = "Addison-Wesley",
  14. year = 1990
  15. }
  16. -------------- 数据文件data.lua
  17. local authors = {} -- a set to collect authors
  18. function Entry (b)        -- Entry即可作为统计工具，记录数据。
  19.     if b.author then 
  20.     authors[b.author] = true 
  21.   end
  22. end

序列化

将数据转成字符流或字节流。

不带循环嵌套的表

  1. function serialize (o)
  2.   if type(o) == "number" then
  3.         io.write(o)
  4.     elseif type(o) == "string" then
  5.         io.write(string.format("%q", o))
  6.     elseif type(o) == "table" then
  7.     -- 如果是以下这种循环或者嵌套的表，就会死循环。
  8.        -- a = {x=1, y=2; {3,4,5}}
  9.     -- a[2] = a        -- cycle
  10.     -- a.z = a[1]    
  12.     a = {}
  13.         io.write("{\n")
  14.         for k,v in pairs(o) do
  15.             io.write(" [")
  16.       serialize(k)
  17.       io.write("] = ")
  18.             serialize(v)
  19.             io.write(",\n")
  20.         end
  21.         io.write("}\n")
  22.     else
  23.         error("cannot serialize a " .. type(o))
  24.     end
  25. end
  27. local t = { 
  28.   a=12, 
  29.   b='Lua', 
  30.   key='another "one"'
  31. }
  32. serialize(t)
  33. {
  34.   ["a"] = 12,
  35.   ["b"] = "Lua",
  36.   ["key"] = "another \"one\"",
  37. }

带循环嵌套的表

  1. function basicSerialize (o)                --一般序列化：number、string
  2.     if type(o) == "number" then
  3.         return tostring(o)
  4.     else        -- assume it is a string
  5.         return string.format("%q", o)
  6.     end
  7. end
  9. -- name        ：key值
  10. -- value    ：value值，可能是自循环table
  11. -- saved    ：save表，保存已经序列化过的table，反之自循环table导致的死循环。
  12.                         键值对：value(table) - name
  13. function save(name, value, saved)
  14.     saved = saved or {}
  15.     io.write(name, " = ")
  16.     if type(value) == "number" or type(value) == "string" then
  17.         io.write(basicSerialize(value), "\n")
  18.     elseif type(value) == "table" then
  19.         if saved[value] then        
  20.             io.write(saved[value], "\n")
  21.         else
  22.             saved[value] = name    -- save name for next time
  23.             io.write("{}\n")        -- create a new table
  24.             for k,v in pairs(value) do    -- save its fields
  25.                 local fieldname = string.format("%s[%s]", name,
  26.                                             basicSerialize(k))
  27.                 save(fieldname, v, saved)
  28.             end
  29.         end
  30.     else
  31.         error("cannot save a " .. type(value))
  32.     end
  33. end
  34. ----------------------------------------
  35. a = {x=1, y=2; {3,4,5}}
  36. a[2] = a
  37. a.z = a[1]
  39. save('a', a)        --序列化自循环表
  41. a = {}
  42. a[1] = {}
  43. a[1][1] = 3
  44. a[1][2] = 4
  45. a[1][3] = 5
  47. a[2] = a
  48. a["y"] = 2
  49. a["x"] = 1
  50. a["z"] = a[1]
  51. ----------------------------------
  52. a = {{"one", "two"}, 3}
  53. b = {k = a[1]}
  55. save('a', a)            -- 不同save表
  56. save('b', b)            -- 不同save表
  57. a = {}
  58. a[1] = {}
  59. a[1][1] = "one"
  60. a[1][2] = "two"
  61. a[2] = 3
  62. b = {}
  63. b["k"] = {}
  64. b["k"][1] = "one"
  65. b["k"][2] = "two"
  67. --------------------------------
  68. a = {{"one", "two"}, 3}
  69. b = {k = a[1]}
  70. local t = {}
  71. save('a', a, t)            --共同save表
  72. save('b', b, t)            --共同save表
  73. a = {}
  74. a[1] = {}
  75. a[1][1] = "one"
  76. a[1][2] = "two"
  77. a[2] = 3
  78. b = {}
  79. b["k"] = a[1]