lua学习项目笔记

这几天草草的浏览了一下电子版的《lua程序设计》，没有懂的地方就自动忽略了，挑拣了一些可以理解的部分一直在推进。推进至后面的时候已经浑浑噩噩的了，有种想看完这本书的强迫症的感觉。推进CAPI部分的时候发现难度一下子提升了，有种难以理解的感觉，而且这本书没有相对应的练习，只是看书没有进行相应的实践，确实难度比较大。这里先暂缓推进这本书的进程，决定拿一下小的项目来试试写lua代码的感觉，写完这个项目在回去体会lua程序设计这本书，这样可能效果会更好一些。这里我会列出项目描述，而且会记录完成这个项目的过程，当然，项目是一个非常简单，而且已经存在优秀的开源库的东西，但是这里先检查一下自己是否能够完成，完成之后可以参阅一下相关开源库的实现，对比之中应该会有所提高。

项目描述：

基于lua 5.2.3 封装实现一个可供其他lua脚本使用的功能模块，具体要求为:
1、实现一个标准的lua功能模块
2、封装json格式的数据与lua value间的互相转换功能
3、遵循json格式定义确保相同的数据源彼此转换后数据仍然一致
4、只允许使用lua内建基础库，不允许使用任何第三方开发库
5、有合理的注释和单元测试代码
6、独立完成此作业，对任何代码抄袭现象零容忍

基本要求：
提交lua代码文件名为json.lua，测试代码和文档（如果有）可以打一个包作为第二个附件提交
json.lua中需要实现以下接口：
function Marshal(json_str) return lua_val end
function Unmarshal(lua_val) return "json_str" end

对基本要求的说明：
1、lua版本要求5.2.3
2、lua的空table统一转化成json的空object，而不是空array
3、test case中的json_str符合ECMA-404 json格式标准
4、Unmarshal传入的lua_val如果是table的话，不会有循环嵌套
5、table如果是以array方式使用，转换如下：{[2]=1,[4]=1} == {nil,1,nil,1} <-> [null,1,null,1]
6、table中有string key时，统一处理成hash table的格式，如：{1,2;a=3} -> {"1":1,"2":2","a":3}
7、不会出现类似 {1,2;["2"]="same key 2 in json"} 造成转换有歧义的table
8、Unicode转成lua字符串时，按lua的字符串格式 \xXX\xYY...
9、能成功转换的话，只需要return单个值

进阶要求：
对test case的错误进行检查，返回相应错误
function Marshal(json_str) return nil, "error_type" end

基本测试方法：
local json = require 'json'

local test_result1 = json.Marshal('{"a":1}')
local test_result2 = json.Unmarshal{ b="cd" }

-- validate test_result1 & test_result2

　

项目解决过程：

一.模块

首先这个问题是实现一个模块，在lua 5.1版开始，lua已经为模块和包定义了一系列的规则，我们需要使用table，函数，元表和环境来实现这些规则。其中lua提供了两个重要的函数实现这些规则，分别是require（使用模块函数）和module（创建模块函数）。

require可以加载模块，这里加载到的为一个table，table内容包含该模块提供的接口和成员变量；规则还定义一个规范的模块应该可以使require返回该模块的table。require使用方法为：

require "<模块名>"。其实这里require的功能感觉和dofile比较像，但是还是存在区别的，require详细的内容我目前也不是很理解，这里先略去。

完成了加载模块的解释，接下来就是自己实现模块需要遵守什么样的规则呢？模块的主要功能就是定义一个table，然后定义这个table需要导出的成员接口&成员变量，然后返回这个table即完成了这个模块的实现。module函数完成了很多简化模块编写的功能；module函数的更加详细部分以及模块编写的公共部分演化这里略去。

local modname = ...
local M = {}
_G[modname] = M
package.loaded[modname] = M

<setup for external access>

setfenv(1,M)

关于子模块和包的部分这里也利用不到，所以这部分知识也略去，关于lua程序设计一书中这部分讲述也稍有复杂，其中印刷题中关于'-'和'_'区分不好，看起来比较吃力，不过关于require和module的部分讲解的非常不错。

所以这部分的代码实现如下：

module(...,package.seeall)

function Marshal(json_str)
print(json_str)
end

function Unmarshal(lua_content)
print(lua_content)
end

　　

这里把函数的内容简化为只进行参数的输出，后面继续分析并实现函数的功能。　　

这部分看起来非常的容易，不过还是要明白其中的道理。

二.JSON语法简析

json的语法非常的简单，数据在 名称/值 对中，数据由逗号分隔，花括号保存对象，方括号保存数组；

json的值类型包含：数字（整数或者浮点数），字符串（双引号），逻辑值（true或者false），数组（方括号中），对象（花括号中），null

所以json语言还是比较简单的。

谈到这种解析的工作，之前接触过（浏览过）一个自己实现的HTMLParser实现，使用的方法是自动机的策略进行实现的。这种有解析思路的项目均可以利用自动机的思想来实现，自动机的课程很早之前学习的了，此时发现智商好低，学习的内容基本都已经完全还给老师了。不过针对JSON的解析可以使用自动机的思路。这里我搬运一下json官网上的自动机图解。

首先json数据是由对象 or 数组组成的基本结构;



json的对象由大括号包含的key:value组成，key:value之间由逗号隔开，其中key为string的类型，string类型具体定义下面给出。value的具体类型下面给出；



json的数组由中括号包含的value组成，value之间由逗号隔开，其中value的具体类型下面给出；



value的具体类型由string，number，object，array和一些其他json常量组成；



string是由双引号包含的一个字符串，其中包含unicode编码和一些转义字符，其中unicode字符在lua中的存储应该也是一个比较棘手的问题；

json中的转义字符也是一个很bug的问题，lua字符串中也存在转义字符。

而且lua中字符串的表示可以利用单引号，双引号和双中括号，其中单双引号的功能比较类似，存在转义符号。然而双中括号会忽略转义符号，所以这个地方编写程序的时候应该特别注意。

所以lua中定义的json字符串的转义符号要转换为lua中的转义字符串，根据上面自动机的标示有8个转义字符和一个unicode转义字符。lua的json字符串中的符号应该为"\\",\\/,\\\\,\\b,\\f,\\n,\\r,\\t,\\u...."这些了，分别应该转为lua中的"",/,\,\b,\f,\n,\r,\t"。

当然lua中内部的转义字符转换也应该逆转换过来；

所以会有两个dict进行转换； 关于unicode码的转换后面进行解释；

json_to_lua = {
['\\"] = '"',
['\\/'] = '/',
['\\\\'] = '\\'
["\\t"] = "\t",
["\\f"] = "\f",
["\\r"] = "\r",
["\\n"] = "\n",
["\\b"] = "\b"
}
lua_json = {
['"'] = '\\"',
['\\'] = '\\\\',
['/'] = '\\/',
['\b'] = '\\b',
['\f'] = '\\f',
['\n'] = '\\n',
['\r'] = '\\r',
['\t'] = '\\t'
}

数字的自动机转移图，其中数字包含正负类型，浮点数，整型，科学技术法，所以合法的数字类型的状态机比较复杂，但是lua中有一个可以偷懒的地方在于tonumber函数的使用，可以将string转换为number，如果转换不合法，则返回nil；

三.lua编写状态机的一些知识

由于上面已经提及了自动机来实现json的解析，然而根据lua程序设计，函数尾调用一节中得知，在lua中”尾调用“的一大应用就是编写”状态机“。

”这种程序通常一个函数就是一个状态，改变状态利用’goto‘或尾调用到另外一个特定的函数。尾调用就是一个函数的return的最后语句是另外一个函数，此时针对此函数的栈信息不进行保存，所以最后一个函数调用相当于goto语句的调用，所以如此可以进行无限的调用也不会产生栈溢出的错误。尾调用详细信息这里略去，只是简单介绍一下。

另外lua中的字符串遍历不是很方便，lua中的string是不变量，也没有提供下标访问的接口，所以只能利用string提供的sub函数去一个字符一个字符的遍历；

四.具体代码的实现

（1）json字符串的解析部分

a. Marsha1解析json字符串的接口，从第一个个字符开始遍历json字符串，position设置为1。

b. skipBlank函数跳过空格，tab，换行等空白字符；

c. 找到第一个有效字符，‘{’或者‘[’，分别继续调用decodeObject和decodeArray函数返回相应的内部lua table即可。如果不是这两个符号，则此json字符串存在格式错误。

--two interface encode json or decode json
function M.Marshal(json_str)

local nowTime = os.time()

--json must be json array or object
local position = 1
position = M.skipBlank(json_str,position)
--null json string case
local json_len = string.len(json_str)
if position > json_len then
return nil,[[null json string]]
end
--change to json object or json array
--otherwise,invalid
local c = string.sub(json_str,position,position)
local res
if c == [[{]] then
res = M.decodeObject(json_str,position)
elseif c == [[[]] then
res = M.decodeArray(json_str,position)
else
res = nil,[[error that json no an object or array,invalid]]
end

M.MarshalTime = M.MarshalTime + os.time() - nowTime

return res
end

　　

接下来就是decodeObject，decodeArray，decodeNumber，decodeString，decodeOther等，分别对应于json中的object，array，number，string，true，false，null等变量；和skipBlank函数同样，这些函数具有类似的输入和输出参数；

关于这些函数的输入，因为整个过程是遍历字符串，所以字符串和当前遍历的位置信息比较重要，所以这些函数的传入参数为json字符串和当前字符的位置信息；

这些函数的输出函数分别为解析到的lua内部的数据结构和下一个字符的位置信息；

（这里实现的时候同样可以把json字符串和指针的位置信息设置为两个全局变量，思路相同）

了解完这些函数的思想之后接下来就容易理解这些函数的实现代码。

跳过空白字符

其中在代码debug的时候遇到了

malformed pattern （missing ']'),error的错误，

这里因为string.find函数把第二个参数中的'['符号判断为正则表达式符号了，所以这里就产生错误，所以这里针对'['符号进行一下特殊处理；

其他方面就只检测当前字符是不是自定义的blankcharacter中的一个即可

--skip the blank character
--blank character include space,\n \r \t
--params
--[in] json_str : json string
--[in] position : current position of the string
--[out] the next of end position of the blank character
function skipBlank(json_str,position)
local blankcharacter = ' \t\r\n'
local json_len = string.len(json_str)
while position <= json_len do
local c = string.sub(json_str,position,position)
--malformed pattern (missing ']'),error
if c == "[" then
return position
elseif string.find(blankcharacter,c) then
position = position + 1
else
break
end
end
return position
end

解析json object

函数看似比较复杂，其实逻辑比较清晰；

json object开始于 '{'，结束于 '}'，由key:value对组成，由 ',' 分隔；

不断的读取key ， ':' ， value 然后填入相应的lua table，返回lua table即可；

其中利用计数的方法保证 ',' 的语法正确；

--decode from json object
--begin with '{'
--params
--[in] json_str : json string
--[in] position : current position of the string
--[out] lua table ,  the next of end the end position of the string
function decodeObject(json_str,position)
local lua_object = {}
local key,subobject,subarray,str,number,othervalue
local c = string.sub(json_str,position,position)
--check case
if c ~= [[{]] then
base.print [[error that object not start with { ]]
return nil,[[error in decodeObject begin]]
end
position = position + 1
position = skipBlank(json_str,position)
c = string.sub(json_str,position,position)
if c == [[}]] then
position = position + 1
return lua_object,position
end
--then json array including {key:value,key:value,key:value,...}
--key --> string
--value including
--string
--number
--object
--array
--true,false,nil
----------------------------------------------------------------
local precount = -1
local curcount = 0
local json_len = string.len(json_str)
while position <= json_len do
position = skipBlank(json_str,position)
c = string.sub(json_str,position,position)
--key:value
if c == [[}]] then
--object over
if precount >= curcount then
--,is adjace to ]
base.print "error that , is adjace to }"
return nil,"error that , is adjace to }"
end
break
elseif c == [[,]] then
--next key:value or over
position = position + 1
precount = precount + 1
if 0 == curcount then
--,is the first,error
base.print [[error that , in key:value is the first]]
return nil,[[error that , in key:value is the first]]
end
if precount >= curcount then
--,is more than one
base.print [[error that , in key:value is more than one]]
return nil,[[error that , in key:value is more than one]]
end
elseif c == [["]] then
--begin key:value
key,position = decodeString(json_str,position)
--:
position = skipBlank(json_str,position)
c = string.sub(json_str,position,position)
if c ~= [[:]] then
base.print [[error,that object not key:value format]]
return nil,[[error in decodeObject,format error]]
else
position = position + 1
end
--begin value
position = skipBlank(json_str,position)
c = string.sub(json_str,position,position)
if c == '[' then
subarray,position = decodeArray(json_str,position)
lua_object[key] = subarray
elseif c == '{' then
subobject,position = decodeObject(json_str,position)
lua_object[key] = subobject
elseif c == [["]] then
str,position = decodeString(json_str,position)
lua_object[key] = str
elseif string.find([[+-0123456789.e]],c) then
number,position = decodeNumber(json_str,position)
lua_object[key] = number
else
othervalue,position = decodeOther(json_str,position)
if othervalue then
lua_object[key] = othervalue
end
end
if not lua_object[key] then
base.print [[error in json object key:value --> value,can't get value]]
return nil,[[error in decodeObject value]]
else
curcount = curcount + 1
end
--end value
else
base.print [[error json format]]
return nil,[[error json format,in decodeObject end]]
end
end
return lua_object,position + 1
end

解析json array

json array的解析开始于 '[' 符号，结束于 ']' 符号，value值之间利用 ',' 隔开；

创建一个lua table，针对value值利用 t[#t+1] = value插入新的值，新的值根据符号调用相应的decode方法即可，

其中为了确保json语法错误被检测出来，利用计数的方法保证 ',' 语法的正确；

--decode from json array
--begin with '['
--params
--[in] json_str : json string
--[in] position : current position of the string
--[out] lua table ,  the next of end the end position of the string
function decodeArray(json_str,position)
local lua_array = {}
local c = string.sub(json_str,position,position)
--check case
if c ~= [[[]] then
base.print [[error that array not start with [ ]]
return nil,[[error in decodeArray begin]]
end
position = position + 1
position = skipBlank(json_str,position)
c = string.sub(json_str,position,position)
if c == ']' then
position = position + 1
return lua_array,position
end
--then json array including [value,value,value...]
--value including
--string
--number
--object
--array
--true,false,nil
-------------------------------------------------------------------------
--about [,] or ["hello",] or [,"hello"] or ["hello",,"world"] check error
--using pre count & cur count to find this
local precount = -1
local curcount = 0
local json_len = string.len(json_str)
while position <= json_len do
position = skipBlank(json_str,position)
c = string.sub(json_str,position,position)
if c == '[' then
subarray,position = decodeArray(json_str,position)
lua_array[#lua_array+1] = subarray
curcount = curcount + 1
elseif c == '{' then
subobject,position = decodeObject(json_str,position)
lua_array[#lua_array+1] = subobject
curcount = curcount + 1
elseif c == [["]] then
str,position = decodeString(json_str,position)
lua_array[#lua_array+1] = str
curcount = curcount + 1
elseif string.find([[+-0123456789.e]],c) then
number,position = decodeNumber(json_str,position)
lua_array[#lua_array+1] = number
curcount = curcount + 1
elseif c == ']' then
--there is some bugs,which is end with ,
if precount >= curcount then
--,is adjace to ]
base.print "error that , is adjace to ]"
return nil,"error that , is adjace to ]"
end
break
elseif c == ',' then
--there is some bugs,which is begin with ,
position = position + 1
precount = precount + 1
if 0 == curcount then
--,is the first,error
base.print [[error that , is the first]]
return nil,[[error that , is the first]]
end
if precount >= curcount then
--,is more than one
base.print [[error that , is more than one]]
return nil,[[error that , is more than one]]
end
else
othervalue,position = decodeOther(json_str,position)
lua_array[#lua_array+1] = othervalue
curcount = curcount + 1
end
end

if position > json_len then
base.print 'error that array not end with ]'
return nil,[[error in decodeArray end]]
end
c = string.sub(json_str,position,position)
if c ~= ']' then
base.print 'error that array not end with ]'
return nil,[[error in decodeArray end]]
end
position = position + 1
return lua_array,position
end　

解析json string

关于unicode的部分还未实现，还不是很了解这方面的知识；

关于string的解析仅仅是从第一个双引号开始，找到最后一个双引号且不是[[\"]]，及转义的双引号，然后截取两个双引号之间的内容，得到字符串即可；

--decode json string,include json key of key/value and the string value
--begin with ' " '
--params
--[in] json_str : json string
--[in] position : current position of the string
--[out] lua string ,  the next of end the end position of the string
function M.decodeString(json_str,position)

nowTime = os.time()

local endposition = position + 1
local json_len = string.len(json_str)
while endposition <= json_len and ( [["]] ~= string.sub(json_str,endposition,endposition) or [[\]] == string.sub(json_str,endposition - 1,endposition - 1) ) do
endposition = endposition + 1
end
local str = string.sub(json_str,position + 1,endposition - 1)

--process str

str = string.gsub(str,'\\u....',function (tstr)
local a = string.sub(tstr,3,6)
local n = tonumber(a,16)
local x
if n < 0x80 then
x = string.char(n % 0x80)
elseif n < 0x800 then
-- [110x xxxx] [10xx xxxx]
x = string.char(0xC0 + (math.floor(n/64) % 0x20), 0x80 + (n % 0x40))
else
-- [1110 xxxx] [10xx xxxx] [10xx xxxx]
x = string.char(0xE0 + (math.floor(n/4096) % 0x10), 0x80 + (math.floor(n/64) % 0x40), 0x80 + (n % 0x40))
end
return x
end
)
str = string.gsub(str,'\\.',escapeSequences)
return str,endposition + 1
end

当然这其中有些转义字符的处理，均利用string.gsub函数，针对相应字符如果table中包含，则进行替换，相关table和函数如下。

local ecapses = {
['"'] = '\\"',
['\\'] = '\\\\',
['/'] = '\\/',
['\b'] = '\\b',
['\f'] = '\\f',
['\n'] = '\\n',
['\r'] = '\\r',
['\t'] = '\\t'
}
function encodeString(s)
return string.gsub(s,'.',function(c) return ecapses[c] end)
end

local escapeSequences = {
["\\t"] = "\t",
["\\f"] = "\f",
["\\r"] = "\r",
["\\n"] = "\n",
["\\b"] = "\b"
}
setmetatable(escapeSequences, {__index = function(t,k)
-- skip "\" aka strip escape
return string.sub(k,2)
end})

解析json number

这里实现number的解析也比较偷懒，获取到连续的比较像number的字符串，利用lua提供的tonumber函数转换为number，失败返回nil

--decode json number
--the valid number of json,include float,int and so on
--[in] json_str : json string
--[in] position : current position of the string
--[out] lua number ,  the next of end the end position of the string
function decodeNumber(json_str,position)
--string to number,lua have this function - tonumber
local acceptCharacter = [[+-0123456789.e]]
if not string.find(acceptCharacter,string.sub(json_str,position,position)) then
base.print [[error that string not start with " ]]
return nil,[[error in decodeNumber begin]]
end
--find the endposition
local endposition = position
local json_len = string.len(json_str)
while endposition <= json_len and string.find(acceptCharacter,string.sub(json_str,endposition,endposition)) do
endposition = endposition + 1
end
local number = base.tonumber(string.sub(json_str,position,endposition - 1))
if not number then
base.print [[error in number format]]
return nil,[[error in decodeNumber end]]
end
return number,endposition
end　

解析json的一些常量

关于json中的常量包含true，false和null，解析得到相应的值即可；

--decode other json value
--include boolean value(true,false) or null
--[in] json_str : json string
--[in] position : current position of the string
--[out] lua boolean or nil ,  the next of end the end position of the string
function decodeOther(json_str,position)
--true,false,null,
--three value
-- "true" --> true
-- "false"--> false
-- "null" --> nil
OtherString = {"true","false","null"}
JsonLua = { ["true"] = true,["false"] = false,["null"] = nil }
for i = 1,#OtherString do
local str = OtherString[i]
if string.sub(json_str,position,position + string.len(str) - 1) == str then
return JsonLua[str],position + string.len(str)
end
end
base.print [[error,invalid json other,not true,false,null]]
return nil,[[error in decodeOther end]]
end

（2）lua内部对象转换json

这部分比较简单，也存在一种可能是我考虑的比较简单，目前感觉实现还是正确的，因为我在debug上面的时候实现了一个printLua函数，打印json转换为lua table的内部结构；

打印出的结构刚好比较类似json的结构，所以后面只需要针对这个函数进行修改，输出部分改为输出至string即可

关于printLua函数：

这个函数的一个辅助函数是判断lua中的table是否为数组形式，或者是键值对的形式；

--this function check lua_table is array or is an object
--compare to json
--if there exists one key/value in the lua_table,it's an object,otherwise,it's an array
--[in] lua_table : table type in lua
--[out] boolean and maxnumber of array : true indicate that the lua table is an array,false indicate that the lua table is an key/value table
function LuaArray(lua_table)
--if lua_table is an array,it imply that all its key's type is number
--if lua_table is an key/value table,imply that there exists string type in its keys
--so just check all its key type
local isarray = true
local maxindex = 0
for k,_ in base.pairs(lua_table) do
if base.type(k) ~= [[number]] then
isarray = false
break
elseif base.type(k) == [[number]] and (math.floor(k) ~= k or k < 1) then
isarray = false
break
else
maxindex = math.max(maxindex,k)
end
end
return isarray,maxindex
end
--for test lua Table
--output lua table
--format output table
function printLuaTable(luaT,space)
local ss = string.rep([[ ]],space)
local isarray,alen = LuaArray(luaT)
if isarray then
io.write(ss .. '[\n')
for i = 1,alen do
io.write(ss .. [[    ]])
if base.type(luaT[i]) == "boolean" then
if luaT[i] then
io.write('true\n')
else
io.write('false\n')
end
elseif base.type(luaT[i]) == "number" then
io.write(luaT[i] .. '\n')
elseif base.type(luaT[i]) == "string" then
io.write(luaT[i] .. '\n')
elseif base.type(luaT[i]) == "nil" then
io.write('nil\n')
else
printLuaTable(luaT[i],space + 4)
end
end
io.write(ss .. ']\n')
else
io.write(ss .. '{\n')
for k,v in base.pairs(luaT) do
local str = [[    ]] .. k .. ':'
io.write(ss .. str)
if base.type(v) == "boolean" then
if v then
io.write('true\n')
else
io.write('false\n')
end
elseif base.type(v) == "number" then
io.write(v .. '\n')
elseif base.type(v) == "string" then
io.write(v .. '\n')
else
printLuaTable(v,space + 4)
end
end
end
io.write(ss .. '}\n')
end

针对输出进行修改如下：

--[out] json string
function Unmarshal(lua_content)
--like output lua_content
--like printLuaTable
--using table concat
result = {}
Unmarsha1Helper(lua_content,result)
return table.concat(result)
end
--[in] lua_content:decode json to lua table
--[in] result:table that convert to json string
--like printLuaTable , all the element insert into result
function Unmarsha1Helper(lua_content,result)
if base.type(lua_content) ~= "table" then
base.print [[error that lua_content is not table]]
return nil,[[error in Unmarsha1Helper end]]
end
local isarray,arraylen = LuaArray(lua_content)
if isarray and arraylen >= 1 then
--array
result[#result+1] = '['
for i = 1,arraylen do
if base.type(lua_content[i]) == "boolean" then
if lua_content[i] then
result[#result+1] = [[true]]
else
result[#result+1] = [[false]]
end
elseif base.type(lua_content[i]) == "number" then
result[#result+1] = '' .. lua_content[i]
elseif base.type(lua_content[i]) == "string" then
result[#result+1] = [["]] .. lua_content[i] .. [["]]
elseif base.type(lua_content[i]) == "nil" then
result[#result+1] = "null"
else
Unmarsha1Helper(lua_content[i],result)
end
result[#result+1] = ','
end
if result[#result] == ',' then
result[#result] = nil
end
result[#result+1] = ']'
else
--object
result[#result+1] = [[{]]
for k,v in base.pairs(lua_content) do
result[#result+1] = '"' .. k .. '"' .. ':'
if base.type(v) == "boolean" then
if v then
result[#result+1] = [[true]]
else
result[#result+1] = [[false]]
end
elseif base.type(v) == "number" then
result[#result+1] = '' .. v
elseif base.type(v) == "string" then
result[#result+1] = [["]] .. v .. [["]]
elseif base.type(v) == "nil" then
result[#result+1] = "null"
else
Unmarsha1Helper(v,result)
end
result[#result+1] = ','
end
if result[#result] == ',' then
result[#result] = nil
end
result[#result+1] = [[}]]
end
end

　

关于lua与json的解析与反解析的基本实现就完成了，本地可以调试通过，接下来就是细致功能的完成和程序健壮性的调整了。

五.编写程序的一些心得

程序的实现过程中也利用了SciTE进行了单步的调试，因为实现完毕之后出现了很多奇怪的问题，死循环，输出不符合语气。用起来感觉SciTE的调试功能还算可以，帮助完成了本地版功能的实现；

实现的过程中同样感受到浏览了一遍lua程序设计之后能够记住的东西实在太少，基本的循环结构可能都不记得，当这个程序完成之后还是需要lua的继续学习，这样应该才算够学习了这门语言吧。

六.unicode码知识

关于unicode与utf8的关系，这篇文章讲的非常的详细：http://www.ruanyifeng.com/blog/2007/10/ascii_unicode_and_utf-8.html

unicode只是一个符号集合，并没有规定具体的如何存储，所以如何存储还需要具体的方案，比如utf8，utf16等等。unicode与utf8的关系如下：

Unicode符号范围 | UTF-8编码方式
(十六进制) | （二进制）
--------------------+---------------------------------------------
0000 0000-0000 007F | 0xxxxxxx
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

所以这里只需要把json中的\uXXXX编码转换为utf8字节码即可。