e2ee仿精易json源码

.版本 2
.支持库 e2ee

.程序集 json_ex
.程序集变量 json1, 存取键值表
.程序集变量 json2, 文本型

.子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用

.子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用

.子程序 解析, 逻辑型, 公开
.参数 json, 文本型
.参数 a, 逻辑型, 可空, 空
.参数 b, 逻辑型, 可空, 空
.局部变量 bool, 逻辑型

bool ＝ json1.从JSON载入 (json, , , )
返回 (bool)

.子程序 取属性, 文本型, 公开
.参数 文本, 文本型
.局部变量 arr, 文本型, , "0"
.局部变量 arr1, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 arr0, 文本型, , "0"
.局部变量 内容, 文本型

文本 ＝ “//” ＋ 文本
.判断开始 (寻找文本 (文本, “['”, , 假) ＞ -1)
    .如果真 (寻找文本 (文本, “['”, , 假) ＞ -1)
        文本_取中间_批量 (文本, “['”, “']”, arr0, , , , , , , )
        文本 ＝ 文本_替换 (文本, 取数组成员数 (arr0), , , “['”, “.”, “']”, “”)
    .如果真结束
    .如果真 (寻找文本 (文本, “//.”, , 假) ＞ -1)
        文本 ＝ 文本_替换 (文本, 1, , , “//.”, “//”)
    .如果真结束

.默认

.判断结束
.如果真 (寻找文本 (文本, “[”, , 假) ＞ -1)
    文本_取中间_批量 (文本, “[”, “]”, arr, , , , , , , )
    .计次循环首 (取数组成员数 (arr), i)
        加入成员 (arr1, 到文本 (到整数 (arr <i>) ＋ 1))
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (arr), i)
        文本 ＝ 文本_替换 (文本, 1, , , arr <i>, “替换”)
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (arr), i)
        文本 ＝ 文本_替换 (文本, 1, , , “替换”, arr1 <i>)
    .计次循环尾 ()
.如果真结束
内容 ＝ json1.取文本 (文本)
.判断开始 (寻找文本 (内容, “{”, , 假) ＞ -1)
    返回 (json1.取JSON值 (文本, 假, , , , ))
.默认
    返回 (内容)
.判断结束

.子程序 取通用属性, 文本型, 公开
.参数 文本, 文本型
.参数 duix, 逻辑型, 可空
.局部变量 arr, 文本型, , "0"
.局部变量 arr1, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 arr0, 文本型, , "0"
.局部变量 内容, 文本型

文本 ＝ “//” ＋ 文本
.判断开始 (寻找文本 (文本, “['”, , 假) ＞ -1)
    .如果真 (寻找文本 (文本, “['”, , 假) ＞ -1)
        文本_取中间_批量 (文本, “['”, “']”, arr0, , , , , , , )
        文本 ＝ 文本_替换 (文本, 取数组成员数 (arr0), , , “['”, “.”, “']”, “”)
    .如果真结束
    .如果真 (寻找文本 (文本, “//.”, , 假) ＞ -1)
        文本 ＝ 文本_替换 (文本, 1, , , “//.”, “//”)
    .如果真结束

.默认

.判断结束
.如果真 (寻找文本 (文本, “[”, , 假) ＞ -1)
    文本_取中间_批量 (文本, “[”, “]”, arr, , , , , , , )
    .计次循环首 (取数组成员数 (arr), i)
        加入成员 (arr1, 到文本 (到整数 (arr <i>) ＋ 1))
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (arr), i)
        文本 ＝ 文本_替换 (文本, 1, , , arr <i>, “替换”)
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (arr), i)
        文本 ＝ 文本_替换 (文本, 1, , , “替换”, arr1 <i>)
    .计次循环尾 ()
.如果真结束
内容 ＝ json1.取文本 (文本)
.判断开始 (寻找文本 (内容, “{”, , 假) ＞ -1)
    返回 (json1.取JSON值 (文本, 假, , , , ))
.默认
    返回 (内容)
.判断结束

.子程序 清除, 逻辑型, 公开

json2 ＝ “”
返回 (json1.清空 ())

.子程序 文本_取中间_批量, 整数型, 公开
.参数 源文本, 文本型, , 比如：欲取全文本为 12345
.参数 前面标识文本, 文本型, , 3的前面为“2”
.参数 后面标识文本, 文本型, , 3的后面为“4”
.参数 存放取出文本的数组, 文本型, 可空 数组, 存放取出文本的数组
.参数 是否不区分大小写, 逻辑型, 可空, 是否区分大小写
.参数 文本长度大于此数的不要, 整数型, 可空, 文本长度大于此数的不要;如取出的文本大于50的不要;留空为不限制(下面参数中的加入的后缀不算在其中，标志文本为真那么标志算在其中)
.参数 为取出的文本加上前缀, 文本型, 可空, 在取出的文本前面加上一段字符或汉字！可空！
.参数 为取出的文本加上后缀, 文本型, 可空, 在取出的文本后面加上一段字符或汉字！可空！
.参数 连前面标识文本一起取出, 逻辑型, 可空, 是否连<前面标识文本>一起取出? 默认为假，不取出！
.参数 连后面标识文本一起取出, 逻辑型, 可空, 是否连<后面标识文本>一起取出? 默认为假，不取出！
.参数 起始位置, 整数型, 可空
.局部变量 数组数量, 整数型
.局部变量 已经找到的, 整数型
.局部变量 StartPos, 整数型
.局部变量 EndPos, 整数型
.局部变量 Search, 文本型
.局部变量 中间长度, 整数型

清除数组 (存放取出文本的数组)
StartPos ＝ 起始位置
.循环判断首 ()
    StartPos ＝ 寻找文本 (源文本, 前面标识文本, StartPos, 是否不区分大小写)
    .如果 (StartPos ≠ -1)
        StartPos ＝ StartPos ＋ 取文本长度 (前面标识文本)
        EndPos ＝ 寻找文本 (源文本, 后面标识文本, StartPos, 是否不区分大小写)
        .如果 (EndPos ≠ -1)
            中间长度 ＝ EndPos － StartPos
            Search ＝ 取文本中间 (源文本, StartPos, 中间长度)
            Search ＝ 为取出的文本加上前缀 ＋ Search ＋ 为取出的文本加上后缀

            .如果真 (连前面标识文本一起取出 ＝ 真)
                Search ＝ 前面标识文本 ＋ Search
            .如果真结束
            .如果真 (连后面标识文本一起取出 ＝ 真)
                Search ＝ Search ＋ 后面标识文本
            .如果真结束

            .如果 (文本长度大于此数的不要 ＝ 0)
                加入成员 (存放取出文本的数组, Search)
            .否则
                .如果真 (取文本长度 (Search) ＜ 文本长度大于此数的不要)
                    加入成员 (存放取出文本的数组, Search)
                .如果真结束

            .如果结束
            处理事件 ()
        .否则
            跳出循环 ()
        .如果结束
        处理事件 ()
    .否则
        跳出循环 ()
    .如果结束
    处理事件 ()
.循环判断尾 (StartPos ≠ -1)

返回 (取数组成员数 (存放取出文本的数组))

.子程序 文本_替换, 文本型, 公开
.参数 原文本, 文本型
.参数 替换进行的次数, 整数型, 可空
.参数 替换的起始位置, 整数型, 可空
.参数 是否区分大小写, 逻辑型, 可空
.参数 欲被替换的子文本1, 文本型
.参数 用作替换的子文本1, 文本型
.参数 欲被替换的子文本2, 文本型, 可空
.参数 用作替换的子文本2, 文本型, 可空
.参数 欲被替换的子文本3, 文本型, 可空
.参数 用作替换的子文本3, 文本型, 可空
.参数 欲被替换的子文本4, 文本型, 可空
.参数 用作替换的子文本4, 文本型, 可空
.参数 欲被替换的子文本5, 文本型, 可空
.参数 用作替换的子文本5, 文本型, 可空
.局部变量 局_文本, 文本型

.如果真 (替换的起始位置 ＝ 0)
    替换的起始位置 ＝ 1
.如果真结束
.如果 (是否为空 (替换进行的次数))
    局_文本 ＝ 子文本替换 (原文本, 欲被替换的子文本1, 用作替换的子文本1, 替换的起始位置, , 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本2, 用作替换的子文本2, 替换的起始位置, , 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本3, 用作替换的子文本3, 替换的起始位置, , 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本4, 用作替换的子文本4, 替换的起始位置, , 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本5, 用作替换的子文本5, 替换的起始位置, , 是否区分大小写)
.否则
    局_文本 ＝ 子文本替换 (原文本, 欲被替换的子文本1, 用作替换的子文本1, 替换的起始位置, 替换进行的次数, 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本2, 用作替换的子文本2, 替换的起始位置, 替换进行的次数, 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本3, 用作替换的子文本3, 替换的起始位置, 替换进行的次数, 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本4, 用作替换的子文本4, 替换的起始位置, 替换进行的次数, 是否区分大小写)
    局_文本 ＝ 子文本替换 (局_文本, 欲被替换的子文本5, 用作替换的子文本5, 替换的起始位置, 替换进行的次数, 是否区分大小写)
.如果结束
返回 (局_文本)

.子程序 置属性, 逻辑型, 公开
.参数 属性名, 文本型
.参数 值, 文本型
.参数 a, 逻辑型, 可空

返回 (json1.置文本 (属性名, 值))

.子程序 成员数, 整数型, 公开
.参数 文本, 文本型, 可空
.局部变量 arr, 文本型, , "0"
.局部变量 arr1, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 arr0, 文本型, , "0"

文本 ＝ “//” ＋ 文本
.判断开始 (寻找文本 (文本, “['”, , 假) ＞ -1)
    .如果真 (寻找文本 (文本, “['”, , 假) ＞ -1)
        文本_取中间_批量 (文本, “['”, “']”, arr0, , , , , , , )
        文本 ＝ 文本_替换 (文本, 取数组成员数 (arr0), , , “['”, “.”, “']”, “”)

    .如果真结束
    .如果真 (寻找文本 (文本, “//.”, , 假) ＞ -1)
        文本 ＝ 文本_替换 (文本, 1, , , “//.”, “//”, , , , , , , , )
    .如果真结束

.默认

.判断结束
.如果真 (寻找文本 (文本, “[”, , 假) ＞ -1)
    文本_取中间_批量 (文本, “[”, “]”, arr, , , , , , , )
    .计次循环首 (取数组成员数 (arr), i)
        加入成员 (arr1, 到文本 (到整数 (arr <i>) ＋ 1))
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (arr), i)
        文本 ＝ 文本_替换 (文本, 1, , , arr <i>, “替换”)
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (arr), i)
        文本 ＝ 文本_替换 (文本, 1, , , “替换”, arr1 <i>)
    .计次循环尾 ()
.如果真结束
返回 (json1.取数量 (文本))

.子程序 到json, 文本型, 公开
.参数 是否修饰, 逻辑型, 可空

返回 (json1.到JSON (假, , , , ))

.子程序 加成员, 文本型, 公开
.参数 json, 文本型

.如果真 (json2 ≠ “”)
    json2 ＝ json2 ＋ “,” ＋ json
.如果真结束
.如果真 (json2 ＝ “”)
    json2 ＝ json
.如果真结束
返回 (json2)

.子程序 到文本1, 文本型, 公开

返回 (json2)

AD：【此广告位招租】如：联系我们