论坛现在已经支持发表火山表格源码
本帖最后由 创世魂 于 2025-12-9 08:39 编辑1、点击火山图标
2、粘贴源码后点击插入(源码必须保证有火山头信息，否则无法渲染。)
效果如下（手机版和app看不到）：
<火山程序 类型 = "通常" 版本 = 1 />
类 启动类 <公开 基础类 = 窗口 @安卓.附加清单 = 常用窗口附加清单.全面屏2 @安卓.附加清单 = 常用附加清单.开启硬件加速 @安卓.附加清单 = 常用窗口附加清单.不改变软键盘状态>
{
变量 按钮1 <类型 = 按钮 内容 = "打开">
变量 编辑框1 <类型 = 编辑框>
方法 按钮_被单击 <接收事件 类型 = 整数 注释 = "用户在组件上单击事件" 注释 = "注意:"
注释 = "1. \"按钮\"类别及\"图片按钮\"组件会自动初始设置\"支持单击\"属性为真,不需要单独设置;"
注释 = "2. 除开上述类别组件外,必须将组件的\"支持单击\"属性设置为真才会发送本事件." 返回值注释 = "返回值备注1" 返回值注释 = "返回值备注2">
参数 来源对象 <类型 = 按钮 注释 = "提供事件产生的具体来源对象">
参数 标记值 <类型 = 整数 注释 = "用户调用\"挂接事件\"命令时所提供的\"标记值\"参数值,非此方式挂接事件则本参数值固定为0.">
{
如果 (来源对象 == 按钮1)
{
变量 局部变量1 <类型 = 文本型>
如果 (局部变量1 == "")
{
变量 局部变量2 <类型 = 文本型>
}
常量 测试内容 <类型 = 文本型 值 = "{\"name\":\"\\u5468\\u6c38\\u56fd\",\"pwd\":\"123456\"}">
编辑框1.内容 = 编码_Unicode解码 (测试内容)
// JSON对象类.创建自文本数据 (测试内容).取文本值 ("name")
}
返回 (0)
}
变量 扫描结果组件1 <类型 = 扫描结果组件>
方法 通知_获得返回数据 <公开 @虚拟方法 = 可覆盖>
参数 请求码 <类型 = 整数>
参数 所返回结果码 <类型 = 整数>
参数 所返回结果信息 <类型 = 启动信息类>
{
父对象.通知_获得返回数据 (请求码, 所返回结果码, 所返回结果信息)
}
}
:噜阿噜66666666666666666666666666，来了 <火山程序 类型 = "通常" 版本 = 1 />
包 火山.程序
类 启动类 <公开 基础类 = 程序类>
{
方法 启动方法 <公开 类型 = 整数>
{
调试输出(666)
返回 (1)
}
}
;P;P;P
牛，非常的好！
<火山程序 类型 = "通常" 版本 = 1 />
类 类_json <公开 注释 = "JSON操作类，使用C++嵌入代码实现，移植自易语言json类" 折叠>
{
变量 dataName <类型 = 文本型>
变量 JsonStr <类型 = 文本型>
方法 类_初始化 <折叠>
{
dataName = "data"
JsonStr = "{}"
}
方法 初始化 <折叠>
{
JsonStr = "{}"
dataName = "data"
}
方法 解析 <公开 类型 = 逻辑型 注释 = "解析JSON文本，成功返回真" 折叠>
参数 JSON文本 <类型 = 文本型 注释 = "必须是标准的JSON格式">
参数 为对象 <类型 = 逻辑型 @默认值 = 假>
{
变量 结果 <类型 = 逻辑型>
@ CWString jsonText = @<JSON文本>;
@ const WCHAR* p = jsonText.GetText();
@ INT_P len = jsonText.GetLength();
@ // 跳过前导空白
@ INT_P i = 0;
@ while (i < len && (p == L' ' || p == L'\t' || p == L'\r' || p == L'\n')) i++;
@ if (i < len && (p == L'{' || p == L'[')) {
@ @<结果> = TRUE;
@ } else {
@ @<结果> = FALSE;
@ }
如果 (结果 == 真)
{
JsonStr = JSON文本
dataName = "data"
}
返回 (结果)
}
方法 清除 <公开 类型 = 逻辑型 注释 = "清除JSON数据" 折叠>
{
JsonStr = "{}"
dataName = "data"
返回 (真)
}
方法 取数据文本 <公开 类型 = 文本型 注释 = "获取完整JSON数据文本" 折叠>
{
返回 (JsonStr)
}
方法 置属性 <公开 类型 = 逻辑型 注释 = "设置JSON属性值，支持简单方括号格式如 [\'name\']" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称，支持方括号格式如 [\'name\']">
参数 值 <类型 = 文本型 注释 = "属性值">
参数 为对象 <类型 = 逻辑型 注释 = "属性解析为json对象或数组" @默认值 = 假>
{
变量 结果 <类型 = 逻辑型>
变量 纯属性名 <类型 = 文本型>
纯属性名 = 内部解析属性名 (属性名)
@ CWString json = @<JsonStr>;
@ CWString cleanPropName = @<纯属性名>;
@ CWString val = @<值>;
@ BOOL isObj = @<为对象>;
@ const WCHAR* pJson = json.GetText();
@ if (pJson == NULL || pJson != L'{') { @<结果> = FALSE; return @<结果>; }
@ CWString searchKey = L"\"";
@ searchKey.AddText(cleanPropName);
@ searchKey.AddText(L"\":");
@ CWString newVal;
@ if (!isObj) {
@ CWString escaped = val;
@ escaped.Replace(L"\\", L"\\\\");
@ escaped.Replace(L"\"", L"\\\"");
@ escaped.Replace(L"\r", L"\\r");
@ escaped.Replace(L"\n", L"\\n");
@ newVal = L"\"";
@ newVal.AddText(escaped);
@ newVal.AddText(L"\"");
@ } else {
@ newVal = val;
@ }
@ INT_P pos = json.SearchText(searchKey.GetText(), 0, FALSE, FALSE);
@ CWString newJson;
@ if (pos != -1) {
@ INT_P valueStart = pos + searchKey.GetLength();
@ while (pJson == L' ') valueStart++;
@ INT_P valueEnd = valueStart;
@ INT_P depth = 0;
@ BOOL inStr = FALSE;
@ while (pJson != L'\0') {
@ if (pJson == L'"' && (valueEnd == 0 || pJson != L'\\')) inStr = !inStr;
@ if (!inStr) {
@ if (pJson == L'{' || pJson == L'[') depth++;
@ else if (pJson == L'}' || pJson == L']') {
@ if (depth == 0) break;
@ depth--;
@ }
@ else if (pJson == L',' && depth == 0) break;
@ }
@ valueEnd++;
@ }
@ newJson.SetText(pJson, valueStart);
@ newJson.AddText(newVal);
@ newJson.AddText(pJson + valueEnd);
@ } else {
@ INT_P jsonLen = json.GetLength();
@ if (jsonLen > 1) {
@ newJson.SetText(pJson, jsonLen - 1);
@ if (jsonLen > 2) newJson.AddText(L",");
@ newJson.AddText(searchKey);
@ newJson.AddText(newVal);
@ newJson.AddText(L"}");
@ }
@ }
@ @<JsonStr> = newJson;
@ @<结果> = TRUE;
返回 (结果)
}
方法 置属性对象 <公开 类型 = 逻辑型 注释 = "属性解析为json对象或数组" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称">
参数 值 <类型 = 文本型 注释 = "JSON对象或数组文本">
{
返回 (置属性 (属性名, 值, 真))
}
方法 属性是否存在 <公开 类型 = 逻辑型 注释 = "检查属性是否存在，支持方括号格式如 [\'name\']" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称，支持方括号格式如 [\'name\']">
{
变量 结果 <类型 = 逻辑型>
变量 纯属性名 <类型 = 文本型>
纯属性名 = 内部解析属性名 (属性名)
@ CWString json = @<JsonStr>;
@ CWString cleanPropName = @<纯属性名>;
@ CWString searchKey = L"\"";
@ searchKey.AddText(cleanPropName);
@ searchKey.AddText(L"\":");
@ @<结果> = (json.SearchText(searchKey.GetText(), 0, FALSE, FALSE) != -1) ? TRUE : FALSE;
返回 (结果)
}
方法 取类型 <公开 类型 = 整数 注释 = "获取属性类型：-1未知,0未定义,1布尔,2数值,4对象,5数组,6字符串，支持方括号格式" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称，支持方括号格式如 [\'name\']">
{
变量 结果 <类型 = 整数>
变量 纯属性名 <类型 = 文本型>
纯属性名 = 内部解析属性名 (属性名)
@ CWString json = @<JsonStr>;
@ CWString cleanPropName = @<纯属性名>;
@ const WCHAR* pJson = json.GetText();
@ @<结果> = -1;
@ if (pJson == NULL) { return @<结果>; }
@ CWString searchKey = L"\"";
@ searchKey.AddText(cleanPropName);
@ searchKey.AddText(L"\":");
@ INT_P pos = json.SearchText(searchKey.GetText(), 0, FALSE, FALSE);
@ if (pos == -1) { @<结果> = 0; return @<结果>; }
@ pos += searchKey.GetLength();
@ while (pJson == L' ' || pJson == L'\t' || pJson == L'\r' || pJson == L'\n') pos++;
@ WCHAR ch = pJson;
@ if (ch == L'"') @<结果> = 6;
@ else if (ch == L'[') @<结果> = 5;
@ else if (ch == L'{') @<结果> = 4;
@ else if (ch == L't' || ch == L'f') @<结果> = 1;
@ else if ((ch >= L'0' && ch <= L'9') || ch == L'-') @<结果> = 2;
@ else if (ch == L'n') @<结果> = 0; // null
返回 (结果)
}
方法 取通用属性 <公开 类型 = 文本型 注释 = "获取属性值，支持 [\'name\'] 或 name.sub 或 [\'name\'].sub 等格式" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称，支持方括号和点号格式">
参数 为对象 <类型 = 逻辑型 注释 = "属性解析为json对象或数组" @默认值 = 假>
{
变量 结果 <类型 = 文本型>
变量 第一部分 <类型 = 文本型>
变量 剩余部分 <类型 = 文本型>
变量 临时json <类型 = 类_json>
变量 中间结果 <类型 = 文本型>
变量 索引值 <类型 = 整数>
@ CWString propName = @<属性名>;
@ const WCHAR* p = propName.GetText();
@ INT_P len = propName.GetLength();
@ CWString firstPart, restPart;
@ INT_P i = 0;
@ // 跳过开头的点号
@ while (i < len && p == L'.') i++;
@ if (i >= len) { @<结果> = L""; return @<结果>; }
@ if (p == L'[') {
@ if (i + 1 < len && p == L'\'') {
@ // ['name'] 格式
@ INT_P start = i + 2;
@ INT_P k = start;
@ while (k < len && p != L'\'') k++;
@ firstPart.SetText(p + start, k - start);
@ k += 2; // 跳过 ']
@ // 跳过后面的点号
@ if (k < len && p == L'.') k++;
@ if (k < len) restPart.SetText(p + k, len - k);
@ @<索引值> = -1;
@ } else {
@ // 格式
@ INT_P start = i + 1;
@ INT_P k = start;
@ while (k < len && p >= L'0' && p <= L'9') k++;
@ CWString idxStr;
@ idxStr.SetText(p + start, k - start);
@ @<索引值> = _wtoi(idxStr.GetText());
@ k++; // 跳过 ]
@ // 跳过后面的点号
@ if (k < len && p == L'.') k++;
@ if (k < len) restPart.SetText(p + k, len - k);
@ firstPart = L"";
@ }
@ } else {
@ // 直接属性名格式 (如 name || name.sub)
@ INT_P start = i;
@ while (i < len && p != L'[' && p != L'.') i++;
@ firstPart.SetText(p + start, i - start);
@ // 跳过点号
@ if (i < len && p == L'.') i++;
@ if (i < len) restPart.SetText(p + i, len - i);
@ @<索引值> = -1;
@ }
@ @<第一部分> = firstPart;
@ @<剩余部分> = restPart;
如果 (索引值 >= 0)
{
中间结果 = 取成员文本 (索引值, "", 真)
}
否则
{
中间结果 = 内部取单一属性 (第一部分, 真)
}
如果 (剩余部分 != "")
{
临时json.解析 (中间结果, 真)
结果 = 临时json.取通用属性 (剩余部分, 为对象)
}
否则
{
结果 = 中间结果
}
返回 (结果)
}
方法 内部取单一属性 <类型 = 文本型 注释 = "内部方法：获取单一属性值" 折叠>
参数 属性名 <类型 = 文本型>
参数 为对象 <类型 = 逻辑型 @默认值 = 假>
{
变量 结果 <类型 = 文本型>
@ CWString json = @<JsonStr>;
@ CWString propName = @<属性名>;
@ CWString result;
@ const WCHAR* pJson = json.GetText();
@ INT_P jsonLen = json.GetLength();
@ if (pJson == NULL || jsonLen == 0) { @<结果> = result; return @<结果>; }
@ CWString searchKey = L"\"";
@ searchKey.AddText(propName);
@ searchKey.AddText(L"\":");
@ INT_P pos = json.SearchText(searchKey.GetText(), 0, FALSE, FALSE);
@ if (pos == -1) { @<结果> = result; return @<结果>; }
@ pos += searchKey.GetLength();
@ while (pos < jsonLen && (pJson == L' ' || pJson == L'\t' || pJson == L'\r' || pJson == L'\n')) pos++;
@ WCHAR ch = pJson;
@ if (ch == L'"') {
@ pos++;
@ INT_P start = pos;
@ while (pos < jsonLen && pJson != L'"') {
@ if (pJson == L'\\' && pos + 1 < jsonLen) pos++;
@ pos++;
@ }
@ result.SetText(pJson + start, pos - start);
@ result.Replace(L"\\\"", L"\"");
@ result.Replace(L"\\n", L"\n");
@ result.Replace(L"\\r", L"\r");
@ result.Replace(L"\\\\", L"\\");
@ } else if (ch == L'{' || ch == L'[') {
@ INT_P start = pos;
@ INT_P depth = 1;
@ BOOL inStr = FALSE;
@ pos++;
@ while (pos < jsonLen && depth > 0) {
@ if (pJson == L'"' && pJson != L'\\') inStr = !inStr;
@ if (!inStr) {
@ if (pJson == L'{' || pJson == L'[') depth++;
@ else if (pJson == L'}' || pJson == L']') depth--;
@ }
@ pos++;
@ }
@ result.SetText(pJson + start, pos - start);
@ } else {
@ // 数值、布尔值、null等
@ INT_P start = pos;
@ INT_P end = pos;
@ while (end < jsonLen && pJson != L',' && pJson != L'}' && pJson != L']') end++;
@ // 去除尾部空白
@ while (end > start && (pJson == L' ' || pJson == L'\t' || pJson == L'\r' || pJson == L'\n')) end--;
@ result.SetText(pJson + start, end - start);
@ }
@ @<结果> = result;
返回 (结果)
}
方法 内部解析属性名 <类型 = 文本型 注释 = "内部方法：解析方括号格式属性名" 折叠>
参数 属性名 <类型 = 文本型>
{
变量 结果 <类型 = 文本型>
@ CWString propName = @<属性名>;
@ CWString cleanPropName;
@ const WCHAR* p = propName.GetText();
@ INT_P len = propName.GetLength();
@ if (len >= 4 && p == L'[' && p == L'\'') {
@ INT_P start = 2;
@ INT_P end = len - 2;
@ while (end > start && (p == L'\'' || p == L']')) end--;
@ if (end >= start) cleanPropName.SetText(p + start, end - start + 1);
@ } else {
@ cleanPropName = propName;
@ }
@ @<结果> = cleanPropName;
返回 (结果)
}
方法 取所有属性名 <公开 类型 = 整数 注释 = "属性名指向JSON类型必须为对象" 折叠>
参数 属性名数组 <类型 = 文本数组类 注释 = "结果保存在此参数中" "">
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
{
变量 结果 <类型 = 整数>
变量 json文本 <类型 = 文本型>
变量 临时属性名 <类型 = 文本型>
变量 计数 <类型 = 整数>
计数 = 0
如果 (属性名 == "")
{
json文本 = JsonStr
}
否则
{
json文本 = 取通用属性 (属性名, 真)
}
@ CWString json = @<json文本>;
@ const WCHAR* p = json.GetText();
@ if (p == NULL || p != L'{') { @<结果> = 0; return @<结果>; }
@ INT_P len = json.GetLength();
@ INT_P depth = 0;
@ BOOL inString = FALSE;
@ BOOL expectKey = TRUE; // 在对象中期待属性名
@ for (INT_P i = 1; i < len; i++) {
@ WCHAR ch = p;
@ // 跳过空白
@ if (ch == L' ' || ch == L'\t' || ch == L'\r' || ch == L'\n') continue;
@ // 处理字符串
@ if (ch == L'"') {
@ INT_P start = i + 1;
@ INT_P k = start;
@ while (k < len && !(p == L'"' && p != L'\\')) k++;
@ // 只有在depth==0且期待属性名时才是属性名
@ if (depth == 0 && expectKey) {
@ CWString keyName;
@ keyName.SetText(p + start, k - start);
@ keyName.Replace(L"\\\"", L"\"");
@ keyName.Replace(L"\\\\", L"\\");
@ @<临时属性名> = keyName;
属性名数组.加入成员 (临时属性名)
@ @<计数>++;
@ expectKey = FALSE;
@ }
@ i = k; // 跳过字符串内容
@ continue;
@ }
@ if (ch == L':') { expectKey = FALSE; continue; }
@ if (ch == L',') { if (depth == 0) expectKey = TRUE; continue; }
@ if (ch == L'{' || ch == L'[') { depth++; continue; }
@ if (ch == L'}' || ch == L']') { depth--; continue; }
@ }
结果 = 计数
返回 (结果)
}
方法 成员数 <公开 类型 = 整数 注释 = "属性名指向JSON类型必须为数组" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
{
变量 结果 <类型 = 整数>
变量 数组文本 <类型 = 文本型>
如果 (属性名 == "")
{
数组文本 = JsonStr
}
否则
{
数组文本 = 取通用属性 (属性名, 真)
}
@ CWString arr = @<数组文本>;
@ const WCHAR* p = arr.GetText();
@ INT_P count = 0;
@ if (p == NULL || p != L'[') { @<结果> = 0; return @<结果>; }
@ INT_P depth = 0;
@ INT_P len = arr.GetLength();
@ BOOL inString = FALSE;
@ for (INT_P i = 0; i < len; i++) {
@ if (p == L'"' && (i == 0 || p != L'\\')) inString = !inString;
@ if (inString) continue;
@ if (p == L'[' || p == L'{') depth++;
@ else if (p == L']' || p == L'}') depth--;
@ else if (p == L',' && depth == 1) count++;
@ }
@ // 如果数组非空,成员数 = 逗号数 + 1
@ if (len > 2) count++;
@ @<结果> = count;
返回 (结果)
}
方法 取属性 <公开 类型 = 类_json 注释 = "获取属性对象" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称">
{
变量 结果 <类型 = 类_json>
变量 obj文本 <类型 = 文本型>
obj文本 = 取通用属性 (属性名, 真)
结果.解析 (obj文本, 真)
返回 (结果)
}
方法 加成员 <公开 类型 = 逻辑型 注释 = "向数组添加成员" 折叠>
参数 值 <类型 = 文本型 注释 = "成员值">
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
参数 为对象 <类型 = 逻辑型 注释 = "属性解析为json对象或数组" @默认值 = 假>
参数 开头添加 <类型 = 逻辑型 注释 = "是否在开头添加" @默认值 = 假>
{
变量 结果 <类型 = 逻辑型>
@ CWString json = @<JsonStr>;
@ CWString val = @<值>;
@ BOOL isObj = @<为对象>;
@ BOOL addFirst = @<开头添加>;
@ const WCHAR* pJson = json.GetText();
@ if (pJson == NULL || pJson != L'[') { @<结果> = FALSE; return @<结果>; }
@ CWString newVal;
@ if (!isObj) {
@ // 处理字符串转义
@ CWString escaped = val;
@ escaped.Replace(L"\\", L"\\\\");
@ escaped.Replace(L"\"", L"\\\"");
@ escaped.Replace(L"\r", L"\\r");
@ escaped.Replace(L"\n", L"\\n");
@ newVal = L"\"";
@ newVal.AddText(escaped);
@ newVal.AddText(L"\"");
@ } else {
@ newVal = val;
@ }
@ CWString newJson;
@ INT_P len = json.GetLength();
@ if (addFirst) {
@ newJson = L"[";
@ newJson.AddText(newVal);
@ if (len > 2) newJson.AddText(L",");
@ newJson.AddText(pJson + 1);
@ } else {
@ newJson.SetText(pJson, len - 1);
@ if (len > 2) newJson.AddText(L",");
@ newJson.AddText(newVal);
@ newJson.AddText(L"]");
@ }
@ @<JsonStr> = newJson;
@ @<结果> = TRUE;
返回 (结果)
}
方法 取成员 <公开 类型 = 类_json 注释 = "获取数组成员对象" 折叠>
参数 成员索引 <类型 = 整数 注释 = "成员索引从0开始">
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
{
变量 结果 <类型 = 类_json>
变量 memberText <类型 = 文本型>
memberText = 取成员文本 (成员索引, 属性名, 真)
结果.解析 (memberText, 真)
返回 (结果)
}
方法 取成员文本 <公开 类型 = 文本型 注释 = "获取数组成员文本值" 折叠>
参数 成员索引 <类型 = 整数 注释 = "成员索引从0开始">
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
参数 为对象 <类型 = 逻辑型 注释 = "属性解析为json对象或数组" @默认值 = 假>
{
变量 结果 <类型 = 文本型>
变量 数组文本 <类型 = 文本型>
如果 (属性名 == "")
{
数组文本 = JsonStr
}
否则
{
数组文本 = 取通用属性 (属性名, 真)
}
@ CWString arr = @<数组文本>;
@ INT_P idx = @<成员索引>;
@ CWString result;
@ const WCHAR* p = arr.GetText();
@ if (p == NULL || p != L'[') { @<结果> = result; return @<结果>; }
@ INT_P arrLen = arr.GetLength();
@ INT_P currentIdx = 0;
@ INT_P i = 1;
@ // 跳过开头空白
@ while (i < arrLen && (p == L' ' || p == L'\t' || p == L'\r' || p == L'\n')) i++;
@ // 遍历找到目标索引
@ while (i < arrLen && currentIdx <= idx) {
@ INT_P elemStart = i;
@ INT_P depth = 0;
@ BOOL inStr = FALSE;
@ // 找到当前元素的结束位置
@ while (i < arrLen) {
@ if (p == L'"' && (i == 0 || p != L'\\')) inStr = !inStr;
@ if (!inStr) {
@ if (p == L'{' || p == L'[') depth++;
@ else if (p == L'}' || p == L']') {
@ if (depth == 0) break;
@ depth--;
@ }
@ else if (p == L',' && depth == 0) break;
@ }
@ i++;
@ }
@ INT_P elemEnd = i;
@ if (currentIdx == idx) {
@ // 去除首尾空白
@ while (elemStart < elemEnd && (p == L' ' || p == L'\t' || p == L'\r' || p == L'\n')) elemStart++;
@ while (elemEnd > elemStart && (p == L' ' || p == L'\t' || p == L'\r' || p == L'\n')) elemEnd--;
@ // 检查是否是字符串
@ if (elemEnd > elemStart && p == L'"' && p == L'"') {
@ elemStart++;
@ elemEnd--;
@ result.SetText(p + elemStart, elemEnd - elemStart);
@ result.Replace(L"\\\"", L"\"");
@ result.Replace(L"\\n", L"\n");
@ result.Replace(L"\\r", L"\r");
@ result.Replace(L"\\\\", L"\\");
@ } else {
@ result.SetText(p + elemStart, elemEnd - elemStart);
@ }
@ break;
@ }
@ // 跳过逗号和空白
@ if (p == L',') i++;
@ while (i < arrLen && (p == L' ' || p == L'\t' || p == L'\r' || p == L'\n')) i++;
@ currentIdx++;
@ }
@ @<结果> = result;
返回 (结果)
}
方法 置成员 <公开 类型 = 逻辑型 注释 = "设置数组成员值" 折叠>
参数 成员索引 <类型 = 整数 注释 = "成员索引从0开始">
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
参数 值 <类型 = 文本型 注释 = "成员值">
参数 为对象 <类型 = 逻辑型 注释 = "属性解析为json对象或数组" @默认值 = 假>
{
变量 结果 <类型 = 逻辑型>
@ CWString json = @<JsonStr>;
@ INT_P idx = @<成员索引>;
@ CWString val = @<值>;
@ BOOL isObj = @<为对象>;
@ const WCHAR* p = json.GetText();
@ if (p == NULL || p != L'[') { @<结果> = FALSE; return @<结果>; }
@ CWString newVal;
@ if (!isObj) {
@ // 处理字符串转义
@ CWString escaped = val;
@ escaped.Replace(L"\\", L"\\\\");
@ escaped.Replace(L"\"", L"\\\"");
@ escaped.Replace(L"\r", L"\\r");
@ escaped.Replace(L"\n", L"\\n");
@ newVal = L"\"";
@ newVal.AddText(escaped);
@ newVal.AddText(L"\"");
@ } else {
@ newVal = val;
@ }
@ INT_P depth = 0;
@ INT_P len = json.GetLength();
@ INT_P currentIdx = 0;
@ INT_P start = 1; // 初始化为数组开始位置之后
@ INT_P end = -1;
@ BOOL inString = FALSE;
@ // 跳过开头空白找到第一个元素
@ while (start < len && (p == L' ' || p == L'\t' || p == L'\r' || p == L'\n')) start++;
@ INT_P elemStart = start;
@ for (INT_P i = start; i < len; i++) {
@ if (p == L'"' && (i == 0 || p != L'\\')) inString = !inString;
@ if (inString) continue;
@ if (p == L'[' || p == L'{') depth++;
@ else if (p == L']' || p == L'}') {
@ if (depth == 0 && currentIdx == idx) { end = i; break; }
@ depth--;
@ }
@ else if (p == L',' && depth == 0) {
@ if (currentIdx == idx) { end = i; break; }
@ currentIdx++;
@ elemStart = i + 1;
@ while (elemStart < len && (p == L' ' || p == L'\t' || p == L'\r' || p == L'\n')) elemStart++;
@ }
@ }
@ if (end == -1) { @<结果> = FALSE; return @<结果>; }
@ CWString newJson;
@ newJson.SetText(p, elemStart);
@ newJson.AddText(newVal);
@ newJson.AddText(p + end);
@ @<JsonStr> = newJson;
@ @<结果> = TRUE;
返回 (结果)
}
方法 删成员 <公开 类型 = 逻辑型 注释 = "删除数组成员" 折叠>
参数 成员索引 <类型 = 整数 注释 = "成员索引从0开始">
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
{
变量 结果 <类型 = 逻辑型>
@ CWString json = @<JsonStr>;
@ INT_P idx = @<成员索引>;
@ const WCHAR* p = json.GetText();
@ if (p == NULL || p != L'[') { @<结果> = FALSE; return @<结果>; }
@ INT_P depth = 0;
@ INT_P len = json.GetLength();
@ INT_P currentIdx = 0;
@ INT_P start = 1;
@ INT_P end = -1;
@ BOOL inString = FALSE;
@ for (INT_P i = 1; i < len; i++) {
@ if (p == L'"' && p != L'\\') inString = !inString;
@ if (inString) continue;
@ if (p == L'[' || p == L'{') depth++;
@ else if (p == L']' || p == L'}') {
@ if (depth == 0 && currentIdx == idx) { end = i; break; }
@ depth--;
@ }
@ else if (p == L',' && depth == 0) {
@ if (currentIdx == idx) { end = i + 1; break; }
@ currentIdx++;
@ start = i + 1;
@ }
@ }
@ if (end == -1) { @<结果> = FALSE; return @<结果>; }
@ CWString newJson;
@ newJson.SetText(p, start);
@ newJson.AddText(p + end);
@ @<JsonStr> = newJson;
@ @<结果> = TRUE;
返回 (结果)
}
方法 删属性 <公开 类型 = 逻辑型 注释 = "删除属性" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称">
{
变量 结果 <类型 = 逻辑型>
@ CWString json = @<JsonStr>;
@ CWString propName = @<属性名>;
@ CWString searchKey = L"\"";
@ searchKey.AddText(propName);
@ searchKey.AddText(L"\"");
@ searchKey.AddText(L":");
@ const WCHAR* pJson = json.GetText();
@ INT_P pos = json.SearchText(searchKey.GetText(), 0, FALSE, FALSE);
@ if (pos == -1) { @<结果> = FALSE; return @<结果>; }
@ // 找到属性开始位置(包括可能的前导逗号)
@ INT_P propStart = pos;
@ while (propStart > 0 && (pJson == L' ' || pJson == L',')) propStart--;
@ if (pJson == L',') propStart++;
@ // 找到值结束位置
@ INT_P valueEnd = pos + searchKey.GetLength();
@ while (pJson == L' ') valueEnd++;
@ INT_P depth = 0;
@ BOOL inStr = FALSE;
@ while (pJson != L'\0') {
@ if (pJson == L'"' && (valueEnd == 0 || pJson != L'\\')) inStr = !inStr;
@ if (!inStr) {
@ if (pJson == L'{' || pJson == L'[') depth++;
@ else if (pJson == L'}' || pJson == L']') {
@ if (depth == 0) break;
@ depth--;
@ }
@ else if (pJson == L',' && depth == 0) { valueEnd++; break; }
@ }
@ valueEnd++;
@ }
@ CWString newJson;
@ newJson.SetText(pJson, propStart);
@ newJson.AddText(pJson + valueEnd);
@ @<JsonStr> = newJson;
@ @<结果> = TRUE;
返回 (结果)
}
方法 置属性数值 <公开 类型 = 逻辑型 注释 = "设置数值属性，支持方括号格式如 [\'name\']" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称，支持方括号格式如 [\'name\']">
参数 值 <类型 = 小数 注释 = "数值">
{
变量 结果 <类型 = 逻辑型>
变量 数值文本 <类型 = 文本型>
变量 纯属性名 <类型 = 文本型>
数值文本 = 到文本 (值)
纯属性名 = 内部解析属性名 (属性名)
@ CWString json = @<JsonStr>;
@ CWString cleanPropName = @<纯属性名>;
@ CWString val = @<数值文本>;
@ const WCHAR* pJson = json.GetText();
@ if (pJson == NULL || pJson != L'{') { @<结果> = FALSE; return @<结果>; }
@ CWString searchKey = L"\"";
@ searchKey.AddText(cleanPropName);
@ searchKey.AddText(L"\":");
@ CWString newVal = val;
@ INT_P pos = json.SearchText(searchKey.GetText(), 0, FALSE, FALSE);
@ CWString newJson;
@ if (pos != -1) {
@ INT_P valueStart = pos + searchKey.GetLength();
@ while (pJson == L' ') valueStart++;
@ INT_P valueEnd = valueStart;
@ INT_P depth = 0;
@ BOOL inStr = FALSE;
@ while (pJson != L'\0') {
@ if (pJson == L'"' && (valueEnd == 0 || pJson != L'\\')) inStr = !inStr;
@ if (!inStr) {
@ if (pJson == L'{' || pJson == L'[') depth++;
@ else if (pJson == L'}' || pJson == L']') {
@ if (depth == 0) break;
@ depth--;
@ }
@ else if (pJson == L',' && depth == 0) break;
@ }
@ valueEnd++;
@ }
@ newJson.SetText(pJson, valueStart);
@ newJson.AddText(newVal);
@ newJson.AddText(pJson + valueEnd);
@ } else {
@ INT_P jsonLen = json.GetLength();
@ if (jsonLen > 1) {
@ newJson.SetText(pJson, jsonLen - 1);
@ if (jsonLen > 2) newJson.AddText(L",");
@ newJson.AddText(searchKey);
@ newJson.AddText(newVal);
@ newJson.AddText(L"}");
@ }
@ }
@ @<JsonStr> = newJson;
@ @<结果> = TRUE;
返回 (结果)
}
方法 取属性数值 <公开 类型 = 小数 注释 = "获取数值属性" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称">
{
变量 文本值 <类型 = 文本型>
变量 结果 <类型 = 小数>
文本值 = 取通用属性 (属性名, 假)
@ CWString val = @<文本值>;
@ @<结果> = _wtof(val.GetText());
返回 (结果)
}
方法 取属性对象 <公开 类型 = 文本型 注释 = "获取对象属性的JSON文本" 折叠>
参数 属性名 <类型 = 文本型 注释 = "属性名称">
{
返回 (取通用属性 (属性名, 真))
}
方法 取回对象 <公开 类型 = 文本型 注释 = "获取内部JSON字符串" 折叠>
{
返回 (JsonStr)
}
方法 取所有属性值 <公开 类型 = 整数 注释 = "取指定路径下所有属性的值" 折叠>
参数 属性值数组 <类型 = 文本数组类 注释 = "结果保存在此参数中">
参数 属性名 <类型 = 文本型 注释 = "属性名称" "">
参数 向下递归 <类型 = 逻辑型 注释 = "是否向下递归" @默认值 = 假>
{
变量 结果 <类型 = 整数>
@ @<结果> = 0;
返回 (结果)
}
}
aixunsoft 发表于 2025-12-7 22:23
包 火山.程序
可以可以，非常好使。 代码点击里面左侧的 +-可以展开/收缩代码 jcos 发表于 2025-12-7 22:25
牛，非常的好！
你这代码好长，不过好在是渲染无压力。 很厉害加油 可以的 手机浏览器登录看到的还是文本代码，没有渲染