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字节码即可。

posted @ 2015-01-18 15:53 weixliu 阅读(...) 评论(...) 编辑 收藏