炫语言AI辅助之基础语法手册

yyz513

根据官方文档个人收集整理，错误之处大佬请指点勿喷


文件下载位于底部  炫语言AI知识库：https://ima.qq.com/wiki/?shareId ... 238fdadbb3e81f4670e

# 炫语言手册之基础语法篇 v1.0

## 目录
1. [主要特色功能](#主要特色功能)
2. [语法关键字](#语法关键字)
3. [数据类型](#数据类型)
4. [变量声明](#变量声明)
5. [运算符](#运算符)
6. [控制结构](#控制结构)
7. [函数定义](#函数定义)
8. [结构体定义](#结构体定义)
9. [类定义](#类定义)
10. [数组语法](#数组语法)
11. [字符串处理](#字符串处理)
12. [调试输出](#调试输出)
13. [命名规范](#命名规范)
14. [代码组织](#代码组织)
15. [最佳实践](#最佳实践)

---

## 主要特色功能

### 1. 缩进和作用域规则 ⭐重要
炫语言通过 **TAB键缩进** 进行代码块对齐，类似Python语言格式：

- **缩进规则**：
  - 使用TAB键进行缩进，不能使用空格
  - 0缩进的代码为全局作用域（全局函数或变量）
  - 通过缩进确定代码是全局还是局部，或子集块
  - 可通过对齐辅助线查看代码缩进

- **作用域确定**：
  - 炫语言通过缩进确定作用域，C/C++通过花括号对"{}"确定作用域
  - 作用域限定了代码的有效范围
  - 省略了大括号对"{}"，通过鼠标右键菜单可以进行相关操作

- **空行处理**：
  - 对于空行可使用`[pass]`关键字占位

```xc
// 全局作用域（0缩进）
整型 g_globalVar = 0

函数 整型 全局函数()
    返回 0

// 局部作用域（TAB缩进）
函数 整型 测试函数()
        整型 localVar = 10      // TAB缩进
        如果 localVar > 5
                调试输出("大于5")    // 双重TAB缩进
                返回 localVar
        否则
                调试输出("小于等于5")
                返回 0
        [pass]  // 空行占位

// 类定义（TAB缩进）
类 我的类
        整型 m_memberVar    // TAB缩进
        函数 构造()
                m_memberVar = 0  // 双重TAB缩进
```

### 2. 中文编程特色
- 支持中文函数名、变量名
- 提供丰富的中文关键字
- 每个英文函数都有对应的中文别名
- 代码可读性强，适合中文用户

### 3. 编码处理
- 默认使用Unicode编码（文本型）
- 支持ANSI编码（文本型A）
- 提供编码转换函数：`W2A()`, `A2W()`
- 支持UTF-8字符串：`U"UTF8字符串"`

---

## 语法关键字

### 程序入口关键字
```xc
函数 整型 入口函数()        // 控制台程序入口
函数 整型 入口函数_窗口()    // 窗口程序入口
函数 整型 入口函数_动态库()  // DLL程序入口
```

### 数据类型关键字
```xc
// 整数类型
字节型       // 1字节，0-255
短整型       // 2字节，-32768-32767
整型         // 4字节，-2147483648-2147483647
长整型       // 8字节
正短整型     // 2字节，0-65535
正整型       // 4字节，0-4294967295
正长整型     // 8字节

// 浮点类型
小数型       // 4字节浮点数
双浮点型     // 8字节浮点数

// 字符类型
字符型       // Unicode字符（双字节）
字符型A      // ANSI字符（单字节）

// 字符串类型
文本型       // Unicode字符串（双字节）
文本型A      // ANSI字符串（单字节）

// 其他类型
逻辑型       // 布尔值（真/假）
字节集       // 二进制数据容器
空类型       // 无返回值类型
```

### 控制结构关键字
```xc
如果         // 条件判断
否则         // 否则分支
分支判断     // 多分支判断
分支         // 分支选项
其他         // 默认分支
跳出         // 跳出循环或分支
循环         // 条件循环
计次循环     // 计数循环
变量循环     // for循环
列表循环     // 遍历循环
到循环尾     // 跳到循环末尾
循环判断首   // 循环开始
循环判断尾   // 循环结束
```

### 函数和类关键字
```xc
函数         // 函数定义
返回         // 函数返回值
类           // 类定义
继承         // 类继承
结构体       // 结构体定义
公开         // 公开成员
私有         // 私有成员
静态         // 静态成员
常量         // 常量定义
```

### 容器关键字
```xc
动态数组     // 动态数组容器
字典         // 键值对容器
迭代器       // 迭代器类型
```

---

## 数据类型

### 基本数据类型
| 类型名 | 大小 | 范围 | 说明 | 示例 |
|--------|------|------|------|------|
| `字节型` | 1字节 | 0-255 | 无符号8位整数 | `字节型 b = 255` |
| `短整型` | 2字节 | -32768-32767 | 有符号16位整数 | `短整型 s = 1000` |
| `整型` | 4字节 | -2147483648-2147483647 | 有符号32位整数 | `整型 i = 100000` |
| `长整型` | 8字节 | -9223372036854775808-9223372036854775807 | 有符号64位整数 | `长整型 l = 1000000000` |
| `正短整型` | 2字节 | 0-65535 | 无符号16位整数 | `正短整型 us = 50000` |
| `正整型` | 4字节 | 0-4294967295 | 无符号32位整数 | `正整型 ui = 3000000000` |
| `正长整型` | 8字节 | 0-18446744073709551615 | 无符号64位整数 | `正长整型 ul = 9000000000000000000` |
| `小数型` | 4字节 | ±3.4E-38-±3.4E+38 | 32位浮点数 | `小数型 f = 3.14f` |
| `双浮点型` | 8字节 | ±1.7E-308-±1.7E+308 | 64位浮点数 | `双浮点型 d = 3.14159` |
| `逻辑型` | 4字节 | 真/假 | 布尔值 | `逻辑型 flag = 真` |

### 字符串类型
| 类型名 | 编码 | 说明 | 示例 |
|--------|------|------|------|
| `文本型` | Unicode | 双字节字符串，默认类型 | `文本型 str = "Hello World"` |
| `文本型A` | ANSI | 单字节字符串 | `文本型A strA = A"Hello World"` |
| `字符型` | Unicode | 双字节字符 | `字符型 ch = 'A'` |
| `字符型A` | ANSI | 单字节字符 | `字符型A chA = A'A'` |

### 复合数据类型
| 类型名 | 说明 | 示例 |
|--------|------|------|
| `字节集` | 二进制数据容器 | `字节集 data` |
| `动态数组<类型>` | 动态数组 | `动态数组<整型> numbers` |
| `字典<键类型,值类型>` | 键值对容器 | `字典<文本型,整型> map` |

---

## 变量声明

### 变量声明规则
```xc
// 1. 全局变量（文件顶部）
整型 g_globalVar = 0
文本型 g_appName = "应用名称"

// 2. 局部变量（函数内部）
函数 整型 测试函数()
    整型 localVar = 10      // 局部变量
    文本型 name = "测试"     // 局部变量
    返回 localVar

// 3. 成员变量（类内部）
类 我的类
    整型 m_memberVar    // 成员变量
    文本型 m_name       // 成员变量
```

### 变量初始化
```xc
// 基本类型初始化
整型 number = 100
双浮点型 price = 99.99
逻辑型 flag = 真
文本型 name = "张三"

// 数组初始化
整型 numbers[5] = {1, 2, 3, 4, 5}
动态数组<整型> list = {1, 2, 3, 4, 5}

// 结构体初始化
点坐标 point = {100, 200}
```

### 常量定义
```xc
// 常量定义
常量 整型 MAX_SIZE = 100
常量 文本型 APP_NAME = "应用名称"
常量 浮点型 PI = 3.14159f

// 宏定义
#宏定义 宽度 10
#宏定义 高度 5
#宏定义 换行 "\n"
```

---

## 运算符

### 算术运算符
```xc
+     // 加法
-     // 减法
*     // 乘法
/     // 除法
%     // 取余
++    // 自增
--    // 自减
```

### 比较运算符
```xc
==    // 等于
!=    // 不等于
>     // 大于
<     // 小于
>=    // 大于等于
<=    // 小于等于
```

### 逻辑运算符
```xc
&&    // 逻辑与 (且)
||    // 逻辑或 (或)
!     // 逻辑非 (取反)
```

### 位运算符
```xc
&     // 按位与
|     // 按位或
^     // 按位异或
~     // 按位取反
<<    // 左移
>>    // 右移
```

### 赋值运算符
```xc
=     // 赋值
+=    // 加法赋值
-=    // 减法赋值
*=    // 乘法赋值
/=    // 除法赋值
%=    // 取余赋值
&=    // 按位与赋值
|=    // 按位或赋值
^=    // 按位异或赋值
<<=   // 左移赋值
>>=   // 右移赋值
```

### 字符串运算符
```xc
+     // 字符串连接
文本型 result = "Hello" + " " + "World"  // "Hello World"
```

---

## 控制结构

### 条件判断
```xc
// 简单if语句
如果 条件
    执行代码

// if-else语句
如果 条件
    执行代码1
否则
    执行代码2

// 多重条件判断
如果 条件1
    执行代码1
否则 条件2
    执行代码2
否则 条件3
    执行代码3
否则 条件4
    执行代码4
否则
    执行默认代码
```

### 分支判断
```xc
// 基本分支判断
分支判断(变量)
    分支(值1)
        执行代码1
        跳出
    分支(值2)
        执行代码2
        跳出
    其他
        执行默认代码
        跳出

// 实际示例
整型 score = 85
分支判断(score)
    分支(90)
        调试输出("优秀")
        跳出
    分支(80)
        调试输出("良好")
        跳出
    分支(60)
        调试输出("及格")
        跳出
    其他
        调试输出("不及格")
        跳出
```

### 循环语句
```xc
// 基本循环
循环 条件
    循环体

// 计数循环
计次循环 整型 i = 0; 次数
    循环体

// 变量循环（for循环）
变量循环(整型 i = 0; i < 10; i++)
    循环体

// 列表循环（遍历数组）
列表循环 整型 i = 0; 数组
    循环体

// 范围循环
循环 i = 0 到 数组.取大小() - 1
    循环体

// 循环控制
跳出        // 跳出循环
到循环尾    // 跳到循环末尾
```

### 实际示例
```xc
// 条件判断示例
整型 score = 85
如果 score >= 90
    调试输出("优秀")
否则 score >= 80
    调试输出("良好")
否则 score >= 60
    调试输出("及格")
否则
    调试输出("不及格")

// 循环示例
整型 i
循环 i = 1 到 10
    调试输出("第", i, "次循环")

动态数组<整型> numbers = {1, 2, 3, 4, 5}
列表循环 整型 i = 0; numbers
    调试输出("数字:", numbers)

// 九九乘法表示例
变量循环(整型 乘数 = 1; 乘数 <= 9; 乘数++)
    变量循环(整型 被乘数 = 1; 被乘数 <= 乘数; 被乘数++)
        控制台_格式输出("%d*%d=%d\t", 被乘数, 乘数, 乘数 * 被乘数)
    控制台_格式输出("\n")
```

---

## 函数定义

### 基本语法
```xc
函数 返回类型 函数名(参数列表)
    函数体
    返回 值
```

### 函数示例
```xc
// 无参数函数
函数 整型 获取随机数()
    返回 取随机数(1, 100)

// 有参数函数
函数 整型 加法(整型 a, 整型 b)
    返回 a + b

// 带默认参数的函数
函数 整型 取最小值_默认值(整型 参数A = 200, 整型 参数B = 100)
    如果 (参数A > 参数B)
        返回 参数B
    否则
        返回 参数A

// 引用参数函数
函数 逻辑型 读取文件(文本型 path, 字节集 &data)
    如果 文件是否存在(path)
        文件类 file
        如果 file.打开(path)
            data = file.读取到字节集()
            file.关闭()
            返回 真
    返回 假

// 重载函数
函数 整型 最大值(整型 a, 整型 b)
    返回 如果 a > b 则 a 否则 b

函数 双浮点型 最大值(双浮点型 a, 双浮点型 b)
    返回 如果 a > b 则 a 否则 b
```

### 函数类型定义
```xc
// 定义函数类型
#函数类型 整型(WINAPI * 函数类型1)(整型, 整型)

// 实现函数
函数 整型 WINAPI Add(整型 a, 整型 b = -1)
        调试输出("add()")
        返回 a + b

// 使用函数类型
函数 整型 入口函数_窗口()
        函数类型1 函数指针 = Add  // 定义变量接收指定类型函数地址
        整型 ret = 函数指针(1, 2)  // 通过地址调用函数
        调试输出(ret)
        返回 0
```

---

## 结构体定义

### 基本结构体
```xc
// 结构体定义
结构体 点坐标
    整型 x
    整型 y

结构体 文件信息
    文本型 文件名
    整型 文件大小
    整型 创建时间
    逻辑型 是否只读

// 带构造函数的结构体
结构体 我的炫语言程序
    文本型 作者名称
    文本型 类型
    整型  字数
    整型  ID
    // 定义构造函数并设置默认值
    函数 空类型 构造()
        作者名称 = "1"
        类型 = "2"
        字数 = 3
        ID = 6
```

### 结构体使用
```xc
// 使用结构体
点坐标 点1
点1.x = 100
点1.y = 200

文件信息 文件
文件.文件名 = "test.txt"
文件.文件大小 = 1024
文件.创建时间 = 1234567890
文件.是否只读 = 假

// 结构体初始化
我的炫语言程序 女朋友1
女朋友1.作者名称 = "易团雪"
女朋友1.类型 = "都市.言情"
女朋友1.字数 = 100000
女朋友1.ID = 0001

我的炫语言程序 女朋友2 = {"李四", "都市", 12, 123}

// 结构体数组
动态数组<我的炫语言程序> 女朋友输出
如果 (女朋友输出.取大小() == 0)
    变量循环(整型 i = 0; i < 20; i++)
        女朋友输出.添加({"易团雪" + 到文本(i), "标签二" + 到文本(i), i, 10})
```

### 结构体作为函数参数
```xc
// 结构体参数传递
函数 整型 函数_我的程序(我的炫语言程序 参数_程序)
    调试输出(参数_程序.作者名称, 参数_程序.类型, 参数_程序.字数, 参数_程序.ID)
    返回 0

// 调用函数
函数_我的程序(女朋友1)
```

---

## 类定义

### 基本类定义
```xc
// 基本类定义
类 自定义类名A
        整型 _成员变量1
        
        函数 构造()
                _成员变量1 = 10
        
        函数 析构()
                占位
        
        函数 整型 Add(整型 a, 整型 b)
                返回 a + b

// 类继承
类 子类名 继承 父类名
    成员变量
    成员函数
```

### 访问控制
```xc
// 公开和私有成员
类 我的房间
    整型  房间宽度 = 13  // 公开成员，外部可以访问
    整型  房间高度 = 15
    整型  房间长度 = 10
    文本型 物品 = "我的西服"

    // 通过成员函数的方式来读取私有成员
    函数 整型 拿钱出去消费()
        返回 我的钱包

    函数 空类型 赚钱回来(整型 赚钱)
        我的钱包 = 我的钱包 + 赚钱

    函数 整型 取体积()
        整型 体积 = 房间高度 * 房间宽度 * 房间长度
        返回 体积

    私有
    整型 我的钱包 = 1000000  // 私有成员，外部不可以访问
```

### 类使用示例
```xc
// 将类实例化具体变量
自定义类名A A1
调试输出(A1._成员变量1)
整型 返回值 = A1.Add(1, 2)

// 将结构体实例化具体变量
结构体A A2
A2.宽度 = 10
A2.高度 = 20
调试输出(A2.宽度, A2.高度)

// 房间类使用
我的房间 房间1
房间1.赚钱回来(100)
房间1.房间宽度 = 130
调试输出(房间1.拿钱出去消费(), 房间1.取体积())
```

---

## 数组语法

### 静态数组
```xc
// 一维数组
整型 numbers[10]
整型 scores[5] = {85, 90, 78, 92, 88}

// 二维数组
整型 matrix[3][3]
整型 grid[2][2] = {{1, 2}, {3, 4}}

// 访问数组元素
numbers[0] = 100
整型 value = scores[2]
matrix[1][1] = 5

// 数组遍历
变量循环(整型 i = 0; i < 5; i++)
    调试输出(scores)

// 二维数组遍历
变量循环(整型 i = 0; i < 2; i++)
    变量循环(整型 j = 0; j < 2; j++)
        调试输出("第", i, "行", "第", j, "列", grid[j])
```

### 动态数组
```xc
// 声明动态数组
动态数组<整型> numbers
动态数组<文本型> names
动态数组<字节型> data

// 添加元素
numbers.添加(1)
numbers.添加(2)
numbers.添加(3)

// 访问元素
整型 value = numbers[0]

// 获取大小
整型 size = numbers.取大小()

// 清空数组
numbers.清空()

// 删除元素
numbers.删除(1)        // 删除索引1的元素
numbers.删除(1, 2)     // 从索引1开始删除2个元素

// 插入元素
numbers.插入(1, 100)   // 在索引1位置插入100

// 重设大小
numbers.重设大小(10)   // 设置数组大小为10

// 遍历数组
列表循环 整型 i = 0; numbers
    调试输出(numbers)

计次循环 整型 i = 0; numbers.取大小()
    调试输出(numbers)
```

### 字典容器
```xc
// 声明字典
字典<文本型, 整型> map
字典<整型, 文本型> reverseMap

// 添加键值对
map["aaa"] = 1
map["bbb"] = 2
map["ccc"] = 3

// 访问值
整型 value = map["aaa"]

// 获取大小
整型 size = map.取大小()

// 查找元素
迭代器 iter = map.查找("aaa")
如果 iter == map.空值()
        调试输出("未找到")
否则
        调试输出("找到")

// 遍历字典
列表循环 迭代器 iter; map
        调试输出("key: ", iter.键, " value: ", iter.值)

// 函数参数传递
函数 空类型 函数参数传递(字典<文本型, 整型> map_a)
        整型 a = map_a["aaa"]
        整型 数量 = map_a.取大小()
        占位
```

---

## 字符串处理

### 字符串声明和初始化
```xc
// Unicode字符串
文本型 str1 = "Hello World"
文本型 str2 = "你好世界"

// ANSI字符串
文本型A str3 = A"Hello World"

// UTF-8字符串
文本型A str4 = U"我是UTF8字符串"

// 字符串连接
文本型 result = str1 + " " + str2
```

### 字符串操作
```xc
文本型 text = "Hello World"

// 获取长度
整型 len = text.取大小()

// 获取字符
字符型 ch = text[0]

// 子字符串
文本型 sub = text.取子文本(0, 5)  // "Hello"

// 查找
整型 pos = text.查找("World")

// 替换
text.替换("World", "炫语言")

// 分割
动态数组<文本型> parts = 文本分割(text, " ")

// 大小写转换
文本型 upper = text.到大写()
文本型 lower = text.到小写()

// 去除空格
文本型 trimmed = text.去除空格()

// 字符串截取
文本型 left = 文本取左边(text, 5)      // "Hello"
文本型 right = 文本取右边(text, 5)     // "World"
文本型 sub1 = 文本取中间(text, 0, 5)   // "Hello"
文本型 sub2 = 文本取中间2(text, 0, 5)  // "Hello"
文本型 sub3 = 文本取中间3(text, "Hello", "World") // " "

// 字符串查找
整型 pos1 = 文本取子文本位置(text, "World")      // 6
整型 pos2 = 文本取子文本位置2(text, "World", 0)  // 6
整型 pos3 = 文本取子文本位置右边(text, "o")      // 7
整型 pos4 = 文本取子文本位置右边2(text, "o", 5)  // 7

// 字符串替换
文本型 replaced = 文本替换(text, "World", "炫语言")  // "Hello 炫语言"
文本型A replacedA = 文本替换A(A"Hello World", A"World", A"炫语言")

// 字符串插入
文本型 inserted = 文本插入(text, 5, " Beautiful ")  // "Hello Beautiful World"
文本型A insertedA = 文本插入A(A"Hello World", 5, A" Beautiful ")
```

### 字符串转换
```xc
// 数值转字符串
文本型 numStr = 到文本(123)
文本型 floatStr = 到文本(3.14)

// 字符串转数值
整型 num = 到整数("123")
双浮点型 price = 到双浮点("99.99")

// 编码转换
文本型A ansiStr = W2A("Unicode字符串")  // Unicode转ANSI
文本型 unicodeStr = A2W(A"ANSI字符串")  // ANSI转Unicode

// 字符串连接
文本型 result = "ABC" + "123" + "456"
文本型A resultA = A"ABC" + A"123" + A"456"

// 路径字符串
文本型 路径1 = "D:\\abc\\data\\123.txt"  // 路径需要加转义符'\'
文本型 路径2 = R"(D:\abc\data\123.txt)"  // R"(原始字符串 不转义路径)"

// UTF-8字符串
文本型A utf8字符串 = U"我是UTF8字符串"
```

### 字符型操作
```xc
// 字符型A 通常只占据 1 个字节,字符型 占据 2 个字节或 4 个字节的空间
// 一个字母或一个阿拉伯数字占 1 个字节,一个中文占 2 个字节

字符型A x[6] = {'X', 'l', 'a', 'n', 'g', '\0'}  // 单字节字符数组
字符型 x2[12] = {'炫', '语', '言', '真', '好','玩'}  // 双字节字符数组
字符型 x3[] = "炫语言牛逼3"  // 双字节字符串

// 字符型A=单字节 主要存储单个字符，而 字符型=双字节 主要存储中文，韩文，日文等
```

---

## 调试输出

### 基本调试输出
```xc
// 基本调试输出 - 自动分割参数
调试输出("Hello", 123, 3.14)  // 输出: Hello, 123, 3.14

// 不分割参数的调试输出
调试输出2("Hello", 123, 3.14)  // 输出: Hello1233.14

// 格式化调试输出
调试输出格式化("字符串: %s, 整数: %d, 浮点数: %.2f", "测试", 100, 3.14159)
调试输出格式化A(A"字符串: %s, 整数: %d, 浮点数: %.2f", A"测试", 100, 3.14159)
```

### 数据调试输出
```xc
// 十六进制调试输出
字节型 data[4] = {0x12, 0x34, 0x56, 0x78}
调试输出十六进制(data, 4)  // 输出: 12 34 56 78
调试输出十六进制(data, 4, 假, 假)  // 输出: 12345678

// 十进制调试输出
调试输出十进制(data, 4)  // 输出: 18 52 86 120

// 二进制调试输出
调试输出二进制(data, 4)  // 输出: 10010 110100 1010110 1111000
```

### 控制台输出
```xc
// 控制台输出
控制台_置中文编码()
控制台_格式输出("Hello %s, 数字: %d\n", "World", 123)
控制台_格式输出A(A"Hello %s, 数字: %d\n", A"World", 123)

// 控制台输入
字符型A input[256] = {0}
控制台_标准输入A(input, 256)  // 读取ANSI字符串
调试输出("输入内容:", input)

// 控制台暂停
控制台_暂停()  // 等待用户按键
```

---

## 命名规范

### 变量命名规范
```xc
// 全局变量：g_前缀
整型 g_globalVar
文本型 g_appName

// 成员变量：m_前缀
整型 m_memberVar
文本型 m_fileName

// 局部变量：无前缀
整型 localVar
文本型 fileName

// 常量：全大写
常量 整型 MAX_SIZE = 100
常量 文本型 APP_NAME = "应用名称"
```

### 函数命名规范
```xc
// 函数命名：动词+名词
函数 整型 获取文件大小(文本型 path)
函数 逻辑型 保存配置()
函数 空类型 清空数据()

// 类命名：名词
类 文件管理器
类 数据库连接

// 变量命名：描述性名称
整型 文件大小
文本型 用户名
逻辑型 是否成功
```

### 文件命名规范
```xc
// 源文件：.xc
main.xc          // 主源文件
common.xh        // 预编译头文件
exe.rc           // 资源文件
main.xml         // UI布局文件
style.css        // 样式文件
resource.res     // 资源文件
```

---

## 代码组织

### 1. 代码组织
```xc
// 1. 头文件包含
#包含 "common.xh"

// 2. 常量定义
常量 整型 MAX_SIZE = 100
常量 文本型 APP_NAME = "我的应用"

// 3. 全局变量
整型 g_globalVar = 0

// 4. 类定义
类 我的类
    成员变量
    成员函数

// 5. 函数定义
函数 整型 我的函数()
    返回 0

// 6. 程序入口
函数 整型 入口函数()
    返回 0
```

### 2. 文件结构
```xc
// common.xh - 预编译头文件
//预编译头文件, 提高修改代码时的编译速度
//将不常修改的内容放在此文件中
//包含外部头文件,库文件(lib)
//申明外部函数, 变量, 宏, 枚举, 数据类型等

// main.xc - 主源文件
#包含 "common.xh"
// 主要代码逻辑

// 项目文件结构
项目名.xcproj    // 项目文件
main.xc          // 主源文件
common.xh        // 预编译头文件
exe.rc           // 资源文件
exe.ico          // 图标文件
main.xml         // UI布局文件（窗口程序）
style.css        // 样式文件（窗口程序）
resource.res     // 资源文件（窗口程序）
```

### 3. 注释规范
```xc
// 单行注释
// 这是单行注释

// 多行注释
/*
这是多行注释
可以跨越多行
*/

// 函数注释
// 函数说明：计算两个数的和
// 参数：a - 第一个数，b - 第二个数
// 返回值：两数之和
函数 整型 加法(整型 a, 整型 b)
    返回 a + b

// 类注释
// 类说明：房间类，用于管理房间信息
// 作者：张三
// 日期：2024-01-01
类 我的房间
    成员变量
    成员函数
```

---

## 最佳实践

### 1. 缩进和代码格式 ⭐重要
```xc
// ✅ 正确的缩进格式
函数 整型 测试函数()
        整型 localVar = 10      // 使用TAB缩进
        如果 localVar > 5
                调试输出("大于5")    // 双重TAB缩进
                返回 localVar
        否则
                调试输出("小于等于5")
                返回 0

// ❌ 错误的缩进格式（使用空格）
函数 整型 错误示例()
   整型 localVar = 10      // 使用空格缩进，错误！
   如果 localVar > 5
      调试输出("大于5")     // 使用空格缩进，错误！
```

**缩进注意事项**：
- 必须使用TAB键进行缩进，不能使用空格
- 缩进决定了代码的作用域
- 可以通过IDE的对齐辅助线查看缩进层级
- 空行可以使用`[pass]`关键字占位

### 2. 错误处理
```xc
// 始终检查函数返回值
如果 文件是否存在("test.txt")
    文件类 file
    如果 file.打开("test.txt")
        // 处理文件
        file.关闭()
    否则
        调试输出("文件打开失败")
否则
    调试输出("文件不存在")
```

### 3. 资源管理
```xc
// 使用RAII模式管理资源
文件类 file
如果 file.打开("test.txt")
    // 使用文件
    // 自动关闭
否则
    调试输出("文件打开失败")
```

### 4. 性能优化
```xc
// 避免频繁字符串连接
文本型 result
result.添加("Hello")
result.添加(" ")
result.添加("World")

// 预分配数组大小
动态数组<整型> numbers
numbers.重设大小(1000)  // 预分配空间
```

### 5. 调试技巧
```xc
// 使用调试输出
调试输出("变量值:", variable)
调试输出("函数执行到:", __函数名__)

// 条件调试
#ifdef DEBUG
    调试输出("调试信息")
#endif

// 格式化输出
调试输出("结果: %d", 100)
调试输出("价格: %.2f", 99.99)
```

### 6. 编码规范
```xc
// 函数命名：动词+名词
函数 整型 获取文件大小(文本型 path)
函数 逻辑型 保存配置()
函数 空类型 清空数据()

// 类命名：名词
类 文件管理器
类 数据库连接

// 变量命名：描述性名称
整型 文件大小
文本型 用户名
逻辑型 是否成功
```

---

## 常见问题

### 1. 缩进和语法问题
**Q: 为什么我的代码编译失败？**
A: 检查以下几点：
- 确保使用TAB键进行缩进，不能使用空格
- 检查缩进是否正确对齐
- 确保没有多余的空格或制表符

**Q: 如何确定代码的作用域？**
A:
- 0缩进的代码为全局作用域
- 每增加一个TAB缩进，作用域就深入一层
- 可以通过IDE的对齐辅助线查看缩进层级

**Q: 空行如何处理？**
A: 可以使用`[pass]`关键字占位，或者直接留空行

### 2. 编码问题
- 使用 `文本型` 处理Unicode字符串
- 使用 `文本型A` 处理ANSI字符串
- 使用 `U"字符串"` 定义UTF-8字符串
- 使用 `W2A()` 和 `A2W()` 进行编码转换

### 3. 内存管理
- 动态数组会自动管理内存
- 文件类会自动关闭文件
- 注意及时释放手动分配的资源

### 4. 线程安全
- 使用临界区保护共享资源
- 使用互斥体进行线程同步
- 使用事件对象进行线程通信

---

**版本**: 1.0  
**更新日期**: 2025年6月29日  
**适用版本**: 炫语言最新IDE版本  
**作者**: ゞ龍ㄙ吻
下载：