Diff Json

Just change left_json and right_json and click Diff! button to see the result.

# coding=utf-8
import time
import collections

def gen_process_list(left_json, right_json, parent=None):
    # state 是什么？
    # 当 json 是 dict 时：
    # 2(b010) 表示仅左json有该key
    # 3(b011) 表示左右都有该key但是值不同（包括类型不同）
    # 7(b111) 表示左右都有该key且值相同
    # 1(b001) 表示仅右json有该key
    # 当 json 是 list 时：
    # 2(b010) 表示仅左json有该index
    # 3(b011) 表示左右都有该index但是值不同（包括类型不同）
    # 7(b111) 表示左右都有该index且值相同
    # 1(b001) 表示仅右json有该index
    # 
    # :param left_json:
    # :param right_json:
    # :param parent:
    # :return: (process_list(key: state, children(key: state, children(...)...)...), mask_state)
    #          (process_list[(key: state, children[(key: state, children...), ...]), ...], mask_state)

# 前置调用保证了两侧的类型相同
    if_list = isinstance(left_json, list)

if if_list:
        process_list = []
        if parent is not None:
            parent["children"] = process_list
        l_len = len(left_json)
        r_len = len(right_json)
        _i = 0
        while _i < l_len:
            lv = left_json[_i]
            pl_item = {
                "state": 2,
                "children": None
            }
            process_list.append(pl_item)
            if _i < r_len:
                pl_item["state"] = 3
                lv_type_l = isinstance(lv, list)
                lv_type_d = isinstance(lv, dict)
                rv_type_l = isinstance(right_json[_i], list)
                rv_type_d = isinstance(right_json[_i], dict)
                if (lv_type_l and rv_type_l) or (lv_type_d and rv_type_d):
                    _, return_state = gen_process_list(lv, right_json[_i], parent=pl_item)
                    pl_item["state"] = return_state
                elif lv == right_json[_i]:
                    pl_item["state"] = 7
            _i += 1
        while _i < r_len:
            pl_item = {
                "state": 1,
                "children": None
            }
            process_list.append(pl_item)
            _i += 1
        mask_state = 7
        for v in process_list:
            c_state = v["state"]
            mask_state = mask_state & c_state
    else:
        process_list = {}
        if parent is not None:
            parent["children"] = process_list
        l_keys = left_json.keys()
        r_keys = right_json.keys()
        for lk, lv in left_json.items():
            process_list[lk] = {
                "state": 2,
                "children": None
            }
            if lk in r_keys:
                process_list[lk]["state"] = 3
                lv_type_l = isinstance(lv, list)
                lv_type_d = isinstance(lv, dict)
                rv_type_l = isinstance(right_json[lk], list)
                rv_type_d = isinstance(right_json[lk], dict)
                if (lv_type_l and rv_type_l) or (lv_type_d and rv_type_d):
                    _, return_state = gen_process_list(lv, right_json[lk], parent=process_list[lk])
                    process_list[lk]["state"] = return_state
                elif lv == right_json[lk]:
                    process_list[lk]["state"] = 7
        for rk, rv in right_json.items():
            if rk not in l_keys:
                process_list[rk] = {
                    "state": 1,
                    "children": None
                }
        mask_state = 7
        for k, v in process_list.items():
            c_state = process_list[k]["state"]
            mask_state = mask_state & c_state
    if parent:
        mask_state = mask_state | parent["state"]
    return process_list, mask_state

def gen_order_json(in_json, process_list):
    # 根据 7 > 3 > 2/1 的顺序排列 key
    if not process_list:
        return in_json

if isinstance(process_list, dict):
        final_json = collections.OrderedDict()
        for k, v in process_list.items():
            state = v["state"]
            if state == 7:
                value = in_json[k]
                final_json[k] = value
        for k, v in process_list.items():
            state = v["state"]
            if state == 3:
                value = in_json[k]
                if isinstance(value, dict):
                    value = gen_order_json(in_json[k], v["children"])
                final_json[k] = value
        for k, v in process_list.items():
            state = v["state"]
            if state == 2 or state == 1:
                if k in in_json:
                    value = in_json[k]
                    if isinstance(value, dict):
                        value = gen_order_json(in_json[k], v["children"])
                    final_json[k] = value
        return final_json
    elif isinstance(process_list, list):
        final_json = []
        _i = 0
        length = len(in_json)
        while _i < length:
            value = in_json[_i]
            if isinstance(value, dict):
                value = gen_order_json(in_json[_i], process_list[_i]["children"])
            final_json.append(value)
            _i += 1
        return final_json

def gen_json_str(in_json, process_list, is_root=True, parent_state=7, is_last=False):
    if isinstance(in_json, dict):
        gen_json_str_arr = []
        keys = in_json.keys()
        k_len = len(keys)
        _i = 0
        while _i < k_len:
            k = keys[_i]
            v = in_json[k]
            if process_list:
                state = process_list[k]["state"]
                children = process_list[k]["children"]
            else:
                state = parent_state
                children = None
            if isinstance(v, dict) or isinstance(v, list):
                key_str = """
                    <div class="line left-indent state-%s">"%s": </div>
                """ % (state, k)
                v_str = gen_json_str(v, children, is_root=False, parent_state=state, is_last=(_i == k_len - 1))
                value_wrapper = """
                    <div class="no-line left-indent state-%s">%s</div>
                """ % (state, v_str)
                gen_json_str_arr += [key_str, value_wrapper]
            else:
                final_v = v
                if isinstance(v, str):
                    final_v = """\"%s\"""" % v
                comma = """<div class="no-line end-comma">,</div>"""
                if _i == k_len - 1:
                    comma = ""
                key_str = """
                    <div class="line left-indent state-%s">"%s": %s%s</div>
                """ % (state, k, final_v, comma)
                gen_json_str_arr.append(key_str)
            _i += 1
        gen_str = ""
        for a in gen_json_str_arr:
            gen_str += a
        comma = ""
        if not is_root and not is_last:
            comma = """<div class="no-line end-comma">,</div>"""
        curly_braces_wrapper = """
            <div class="line left-curly-brace symbol"> { </div>
            <div class="no-line">%s</div>
            <div class="line right-curly-brace symbol"> }%s </div>
        """ % (gen_str, comma)
        return curly_braces_wrapper
    elif isinstance(in_json, list):
        gen_json_str_arr = []
        _i = 0
        length = len(in_json)
        while _i < length:
            v = in_json[_i]
            if process_list:
                state = process_list[_i]["state"]
                children = process_list[_i]["children"]
            else:
                state = parent_state
                children = None
            if isinstance(v, dict) or isinstance(v, list):
                v_str = gen_json_str(v, children, is_root=False, parent_state=state, is_last=(_i == length - 1))
                value_wrapper = """
                    <div class="line left-indent state-%s">%s</div>
                """ % (state, v_str)
                gen_json_str_arr += [value_wrapper]
            else:
                final_v = v
                if isinstance(v, str):
                    final_v = """\"%s\"""" % v
                comma = """<div class="no-line end-comma">,</div>"""
                if _i == length - 1:
                    comma = ""
                v_str = """
                    <div class="line left-indent state-%s">%s%s</div>
                """ % (state, final_v, comma)
                gen_json_str_arr.append(v_str)
            _i += 1
        gen_str = ""
        for a in gen_json_str_arr:
            gen_str += a
        comma = ""
        if not is_root and not is_last:
            comma = """<div class="no-line end-comma">,</div>"""
        bracket_wrapper = """
            <div class="line left-bracket symbol"> [ </div>
            <div class="no-line">%s</div>
            <div class="line right-bracket symbol"> ]%s </div>
        """ % (gen_str, comma)
        return bracket_wrapper

def gen_html_str(left_json, right_json, process_list):
    left_html = gen_json_str(left_json, process_list)
    right_html = gen_json_str(right_json, process_list)
    html_wrapper = """
            <div class="diff-container">
              <div class="left-area">%s</div>
              <div class="right-area">%s</div>
            </div>
    """ % (left_html, right_html)
    return html_wrapper

def json_diff(left_json, right_json):
    if_left_list = isinstance(left_json, list)
    if_right_list = isinstance(left_json, list)
    if_left_dict = isinstance(left_json, dict)
    if_right_dict = isinstance(left_json, dict)

if (if_left_list and if_right_list) or (if_left_dict and if_right_dict):
        process_list, status = gen_process_list(left_json, right_json)
        order_left_json = gen_order_json(left_json, process_list)
        order_right_json = gen_order_json(right_json, process_list)
        html_wrapper = gen_html_str(order_left_json, order_right_json, process_list)
        print html_wrapper
    else:
        return "Not same type"

def main():
    left_json = [{"key1": "value1", "key2": "value2", "key3": "value3", "list1": [{"a": []}, "2", "4", "5"],
                  "list2": {"a": 1.2, "c": 2, "b": 3}}, {"a": 1}]
    right_json = [{"key1": "value1", "key2": "value22", "key4": "value4", "list1": [{"a": [1]}, "2", "4", "5"],
                    "list2": {"a": 1.2, "b": 2, "d": 3.3}}, {"a": 1}]
    json_diff(left_json, right_json)

if __name__ == "__main__":
    main()

grey means both have key/index and their value is same
blue means both have key/index and their value is not same
purple means only left_json has this key/index
green means only right_json has this key/index