From 77e8640b3617523d5911809270104f33d6c9edc6 Mon Sep 17 00:00:00 2001
From: Li Jin <dragon-fly@qq.com>
Date: Mon, 17 Nov 2025 09:12:26 +0800
Subject: Updated doc. [skip CI]

---
 doc/docs/zh/doc/README.md | 183 +++++++++++++++++++++++-----------------------
 1 file changed, 92 insertions(+), 91 deletions(-)

(limited to 'doc/docs')

diff --git a/doc/docs/zh/doc/README.md b/doc/docs/zh/doc/README.md
index a799a5b..845198c 100755
--- a/doc/docs/zh/doc/README.md
+++ b/doc/docs/zh/doc/README.md
@@ -9,7 +9,7 @@ title: 参考手册
 
 ## 介绍
 
-月之脚本（YueScript）是一种动态语言，可以编译为Lua。它是[MoonScript](https://github.com/leafo/moonscript)的方言。用月之脚本编写的代码既有表现力又非常简洁。它适合编写一些更易于维护的代码，并在嵌入 Lua 的环境中运行，如游戏或网站服务器。
+月之脚本（YueScript）是一种动态语言，可以编译为 Lua。它是 [MoonScript](https://github.com/leafo/moonscript) 的方言。用月之脚本编写的代码既有表现力又非常简洁。它适合编写一些更易于维护的代码，并在嵌入 Lua 的环境中运行，如游戏或网站服务器。
 
 Yue（月）是中文中“月亮”的名称。
 
@@ -109,7 +109,7 @@ export 🌛 = "月之脚本"
 
 * **Lua 模块**
 
-&emsp;安装 [luarocks](https://luarocks.org)，一个Lua模块的包管理器。然后作为Lua模块和可执行文件安装它：
+&emsp;安装 [luarocks](https://luarocks.org)，一个 Lua 模块的包管理器。然后作为 Lua 模块和可执行文件安装它：
 
 ```
 > luarocks install yuescript
@@ -150,14 +150,14 @@ export 🌛 = "月之脚本"
 
 ### Lua 模块
 
-在Lua中使用月之脚本模块：
+在 Lua 中使用月之脚本模块：
 
 * **用法 1**
-在Lua中引入 "你的脚本入口文件.yue"。
+在 Lua 中引入 "你的脚本入口文件.yue"。
 ```Lua
 require("yue")("你的脚本入口文件")
 ```
-当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import**进行脚本引用即可。错误消息中的代码行号也会被正确处理。
+当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import** 进行脚本引用即可。错误消息中的代码行号也会被正确处理。
 
 * **用法 2**
 手动引入月之脚本模块并重写错误消息来帮助调试。
@@ -172,7 +172,7 @@ end)
 ```
 
 * **用法 3**
-在Lua中使用月之脚本编译器功能。
+在 Lua 中使用月之脚本编译器功能。
 ```lua
 local yue = require("yue")
 local codes, err, globals = yue.to_lua([[
@@ -492,7 +492,7 @@ $printNumAndStr 123, "hello"
 
 ## 操作符
 
-Lua的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
+Lua 的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
 
 ```moonscript
 tb\func! if tb ~= nil
@@ -577,11 +577,11 @@ print v(1) > v(2) <= v(3)
 </pre>
 </YueDisplay>
 
-在上面的例子里，中间的表达式`v(2)`仅被计算一次，如果把表达式写成`v(1) < v(2) and v(2) <= v(3)`的方式，中间的`v(2)`才会被计算两次。在链式比较中，求值的顺序往往是未定义的。所以强烈建议不要在链式比较中使用具有副作用（比如做打印操作）的表达式。如果需要使用有副作用的函数，应明确使用短路 `and` 运算符来做连接。
+在上面的例子里，中间的表达式 `v(2)` 仅被计算一次，如果把表达式写成 `v(1) < v(2) and v(2) <= v(3)` 的方式，中间的 `v(2)` 才会被计算两次。在链式比较中，求值的顺序往往是未定义的。所以强烈建议不要在链式比较中使用具有副作用（比如做打印操作）的表达式。如果需要使用有副作用的函数，应明确使用短路 `and` 运算符来做连接。
 
 ### 表追加
 
-**[] =** 操作符用于向Lua表的最后插入值。
+**[] =** 操作符用于向 Lua 表的最后插入值。
 
 ```moonscript
 tab = []
@@ -613,7 +613,7 @@ tbA[] = ...tbB
 
 ### 表扩展
 
-你可以使用前置 `...` 操作符在Lua表中插入数组表或哈希表。
+你可以使用前置 `...` 操作符在 Lua 表中插入数组表或哈希表。
 
 ```moonscript
 parts =
@@ -672,7 +672,7 @@ data.items[#] = 1
 **<>** 操作符可提供元表操作的快捷方式。
 
 * **元表创建**
-使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的Lua表。
+使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的 Lua 表。
 
 ```moonscript
 mt = {}
@@ -814,7 +814,7 @@ readFile "example.txt"
 
 ### 空值合并
 
-如果其左操作数不是**nil**，则nil合并运算符 **??** 返回其左操作数的值；否则，它将计算右操作数并返回其结果。如果左操作数计算结果为非nil的值，**??** 运算符将不再计算其右操作数。
+如果其左操作数不是 **nil**，则nil合并运算符 **??** 返回其左操作数的值；否则，它将计算右操作数并返回其结果。如果左操作数计算结果为非 nil 的值，**??** 运算符将不再计算其右操作数。
 ```moonscript
 local a, b, c, d
 a = b ?? c ?? d
@@ -1093,7 +1093,7 @@ export default ->
 
 ## 赋值
 
-月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过**local**和**global**声明来改变声明变量的作用范围。
+月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过 **local** 和 **global** 声明来改变声明变量的作用范围。
 
 ```moonscript
 hello = "world"
@@ -1222,9 +1222,9 @@ do
 
 ## 解构赋值
 
-解构赋值是一种快速从Lua表中按名称或基于数组中的位置提取值的方法。
+解构赋值是一种快速从 Lua 表中按名称或基于数组中的位置提取值的方法。
 
-通常当你看到一个字面量的Lua表，比如{1,2,3}，它位于赋值的右侧，因为它是一个值。解构赋值语句的写法就是交换了字面量Lua表的角色，并将其放在赋值语句的左侧。
+通常当你看到一个字面量的 Lua 表，比如 `{1,2,3}`，它位于赋值的右侧，因为它是一个值。解构赋值语句的写法就是交换了字面量 Lua 表的角色，并将其放在赋值语句的左侧。
 
 最好是通过示例来解释。以下是如何从表格中解包前两个值的方法：
 
@@ -1323,7 +1323,7 @@ print first, second, color
 </pre>
 </YueDisplay>
 
-有时候我们会需要从Lua表中提取值并将它们赋给与键同名的局部变量。为了避免编写重复代码，我们可以使用 **:** 前缀操作符：
+有时候我们会需要从 Lua 表中提取值并将它们赋给与键同名的局部变量。为了避免编写重复代码，我们可以使用 **:** 前缀操作符：
 
 ```moonscript
 {:concat, :insert} = table
@@ -1415,7 +1415,7 @@ print last   -- 打印: last
 
 ### 在其它地方的解构赋值
 
-解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在for循环中：
+解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在 for 循环中：
 
 ```moonscript
 tuples = [
@@ -1438,7 +1438,7 @@ for [left, right] in *tuples
 </pre>
 </YueDisplay>
 
-我们知道数组表中的每个元素都是一个两项的元组，所以我们可以直接在for语句的名称子句中使用解构来解包它。
+我们知道数组表中的每个元素都是一个两项的元组，所以我们可以直接在 for 语句的名称子句中使用解构来解包它。
 
 ## If 赋值
 
@@ -1506,7 +1506,7 @@ while byte := stream\read_one!
 
 ## 可变参数赋值
 
-你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用Lua的方式访问其内容。
+你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用 Lua 的方式访问其内容。
 ```moonscript
 list = [1, 2, 3, 4, 5]
 fn = (ok) -> ok, table.unpack list
@@ -1583,7 +1583,7 @@ func --[[端口]] 3000, --[[ip]] "192.168.1.1"
 
 ## 错误处理
 
-用于统一进行Lua错误处理的便捷语法。
+用于统一进行 Lua 错误处理的便捷语法。
 
 ```moonscript
 try
@@ -1685,7 +1685,7 @@ catch e
 
 ## 属性
 
-月之脚本现在提供了Lua 5.4新增的叫做属性的语法支持。在月之脚本编译到的Lua目标版本低于5.4时，你仍然可以同时使用`const`和`close`的属性声明语法，并获得常量检查和作用域回调的功能。
+月之脚本现在提供了 Lua 5.4 新增的叫做属性的语法支持。在月之脚本编译到的 Lua 目标版本低于 5.4 时，你仍然可以同时使用`const` 和 `close` 的属性声明语法，并获得常量检查和作用域回调的功能。
 
 ```moonscript
 const a = 123
@@ -1726,9 +1726,9 @@ global const Constant = 123
 
 ## 字面量
 
-Lua中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和**nil**。
+Lua 中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和 **nil**。
 
-但与Lua不同的是，单引号和双引号字符串内部允许有换行：
+但与 Lua 不同的是，单引号和双引号字符串内部允许有换行：
 
 ```moonscript
 some_string = "这是一个字符串
@@ -1927,7 +1927,7 @@ print "数字的和是", sum 10, 20
 </pre>
 </YueDisplay>
 
-如果你需要做显式返回，可以使用return关键字：
+如果你需要做显式返回，可以使用 return 关键字：
 
 ```moonscript
 sum = (x, y) -> return x + y
@@ -1953,7 +1953,7 @@ a, b = mystery 10, 20
 
 ### 粗箭头
 
-因为在Lua中调用方法时，经常习惯将对象作为第一个参数传入，所以月之脚本提供了一种特殊的语法来创建自动包含self参数的函数。
+因为在 Lua 中调用方法时，经常习惯将对象作为第一个参数传入，所以月之脚本提供了一种特殊的语法来创建自动包含 self 参数的函数。
 
 ```moonscript
 func = (num) => @value + num
@@ -1966,7 +1966,7 @@ func = (num) => @value + num
 
 ### 参数默认值
 
-可以为函数的参数提供默认值。如果参数的值为nil，则确定该参数为空。任何具有默认值的nil参数在函数体运行之前都会被替换。
+可以为函数的参数提供默认值。如果参数的值为 nil，则确定该参数为空。任何具有默认值的 nil 参数在函数体运行之前都会被替换。
 
 ```moonscript
 my_function = (name = "某物", height = 100) ->
@@ -2038,7 +2038,7 @@ my_func 5, 6, 7,
 </pre>
 </YueDisplay>
 
-因为Lua表也使用逗号作为分隔符，这种缩进语法有助于让值成为参数列表的一部分，而不是Lua表的一部分。
+因为 Lua 表也使用逗号作为分隔符，这种缩进语法有助于让值成为参数列表的一部分，而不是 Lua 表的一部分。
 
 ```moonscript
 x = [
@@ -2252,7 +2252,7 @@ print result, msg
 
 ## 表格字面量
 
-和Lua一样，表格可以通过花括号进行定义。
+和 Lua 一样，表格可以通过花括号进行定义。
 
 ```moonscript
 some_values = [1, 2, 3, 4]
@@ -2335,7 +2335,7 @@ y = type: "狗", legs: 4, tails: 1
 </pre>
 </YueDisplay>
 
-表格字面量的键可以使用Lua语言的关键字，而无需转义：
+表格字面量的键可以使用 Lua 语言的关键字，而无需转义：
 
 ```moonscript
 tbl = {
@@ -2371,7 +2371,7 @@ print_table :hair, :height
 </pre>
 </YueDisplay>
 
-如果你希望表中字段的键是某个表达式的结果，那么可以用 **[ ]** 包裹它，就像在Lua中一样。如果键中有任何特殊字符，也可以直接使用字符串字面量作为键，省略方括号。
+如果你希望表中字段的键是某个表达式的结果，那么可以用 **[ ]** 包裹它，就像在 Lua 中一样。如果键中有任何特殊字符，也可以直接使用字符串字面量作为键，省略方括号。
 
 ```moonscript
 t = {
@@ -2388,7 +2388,7 @@ t = {
 </pre>
 </YueDisplay>
 
-Lua的表同时具有数组部分和哈希部分，但有时候你会希望在书写Lua表时，对Lua表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
+Lua 的表同时具有数组部分和哈希部分，但有时候你会希望在书写 Lua 表时，对 Lua 表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
 
 ```moonscript
 some_values = [ 1, 2, 3, 4 ]
@@ -2403,11 +2403,11 @@ list_with_one_element = [ 1, ]
 
 ## 推导式
 
-推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生Lua表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
+推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生 Lua 表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
 
 ### 列表推导式
 
-以下操作创建了一个items表的副本，但所有包含的值都翻倍了。
+以下操作创建了一个 items 表的副本，但所有包含的值都翻倍了。
 
 ```moonscript
 items = [1, 2, 3, 4]
@@ -2420,7 +2420,7 @@ doubled = [item * 2 for i, item in ipairs items]
 </pre>
 </YueDisplay>
 
-可以使用when子句筛选新表中包含的项目：
+可以使用 `when` 子句筛选新表中包含的项目：
 
 ```moonscript
 slice = [item for i, item in ipairs items when i > 1 and i < 3]
@@ -2431,7 +2431,7 @@ slice = [item for i, item in ipairs items when i > 1 and i < 3]
 </pre>
 </YueDisplay>
 
-因为我们常常需要迭代数值索引表的值，所以引入了 **\*** 操作符来做语法简化。doubled示例可以重写为：
+因为我们常常需要迭代数值索引表的值，所以引入了 **\*** 操作符来做语法简化。doubled 示例可以重写为：
 
 ```moonscript
 doubled = [item * 2 for item in *items]
@@ -2463,9 +2463,9 @@ flat = [...v for k,v in pairs data]
 </pre>
 </YueDisplay>
 
-for和when子句可以根据需要进行链式操作。唯一的要求是推导式中至少要有一个for子句。
+for 和 when 子句可以根据需要进行链式操作。唯一的要求是推导式中至少要有一个 for 子句。
 
-使用多个for子句与使用多重循环的效果相同：
+使用多个 for 子句与使用多重循环的效果相同：
 
 ```moonscript
 x_coords = [4, 5, 6, 7]
@@ -2484,7 +2484,7 @@ for y in *y_coords]
 </pre>
 </YueDisplay>
 
-在推导式中也可以使用简单的数值for循环：
+在推导式中也可以使用简单的数值 for 循环：
 
 ```moonscript
 evens = [i for i = 1, 100 when i % 2 == 0]
@@ -2499,7 +2499,7 @@ evens = [i for i = 1, 100 when i % 2 == 0]
 
 表格推导式和列表推导式的语法非常相似，只是要使用 **{** 和 **}** 并从每次迭代中取两个值。
 
-以下示例生成了表格thing的副本：
+以下示例生成了表格 thing 的副本：
 
 ```moonscript
 thing = {
@@ -2561,9 +2561,9 @@ tbl = {unpack tuple for tuple in *tuples}
 
 ### 切片
 
-当使用 **\*** 操作符时，月之脚本还提供了一种特殊的语法来限制要遍历的列表范围。这个语法也相当于在for循环中设置迭代边界和步长。
+当使用 **\*** 操作符时，月之脚本还提供了一种特殊的语法来限制要遍历的列表范围。这个语法也相当于在 for 循环中设置迭代边界和步长。
 
-下面的案例中，我们在切片中设置最小和最大边界，取索引在1到5之间（包括1和5）的所有项目：
+下面的案例中，我们在切片中设置最小和最大边界，取索引在 1 到 5 之间（包括 1 和 5）的所有项目：
 
 ```moonscript
 slice = [item for item in *items[1, 5]]
@@ -2585,7 +2585,7 @@ slice = [item for item in *items[2,]]
 </pre>
 </YueDisplay>
 
-如果省略了最小边界，便默认会设置为1。这里我们只提供一个步长，并留下其他边界为空。这样会使得代码取出所有奇数索引的项目：(1, 3, 5, …)
+如果省略了最小边界，便默认会设置为 1。这里我们只提供一个步长，并留下其他边界为空。这样会使得代码取出所有奇数索引的项目：(1, 3, 5, …)
 
 ```moonscript
 slice = [item for item in *items[,,2]]
@@ -2638,7 +2638,7 @@ sub_list = items[2, 4]
 
 ## for 循环
 
-Lua中有两种for循环形式，数字型和通用型：
+Lua 中有两种 for 循环形式，数字型和通用型：
 
 ```moonscript
 for i = 10, 20
@@ -2691,7 +2691,7 @@ for j = 1, 10, 3 do print j
 </pre>
 </YueDisplay>
 
-for循环也可以用作表达式。for循环主体中的最后一条语句会被强制转换为一个返回值的表达式，并会将表达式计算结果的值追加到一个作为结果的数组表中。
+for 循环也可以用作表达式。for 循环主体中的最后一条语句会被强制转换为一个返回值的表达式，并会将表达式计算结果的值追加到一个作为结果的数组表中。
 
 将每个偶数加倍：
 
@@ -2712,9 +2712,9 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
 
-此外，for循环还支持带返回值的break语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
+此外，for 循环还支持带返回值的 break 语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
 
-例如，查找第一个大于10的数字：
+例如，查找第一个大于 10 的数字：
 
 ```moonscript
 first_large = for n in *numbers
@@ -2727,9 +2727,9 @@ first_large = for n in *numbers
 </pre>
 </YueDisplay>
 
-你还可以结合for循环表达式与continue语句来过滤值。
+你还可以结合 for 循环表达式与 continue 语句来过滤值。
 
-注意出现在函数体末尾的for循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加for循环表达式。
+注意出现在函数体末尾的 for 循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回 nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加 for 循环表达式。
 
 ```moonscript
 func_a = -> for i = 1, 10 do print i
@@ -2752,7 +2752,7 @@ print func_b! -- 打印 table 对象
 
 ## repeat 循环
 
-repeat循环是从Lua语言中搬过来的相似语法：
+repeat 循环是从 Lua 语言中搬过来的相似语法：
 
 ```moonscript
 i = 10
@@ -2773,7 +2773,7 @@ until i == 0
 
 ## while 循环
 
-在月之脚本中的while循环有四种写法：
+在月之脚本中的 while 循环有四种写法：
 
 ```moonscript
 i = 10
@@ -2812,7 +2812,7 @@ until running == false do my_function!
 </pre>
 </YueDisplay>
 
-像for循环的语法一样，while循环也可以作为一个表达式使用。为了使函数返回while循环的累积列表值，必须明确使用返回语句返回while循环表达式。
+像 for 循环的语法一样，while 循环也可以作为一个表达式使用。为了使函数返回 while 循环的累积列表值，必须明确使用返回语句返回 while 循环表达式。
 
 ## 继续
 
@@ -2930,13 +2930,14 @@ print message -- 打印: 我很高
 </pre>
 </YueDisplay>
 
-if的反义词是unless（相当于if not，如果 vs 除非）：
+if 的反义词是 unless（相当于 if not，正如“如果”对应“除非”）：
 
 ```moonscript
 unless os.date("%A") == "Monday"
   print "今天不是星期一！"
 ```
 <YueDisplay>
+
 <pre>
 unless os.date("%A") == "Monday"
   print "今天不是星期一！"
@@ -2988,7 +2989,7 @@ print "你很幸运!" unless math.random! > 0.1
 
 ## 代码行修饰符
 
-为了方便编写代码，循环语句和if语句可以应用于单行代码语句的末尾：
+为了方便编写代码，循环语句和 if 语句可以应用于单行代码语句的末尾：
 
 ```moonscript
 print "你好，世界" if name == "Rob"
@@ -2999,7 +3000,7 @@ print "你好，世界" if name == "Rob"
 </pre>
 </YueDisplay>
 
-修饰for循环的示例：
+修饰 for 循环的示例：
 
 ```moonscript
 print "项目: ", item for item in *items
@@ -3010,7 +3011,7 @@ print "项目: ", item for item in *items
 </pre>
 </YueDisplay>
 
-修饰while循环的示例：
+修饰 while 循环的示例：
 
 ```moonscript
 game\update! while game\isRunning!
@@ -3027,7 +3028,7 @@ reader\parse_line! until reader\eof!
 
 ## switch 语句
 
-switch语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和if语句一样，switch语句在最后可以接一个else代码块来处理没有匹配的情况。在生成的Lua代码中，进行比较是使用==操作符完成的。switch语句中也可以使用赋值表达式来储存临时变量值。
+switch 语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和 if 语句一样，switch 语句在最后可以接一个 else 代码块来处理没有匹配的情况。在生成的 Lua 代码中，进行比较是使用 == 操作符完成的。switch 语句中也可以使用赋值表达式来储存临时变量值。
 
 ```moonscript
 switch name := "Dan"
@@ -3050,9 +3051,9 @@ switch name := "Dan"
 </pre>
 </YueDisplay>
 
-switch语句的when子句中可以通过使用逗号分隔的列表来匹配多个值。
+switch 语句的 when 子句中可以通过使用逗号分隔的列表来匹配多个值。
 
-switch语句也可以作为表达式使用，下面我们可以将switch语句返回的结果分配给一个变量：
+switch 语句也可以作为表达式使用，下面我们可以将 switch 语句返回的结果分配给一个变量：
 
 ```moonscript
 b = 1
@@ -3077,7 +3078,7 @@ next_number = switch b
 </pre>
 </YueDisplay>
 
-我们可以使用then关键字在when子句的同一行上编写处理代码。else代码块的后续代码中要写在同一行上不需要额外的关键字。
+我们可以使用 then 关键字在 when 子句的同一行上编写处理代码。else 代码块的后续代码中要写在同一行上不需要额外的关键字。
 
 ```moonscript
 msg = switch math.random(1, 5)
@@ -3094,7 +3095,7 @@ msg = switch math.random(1, 5)
 </pre>
 </YueDisplay>
 
-如果在编写switch语句时希望少写一个缩进，那么你可以把第一个when子句放在switch开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
+如果在编写 switch 语句时希望少写一个缩进，那么你可以把第一个 when 子句放在 switch 开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
 
 ```moonscript
 switch math.random(1, 5)
@@ -3123,11 +3124,11 @@ else
 </pre>
 </YueDisplay>
 
-值得注意的是，在生成Lua代码时，我们要做检查的目标变量会放在==表达式的右侧。当你希望给when子句的比较对象定义一个\_\_eq元方法来重载判断逻辑时，可能会有用。
+值得注意的是，在生成 Lua 代码时，我们要做检查的目标变量会放在 == 表达式的右侧。当你希望给 when 子句的比较对象定义一个 \_\_eq 元方法来重载判断逻辑时，可能会有用。
 
 ### 表格匹配
 
-在switch的when子句中，如果期待检查目标是一个表格，且可以通过特定的结构进行解构并获得非nil值，那么你可以尝试使用表格匹配的语法。
+在 switch 的 when 子句中，如果期待检查目标是一个表格，且可以通过特定的结构进行解构并获得非 nil 值，那么你可以尝试使用表格匹配的语法。
 
 ```moonscript
 items =
@@ -3302,7 +3303,7 @@ switch segments
 
 ## 面向对象编程
 
-在以下的示例中，月之脚本生成的Lua代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看Lua代码。
+在以下的示例中，月之脚本生成的 Lua 代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看 Lua 代码。
 
 一个简单的类：
 
@@ -3331,11 +3332,11 @@ class Inventory
 </pre>
 </YueDisplay>
 
-在月之脚本中采用面向对象的编程方式时，通常会使用类声明语句结合Lua表格字面量来做类定义。这个类的定义包含了它的所有方法和属性。在这种结构中，键名为“new”的成员扮演了一个重要的角色，是作为构造函数来使用。
+在月之脚本中采用面向对象的编程方式时，通常会使用类声明语句结合 Lua 表格字面量来做类定义。这个类的定义包含了它的所有方法和属性。在这种结构中，键名为 “new” 的成员扮演了一个重要的角色，是作为构造函数来使用。
 
-值得注意的是，类中的方法都采用了粗箭头函数语法。当在类的实例上调用方法时，该实例会自动作为第一个参数被传入，因此粗箭头函数用于生成一个名为“self”的参数。
+值得注意的是，类中的方法都采用了粗箭头函数语法。当在类的实例上调用方法时，该实例会自动作为第一个参数被传入，因此粗箭头函数用于生成一个名为 “self” 的参数。
 
-此外，“@”前缀在变量名上起到了简化作用，代表“self”。例如，`@items` 就等同于 `self.items`。
+此外，“@” 前缀在变量名上起到了简化作用，代表 “self”。例如，`@items` 就等同于 `self.items`。
 
 为了创建类的一个新实例，可以将类名当作一个函数来调用，这样就可以生成并返回一个新的实例。
 
@@ -3357,7 +3358,7 @@ inv\add_item "pants"
 
 需要特别注意的是，类的所有属性在其实例之间是共享的。这对于函数类型的成员属性通常不会造成问题，但对于其他类型的属性，可能会导致意外的结果。
 
-例如，在下面的示例中，clothes属性在所有实例之间共享。因此，对这个属性在一个实例中的修改，将会影响到其他所有实例。
+例如，在下面的示例中，clothes 属性在所有实例之间共享。因此，对这个属性在一个实例中的修改，将会影响到其他所有实例。
 
 ```moonscript
 class Person
@@ -3409,7 +3410,7 @@ class Person
 
 ### 继承
 
-`extends`关键字可以在类声明中使用，以继承另一个类的属性和方法。
+`extends` 关键字可以在类声明中使用，以继承另一个类的属性和方法。
 
 ```moonscript
 class BackPack extends Inventory
@@ -3429,11 +3430,11 @@ class BackPack extends Inventory
 </YueDisplay>
 
 
-在这一部分，我们对月之脚本中的`Inventory`类进行了扩展，加入了对可以携带物品数量的限制。
+在这一部分，我们对月之脚本中的 `Inventory` 类进行了扩展，加入了对可以携带物品数量的限制。
 
-在这个特定的例子中，子类并没有定义自己的构造函数。因此，当创建一个新的实例时，系统会默认调用父类的构造函数。但如果我们在子类中定义了构造函数，我们可以利用`super`方法来调用并执行父类的构造函数。
+在这个特定的例子中，子类并没有定义自己的构造函数。因此，当创建一个新的实例时，系统会默认调用父类的构造函数。但如果我们在子类中定义了构造函数，我们可以利用 `super` 方法来调用并执行父类的构造函数。
 
-此外，当一个类继承自另一个类时，它会尝试调用父类上的`__inherited`方法（如果这个方法存在的话），以此来向父类发送通知。这个`__inherited`函数接受两个参数：被继承的父类和继承的子类。
+此外，当一个类继承自另一个类时，它会尝试调用父类上的 `__inherited` 方法（如果这个方法存在的话），以此来向父类发送通知。这个 `__inherited` 函数接受两个参数：被继承的父类和继承的子类。
 
 ```moonscript
 class Shelf
@@ -3456,15 +3457,15 @@ class Cupboard extends Shelf
 
 ### super 关键字
 
-`super`是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
+`super` 是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
 
-当`super`被作为一个函数调用时，它将调用父类中与之同名的函数。此时，当前的`self`会自动作为第一个参数传递，正如上面提到的继承示例所展示的那样。
+当 `super` 被作为一个函数调用时，它将调用父类中与之同名的函数。此时，当前的 `self` 会自动作为第一个参数传递，正如上面提到的继承示例所展示的那样。
 
-在将`super`当作普通值使用时，它实际上是对父类对象的引用。通过这种方式，我们可以访问父类中可能被子类覆盖的值，就像访问任何普通对象一样。
+在将 `super` 当作普通值使用时，它实际上是对父类对象的引用。通过这种方式，我们可以访问父类中可能被子类覆盖的值，就像访问任何普通对象一样。
 
-此外，当使用`\`操作符与`super`一起使用时，`self`将被插入为第一个参数，而不是使用`super`本身的值。而在使用`.`操作符来检索函数时，则会返回父类中的原始函数。
+此外，当使用 `\` 操作符与 `super` 一起使用时，`self`将被插入为第一个参数，而不是使用 `super` 本身的值。而在使用`.`操作符来检索函数时，则会返回父类中的原始函数。
 
-下面是一些使用`super`的不同方法的示例：
+下面是一些使用 `super` 的不同方法的示例：
 
 ```moonscript
 class MyClass extends ParentClass
@@ -3523,9 +3524,9 @@ print BackPack.size -- 打印 10
 
 如果在类对象的元表中找不到某个属性，系统会从基表中检索该属性。这就意味着我们可以直接从类本身访问到其方法和属性。
 
-需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的“__base”字段。
+需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的 “__base” 字段。
 
-此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的“__name”字段中。
+此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的 “__name” 字段中。
 
 ```moonscript
 print BackPack.__name -- 打印 Backpack
@@ -3607,7 +3608,7 @@ print Counter.count -- 输出 2
 
 ### 类声明语句
 
-在类声明的主体中，除了键/值对外，我们还可以编写普通的表达式。在这种类声明体中的普通代码的上下文中，self等于类对象，而不是实例对象。
+在类声明的主体中，除了键/值对外，我们还可以编写普通的表达式。在这种类声明体中的普通代码的上下文中，self 等于类对象，而不是实例对象。
 
 以下是创建类变量的另一种方法：
 
@@ -3647,9 +3648,9 @@ class MoreThings
 
 ### @ 和 @@ 值
 
-当@和@@前缀在一个名字前时，它们分别代表在self和self.\_\_class中访问的那个名字。
+当 @ 和 @@ 前缀在一个名字前时，它们分别代表在 self 和 self.\_\_class 中访问的那个名字。
 
-如果它们单独使用，它们是self和self.\_\_class的别名。
+如果它们单独使用，它们是 self 和 self.\_\_class 的别名。
 
 ```moonscript
 assert @ == self
@@ -3662,7 +3663,7 @@ assert @@ == self.__class
 </pre>
 </YueDisplay>
 
-例如，使用@@从实例方法快速创建同一类的新实例的方法：
+例如，使用 @@ 从实例方法快速创建同一类的新实例的方法：
 
 ```moonscript
 some_instance_method = (...) => @@ ...
@@ -3740,7 +3741,7 @@ x = class Bucket
 
 ### 匿名类
 
-声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name属性将为nil。如果出现在赋值语句中，赋值操作左侧的名称将代替nil。
+声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name 属性将为 nil。如果出现在赋值语句中，赋值操作左侧的名称将代替 nil。
 
 ```moonscript
 BigBucket = class extends Bucket
@@ -3811,11 +3812,11 @@ assert y.__class.__parent ~= X -- X 不是 Y 的父类
 
 ## with 语句
 
-在编写Lua代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
+在编写 Lua 代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
 
 这导致在代码中多次重复引用对象的名称，增加了不必要的文本噪音。一个常见的解决方案是在创建对象时，在构造函数传入一个表，该表包含要覆盖设置的键和值的集合。这样做的缺点是该对象的构造函数必须支持这种初始化形式。
 
-with块有助于简化编写这样的代码。在with块内，我们可以使用以.或\开头的特殊语句，这些语句代表我们正在使用的对象的操作。
+with 块有助于简化编写这样的代码。在 with 块内，我们可以使用以 . 或 \ 开头的特殊语句，这些语句代表我们正在使用的对象的操作。
 
 例如，我们可以这样处理一个新创建的对象：
 
@@ -3836,7 +3837,7 @@ with Person!
 </pre>
 </YueDisplay>
 
-with语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
+with 语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
 
 ```moonscript
 file = with File "favorite_foods.txt"
@@ -3870,9 +3871,9 @@ me = create_person "Leaf", [dad, mother, sister]
 </pre>
 </YueDisplay>
 
-在此用法中，with可以被视为K组合子（k-combinator）的一种特殊形式。
+在此用法中，with 可以被视为K组合子（k-combinator）的一种特殊形式。
 
-如果你想给表达式另外起一个名称的话，with语句中的表达式也可以是一个赋值语句。
+如果你想给表达式另外起一个名称的话，with 语句中的表达式也可以是一个赋值语句。
 
 ```moonscript
 with str := "你好"
@@ -3925,7 +3926,7 @@ with? obj
 
 ## do 语句
 
-当用作语句时，do语句的作用就像在Lua中差不多。
+当用作语句时，do 语句的作用就像在 Lua 中差不多。
 
 ```moonscript
 do
@@ -3942,7 +3943,7 @@ print var -- 这里是nil
 </pre>
 </YueDisplay>
 
-月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将do语句代码块的最后一个语句作为表达式返回的结果。
+月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将 do 语句代码块的最后一个语句作为表达式返回的结果。
 
 ```moonscript
 counter = do
@@ -4126,7 +4127,7 @@ print i, k -- 这些已经被更新
 
 ## 月之脚本语言库
 
-使用`require("yue")`来访问。
+使用 `require("yue")` 来访问。
 
 ### yue
 
-- 
cgit v1.2.3-55-g6feb