Python 实现 JSON 器

Json 解析

Json 的组成

JSON结构共有2种

1. 对象结构
2. 数组结构

一个合法的JSON字符串可以包含这几种元素:

1. 特殊符号,如"{" “}“表示一个JSON Object，”[” "]“表示一个JSON Array，”:“用于分隔key-value，”,"用于分隔两个元素
2. 字符串，用引号引起来
3. 数字，包含0-9，浮点数带有".“，表示符号可带有” " “-”
4. 常量有true, false, null

对象结构

对象结构是使用大括号“{”括起来的，大括号是由0个或多个用英文逗号分隔的“关键字:值”对(key:value)构成。

语法：

{
    "健名1"： "值1",
    "健名2"： "值2"
}

说明：

jsonObj指的是json对象。对象结构是以"{“开始，到”}"结束。其中"键值"和"值"之间英文冒号构成对，两个"键名:值"之间用英文逗号分隔。

注意，这里的键名是字符串，但是值可以是数值、字符串、对象、数组或逻辑true和false。

数组结构

JSON数组结构是用中括号"[]“括起来，中括号内部由0个或多个英文逗号”,"分隔的值列表组成。

语法:

[
    {"name": "ywh"},
    {"age": 18}
]

说明：

数组结构是以"{“开始，到”]“结束，这一点跟JSON对象不同。在JSON数组中，每一对”{}"相当于一个JSON对象，大家看看像不像？而且语法都非常类似。

注意，这里的键名是字符串，但是值可以是数值、字符串、对象、数组或逻辑true和false。

词法分析

词法分析的主要目的是将字符串解析成一小组一小组的合法元素，要将那些是结构所需的符号，数据表达的符号识别出来。比如要将字符串 12.0解析为一个数字12.0等等。

可以分析json的组成发现，特殊的元素都只包含一个字符，常量，数字的表示中间则不会出现空格或其他不相关字符，因此可以轻易地用表达的特征区分，如：

• 数字 可以匹配一段连续的且所有字符都在0-9或者是("." " " "-")的范围内。

• 字符串 对于字符串我们则只需要考虑在双引号"之间的任何字符。特殊的话我们需要考虑到字符串中的特殊的转义字符比如字符\"转义之后的意思其实就是"。

• 常量 对于(true, false, null)这些常量与字符串的不同之处就是它们不会被"所包裹。所以我们只需要读取结构分隔符（例如：(":", ",", "]","}")）之间的字符串，并在匹配字符后查看是否有对应的常量。

• 空格字符 空格字符一般，让我们的json数据看起来结构更加清晰。但是在解析到相应语言的数据结构的时候则不需要考虑，所以遇到有效字符片段后的空格都跳过。

• 结构标志性字符 一般单独出现，并且位置比较特殊。比如{作为对象的开始，在对象中:的下一个有效字符片段作为相应value

后面将这些特殊的元素组合称为 合法字符组

所以json解析器要做的就是,如何识别出字符串中一小组一小组的合法元素，同时要根据 结构标志性字符 将得到的合法元素组逻辑拼接起来并检查其中是否有非法格式。

因此编写了下面这个Tokener类：

class Tokener():
  """
    ## TODO: 字符串中的各种 Token 解析
  """
  def __init__(self, json_str):
    self.__str = json_str    # json 字符串
    self.__i = 0   #  当前读到的字符位置
    self.__cur_token = None    # 当前的字符
  
  def __cur_char(self):
    """
      ## 读取当前的字符的位置
    """
    if self.__i < len(self.__str):
      return self.__str[self.__i]
    return ''
  
  def __move_i(self, step=1):
    """
      ## 读取下一个字符
    """
    if self.__i < len(self.__str): self.__i  = step
  
  def __next_string(self):
    """
      ## str 字符片段读取
    """
    outstr = ''
    trans_flag = False
    self.__move_i()
    while  self.__cur_char() != '':
      ch = self.__cur_char()
      if ch == "\\": trans_flag = True  # 处理转义
      else:
        if not trans_flag:
          if ch == '"':
            break
        else:
          trans_flag = False
      outstr  = ch
      self.__move_i()
    return outstr

  def __next_number(self):
    """
      ## number 字符片段读取
    """
    expr = ''
    while  self.__cur_char().isdigit() or self.__cur_char() in ('.', ' ', '-'):
      expr  = self.__cur_char()
      self.__move_i()
    self.__move_i(-1)
    if "." in expr: return float(expr)
    else: return int(expr)
  
  def __next_const(self):
    """
      ## bool 字符片段读取
    """
    outstr = ''
    while self.__cur_char().isalpha() and len(outstr) < 5:
      outstr  = self.__cur_char()
      self.__move_i()
    self.__move_i(-1)
    
    if outstr in ("true", "false", "null"):
      return {
        "true": True,
        "false": False,
        "null": None,
      }[outstr]
    raise Exception(f"Invalid symbol {outstr}")
  
  def next(self):
    """
      ## 解析这段 json 字符串
      ## TODO: 获得下一个字符片段(合法字符组)
    """
    is_white_space = lambda a_char: a_char in ("\x20", "\n", "\r", "\t")
    while is_white_space(self.__cur_char()):
      self.__move_i()
    
    ch = self.__cur_char()
    if ch == '':
      cur_token = None
    elif ch in ('{', '}', '[', ']', ',', ':'):
      # 这些特殊的包裹性、分隔性字符作为单独的token
      cur_token = ch
    elif ch == '"':
      # 以 “ 开头代表是一个字符串
      cur_token = self.__next_string()
    elif ch.isalpha():
      # 直接以字母开头的话检查是不是 bool 类型的
      cur_token = self.__next_const()
    elif ch.isdigit() or ch in ( '-', ' '):
      # 以数字开头或者是 -符号开头
      cur_token = self.__next_number()
    
    self.__move_i()
    self.__cur_token = cur_token
    
    return cur_token is not None
  
  def cur_token(self):
    # 当前的合法元素组
    return self.__cur_token

代码注释中的 Token 就可以理解为合法字符组。

调用这个类中的next函数就可以获得下一个合法的字符组。也是将其中的字符串、数字、常量、特殊性分隔符识别出来。

逻辑性解析

首先我们需要去区分两种json类型

上图做的就是确定，这个json最外层属于哪种json类型的，然后根据两种类型的特征去解析。

解析对象类型

解析数组类型

完整代码

class Tokener():
  """
    ## TODO: 字符串中的各种 Token 解析
  """
  def __init__(self, json_str):
    self.__str = json_str    # json 字符串
    self.__i = 0   #  当前读到的字符位置
    self.__cur_token = None    # 当前的字符
  
  def __cur_char(self):
    """
      ## 读取当前的字符的位置
    """
    if self.__i < len(self.__str):
      return self.__str[self.__i]
    return ''
  
  def __move_i(self, step=1):
    """
      ## 读取下一个字符
    """
    if self.__i < len(self.__str): self.__i  = step
  
  def __next_string(self):
    """
      ## str 字符片段读取
    """
    outstr = ''
    trans_flag = False
    self.__move_i()
    while  self.__cur_char() != '':
      ch = self.__cur_char()
      if ch == "\\": trans_flag = True  # 处理转义
      else:
        if not trans_flag:
          if ch == '"':
            break
        else:
          trans_flag = False
      outstr  = ch
      self.__move_i()
    return outstr

  def __next_number(self):
    """
      ## number 字符片段读取
    """
    expr = ''
    while  self.__cur_char().isdigit() or self.__cur_char() in ('.', ' ', '-'):
      expr  = self.__cur_char()
      self.__move_i()
    self.__move_i(-1)
    if "." in expr: return float(expr)
    else: return int(expr)
  
  def __next_const(self):
    """
      ## bool 字符片段读取
    """
    outstr = ''
    while self.__cur_char().isalpha() and len(outstr) < 5:
      outstr  = self.__cur_char()
      self.__move_i()
    self.__move_i(-1)
    
    if outstr in ("true", "false", "null"):
      return {
        "true": True,
        "false": False,
        "null": None,
      }[outstr]
    raise Exception(f"Invalid symbol {outstr}")
  
  def next(self):
    """
      ## 解析这段 json 字符串
      ## TODO: 获得下一个字符片段
    """
    is_white_space = lambda a_char: a_char in ("\x20", "\n", "\r", "\t")
    while is_white_space(self.__cur_char()):
      self.__move_i()
    
    ch = self.__cur_char()
    if ch == '':
      cur_token = None
    elif ch in ('{', '}', '[', ']', ',', ':'):
      # 这些特殊的包裹性、分隔性字符作为单独的token
      cur_token = ch
    elif ch == '"':
      # 以 “ 开头代表是一个字符串
      cur_token = self.__next_string()
    elif ch.isalpha():
      # 直接以字母开头的话检查是不是 bool 类型的
      cur_token = self.__next_const()
    elif ch.isdigit() or ch in ( '-', ' '):
      # 以数字开头或者是 -符号开头
      cur_token = self.__next_number()
    
    self.__move_i()
    self.__cur_token = cur_token
    
    return cur_token is not None
  
  def cur_token(self):
    return self.__cur_token


class JsonDecoder():
  """
    TODO: json 字符串解析
  """
  def __init__(self):
    pass
  
  def __json_object(self, tokener):
    """
      ## json 解析json中的对象结构
    """
    obj = {}
    # 判断是否为 object 起始字符 
    if tokener.cur_token() != "{":
      raise Exception('Json must start with "{"')
    
    while True:  # 循环中每次都去解析一组键值对
      tokener.next()
      tk_temp = tokener.cur_token()
      # 如果直接遇到闭回的 } 则直接返回空结构体
      if tk_temp == "}":
        return {}
    
      if not isinstance(tk_temp, str):
        raise Exception(f'invalid key {tk_temp}')

      # 解析得到 键值对中  key
      key = tk_temp
      tokener.next()
      if tokener.cur_token() != ":":
        raise Exception(f'expect ":" after {key} ')
      
      # 解析得到 键值对中 value
      tokener.next()
      val = tokener.cur_token()
      if val == "[":
        val = self.__json_array(tokener)
      elif val == "{":
        val = self.__json_object(tokener)
      obj[key] = val

      # 解析与下一组键值对的
      tokener.next()
      tk_split = tokener.cur_token()
      if tk_split == ",":    # 若遇到多个元素则重新进入循环
        continue
      elif tk_split == "}":    # 如果为 } 则说明对象闭合
        break
      else:
        if tk_split is None:
          print(f"tk_split {tk_split}")
          raise Exception('missing "}" at the end of object')
        raise Exception(f'unexpected token "{tk_split}" at key "{tk_split}" ')
    return obj
    
  def __json_array(self, tokener):
    if tokener.cur_token() != "[":
      raise Exception('Json array must start with "["')
    arr = []
    while True:
      # 每次遍历都能得到数组中的一个元素
      tokener.next()
      tk_temp = tokener.cur_token()
      if "tk_temp" == "]": return arr
      if tk_temp == "{":
        val = self.__json_object(tokener)
      elif tk_temp == "[":
        val = self.__json_array(tokener)
      elif tk_temp in (',', ":", "}"):
        raise  Exception(f"unexpected token {tk_temp}")
      else:
        val = tk_temp
      arr.append(val)
      
      # 解析获得与数值的逻辑连接符
      tokener.next()
      tk_end = tokener.cur_token()
      if tk_end == ",":
        continue
      if tk_end == "]":
        break
      else:
        if tk_end is None:
          raise  Exception('missing "]" at the end of array')
    return arr
  
  def decode(self, json_str:str):
    tokener = Tokener(json_str)
    if not tokener.next():
      return None
    first_token = tokener.cur_token()
    
    if first_token == "{":
      decode_val = self.__json_object(tokener)
    elif first_token == "[":
      decode_val = self.__json_array(tokener)
    else:
      raise Exception('Json must start with "{"')
    
    if tokener.next():
      raise Exception(f"unexpected token {tokener.cur_token()}")
    return decode_val

def get_testData():
  """
    ## 获得测试数据
  """
  with open("./data.json", "r", encoding="utf-8") as file:
    return file.read()

def test():
  data = get_testData()
  decoder = JsonDecoder()
  print(decoder.decode(data))

if __name__ == '__main__':
  test()

小结

总结一下解析中的要点：

• 分析元始格式化数据的格式特点

• 解析字符串中的合法字符组

• 通过逻辑符将解析得到的合法字符组逻辑串联起来

这篇好文章是转载于：学新通技术网