Pseudocode

# 剑桥IGCSE计算机科学 0478 Pseudocode 完整指南

按照**从简单到复杂**的顺序，系统地讲解每个语法结构，并提供循序渐进的练习例子。

------

## 📚 第一部分：变量与基本输入输出

### 1. **DECLARE（声明变量）**

**语法：** `DECLARE <identifier> : <data type>`

**解释：** 在使用变量前，需要先声明它的名称和数据类型。

**常用数据类型：**

- `INTEGER` - 整数
- `REAL` - 小数
- `STRING` - 文字
- `BOOLEAN` - 布尔值（TRUE/FALSE）
- `CHAR` - 单个字符

**例子1（基础）：**

```
DECLARE Age : INTEGER
DECLARE Name : STRING
DECLARE Price : REAL
DECLARE IsStudent : BOOLEAN

Age ← 15
Name ← "Zhang Wei"
Price ← 29.99
IsStudent ← TRUE

OUTPUT Name, " is ", Age, " years old"
```

**运行结果：**

```
Zhang Wei is 15 years old
```

------

### 2. **CONSTANT（常量）**

**语法：** `CONSTANT <identifier> ← <value>`

**解释：** 常量的值在程序运行中不能改变。

**例子2（基础）：**

```
CONSTANT PI ← 3.14159
CONSTANT TAX_RATE ← 0.07
DECLARE Radius : REAL
DECLARE Area : REAL

INPUT Radius
Area ← PI * Radius * Radius
OUTPUT "圆的面积是: ", Area
```

**假设用户输入：** `5`

**运行结果：**

```
圆的面积是: 78.53975
```

------

### 3. **赋值（Assignment）**

**语法：** `<identifier> ← <value>`

**解释：** 用 `←` 符号给变量赋值（注意不是等号）。

**例子3（基础）：**

```
DECLARE Score : INTEGER
DECLARE Grade : STRING

Score ← 85
Grade ← "B"
OUTPUT "你的分数是 ", Score, ", 等级是 ", Grade
```

**运行结果：**

```
你的分数是 85, 等级是 B
```

------

### 4. **INPUT 和 OUTPUT**

**语法：**

- `INPUT <identifier>` - 接收用户输入
- `OUTPUT <value(s)>` - 显示输出

**例子4（实用练习）：**

```
DECLARE FirstName : STRING
DECLARE LastName : STRING
DECLARE BirthYear : INTEGER
DECLARE CurrentYear : INTEGER
DECLARE Age : INTEGER

OUTPUT "请输入你的名字: "
INPUT FirstName
OUTPUT "请输入你的姓氏: "
INPUT LastName
OUTPUT "请输入你的出生年份: "
INPUT BirthYear

CurrentYear ← 2025
Age ← CurrentYear - BirthYear

OUTPUT "你好, ", FirstName, " ", LastName
OUTPUT "你今年 ", Age, " 岁"
```

**假设用户输入：** `Li`, `Ming`, `2010`

**运行结果：**

```
请输入你的名字: 
Li
请输入你的姓氏: 
Ming
请输入你的出生年份: 
2010
你好, Li Ming
你今年 15 岁
```

------

## 🔢 第二部分：算术运算

### 5. **基本运算符**

**符号：** `+`, `-`, `*`, `/`, `^`

**例子5（计算器）：**

```
DECLARE Num1 : REAL
DECLARE Num2 : REAL
DECLARE Sum : REAL
DECLARE Product : REAL
DECLARE Power : REAL

INPUT Num1
INPUT Num2

Sum ← Num1 + Num2
Product ← Num1 * Num2
Power ← Num1 ^ Num2

OUTPUT Num1, " + ", Num2, " = ", Sum
OUTPUT Num1, " × ", Num2, " = ", Product
OUTPUT Num1, " ^ ", Num2, " = ", Power
```

**假设用户输入：** `5`, `3`

**运行结果：**

```
5
3
5 + 3 = 8
5 × 3 = 15
5 ^ 3 = 125
```

------

### 6. **DIV 和 MOD**

**语法：**

- `DIV(num1, num2)` - 整数除法（只保留整数部分）
- `MOD(num1, num2)` - 取余数（模运算）

**例子6（找零钱）：**

```
DECLARE Money : INTEGER
DECLARE TenDollar : INTEGER
DECLARE FiveDollar : INTEGER
DECLARE OneDollar : INTEGER

OUTPUT "请输入金额（元）: "
INPUT Money

TenDollar ← DIV(Money, 10)
Money ← MOD(Money, 10)

FiveDollar ← DIV(Money, 5)
Money ← MOD(Money, 5)

OneDollar ← Money

OUTPUT "需要:"
OUTPUT TenDollar, " 张十元"
OUTPUT FiveDollar, " 张五元"
OUTPUT OneDollar, " 张一元"
```

**假设用户输入：** `37`

**运行结果：**

```
请输入金额（元）: 
37
需要:
3 张十元
1 张五元
2 张一元
```

------

**例子7（判断奇偶数）：**

```
DECLARE Number : INTEGER

INPUT Number

IF MOD(Number, 2) = 0
THEN
    OUTPUT Number, " 是偶数"
ELSE
    OUTPUT Number, " 是奇数"
ENDIF
```

**假设用户输入：** `17`

**运行结果：**

```
17
17 是奇数
```

**假设用户输入：** `24`

**运行结果：**

```
24
24 是偶数
```

------

## 🔀 第三部分：条件语句

### 7. **IF...THEN...ENDIF**

**例子8（简单判断）：**

```
DECLARE Temperature : INTEGER

INPUT Temperature

IF Temperature > 30
THEN
    OUTPUT "天气很热！"
ENDIF

IF Temperature < 10
THEN
    OUTPUT "天气很冷！"
ENDIF
```

**假设用户输入：** `35`

**运行结果：**

```
35
天气很热！
```

**假设用户输入：** `5`

**运行结果：**

```
5
天气很冷！
```

------

### 8. **IF...THEN...ELSE...ENDIF**

**例子 9（及格判断）：**

```
DECLARE Score : INTEGER

INPUT Score

IF Score >= 60
THEN
    OUTPUT "恭喜你及格了！"
ELSE
    OUTPUT "很遗憾，你不及格。"
ENDIF
```

**假设用户输入：** `75`

**运行结果：**

```
75
恭喜你及格了！
```

**假设用户输入：** `45`

**运行结果：**

```
45
很遗憾，你不及格。
```

------

**例子10（多层IF - 成绩等级）：**

```
DECLARE Mark : INTEGER
DECLARE Grade : STRING

INPUT Mark

IF Mark >= 90
THEN
    Grade ← "A"
ELSE
    IF Mark >= 80
    THEN
        Grade ← "B"
    ELSE
        IF Mark >= 70
        THEN
            Grade ← "C"
        ELSE
            IF Mark >= 60
            THEN
                Grade ← "D"
            ELSE
                Grade ← "F"
            ENDIF
        ENDIF
    ENDIF
ENDIF

OUTPUT "你的等级是: ", Grade
```

**假设用户输入：** `85`

**运行结果：**

```
85
你的等级是: B
```

**假设用户输入：** `55`

**运行结果：**

```
55
你的等级是: F
```

------

### 9. **CASE OF（选择语句）**

**例子11（基础CASE）：**

```
DECLARE DayNumber : INTEGER

INPUT DayNumber

CASE OF DayNumber
    1 : OUTPUT "星期一"
    2 : OUTPUT "星期二"
    3 : OUTPUT "星期三"
    4 : OUTPUT "星期四"
    5 : OUTPUT "星期五"
    6 : OUTPUT "星期六"
    7 : OUTPUT "星期日"
ENDCASE
```

**假设用户输入：** `3`

**运行结果：**

```
3
星期三
```

**假设用户输入：** `7`

**运行结果：**

```
7
星期日
```

------

### 10. **CASE OF...OTHERWISE**

**例子12（带默认选项的CASE）：**

```
DECLARE Choice : INTEGER
DECLARE Price : REAL

OUTPUT "菜单:"
OUTPUT "1. 炒饭 - $5"
OUTPUT "2. 面条 - $6"
OUTPUT "3. 汉堡 - $8"
OUTPUT "请选择(1-3): "
INPUT Choice

CASE OF Choice
    1 : Price ← 5
    2 : Price ← 6
    3 : Price ← 8
    OTHERWISE 
        OUTPUT "无效选择！"
        Price ← 0
ENDCASE

IF Price > 0
THEN
    OUTPUT "你需要支付 $", Price
ENDIF
```

**假设用户输入：** `2`

**运行结果：**

```
菜单:
1. 炒饭 - $5
2. 面条 - $6
3. 汉堡 - $8
请选择(1-3): 
2
你需要支付 $6
```

**假设用户输入：** `9`

**运行结果：**

```
菜单:
1. 炒饭 - $5
2. 面条 - $6
3. 汉堡 - $8
请选择(1-3): 
9
无效选择！
```

------

## 🔁 第四部分：循环结构

### 11. **FOR 循环（基础）**

**例子13（打印数字）：**

```
DECLARE i : INTEGER

FOR i ← 1 TO 10
    OUTPUT i
NEXT i
```

**运行结果：**

```
1
2
3
4
5
6
7
8
9
10
```

------

**例子14（乘法表）：**

```
DECLARE Number : INTEGER
DECLARE i : INTEGER

INPUT Number

FOR i ← 1 TO 10
    OUTPUT Number, " × ", i, " = ", Number * i
NEXT i
```

**假设用户输入：** `7`

**运行结果：**

```
7
7 × 1 = 7
7 × 2 = 14
7 × 3 = 21
7 × 4 = 28
7 × 5 = 35
7 × 6 = 42
7 × 7 = 49
7 × 8 = 56
7 × 9 = 63
7 × 10 = 70
```

------

### 12. **FOR 循环（带STEP）**

**例子15（偶数）：**

```
DECLARE i : INTEGER

OUTPUT "1到20之间的偶数:"
FOR i ← 2 TO 20 STEP 2
    OUTPUT i
NEXT i
```

**运行结果：**

```
1到20之间的偶数:
2
4
6
8
10
12
14
16
18
20
```

------

**例子16（倒数）：**

```
DECLARE i : INTEGER

OUTPUT "倒计时:"
FOR i ← 10 TO 1 STEP -1
    OUTPUT i
NEXT i
OUTPUT "发射！"
```

**运行结果：**

```
倒计时:
10
9
8
7
6
5
4
3
2
1
发射！
```

------

### 13. **REPEAT...UNTIL**

**例子17（输入验证）：**

```
DECLARE Password : STRING
CONSTANT CORRECT_PASSWORD ← "abc123"

REPEAT
    OUTPUT "请输入密码: "
    INPUT Password
    IF Password <> CORRECT_PASSWORD
    THEN
        OUTPUT "密码错误，请重试！"
    ENDIF
UNTIL Password = CORRECT_PASSWORD

OUTPUT "登录成功！"
```

**假设用户输入过程：** `123` → `wrong` → `abc123`

**运行结果：**

```
请输入密码: 
123
密码错误，请重试！
请输入密码: 
wrong
密码错误，请重试！
请输入密码: 
abc123
登录成功！
```

------

**例子18（猜数字游戏）：**

```
DECLARE Secret : INTEGER
DECLARE Guess : INTEGER

Secret ← 42

OUTPUT "我想了一个1-100之间的数字"

REPEAT
    OUTPUT "请猜: "
    INPUT Guess
    IF Guess < Secret
    THEN
        OUTPUT "太小了！"
    ENDIF
    IF Guess > Secret
    THEN
        OUTPUT "太大了！"
    ENDIF
UNTIL Guess = Secret

OUTPUT "恭喜你猜对了！"
```

**假设用户输入过程：** `50` → `30` → `40` → `42`

**运行结果：**

```
我想了一个1-100之间的数字
请猜: 
50
太大了！
请猜: 
30
太小了！
请猜: 
40
太小了！
请猜: 
42
恭喜你猜对了！
```

------

### 14. **WHILE...DO...ENDWHILE**

**例子19（累加）：**

```
DECLARE Total : INTEGER
DECLARE Number : INTEGER

Total ← 0
Number ← 0

WHILE Number < 100 DO
    Number ← Number + 10
    Total ← Total + Number
ENDWHILE

OUTPUT "总和是: ", Total
```

**运行结果：**

```
总和是: 550
```

**解释：** 10 + 20 + 30 + 40 + 50 + 60 + 70 + 80 + 90 + 100 = 550

------

**例子20（倒计时）：**

```
DECLARE Count : INTEGER

Count ← 5

WHILE Count > 0 DO
    OUTPUT Count
    Count ← Count - 1
ENDWHILE

OUTPUT "时间到！"
```

**运行结果：**

```
5
4
3
2
1
时间到！
```

------

## 📝 第六部分：字符串函数

### 15. **LENGTH（长度）**

**例子21：**

```
DECLARE Name : STRING
DECLARE NameLength : INTEGER

INPUT Name
NameLength ← LENGTH(Name)

OUTPUT "你的名字有 ", NameLength, " 个字符"
```

**假设用户输入：** `Zhang Wei`

**运行结果：**

```
Zhang Wei
你的名字有 9 个字符
```

------

### 16. **LCASE 和 UCASE（大小写转换）**

**例子22：**

```
DECLARE Text : STRING

INPUT Text

OUTPUT "小写: ", LCASE(Text)
OUTPUT "大写: ", UCASE(Text)
```

**假设用户输入：** `Hello World`

**运行结果：**

```
Hello World
小写: hello world
大写: HELLO WORLD
```

------

### 17. **SUBSTRING（截取子字符串）**

**语法：** `SUBSTRING(字符串, 起始位置, 长度)`

**例子23（提取首字母）：**

```
DECLARE FullName : STRING
DECLARE Initial : STRING

INPUT FullName
Initial ← SUBSTRING(FullName, 1, 1)

OUTPUT "你名字的首字母是: ", Initial
```

**假设用户输入：** `Michael`

**运行结果：**

```
Michael
你名字的首字母是: M
```

------

**例子24（隐藏密码）：**

```
DECLARE Password : STRING
DECLARE FirstThree : STRING

INPUT Password
FirstThree ← SUBSTRING(Password, 1, 3)

OUTPUT "密码提示: ", FirstThree, "***"
```

**假设用户输入：** `secure123`

**运行结果：**

```
secure123
密码提示: sec***
```

------

## 🔢 第七部分：数学函数

### 18. **ROUND（四舍五入）**

**例子25：**

```
DECLARE Price : REAL
DECLARE RoundedPrice : REAL

Price ← 19.567

RoundedPrice ← ROUND(Price, 2)
OUTPUT "精确到2位小数: $", RoundedPrice

RoundedPrice ← ROUND(Price, 0)
OUTPUT "四舍五入到整数: $", RoundedPrice
```

**运行结果：**

```
精确到2位小数: $19.57
四舍五入到整数: $20
```

------

### 19. **RANDOM（随机数）**

**例子26（骰子）：**

```
DECLARE DiceRoll : INTEGER

DiceRoll ← INT(RANDOM() * 6) + 1
OUTPUT "你掷出了: ", DiceRoll
```

**运行结果（随机）：**

```
你掷出了: 4
```

或

```
你掷出了: 6
```

------

**例子27（抽奖）：**

```
DECLARE Winner : INTEGER
DECLARE i : INTEGER

OUTPUT "抽奖开始！"
FOR i ← 1 TO 5
    Winner ← INT(RANDOM() * 100) + 1
    OUTPUT "第 ", i, " 个幸运号码: ", Winner
NEXT i
```

**运行结果（示例）：**

```
抽奖开始！
第 1 个幸运号码: 42
第 2 个幸运号码: 78
第 3 个幸运号码: 15
第 4 个幸运号码: 91
第 5 个幸运号码: 33
```

## 📊 第二部分：数组

### 20. **一维数组**

**语法：** `DECLARE <identifier> : ARRAY[<l>:<u>] OF <data type>`

**解释：**

- `<l>` 是起始索引（lower bound）
- `<u>` 是结束索引（upper bound）

**例子28（基础）：**

```
DECLARE Scores : ARRAY[1:5] OF INTEGER
DECLARE i : INTEGER

// 输入5个分数
FOR i ← 1 TO 5
    OUTPUT "请输入第 ", i, " 个分数: "
    INPUT Scores[i]
NEXT i

// 输出所有分数
OUTPUT "你输入的分数是:"
FOR i ← 1 TO 5
    OUTPUT "分数 ", i, ": ", Scores[i]
NEXT i
```

**假设用户输入：** `85`, `90`, `78`, `92`, `88`

**运行结果：**

```
请输入第 1 个分数: 
85
请输入第 2 个分数: 
90
请输入第 3 个分数: 
78
请输入第 4 个分数: 
92
请输入第 5 个分数: 
88
你输入的分数是:
分数 1: 85
分数 2: 90
分数 3: 78
分数 4: 92
分数 5: 88
```

------

**例子29（计算平均分）：**

```
DECLARE Marks : ARRAY[1:10] OF INTEGER
DECLARE Total : INTEGER
DECLARE Average : REAL
DECLARE i : INTEGER

Total ← 0

FOR i ← 1 TO 10
    INPUT Marks[i]
    Total ← Total + Marks[i]
NEXT i

Average ← Total / 10
OUTPUT "平均分是: ", Average
```

**假设用户输入：** `80`, `85`, `90`, `75`, `88`, `92`, `78`, `85`, `89`, `91`

**运行结果：**

```
80
85
90
75
88
92
78
85
89
91
平均分是: 85.3
```

------

### 21. **二维数组**

**语法：** `DECLARE <identifier> : ARRAY[<l1>:<u1>, <l2>:<u2>] OF <data type>`

**解释：** 二维数组像一个表格，有行和列。

**例子30（座位表）：**

```
DECLARE Classroom : ARRAY[1:3, 1:4] OF STRING
DECLARE Row : INTEGER
DECLARE Col : INTEGER

// 输入学生姓名
FOR Row ← 1 TO 3
    FOR Col ← 1 TO 4
        OUTPUT "输入第 ", Row, " 行, 第 ", Col, " 列的学生: "
        INPUT Classroom[Row, Col]
    NEXT Col
NEXT Row

// 显示座位表
OUTPUT "座位表:"
FOR Row ← 1 TO 3
    FOR Col ← 1 TO 4
        OUTPUT Classroom[Row, Col]
    NEXT Col
    OUTPUT ""  // 换行
NEXT Row
```

**假设用户输入学生名字（简化版）：** 第1行：`Tom`, `Amy`, `Bob`, `Sue` 第2行：`Jim`, `Eva`, `Max`, `Zoe` 第3行：`Dan`, `Kim`, `Lee`, `Pat`

**运行结果：**

```
输入第 1 行, 第 1 列的学生: 
Tom
输入第 1 行, 第 2 列的学生: 
Amy
... (省略中间输入过程)
座位表:
Tom
Amy
Bob
Sue

Jim
Eva
Max
Zoe

Dan
Kim
Lee
Pat 
```

## 📁 第八部分：文件处理

### 22. **文件的基本操作**

在程序中，我们经常需要将数据保存到文件中，或者从文件中读取数据。文件处理让数据可以**永久保存**，即使程序关闭后也不会丢失。

------

### 23. **文件操作的基本步骤**

处理文件通常需要三个步骤：

1. **打开文件**（OPEN）
2. **读取或写入数据**（READFILE / WRITEFILE）
3. **关闭文件**（CLOSEFILE）

------

### 24. **OPEN FOR WRITE（打开文件用于写入）**

**语法：** `OPEN <filename> FOR WRITE`

**解释：** 打开一个文件准备写入数据。如果文件不存在，会自动创建；如果文件已存在，**原有内容会被清空**。

------

### 25. **WRITEFILE（写入文件）**

**语法：** `WRITEFILE <filename>, <data>`

**解释：** 将数据写入到文件中的一行。

------

### 26. **OPEN FOR READ（打开文件用于读取）**

**语法：** `OPEN <filename> FOR READ`

**解释：** 打开一个文件准备读取数据。

------

### 27. **READFILE（读取文件）**

**语法：** `READFILE <filename>, <variable>`

**解释：** 从文件中读取一行数据，并存储到变量中。

------

### 28. **CLOSEFILE（关闭文件）**

**语法：** `CLOSEFILE <filename>`

**解释：** 操作完成后必须关闭文件，这样可以确保数据正确保存，并释放系统资源。

------

## 📝 完整例子

### **例子31（基础文件读写）：**

```
DECLARE TextLine : STRING
DECLARE MyFile : STRING

MyFile ← "MyText.txt"

// 写入文件
OPEN MyFile FOR WRITE
OUTPUT "请输入一行文字："
INPUT TextLine
WRITEFILE MyFile, TextLine
CLOSEFILE MyFile

// 读取文件
OUTPUT "文件中保存的内容是："
OPEN MyFile FOR READ
READFILE MyFile, TextLine
OUTPUT TextLine
CLOSEFILE MyFile
```

**假设用户输入：** `Hello, World!`

**运行结果：**

```
请输入一行文字：
Hello, World!
文件中保存的内容是：
Hello, World!
```

**解释：**

1. 程序首先打开文件 `MyText.txt` 用于写入
2. 用户输入一行文字
3. 文字被写入文件并关闭
4. 然后重新打开文件用于读取
5. 读取刚才写入的文字并显示
6. 最后关闭文件

------

### **例子32（保存多条记录）：**

```
DECLARE StudentName : STRING
DECLARE StudentFile : STRING
DECLARE i : INTEGER

StudentFile ← "Students.txt"

// 写入3个学生的名字
OPEN StudentFile FOR WRITE
FOR i ← 1 TO 3
    OUTPUT "请输入第 ", i, " 个学生的名字："
    INPUT StudentName
    WRITEFILE StudentFile, StudentName
NEXT i
CLOSEFILE StudentFile

// 读取并显示所有学生名字
OUTPUT "学生名单："
OPEN StudentFile FOR READ
FOR i ← 1 TO 3
    READFILE StudentFile, StudentName
    OUTPUT i, ". ", StudentName
NEXT i
CLOSEFILE StudentFile
```

**假设用户输入：** `张伟`, `李娜`, `王明`

**运行结果：**

```
请输入第 1 个学生的名字：
张伟
请输入第 2 个学生的名字：
李娜
请输入第 3 个学生的名字：
王明
学生名单：
1. 张伟
2. 李娜
3. 王明
```

------

### **例子33（保存和读取成绩）：**

```
DECLARE ScoreFile : STRING
DECLARE Name : STRING
DECLARE Score : INTEGER
DECLARE i : INTEGER

ScoreFile ← "Scores.txt"

// 保存5个学生的成绩
OPEN ScoreFile FOR WRITE
FOR i ← 1 TO 5
    OUTPUT "输入学生姓名："
    INPUT Name
    OUTPUT "输入分数："
    INPUT Score
    WRITEFILE ScoreFile, Name
    WRITEFILE ScoreFile, Score
NEXT i
CLOSEFILE ScoreFile

// 读取并显示成绩
OUTPUT "成绩单："
OPEN ScoreFile FOR READ
FOR i ← 1 TO 5
    READFILE ScoreFile, Name
    READFILE ScoreFile, Score
    OUTPUT Name, ": ", Score, " 分"
NEXT i
CLOSEFILE ScoreFile
```

**假设用户输入：**

- 学生1：`Tom`, `85`
- 学生2：`Amy`, `92`
- 学生3：`Bob`, `78`
- 学生4：`Sue`, `95`
- 学生5：`Jim`, `88`

**运行结果：**

```
输入学生姓名：
Tom
输入分数：
85
... (省略中间输入)
成绩单：
Tom: 85 分
Amy: 92 分
Bob: 78 分
Sue: 95 分
Jim: 88 分
```

------

### 29. **EOF（检测文件末尾）**

**语法：** `EOF(<filename>)`

**解释：** 返回 `TRUE` 如果已经读到文件末尾，返回 `FALSE` 如果还有数据可读。这在不知道文件有多少行数据时非常有用。

**例子34（读取未知数量的数据）：**

```
DECLARE DataFile : STRING
DECLARE Number : INTEGER
DECLARE Total : INTEGER
DECLARE Count : INTEGER

DataFile ← "Numbers.txt"
Total ← 0
Count ← 0

// 假设文件已经包含一些数字
OPEN DataFile FOR READ

WHILE NOT EOF(DataFile) DO
    READFILE DataFile, Number
    Total ← Total + Number
    Count ← Count + 1
ENDWHILE

CLOSEFILE DataFile

OUTPUT "共读取了 ", Count, " 个数字"
OUTPUT "总和是: ", Total
OUTPUT "平均值是: ", Total / Count
```

**假设文件 Numbers.txt 包含：**

```
10
20
30
40
50
```

**运行结果：**

```
共读取了 5 个数字
总和是: 150
平均值是: 30
```

------

### **例子35（简单的日记程序）：**

```
DECLARE DiaryFile : STRING
DECLARE Entry : STRING
DECLARE Choice : INTEGER

DiaryFile ← "Diary.txt"

OUTPUT "1. 写日记"
OUTPUT "2. 读日记"
OUTPUT "请选择："
INPUT Choice

CASE OF Choice
    1 :
        OPEN DiaryFile FOR WRITE
        OUTPUT "请写下今天的日记："
        INPUT Entry
        WRITEFILE DiaryFile, Entry
        CLOSEFILE DiaryFile
        OUTPUT "日记已保存！"
    
    2 :
        OPEN DiaryFile FOR READ
        OUTPUT "你的日记内容："
        READFILE DiaryFile, Entry
        OUTPUT Entry
        CLOSEFILE DiaryFile
    
    OTHERWISE
        OUTPUT "无效选择"
ENDCASE
```

**场景1 - 写日记，用户输入选择：** `1`，然后输入：`今天天气很好，我很开心！`

**运行结果：**

```
1. 写日记
2. 读日记
请选择：
1
请写下今天的日记：
今天天气很好，我很开心！
日记已保存！
```

**场景2 - 读日记，用户输入选择：** `2`

**运行结果：**

```
1. 写日记
2. 读日记
请选择：
2
你的日记内容：
今天天气很好，我很开心！
```

------

## 🔑 文件处理要点总结

### **重要提醒：**

1. **必须先打开文件才能读写**
   - 写入用：`OPEN <filename> FOR WRITE`
   - 读取用：`OPEN <filename> FOR READ`
2. **写入和读取不能同时进行**
   - 如果需要先写入再读取，必须先 `CLOSEFILE`，然后重新 `OPEN`
3. **用完必须关闭文件**
   - 使用 `CLOSEFILE <filename>`
4. **FOR WRITE 会清空原有内容**
   - 如果文件已存在，打开 FOR WRITE 会删除原有所有内容
5. **读取顺序很重要**
   - 每次 `READFILE` 读取一行
   - 下一次 `READFILE` 会读取下一行
6. **使用 EOF 处理不定长度文件**
   - `WHILE NOT EOF(filename) DO` 可以读取所有数据直到文件末尾

------

### **常见错误：**

❌ **错误1：忘记关闭文件**

```
OPEN MyFile FOR WRITE
WRITEFILE MyFile, "Hello"
// 忘记 CLOSEFILE - 数据可能丢失！
```

✅ **正确：**

```
OPEN MyFile FOR WRITE
WRITEFILE MyFile, "Hello"
CLOSEFILE MyFile
```

------

❌ **错误2：未打开文件就尝试读写**

```
WRITEFILE MyFile, "Hello"  // 错误！文件未打开
```

✅ **正确：**

```
OPEN MyFile FOR WRITE
WRITEFILE MyFile, "Hello"
CLOSEFILE MyFile
```

------

❌ **错误3：同时打开文件用于读和写**

```
OPEN MyFile FOR WRITE
WRITEFILE MyFile, "Hello"
READFILE MyFile, Text  // 错误！此时文件是写入模式
```

✅ **正确：**

```
OPEN MyFile FOR WRITE
WRITEFILE MyFile, "Hello"
CLOSEFILE MyFile

OPEN MyFile FOR READ
READFILE MyFile, Text
CLOSEFILE MyFile
```

------

通过文件处理，你可以：

- ✅ 保存用户数据（如游戏进度、设置）
- ✅ 创建简单的数据库
- ✅ 记录日志和历史记录
- ✅ 在不同运行之间保持程序状态

这是一个非常强大的功能，让你的程序可以"记住"信息！