feat: 校对脚本章节

Author: Myriad-Dreamin

src/tutorial/scripting-composite.typ

@@ -8,53 +8,53 @@
 
 脚本模式中有两类核心复合字面量。一曰「数组」，一曰「字典」。
 
-「数组」是按照顺序存储的一些「值」，你可以在「数组」中存放*任意内容*而不拘泥于类型。你可以使用圆括号与一个逗号分隔的列表创建一个*数组字面量*：
+「数组」是按照顺序存储的一些「值」，你可以在「数组」中存放*任意内容*而不受类型限制。你可以使用圆括号与一个逗号分隔的列表创建一个*数组字面量*：
 
 #code(```typ
 #(1, "OvO", [一段内容])
 ```)
 
 == 字典字面量 <grammar-dict-literal>
 
-所谓「字典」即是「键值对」的集合，其每一项是由冒号分隔的「键值对」。如下例所示，冒号左侧，“neco-mimi”等「标识符」或「字符串」是字典的「键」，而冒号右侧分别是对应的「值」。
+所谓「字典」即是「键值对」的集合，其每一项是由冒号分隔的「键值对」。如下例所示，冒号左侧，“neko-mimi”等「标识符」或「字符串」是字典的「键」，而冒号右侧分别是对应的「值」。
 
 #code(```typ
 #(neko-mimi: 2, "utterance": "喵喵喵")
 ```)
 
 == 数组和字典的典型构造
 
-特别讲解一些关于数组与字典相关的典型构造：
+下面特别讲解一些与数组和字典相关的典型构造：
 
 #code(```typ
 #() \ // 是空的数组
 #(:) \ // 是空的字典
 #(1) \ // 被括号包裹的整数1
 #(()) \ // 被括号包裹的空数组
-#((())) \ // 被括号包裹的被括号包裹的空数组
+#((())) \ // 被两层括号包裹的空数组
 #(1,) \ // 是含有一个元素的数组
 ```)
 
 `()`是空的数组<grammar-empty-array>，不含任何值。`(:)`是空的字典<grammar-empty-dict>，不含任何键值对。
 
 如果括号内含了一个值，例如`(1)`，那么它仅仅是被括号包裹的整数1，仍然是整数1本身。
 
-类似的，`(())`是被括号包裹的空数组<grammar-paren-empty-array>，`((()))`是被括号包裹的被括号包裹的空数组。
+类似地，`(())`是被括号包裹的空数组<grammar-paren-empty-array>，`((()))`是被两层括号包裹的空数组。
 
 为了构建含有一个元素的数组，需要在列表末尾额外放置一个逗号以示区分，例如`(1,)`。<grammar-single-member-array>
 
 // https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Trailing_commas
-这种逗号被称为尾后逗号。
+这种逗号被称为尾随逗号。
 
 // todo: 改进
-构造数组字面量时，允许尾随一个多余的逗号而不造成影响。
+构造数组字面量时，允许在末尾保留一个多余的逗号而不造成影响。
 
 #code(```typ
 #let x = (1, "OvO", [一段内容] , ); #x
 //          这里有一个多余的逗号^^^
 ```)
 
-构造字典字面量时，允许尾随一个多余的逗号。
+构造字典字面量时，也允许在末尾保留一个多余的逗号。
 
 #code(```typ
 #let cat = (attribute: [kawaii\~], ); #cat
@@ -65,22 +65,22 @@
 
 这是本节最难的内容，非程序员朋友想要灵活运用可能有点困难。
 
-除了使用字面量「构造」元素，Typst还支持「构造」的反向操作：「解构赋值」。顾名思义，你可以在左侧用相似的语法从数组<grammar-destruct-array>或字典中获取值并赋值到*对应*的变量上。<grammar-destruct-dict>
+除了使用字面量「构造」元素，Typst还支持「构造」的反向操作：「解构赋值」。顾名思义，你可以在左侧使用相似的语法从数组<grammar-destruct-array>或字典中获取值，并赋值到*对应*的变量上。<grammar-destruct-dict>
 
 #code(```typ
 #let (attr: a) = (attr: [kawaii\~])
 #a
 ```)
 
-「解构赋值」必须一一对应，但你也可以使用「占位符」（`_`）或「延展符」（`..`）以作*部分*解构：<grammar-destruct-array-eliminate>
+「解构赋值」必须一一对应，但你也可以使用「占位符」（`_`）或「延展符」（`..`）做*部分*解构：<grammar-destruct-array-eliminate>
 
 #code(```typ
 #let (first, ..) = (1, 2, 3)
 #let (.., second-last, _) = (7, 8, 9, 10)
 #first, #second-last
 ```)
 
-数组的「解构赋值」有一个妙用，那就是重映射内容。<grammar-array-remapping>
+数组的「解构赋值」有一个妙用，那就是重映射变量。<grammar-array-remapping>
 
 #code(```typ
 #let (a, b, c) = (1, 2, 3)
@@ -96,7 +96,7 @@
 
 == 数组和字典的成员访问
 
-为了访问数组，你可以使用`at`方法。“at”在中文里是“在”的意思，它表示对「数组」使用「索引」操作。`at(0)`索引到第1个值，`at(n)`索引到第 $n + 1$ 个值，以此类推。如下所示：
+要访问数组元素，你可以使用`at`方法。“at”在中文里是“在”的意思，它表示对「数组」使用「索引」操作。`at(0)`索引到第1个值，`at(n)`索引到第 $n + 1$ 个值，以此类推。如下所示：
 
 #code(```typ
 #let x = (1, "OvO", [一段内容])
@@ -105,14 +105,14 @@
 
 至于「索引」从零开始的原因，这只是约定俗成。等你习惯了，你也会变成计数从零开始的好程序员。
 
-为了访问字典，你可以使用`at`方法。但由于「键」都是字符串，你需要使用字符串作为字典的「索引」。
+要访问字典中的值，你可以使用`at`方法。但由于「键」都是字符串，你需要使用字符串作为字典的「索引」。
 
 #code(```typ
 #let cat = (attribute: [kawaii\~])
 #cat.at("attribute")
 ```)
 
-为了方便，Typst允许你直接通过成员方法访问字典对应「键」的值： <grammar-dict-member-exp>
+为了方便，Typst允许你直接通过成员语法访问字典对应「键」的值： <grammar-dict-member-exp>
 
 #code(```typ
 #let cat = ("attribute": [kawaii\~])
@@ -121,28 +121,28 @@
 
 == 数组和字典的「存在谓词」
 
-为了访问数组，你可以使用`contains`方法。“contain”在中文里是“包含”的意思，如下所示：
+要判断数组中是否包含某个值，你可以使用`contains`方法。“contain”在中文里是“包含”的意思，如下所示：
 
 #code(```typ
 #let x = (1, "OvO", [一段内容])
 #x.contains[一段内容]
 ```)
 
-因为这太常用了，typst专门提供了`in`语法，表示判断`x`是否*存在于*某个数组中：<grammar-array-in>
+因为这太常用了，Typst专门提供了`in`语法，表示判断`x`是否*存在于*某个数组中：<grammar-array-in>
 
 #code(```typ
 #([一段内容] in (1, "OvO", [一段内容])) \
 #([另一段内容] in (1, "OvO", [一段内容]))
 ```)
 
-字典也可以使用此语法，表示判断`x`是否是字典的一个「键」。特别地，你还可以前置一个`not`判断`x`是否*不在*某个数组或字典中：<grammar-dict-in>
+字典也可以使用此语法，表示判断`x`是否是字典的一个「键」。特别地，你还可以在前面加一个`not`，判断`x`是否*不在*某个数组或字典中：<grammar-dict-in>
 
 #code(```typ
 #let cat = (neko-mimi: 2)
 #("neko-kiki" not in cat)
 ```)
 
-注意：`x in (...)`与`"x" in (...)`是不同的。例如`neko-mimi in cat`将检查`neko-mimi`变量的内容是否是字典变量`cat`的一个「键」，而`"neko-mimi"`检查对应字符串是否在其中。
+注意：`x in (...)`与`"x" in (...)`是不同的。例如`neko-mimi in cat`将检查`neko-mimi`变量的内容是否是字典变量`cat`的一个「键」，而`"neko-mimi" in cat`则检查对应字符串是否在其中。
 
 // field access
 // - dictionary
@@ -152,7 +152,7 @@
 
 == 位置参数声明 <grammar-positional-param>
 
-typst通过数组和字典在执行时向函数传递参数。上一节我们学会了基本的函数声明，若进一步理解了数组和字典，可以定义更复杂的函数。接下来我们讲透Typst中如何声明复杂函数，以及如何调用函数。
+Typst通过数组和字典的形式在执行时向函数传递参数。上一章我们学会了基本的函数声明，若进一步理解了数组和字典，就可以定义更复杂的函数。接下来我们讲讲Typst中如何声明复杂函数，以及如何调用函数。
 
 其中最简单的是位置参数声明，我们在上节已经学过。
 
@@ -161,11 +161,11 @@ typst通过数组和字典在执行时向函数传递参数。上一节我们学
 #f(1, 2)
 ```)
 
-在函数调用的时候，位置参数必须按照声明的顺序传递。例子中，向`f`函数传递了两个位置参数`1`和`2`，于是`a`和`b`作为变量被赋值为了`1`和`2`，接着这个函数返回一个「内容块」，其中用到了`a`和`b`变量。
+在函数调用的时候，位置参数必须按照声明的顺序传递。例子中，向`f`函数传递了两个位置参数`1`和`2`，于是`a`和`b`作为变量被赋值为`1`和`2`，接着这个函数返回一个「内容块」，其中用到了`a`和`b`变量。
 
 == 具名参数声明 <grammar-named-param>
 
-函数可以包含「具名参数」，其看起来就像字典的一项，冒号右侧则是参数的*默认值*：
+函数可以包含「具名参数」，看起来就像字典的一项，冒号右侧则是参数的*默认值*：
 
 #code(```typ
 #let g(name: "？") = [你是#name]
@@ -187,7 +187,7 @@ typst通过数组和字典在执行时向函数传递参数。上一节我们学
 
 == 参数类型 <grammar-param-literal>
 
-什么是「参数类型」（argument type）？在typst中，你完全可以先把函数参数准备好，然后直接调用函数：
+什么是「参数类型」（argument type）？在Typst中，你完全可以先把函数参数准备好，然后直接调用函数：
 
 #code(```typ
 #let sum(..args, init: 0) = init + args.pos().sum()
@@ -197,7 +197,7 @@ typst通过数组和字典在执行时向函数传递参数。上一节我们学
 
 `arguments`是一个类型，`arguments(1, 2)`是一个表达式，它返回一个`arguments`类型的值。
 
-也可以预先传递参数，然后直接调用函数：
+也可以预先准备参数，然后直接调用函数：
 
 #code(```typ
 #let sum(..args, init: 0) = init + args.pos().sum()
@@ -241,7 +241,7 @@ typst通过数组和字典在执行时向函数传递参数。上一节我们学
 #first-and-last(("开头", "中间", "结尾"))
 ```)
 
-如果你希望保留字典中剩下的项目，也可以把`..`后接一个变量名：
+如果你希望保留字典中剩下的项目，也可以在`..`后接一个变量名：
 
 #code(```typ
 #let describe((name, ..other)) = [#name：#repr(other)]

src/tutorial/scripting-literal.typ

@@ -4,7 +4,7 @@
 
 Typst很快，并非因为它的#term("parser")和#term("interpreter")具有惊世的执行性能，而是语言特性本身适合缓存优化。
 
-自本节起，本教程将进入第二阶段，希望不仅让你了解如何使用脚本，还一并讲解Typst的执行原理。当然，我们不会陷入Typst的细节。所有在教程中出现的原理都是为了更好地了解语言本身。
+自本节起，本教程将进入第二阶段，希望不仅让你了解如何使用脚本，还一并讲解Typst的执行原理。当然，我们不会陷入Typst的细节。教程中出现的原理都是为了帮助你更好地理解语言本身。
 
 // 什么是自省
 // 程序不会自己自省，这是给你看的
@@ -22,7 +22,7 @@ Typst很快，并非因为它的#term("parser")和#term("interpreter")具有惊
 ```)
 
 #pro-tip[
-  #term("introspection function")是指那些为你获取解释器内部状态的函数。它们往往接受一些语言对象，而返回存储在解释器内部的相关信息。在这里，#typst-func("repr")接受任意值，而返回对应的代码表示。
+  #term("introspection function")是指那些用于获取解释器内部状态的函数。它们往往接受一些语言对象，并返回存储在解释器内部的相关信息。在这里，#typst-func("repr")接受任意值，并返回对应的代码表示。
 ]
 
 == `type`函数 <grammar-type>
@@ -84,9 +84,9 @@ Typst很快，并非因为它的#term("parser")和#term("interpreter")具有惊
 
 == 基本字面量
 
-我们将介绍所有基本字面量，这是脚本的“一加一”。其实在上一节，我们已经见过了一部分字面量，但皆凭直觉使用：```typc 1```不就是数字吗，那么在Typst中，它就是数字。与之相对，TeX底层没有数字和字符串的概念。
+我们将介绍所有基本字面量，这是脚本的“一加一”。其实在上一节，我们已经见过一部分字面量，但皆凭直觉使用：```typc 1```不就是数字吗，那么在Typst中，它就是数字。与之相对，TeX底层没有数字和字符串的概念。
 
-如果你学过Python等语言，那么这将对你来说不是问题。在Typst中，常用的字面量并不多，它们是：
+如果你学过Python等语言，那么这对你来说不是问题。在Typst中，常用的字面量并不多，它们是：
 + #term("none literal")。
 + #term("boolean literal")。
 + #term("integer literal")。
@@ -136,7 +136,7 @@ Typst很快，并非因为它的#term("parser")和#term("interpreter")具有惊
 
 === 布尔字面量
 
-一个布尔字面量表示逻辑的确否。它要么为```typc false```（真）<grammar-true-literal>要么为```typc true```（假）<grammar-false-literal>。
+一个布尔字面量表示逻辑的确否。它要么为```typc false```（假）<grammar-false-literal>，要么为```typc true```（真）<grammar-true-literal>。
 
 #code(```typ
 假设 #false 那么一切为 #true。
@@ -174,7 +174,7 @@ $1 < 2$的结果为：#(1 < 2)
 
 === 浮点数字面量 <grammar-float-literal>
 
-浮点数与整数非常类似。最常见的浮点数由至少一个整数部分或小数部分组成：
+浮点数与整数非常类似。最常见的浮点数由整数部分或小数部分组成：
 
 #code(```typ
 浮点数#(1.001)、小数部分#(.1) 和整数部分#(2.)。
@@ -236,13 +236,13 @@ Typst中所有字符串都是`utf-8`编码的，因此使用时不存在编码
 
 == 类型转换
 
-类型本身也是函数，例如`int`类型可以接受字符串，转换成整数。
+类型本身也可以当作函数使用，例如`int`类型可以接受字符串，转换成整数。
 
 #code(```typ
 #int("11"), #int("-23")
 ```)
 
-从转换的角度，`eval`可以将代码字符串转换成值。例如，你可以转换16进制数字：
+从转换的角度，`eval`可以将代码字符串转换成值。例如，你可以转换十六进制数字：
 
 #code(```typ
 #eval("0x3f")
@@ -261,7 +261,7 @@ Typst中所有字符串都是`utf-8`编码的，因此使用时不存在编码
 // 基于以上两个特性，Typst为什么快？
 
 // + Typst支持增量解析文件。
-// + Typst所有由*用户声明*的函数都是纯的，在其上的调用都是纯的。例如Typst天生支持快速计算递归实现的fibnacci函数：
+// + Typst所有由*用户声明*的函数都是纯的，在其上的调用都是纯的。例如Typst天生支持快速计算递归实现的fibonacci函数：
 
 //   #code(```typ
 //   #let fib(n) = if n <= 1 { n } else { fib(n - 1) + fib(n - 2) }
@@ -273,14 +273,14 @@ Typst中所有字符串都是`utf-8`编码的，因此使用时不存在编码
 
 #todo-box[重写总结]
 
-基于《字面量、变量和函数》掌握的知识你应该可以：
+基于本章掌握的知识，你应该可以：
 + 查看#(refs.ref-type-builtin)[《参考：内置类型》]，以掌握内置类型的使用方法。
 + 查看#(refs.ref-visualization)[《参考：图形与几何元素》]，以掌握图形和几何元素的使用方法。
-+ 查看#(refs.ref-wasm-plugin)[《参考：WASM插件》]，以掌握在Typst中使用Rust、JavaScript、Python等语言编写插件库。
++ 查看#(refs.ref-wasm-plugin)[《参考：WASM插件》]，以掌握在Typst中使用Rust、JavaScript、Python等语言编写插件库的方法。
 + 阅读#(refs.ref-grammar)[《参考：语法示例检索表》]，以检查自己的语法掌握程度。
 + 查看#(refs.ref-typebase)[《参考：基本类型》]，以掌握基本类型的使用方法。
 + 查看#(refs.ref-color)[《参考：颜色、色彩渐变与模式》]，以掌握色彩的高级管理方法。
-+ 查看#(refs.ref-data-process)[《参考：数据读写与数据处理》]，以助你从外部读取数据或将文档数据输出到文件。
++ 查看#(refs.ref-data-process)[《参考：数据读写与数据处理》]，以助你从外部读取数据或将文档数据输出到文件。
 + 查看#(refs.ref-bibliography)[《参考：导入和使用参考文献》]，以助你导入和使用参考文献。
 + 阅读基本参考部分中的所有内容。
 
@@ -366,4 +366,3 @@ Typst中所有字符串都是`utf-8`编码的，因此使用时不存在编码
 ][
   #q1
 ]
-