qq812913329 发表于 2025-3-6 10:01
老吴做不出，做出了你们也承受不住api的成本。用cursor吧，
DeepSeek成本非常低的啊？
牛逼
强烈支持楼主出一个使用cursor写火山视窗代码的方法，希望楼主能整理一个详细一些的，非常感谢。或者看看能不能分享一下楼主用的提示词，也非常感谢
楼主大义分享
qwyan 发表于 2025-3-7 05:20
强烈支持楼主出一个使用cursor写火山视窗代码的方法，希望楼主能整理一个详细一些的，非常感谢。或者看看能 ...
---
description: 火山json规则
globs:
alwaysApply: false
---
如果当前规则被启用，请开开头回复，火山规则已经被启用
# 火山程序语言编写规则
严格遵守火山语法
## **重要格式规则**
### **类成员排序规则（非常重要）**
**火山语言对类成员的声明顺序有严格要求，必须按照以下顺序排列：**
1. **首先声明所有变量**
2. **然后声明所有事件处理方法**（带有`接收事件`标记的方法）
3. **最后声明所有普通方法**
**不遵循这个顺序会导致编译错误，如"无效的成员位置"。**
**错误示例：**
```
类 错误示例类 {
变量 变量1 <类型 = 整数>
// 错误：普通方法放在了事件处理方法之前
方法 普通方法 <类型 = 整数>
{
返回 (0)
}
方法 事件处理方法 <接收事件>
参数 参数1 <类型 = 整数>
{
返回 (0)
}
}
```
**正确示例：**
```
类 正确示例类 {
变量 变量1 <类型 = 整数>
方法 事件处理方法 <接收事件>
参数 参数1 <类型 = 整数>
{
返回 (0)
}
方法 普通方法 <类型 = 整数>
{
返回 (0)
}
}
```
## 参考文档路径
- 库文件：`docs2\huoshan\j_json.wsv`
- 示例文件：`docs2\huoshan\蓝牙操作模块.wsv`
# 火山JSON代码生成执行规则文档
## 一、火山语言基础语法
### 1. 程序结构
- **文件头**：每个火山程序必须以 `<火山程序 类型 = "通常" 版本 = 1 />` 开始
- **包声明**：使用 `包 "包名"` 进行包声明
- **代码组织**：代码主要通过类、方法和变量组织
### 2. 变量声明规则
- **语法格式**：`变量 变量名 <类型 = 类型名 [属性列表]>`
- **常见属性**：
- `公开` - 表示变量可公开访问
- `类型` - 指定变量类型
- `值` - 指定初始值
- `注释` - 添加变量注释
- `折叠` - 在IDE中可折叠显示
- **基本类型**：
- `整数` - 整数类型
- `小数` - 浮点数类型
- `文本型` - 字符串类型
- `逻辑型` - 布尔类型
- `对象类` - 通用对象类型
### 3. 方法定义规则
- **语法格式**：`方法 方法名 <[访问修饰符] [类型 = 返回类型] [属性列表]>`
- **参数定义**：`参数 参数名 <类型 = 类型名 [属性列表]>`
- **参数默认值**：使用 `@默认值 = 值` 指定
- **返回语句**：使用 `返回 (值)` 返回值
### 4. 控制结构
- **条件语句**：
```
如果 (条件) {
// 代码块
} 否则 (条件) {
// 代码块
} 否则 {
// 代码块
}
```
- **循环语句**：
```
循环 (初始值, 结束值, 变量) {
// 代码块
}
```
- **条件循环**：
```
判断循环 (条件) {
// 代码块
}
```
- **异常处理**：
```
开始俘获异常 () {
// 可能抛出异常的代码
} 俘获所有异常 () {
// 异常处理代码
}
```
## 二、JSON对象操作详解
### 1. JSON对象类
#### 创建JSON对象
```
// 创建空JSON对象
变量 json对象 <类型 = JSON对象类>
json对象 = 新建对象 (JSON对象类)
// 从文本创建JSON对象
变量 json对象 <类型 = JSON对象类>
json对象 = JSON对象类.创建自文本数据 (JSON文本)
```
#### 添加键值对
```
// 添加不同类型的值
json对象.置入文本值 ("键名", "文本值")
json对象.置入整数值 ("键名", 123)
json对象.置入小数值 ("键名", 123.45)
json对象.置入逻辑值 ("键名", 真)
json对象.置入长整数值 ("键名", 长整数值)
json对象.置入对象值 ("键名", 子对象)
```
#### 读取值
```
// 读取不同类型的值
变量 文本值 <类型 = 文本型>
文本值 = json对象.取文本值 ("键名", "默认值")
变量 整数值 <类型 = 整数>
整数值 = json对象.取整数值 ("键名", 0)
变量 子对象 <类型 = JSON对象类>
子对象 = json对象.取对象值 ("键名")
```
#### 转换为文本
```
// 转换为格式化的JSON文本
变量 json文本 <类型 = 文本型>
json文本 = json对象.到可读文本 (2)// 2是缩进空格数
```
### 2. JSON数组类
#### 创建JSON数组
```
// 创建空JSON数组
变量 json数组 <类型 = JSON数组类>
json数组 = 新建对象 (JSON数组类)
// 从文本创建JSON数组
变量 json数组 <类型 = JSON数组类>
json数组 = JSON数组类.创建自文本数据 (JSON文本)
```
#### 添加元素
```
// 添加不同类型的值
json数组.置入文本值 ("文本值")
json数组.置入整数值 (123)
json数组.置入对象值 (子对象)
// 在指定位置添加值
json数组.置入文本值到指定位置 (0, "文本值")
```
#### 读取元素
```
// 读取不同类型的值
变量 文本值 <类型 = 文本型>
文本值 = json数组.取文本值 (0, "默认值")
变量 子对象 <类型 = JSON对象类>
子对象 = json数组.取对象值 (0)
```
## 三、复杂JSON结构构建
### 1. 嵌套对象构建
```
// 主对象
变量 json主对象 <类型 = JSON对象类>
json主对象 = 新建对象 (JSON对象类)
// 子对象
变量 json子对象 <类型 = JSON对象类>
json子对象 = 新建对象 (JSON对象类)
json子对象.置入文本值 ("名称", "子对象名称")
json子对象.置入整数值 ("值", 100)
// 将子对象添加到主对象
json主对象.置入对象值 ("子对象", json子对象)
```
### 2. 对象数组构建
```
// 主对象
变量 json主对象 <类型 = JSON对象类>
json主对象 = 新建对象 (JSON对象类)
// 数组
变量 json数组 <类型 = JSON数组类>
json数组 = 新建对象 (JSON数组类)
// 添加元素到数组
变量 i <类型 = 整数>
循环 (0, 5, i) {
变量 元素 <类型 = JSON对象类>
元素 = 新建对象 (JSON对象类)
元素.置入文本值 ("名称", "元素" + 到文本 (i))
元素.置入整数值 ("索引", i)
json数组.置入对象值 (元素)
}
// 将数组添加到主对象
json主对象.置入对象值 ("列表", json数组)
```
## 四、网络通信中的JSON
### 1. 构建请求JSON
```
// 创建请求对象
变量 请求对象 <类型 = JSON对象类>
请求对象 = 新建对象 (JSON对象类)
// 添加基本信息
请求对象.置入文本值 ("type", "请求类型")
请求对象.置入文本值 ("device_id", 设备ID)
请求对象.置入长整数值 ("timestamp", 日期时间类_.取现行时间戳2_(,))
// 添加参数对象
变量 参数对象 <类型 = JSON对象类>
参数对象 = 新建对象 (JSON对象类)
参数对象.置入文本值 ("key", "value")
参数对象.置入整数值 ("number", 123)
// 组装请求
请求对象.置入对象值 ("params", 参数对象)
```
### 2. 解析响应JSON
```
// 获取响应文本
变量 响应文本 <类型 = 文本型>
响应文本 = 对象到文本 (网络响应1.取响应内容 ())
// 解析响应
变量 响应对象 <类型 = JSON对象类>
响应对象 = JSON对象类.创建自文本数据 (响应文本)
// 安全提取数据
开始俘获异常 () {
变量 状态码 <类型 = 整数>
状态码 = 响应对象.取整数值 ("status", 0)
变量 数据对象 <类型 = JSON对象类>
数据对象 = 响应对象.取对象值 ("data")
如果 (数据对象 != 空对象) {
// 处理数据
}
} 俘获所有异常 () {
// 处理异常
}
```
## 五、常见错误及避免方法
### 1. 空对象检查
```
// 正确的空对象检查
如果 (json对象 != 空对象) {
// 操作json对象
}
// 检查获取的子对象
变量 子对象 <类型 = JSON对象类>
子对象 = json对象.取对象值 ("键名")
如果 (子对象 != 空对象) {
// 操作子对象
}
```
### 2. 异常处理
```
// 使用异常处理保护JSON操作
开始俘获异常 () {
// JSON操作代码
变量 值 <类型 = 文本型>
值 = json对象.取文本值2 ("键名")
} 俘获所有异常 () {
// 异常处理代码
}
```
### 3. 类型转换检查
```
// 在类型转换前检查
变量 可能的整数 <类型 = 文本型>
可能的整数 = json对象.取文本值 ("数字字段", "0")
变量 整数值 <类型 = 整数>
如果 (是否为数字 (可能的整数)) {
整数值 = 到整数 (可能的整数)
} 否则 {
整数值 = 0
}
```
### 4. 变量命名冲突
火山语言中，类的成员变量和方法参数不能使用相同的名称，否则会导致编译错误。
**错误示例：**
```
类 示例类 {
变量 姓名 <类型 = 文本型>
方法 设置信息 <公开>
参数 姓名 <类型 = 文本型>// 错误：与类成员变量同名
{
// 方法体
}
}
```
**正确示例：**
```
类 示例类 {
变量 姓名 <类型 = 文本型>
方法 设置信息 <公开>
参数 姓名参数 <类型 = 文本型>// 正确：使用不同的名称
{
姓名 = 姓名参数// 将参数值赋给成员变量
}
}
```
当需要在类中使用成员变量和同名参数时，推荐的命名规范：
- 为参数名添加"参数"后缀
- 为成员变量添加"成员"或"_"前缀
- 使用更具描述性的命名区分参数和成员变量
### 5. JSON数组操作错误
#### 5.1 正确添加元素到JSON数组
在火山语言中，向JSON数组添加元素有多种方法，必须使用正确的方法以避免结构错误。
**正确示例**：
```
// 创建数组
变量 数组 <类型 = JSON数组类>
数组 = 新建对象 (JSON数组类)
// 添加简单值到数组
数组.置入文本值 ("文本元素")// 添加文本
数组.置入整数值 (123) // 添加整数
数组.置入逻辑值 (真) // 添加布尔值
// 添加对象到数组
变量 对象元素 <类型 = JSON对象类>
对象元素 = 新建对象 (JSON对象类)
对象元素.置入文本值 ("name", "张三")
数组.置入对象值 (对象元素) // 正确：使用置入对象值方法
```
**错误示例**：
```
// 错误：不能直接使用置入文本值等方法添加带键名的元素
数组.置入文本值 ("name", "张三")// 错误：数组元素没有键名
// 错误：忘记创建新对象
变量 对象元素 <类型 = JSON对象类>
数组.置入对象值 (对象元素)// 错误：未初始化的对象
```
#### 5.2 处理多层嵌套的数组和对象
处理复杂的嵌套结构时，需要特别注意层次关系和对象引用。
**正确示例**：
```
// 创建包含对象数组的对象
变量 主对象 <类型 = JSON对象类>
主对象 = 新建对象 (JSON对象类)
// 创建数组
变量 用户列表 <类型 = JSON数组类>
用户列表 = 新建对象 (JSON数组类)
// 创建数组元素1
变量 用户1 <类型 = JSON对象类>
用户1 = 新建对象 (JSON对象类)
用户1.置入文本值 ("name", "张三")
// 创建嵌套对象
变量 联系方式1 <类型 = JSON对象类>
联系方式1 = 新建对象 (JSON对象类)
联系方式1.置入文本值 ("email", "zhangsan@example.com")
// 将嵌套对象添加到元素中
用户1.置入对象值 ("contact", 联系方式1)
// 将元素添加到数组
用户列表.置入对象值 (用户1)
// 创建数组元素2（重复类似步骤）
变量 用户2 <类型 = JSON对象类>
用户2 = 新建对象 (JSON对象类)
用户2.置入文本值 ("name", "李四")
变量 联系方式2 <类型 = JSON对象类>
联系方式2 = 新建对象 (JSON对象类)
联系方式2.置入文本值 ("email", "lisi@example.com")
用户2.置入对象值 ("contact", 联系方式2)
用户列表.置入对象值 (用户2)
// 将数组添加到主对象
主对象.置入对象值 ("users", 用户列表)
```
#### 5.3 JSON结构完整性检查
在生成复杂JSON结构时，应当注意以下几点以确保结构完整性：
1. **确保开始和结束括号匹配**：
- 对象使用 `{}`
- 数组使用 `[]`
2. **检查父子关系**：
- 确保每个子对象都被正确添加到其父对象中
- 使用正确的方法添加元素（如 `置入对象值`、`置入文本值` 等）
3. **完整性测试**：
- 生成JSON后，检查生成的结果是否符合预期结构
- 可以使用调试输出检查生成的JSON文本
**完整性检查示例**：
```
// 生成完成后，检查结果
变量 结果 <类型 = 文本型>
结果 = 主对象.到可读文本 (2)
调试输出 (结果)// 检查生成的JSON是否符合预期
```
## 六、实战模式
### 1. WebSocket通信模式
```
// 构建WebSocket消息
变量 消息对象 <类型 = JSON对象类>
消息对象 = 新建对象 (JSON对象类)
消息对象.置入文本值 ("类型", "app")
变量 数据对象 <类型 = JSON对象类>
数据对象 = 新建对象 (JSON对象类)
数据对象.置入文本值 ("type", "操作类型")
数据对象.置入文本值 ("device_id", 设备ID)
// 添加数据对象到消息
消息对象.置入对象值 ("数据", 数据对象)
// 发送消息
websocket客户端.发送文本 (消息对象.到可读文本 (0))
```
### 2. 配置读写模式
```
// 读取配置
变量 配置文本 <类型 = 文本型>
配置文本 = 文件读入文本 ("配置路径")
变量 配置对象 <类型 = JSON对象类>
配置对象 = JSON对象类.创建自文本数据 (配置文本)
// 修改配置
配置对象.置入文本值 ("新设置", "新值")
// 保存配置
文件写出文本 ("配置路径", 配置对象.到可读文本 (2))
```
## 七、代码示例
### 完整的JSON操作示例
```
// 创建一个复杂的JSON对象
变量 配置 <类型 = JSON对象类>
配置 = 新建对象 (JSON对象类)
// 添加基本属性
配置.置入文本值 ("名称", "配置名称")
配置.置入整数值 ("版本", 1)
配置.置入逻辑值 ("启用", 真)
// 添加子对象
变量 用户信息 <类型 = JSON对象类>
用户信息 = 新建对象 (JSON对象类)
用户信息.置入文本值 ("用户名", "张三")
用户信息.置入整数值 ("年龄", 30)
配置.置入对象值 ("用户", 用户信息)
// 添加数组
变量 模块列表 <类型 = JSON数组类>
模块列表 = 新建对象 (JSON数组类)
模块列表.置入文本值 ("模块1")
模块列表.置入文本值 ("模块2")
模块列表.置入文本值 ("模块3")
配置.置入对象值 ("模块", 模块列表)
// 转换为文本并输出
变量 配置文本 <类型 = 文本型>
配置文本 = 配置.到可读文本 (2)
调试输出 (配置文本)
```
遵循以上规则和示例，可以确保AI能够准确无误地生成火山JSON代码，避免常见错误和陷阱。
qwyan 发表于 2025-3-7 05:20
强烈支持楼主出一个使用cursor写火山视窗代码的方法，希望楼主能整理一个详细一些的，非常感谢。或者看看能 ...
原理在我历史题，火山安卓，视窗，go，h5都可以写。我过一两个月才有空完善。效果反正你们是看到了吧 json库只是我调教了几分钟就有这效果
qq812913329 发表于 2025-3-7 18:13
原理在我历史题，火山安卓，视窗，go，h5都可以写。我过一两个月才有空完善。效果反正你们是看到了吧 jso ...
就是把火山的类库全部复制成文本保存到文本文档，然后让它先学习文本文档的方法，然后再提问吗
qwyan 发表于 2025-3-7 21:22
就是把火山的类库全部复制成文本保存到文本文档，然后让它先学习文本文档的方法，然后再提问吗 ...
en
qq812913329 发表于 2025-3-7 21:43
en
我昨天看了你的帖子后，把火山的基本类复制成文本后，发给它先学习，然后让它封装一个简单判断指定文件是否存在，存在则创建一个txt文本文档，不存在则调试输出不存在，但是它好像会用到嵌入式，没有就使用基本类中的方法来实现封装那个功能，请问可以分享一下你给它的提示词吗
qwyan 发表于 2025-3-8 03:12
我昨天看了你的帖子后，把火山的基本类复制成文本后，发给它先学习，然后让它封装一个简单判断指定文件是 ...
通过网盘分享的文件：h1.mdc
链接: https://pan.baidu.com/s/15A9DPySrqSzyO9P68lm-Yg?pwd=nw3r 提取码: nw3r
--来自百度网盘超级会员v7的分享