入职作业之 json 数据与 lua value 转换

题目任务描述：封装json格式的数据与lua value间的互相转换功能

下载ECMA-404的描述文件，观察json的数据格式。

根据描述，一个json value可以是这些类型: object, array, number, string, true, false, or null。

value

下面是描述几种数据类型的图。

object

array

number

string

这些图的描述能力应该等同BNF，所以需要处理的操作大概有：

串联如，C等于A串联B(C＝AB)，即匹配一个C等同于匹配一个A接着匹配一个B
并联如，C等于A并联A(C=A B)，即匹配一个C等同于匹配一个A或者匹配一个B

匹配0或1次如，C等于匹配A0或1次(C=A?)，即匹配一个C等同于匹配一个A0或多次，该操作可以由 C=A

”” 代替，其中”“表示空串。

匹配0或任意次如，C等于匹配A0或任意次(C=A*)，即匹配一个C等同于匹配一个A0或任意次

则最简单的，上述的value可以描述成

value ＝ object | array | number | string | true | false | null

object可以描述成，(引号内表示终结符，括号指示结合顺序)

object ＝ "{" ((string ":" value) ("," string ":" value)*)? "}"

其他就依次类推…

回来开始写代码：

先定义最简单的匹配函数的格式：

 -- the matcher function
 function matcher(json_str, start)
 	...
 	return result, value, new_start
 end

最简单的匹配函数，接受一个待匹配的字符串和一个起始下标，返回匹配结果（true

false），匹配成功后的返回数据，一个新的起始下标。

定义两个最简单的结果处理函数，一个不处理输入直接返回，另一个直接返回nil，后面会常用到

-- result handler
local no_h = function(v) return v end
local nil_h = function() return nil end

定义一个生成基本匹配函数的生成函数，接受一个lua find的匹配表达式和一个结果处理函数，返回一个匹配函数。

-- matcher function generator
local generator = function(pattern, handler)
– the matcher function

function matcher(json_str, start)

local _, e = string.find(json_str, "^"…pattern, start)
if e then
  return true, handler(string.sub(json_str, start, e)), e+1
else
  return false, nil, start
end

end
return matcher

end

根据最开始的描述，需要的操作至少还有：并联、串联、匹配0或一次、匹配0或任意次。

下面是并联多个匹配函数的并联操作，输入一个匹配函数列表和一个结果处理函数，返回一个并联后的匹配函数。

-- parallelize matchers
parallelize = function(matchers,handler)
  if handler == nil then
    handler = no_h
  end
– the paralleized matcher function

function p_matcher(json_str, start)

local r,v,s
for i=1,#matchers do
  r,v,s = matchers[i](json_str, start)
  if r then
    if handler == nil_h then return true, nil, s end
    if handler == no_h then return true, v, s end
    return r,handler(v),s
  end
end

return false,nil,start

end
return p_matcher

end

下面是串联多个匹配函数的串联操作，输入一个匹配函数列表和一个结果处理函数，返回一个串联后的匹配函数。

-- serialize matchers
serialize = function(matchers,handler)
  if handler == nil then
    handler = no_h
  end
– the serialized matcher function

function s_matcher(json_str, start)

local r,v,s = false,nil,start

local results = {}
for i=1,#matchers do
  r,v,s = matchers[i](json_str, s)
  if r == false then
    return false,nil,start
  end
  table.insert(results,v)
end

if handler == nil_h then return true, nil, s end
if handler == no_h then return true, results, s end
return true,handler(results),s

end
return s_matcher

end

匹配0或任意次和匹配1或任意次之间存在转换关系，实现中选了1或任意次匹配作为原子操作，0或任意次可以描述为:(““表示空串)

0_or_more = one_or_more | ""

下面是1或任意次匹配操作，接受一个匹配函数和一个结果处理函数，返回一个匹配1次或任意次的匹配函数。

-- make a matcher match one or more
one_or_more = function(matcher, handler)
  if handler == nil then
    handler = function(v) return v end
  end
– the one or more matcher function

function oom_matcher(json_str, start)

local r,v,s = false,nil,start

local results = {}
r,v,s = matcher(json_str, s)
if r == false then
  return false,nil,s
end
table.insert(results,v)

while true do
  r,v,s = matcher(json_str, s)
  if r == false then
    break
  end
  table.insert(results,v)
end

if handler == nil_h then return true, nil, s end
if handler == no_h then return true, results, s end
return true,handler(results),s

end
return oom_matcher

end

下面定义了一个空串匹配函数，和定义一个0或1次匹配操作函数。

-- empty
local empty_m = generator("",nil_h)
– or empty helper

local or_empty = function(matcher)

return parallelize{matcher,empty_m}

end

定义完这些，就可以开始描述我们的匹配函数了。

-- main matchers
local null_m, boolean_m, number_m, string_m, object_m, array_m, value_m, value_a

value匹配函数的描述，value为number_m,string_m,boolean_m,null_m,object_m,array_m并联。

-- value
value_m = function(json_str,s)
  -- use value_a to bootup
  if value_a==nil then
    value_a = parallelize{number_m,string_m,boolean_m,null_m,object_m,array_m}
  end
  return value_a(json_str,s)
end

这里的value需要使用value_a来协助描述，因为代码最终会出现循环引用，此时number_m,string_m,boolean_m,null_m,object_m,array_m都还没定义，需要在定义好后，才能生成value的匹配函数。

匹配null的函数，使用生成函数生成。

-- null
null_m = generator("null",function() return nil end)

匹配boolean的函数，true和false使用生成函数生成，然后并联true和false匹配函数，生成boolean匹配函数。

-- boolean
local true_m = generator("true", function() return true end)
local false_m = generator("false", function() return false end)
boolean_m = parallelize{true_m,false_m}

匹配number的函数，根据最上面的图，描述为如下：

-- number
local sign_m = generator("[+-]?",no_h)
local minus_or_no_m = generator("[-]?",no_h)
local number_no_0_m = generator("[1-9]%d*",no_h)
local number_0_m = generator("0",no_h)
local dot_number_m = generator("%.%d+",no_h)
local e_number_m = generator("[eE][+-]?%d+",no_h)
number_m = serialize(

{

minus_or_no_m,

parallelize{number_0_m,number_no_0_m},

or_empty(dot_number_m),

or_empty(e_number_m)

},

function(t) return tonumber(table.concat(t)) end

)

string需要处理unicode2utf8编码转换及转义符号。

unicode到utf8转换函数：

-- string
local function hex2utf8(hex)
  local v, utf8str = 0, ""  
  v = tonumber(hex,16)
  if v >= 0x0800 then
    utf8str = string.char(v%0x40+0x80)
    v = math.modf(v/0x40)
    vv = v % 0x40
    utf8str = string.char(vv+0x80) .. utf8str
    v = math.modf(v/0x40)
    utf8str = string.char(v+0xe0) .. utf8str
  elseif v >= 0x0080 then
    utf8str = string.char(v%0x40+0x80)
    v = math.modf(v/0x40)
    utf8str = string.char(v+0xc0) .. utf8str
  else
    utf8str = string.char(v)
  end
  return utf8str
end

匹配引号的函数，使用生成函数生成。

-- string
local quotation_m = generator(""",nil_h)

匹配非”"字符的函数，生成函数生成。

local char_m = generator("[^"\]+", no_h)

转义表

local escape_char = {
    ["""] = """,
    ["\"] = "\",
    ["/"]  = "/",
    ["b"]  = "b",
    ["f"]  = "f",
    ["n"]  = "n",
    ["r"]  = "r",
    ["t"]  = "t",
  }

匹配”"字符函数。

local backslash_m = generator("\", nil_h)

转义符号匹配和处理函数，注意传入的结果处理函数。

local escape_char_m = generator("["\/bfnrt]",function(c) return escape_char[c] end)

unicode匹配和处理函数，注意传入的结果处理函数。

local unicode_char_m = generator("u[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]", function(v) return hex2utf8(string.sub(v,2)) end)

string的描述

string_m = serialize(
  {
    quotation_m,
    or_empty(
        one_or_more(
          parallelize{
            char_m,
            serialize(
              {
                backslash_m,
                parallelize{escape_char_m,unicode_char_m}
              },
              table.concat
              ),
            },
          table.concat
          )
      ),
    quotation_m
  },
  table.concat
)

object的描述，各层结果处理函数比较复杂。

-- object
-- brace_l
local brace_l_m = generator("%s*" .. "{" .. "%s*",nil_h)
local brace_r_m = generator("%s*" .. "}" .. "%s*",nil_h)
local colon_m = generator("%s*:%s*",nil_h)
local comma_m = generator("%s*,%s*",nil_h)
local object_item_m = serialize{string_m,colon_m,value_m}
object_m = serialize(

{

brace_l_m,

or_empty(

serialize(

{

object_item_m,

or_empty(

one_or_more(

serialize(

{comma_m,object_item_m},

function(t) return t[1] end

)

)

)

},

function(t)

if t[2] then

table.insert(t[2],t[1])

return t[2]

else

return {t[1]}

end

end

)

),

brace_r_m

},

function(t)

local o = {}
if t[1] then
  for k,v in pairs(t[1]) do
    o[v[1]] = v[2]
  end
end

return o

end

)

array的描述，array需要保持一个状态index，如果直接用基本操作描述，传入的结果处理函数会比较蛋疼，所以用函数实现了。

-- arrary
local bracket_l_m = generator("%s*%[%s*",nil_h)
local bracket_r_m = generator("%s*%]%s*",nil_h)
array_m = function(json_str, start)
local array,index = {}, 1

local add_item = function(v) array[index] = v[1]; index=index+1 end

local array_item_m = serialize({value_m},add_item)
local array_a = serialize{

bracket_l_m,

or_empty(

serialize{

array_item_m,

or_empty(

one_or_more(serialize{comma_m,array_item_m})

)

}

),

bracket_r_m

}
local r,v,s = array_a(json_str,start)

return r,array,s

end

最后，匹配函数

local function Marshal(json_str)
  local result,value,start = value_m(json_str,1)
  if result and start == #json_str+1 then
    return value
  else
    return nil, "error_type"
  end
end

lua table 反解析成 json string 的比较直观，对每一种lua value类型写一个转换函数即可，此处不冗述。