diff --git a/CHANGELOG.md b/CHANGELOG.md index 0fa421de7..e5a6df838 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -56,6 +56,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Removed the Programmatic API page due to frequent changes. To use the API, please refer to the compiler sources: PR [#1184](https://github.com/tact-lang/tact/pull/1184) - Added a link to the article by CertiK to Security best practices page: PR [#1185](https://github.com/tact-lang/tact/pull/1185) - Added a note on `dump()` being computationally expensive: PR [#1189](https://github.com/tact-lang/tact/pull/1189) +- Fixed links in Chinese translation: PR [#1206](https://github.com/tact-lang/tact/pull/1206) ### Release contributors diff --git a/docs/src/content/docs/zh-cn/book/bounced.mdx b/docs/src/content/docs/zh-cn/book/bounced.mdx index f9c900d2c..a41410c18 100644 --- a/docs/src/content/docs/zh-cn/book/bounced.mdx +++ b/docs/src/content/docs/zh-cn/book/bounced.mdx @@ -26,7 +26,7 @@ contract MyContract { } ``` -要手动处理被退回的信息，您可以使用回退定义，直接处理原始的 [`Slice{:tact}`](/book/cells#slices)。请注意，这样的接收器将获得由您的合约产生的**所有**被退回的信息： +要手动处理被退回的信息，您可以使用回退定义，直接处理原始的 [`Slice{:tact}`](/zh-cn/book/cells#slices)。请注意，这样的接收器将获得由您的合约产生的**所有**被退回的信息： ```tact /rawMsg: Slice/ contract MyContract { diff --git a/docs/src/content/docs/zh-cn/book/cells.mdx b/docs/src/content/docs/zh-cn/book/cells.mdx index 841856951..d1de13592 100644 --- a/docs/src/content/docs/zh-cn/book/cells.mdx +++ b/docs/src/content/docs/zh-cn/book/cells.mdx @@ -12,7 +12,7 @@ title: 细胞、建造者和切片 ### Kinds {#cells-kinds} -虽然 [TVM][tvm] 类型 [`单元格{:tact}`](#cells)指的是所有单元格，但有不同的单元格类型，其内存布局也各不相同。 前面描述的单元格（#cells）通常被称为_ordinary_（或 simple）单元格--这是最简单、最常用的单元格，只能包含数据。 绝大多数关于细胞及其用法的描述、指南和[参考文献](/ref/core-cells)都假定细胞是普通的。 +虽然 [TVM][tvm] 类型 [`单元格{:tact}`](#cells)指的是所有单元格，但有不同的单元格类型，其内存布局也各不相同。 前面描述的单元格（#cells）通常被称为_ordinary_（或 simple）单元格--这是最简单、最常用的单元格，只能包含数据。 绝大多数关于细胞及其用法的描述、指南和[参考文献](/zh-cn/ref/core-cells)都假定细胞是普通的。 其他类型的细胞统称为_外来细胞_（或特殊细胞）。 它们有时会出现在 TON 区块链上的区块和其他数据结构的实际表示中。 它们的内存布局和用途与普通电池大不相同。 @@ -21,7 +21,7 @@ title: 细胞、建造者和切片 [TVM][tvm]目前支持以下奇异细胞子类型： - [剪枝单元格][c-pruned]，子类型编码为 $1$ - 它们代表删除的单元格子树。 -- [图书馆引用单元][c-library]，子类型编码为 $2$ - 它们用于存储图书馆，通常在[masterchain](/book/masterchain)上下文中使用。 +- [图书馆引用单元][c-library]，子类型编码为 $2$ - 它们用于存储图书馆，通常在[masterchain](/zh-cn/book/masterchain)上下文中使用。 - [梅克尔证明单元][c-mproof]，子类型编码为 $3$ - 它们用于验证其他单元的树数据的某些部分是否属于完整树。 - [梅克尔更新单元][c-mupdate]，子类型编码为 $4$ - 它们总是有两个引用，对这两个引用的行为类似于[梅克尔证明][mproof]。 @@ -63,7 +63,7 @@ title: 细胞、建造者和切片 最后，为每个参考单元存储其标准表示的[SHA-256][sha-2] 哈希值，每个参考单元占用 $32$ 字节，并递归重复上述算法。 请注意，不允许循环引用单元格，因此递归总是以定义明确的方式结束。 -如果我们要计算这个单元格的标准表示的哈希值，就需要将上述步骤中的所有字节连接在一起，然后使用 [SHA-256][sha-2] 哈希值进行散列。 这是[TVM][tvm]的[`HASHCU`和`HASHSU`指令](https://docs.ton.org/learn/tvm-instructions/instructions)以及 Tact 的[`Cell.hash(){:tact}`](/ref/core-cells#cellhash)和[`Slice.hash(){:tact}`](/ref/core-cells#slicehash)函数背后的算法。 +如果我们要计算这个单元格的标准表示的哈希值，就需要将上述步骤中的所有字节连接在一起，然后使用 [SHA-256][sha-2] 哈希值进行散列。 这是[TVM][tvm]的[`HASHCU`和`HASHSU`指令](https://docs.ton.org/learn/tvm-instructions/instructions)以及 Tact 的[`Cell.hash(){:tact}`](/zh-cn/ref/core-cells#cellhash)和[`Slice.hash(){:tact}`](/zh-cn/ref/core-cells#slicehash)函数背后的算法。 #### Bag of Cells {#cells-boc} @@ -122,10 +122,10 @@ title: 细胞、建造者和切片 ## Serialization types -与 [`Int{:tact}`](/book/integers)类型的序列化选项类似，`Cell{:tact}`、`Builder{:tact}` 和`Slice{:tact}` 在以下情况下也有不同的值编码方式： +与 [`Int{:tact}`](/zh-cn/book/integers)类型的序列化选项类似，`Cell{:tact}`、`Builder{:tact}` 和`Slice{:tact}` 在以下情况下也有不同的值编码方式： -- 作为 [contracts](/book/contracts) 和 [traits](/book/types#traits) 的 [storage variables](/book/contracts#variables) 、 -- 以及 [Structs](/book/structs and-messages#structs) 和 [Messages](/book/structs and-messages#messages) 的字段。 +- 作为 [contracts](/zh-cn/book/contracts) 和 [traits](/zh-cn/book/types#traits) 的 [storage variables](/zh-cn/book/contracts#variables) 、 +- 以及 [Structs](/zh-cn/book/structs and-messages#structs) 和 [Messages](/zh-cn/book/structs and-messages#messages) 的字段。 ```tact {2-3} contract SerializationExample { @@ -201,9 +201,9 @@ receive(msg: JettonTransferNotification) { :::note - 注意，通过 `as remaining{:tact}` 序列化的单元格不能是 [可选](/book/optionals)。 也就是说，指定类似 `Cell? as remaining{:tact}`, `Builder? 作为剩余{:tact}` 或 `切片？ 剩余的{:tact}` 会导致编译错误。 + 注意，通过 `as remaining{:tact}` 序列化的单元格不能是 [可选](/zh-cn/book/optionals)。 也就是说，指定类似 `Cell? as remaining{:tact}`, `Builder? 作为剩余{:tact}` 或 `切片？ 剩余的{:tact}` 会导致编译错误。 - 另外请注意，将 `Cell{:tact}` 指定为[map](/book/maps) 值类型的 `remaining{:tact}` 会被视为错误，无法编译。 + 另外请注意，将 `Cell{:tact}` 指定为[map](/zh-cn/book/maps) 值类型的 `remaining{:tact}` 会被视为错误，无法编译。 ::: @@ -229,7 +229,7 @@ receive(msg: JettonTransferNotification) { 在 Tact 中，至少有两种构建和解析单元格的方法： -- [手动](#cnp-manually)，其中涉及积极使用[`Builder{:tact}`](#builders)、[`Slice{:tact}`](#slices)和[相关方法](/ref/core-cells)。 +- [手动](#cnp-manually)，其中涉及积极使用[`Builder{:tact}`](#builders)、[`Slice{:tact}`](#slices)和[相关方法](/zh-cn/ref/core-cells)。 - [使用结构体](#cnp-structs)，这是一种值得推荐且更加方便的方法。 #### Manually {#cnp-manually} @@ -246,30 +246,30 @@ receive(msg: JettonTransferNotification) { | [`.storeRef(cell){:tact}`][b-8] | [`Slice.loadRef(){:tact}`][s-8] | | [`.endCell(){:tact}`][b-9] | [`Slice.endParse(){:tact}`][s-9] | -[b-1]: /ref/core-cells#begincell -[b-2]: /ref/core-cells#builderstoreuint -[b-3]: /ref/core-cells#builderstoreint -[b-4]: /ref/core-cells#builderstorebool -[b-5]: /ref/core-cells#builderstoreslice -[b-6]: /ref/core-cells#builderstorecoins -[b-7]: /ref/core-cells#builderstoreaddress -[b-8]: /ref/core-cells#builderstoreref -[b-9]: /ref/core-cells#builderendcell -[s-1]: /ref/core-cells#cellbeginparse -[s-2]: /ref/core-cells#sliceloaduint -[s-3]: /ref/core-cells#sliceloadint -[s-4]: /ref/core-cells#sliceloadbool -[s-5]: /ref/core-cells#sliceloadbits -[s-6]: /ref/core-cells#sliceloadcoins -[s-7]: /ref/core-cells#sliceloadaddress -[s-8]: /ref/core-cells#sliceloadref -[s-9]: /ref/core-cells#sliceendparse +[b-1]: /zh-cn/ref/core-cells#begincell +[b-2]: /zh-cn/ref/core-cells#builderstoreuint +[b-3]: /zh-cn/ref/core-cells#builderstoreint +[b-4]: /zh-cn/ref/core-cells#builderstorebool +[b-5]: /zh-cn/ref/core-cells#builderstoreslice +[b-6]: /zh-cn/ref/core-cells#builderstorecoins +[b-7]: /zh-cn/ref/core-cells#builderstoreaddress +[b-8]: /zh-cn/ref/core-cells#builderstoreref +[b-9]: /zh-cn/ref/core-cells#builderendcell +[s-1]: /zh-cn/ref/core-cells#cellbeginparse +[s-2]: /zh-cn/ref/core-cells#sliceloaduint +[s-3]: /zh-cn/ref/core-cells#sliceloadint +[s-4]: /zh-cn/ref/core-cells#sliceloadbool +[s-5]: /zh-cn/ref/core-cells#sliceloadbits +[s-6]: /zh-cn/ref/core-cells#sliceloadcoins +[s-7]: /zh-cn/ref/core-cells#sliceloadaddress +[s-8]: /zh-cn/ref/core-cells#sliceloadref +[s-9]: /zh-cn/ref/core-cells#sliceendparse #### Using Structs {#cnp-structs} [结构][struct]和[消息][messages]几乎就是活生生的[TL-B 模式][tlb]。 也就是说，它们本质上是用可维护、可验证和用户友好的 Tact 代码表达的[TL-B 模式][tlb]。 -强烈建议使用它们及其 [方法](/book/functions#extension-function)，如 [`Struct.toCell(){:tact}`][st-tc]和 [`Struct.fromCell(){:tact}`][st-fc]，而不是手动构造和解析单元格，因为这样可以得到更多声明性和不言自明的合约。 +强烈建议使用它们及其 [方法](/zh-cn/book/functions#extension-function)，如 [`Struct.toCell(){:tact}`][st-tc]和 [`Struct.fromCell(){:tact}`][st-fc]，而不是手动构造和解析单元格，因为这样可以得到更多声明性和不言自明的合约。 [上文](#cnp-manually)的手动解析示例可以使用[Structs][struct]重新编写，如果愿意，还可以使用字段的描述性名称： @@ -313,7 +313,7 @@ fun example() { :::note[Useful links:] - [Convert serialization](/book/func#convert-serialization) + [Convert serialization](/zh-cn/book/func#convert-serialization) [`Struct.toCell(){:tact}` 在核心库中][st-tc] [`Struct.fromCell(){:tact}` 在核心库中][st-fc] [`Struct.fromSlice(){:tact}` 在核心库中][st-fs] @@ -323,12 +323,12 @@ fun example() { ::: -[st-tc]: /ref/core-cells#structtocell -[st-fc]: /ref/core-cells#structfromcell -[st-fs]: /ref/core-cells#structfromslice -[msg-tc]: /ref/core-cells#messagetocell -[msg-fc]: /ref/core-cells#messagefromcell -[msg-fs]: /ref/core-cells#messagefromslice +[st-tc]: /zh-cn/ref/core-cells#structtocell +[st-fc]: /zh-cn/ref/core-cells#structfromcell +[st-fs]: /zh-cn/ref/core-cells#structfromslice +[msg-tc]: /zh-cn/ref/core-cells#messagetocell +[msg-fc]: /zh-cn/ref/core-cells#messagefromcell +[msg-fs]: /zh-cn/ref/core-cells#messagefromslice ### Check if empty {#operations-empty} @@ -336,7 +336,7 @@ fun example() { 要检查是否有任何位，请使用[`Slice.dataEmpty(){:tact}`][s-de]。要检查是否存在引用，请使用[`Slice.refsEmpty(){:tact}`][s-re]。要同时检查这两项，请使用[`Slice.empty(){:tact}`][s-e]。 -如果[`Slice{:tact}`](#slices)不完全为空，也要抛出[exit code 9](/book/exit-codes#9)，请使用[`Slice.endParse(){:tact}`][s-ep]。 +如果[`Slice{:tact}`](#slices)不完全为空，也要抛出[exit code 9](/zh-cn/book/exit-codes#9)，请使用[`Slice.endParse(){:tact}`][s-ep]。 ```tact // 准备工作 @@ -370,8 +370,8 @@ try { :::note[Useful links:] - [`Cell.asSlice(){:tact}` 在核心库中](/ref/core-cells#cellasslice)\ - [`Builder.asSlice(){:tact}` 在核心库中](/ref/core-cells#builderasslice)\ + [`Cell.asSlice(){:tact}` 在核心库中](/zh-cn/ref/core-cells#cellasslice)\ + [`Builder.asSlice(){:tact}` 在核心库中](/zh-cn/ref/core-cells#builderasslice)\ [`Slice.dataEmpty(){:tact}` 在核心库中][s-de]\ [`Slice.refsEmpty(){:tact}` 在核心库中][s-re]\ [`Slice.empty(){:tact}` 在核心库中][s-e]\ @@ -379,10 +379,10 @@ try { ::: -[咝--咝]: /ref/core-cells#slicedataempty -[re]: /ref/core-cells#slicerefsempty -[s-e]: /ref/core-cells#sliceempty -[s-ep]: /ref/core-cells#sliceendparse +[咝--咝]: /zh-cn/ref/core-cells#slicedataempty +[re]: /zh-cn/ref/core-cells#slicerefsempty +[s-e]: /zh-cn/ref/core-cells#sliceempty +[s-ep]: /zh-cn/ref/core-cells#sliceendparse ### Check if equal {#operations-equal} @@ -424,16 +424,16 @@ let areSlicesNotEqual = aSlice.hash() != bSlice.hash(); // false :::note[Useful links:] - [核心库中的 `Cell.hash(){:tact}`](/ref/core-cells#cellhash)/ - [核心库中的 `Slice.hash(){:tact}`](/ref/core-cells#slicehash)/ + [核心库中的 `Cell.hash(){:tact}`](/zh-cn/ref/core-cells#cellhash)/ + [核心库中的 `Slice.hash(){:tact}`](/zh-cn/ref/core-cells#slicehash)/ [`=={:tact}`和`!={:tact}`][bin-eq]。 ::: -[p]: /book/types#primitive-types -[struct]: /book/structs-and-messages#structs -[message]: /book/structs-and-messages#messages -[recv]: /book/contracts#receiver-functions +[p]: /zh-cn/book/types#primitive-types +[struct]: /zh-cn/book/structs-and-messages#structs +[message]: /zh-cn/book/structs-and-messages#messages +[recv]: /zh-cn/book/contracts#receiver-functions [tvm]: https://docs.ton.org/learn/tvm-instructions/tvm-overview [tlb]: https://docs.ton.org/develop/data-formats/tl-b-language @@ -441,4 +441,4 @@ let areSlicesNotEqual = aSlice.hash() != bSlice.hash(); // false [sha-2]: https://en.wikipedia.org/wiki/SHA-2#Hash_standard [quadtree]: https://en.wikipedia.org/wiki/Quadtree -[bin-eq]: /book/operators#binary-equality +[bin-eq]: /zh-cn/book/operators#binary-equality diff --git a/docs/src/content/docs/zh-cn/book/config.mdx b/docs/src/content/docs/zh-cn/book/config.mdx index f12a4bacf..4d41ca9fc 100644 --- a/docs/src/content/docs/zh-cn/book/config.mdx +++ b/docs/src/content/docs/zh-cn/book/config.mdx @@ -144,7 +144,7 @@ title: 配置 :::note - 更多信息，请访问专用页面：[调试](/book/debug)。 + 更多信息，请访问专用页面：[调试](/zh-cn/book/debug)。 ::: @@ -152,7 +152,7 @@ title: 配置 默认为 `false{:json}`。 -如果设置为 `true{:json}`，则启用 [masterchain](/book/masterchain) 支持。 +如果设置为 `true{:json}`，则启用 [masterchain](/zh-cn/book/masterchain) 支持。 ```json filename="tact.config.json" {8,14} { @@ -177,7 +177,7 @@ title: 配置 :::note - 更多信息，请访问专用页面：[大师链](/book/masterchain)。 + 更多信息，请访问专用页面：[大师链](/zh-cn/book/masterchain)。 ::: @@ -185,7 +185,7 @@ title: 配置 默认为 `false{:json}`。 -如果设置为 `true{:json}`，则启用对 [external](/book/external) 消息接收器的支持。 +如果设置为 `true{:json}`，则启用对 [external](/zh-cn/book/external) 消息接收器的支持。 ```json filename="tact.config.json" {8,14} { @@ -210,7 +210,7 @@ title: 配置 :::note - 更多信息，请访问专用页面：[外部信息](/book/external)。 + 更多信息，请访问专用页面：[外部信息](/zh-cn/book/external)。 ::: @@ -218,7 +218,7 @@ title: 配置 默认为 `false{:json}`。 -如果设置为 `true{:json}`，则可生成带有描述合同 ABI 的 IPFS 链接的[getter](/book/contracts#getter-functions)。 +如果设置为 `true{:json}`，则可生成带有描述合同 ABI 的 IPFS 链接的[getter](/zh-cn/book/contracts#getter-functions)。 ```json filename="tact.config.json" {8,14} { @@ -243,7 +243,7 @@ title: 配置 :::note - 在专用网页上阅读更多信息：[OTP-003：自我 ABI 报告](/ref/evolution/otp-003)。 + 在专用网页上阅读更多信息：[OTP-003：自我 ABI 报告](/zh-cn/ref/evolution/otp-003)。 ::: @@ -276,7 +276,7 @@ title: 配置 :::note - 了解更多信息：[支持的接口](/book/contracts#interfaces)。 + 了解更多信息：[支持的接口](/zh-cn/book/contracts#interfaces)。 ::: diff --git a/docs/src/content/docs/zh-cn/book/constants.mdx b/docs/src/content/docs/zh-cn/book/constants.mdx index 0a378befb..b0d83935f 100644 --- a/docs/src/content/docs/zh-cn/book/constants.mdx +++ b/docs/src/content/docs/zh-cn/book/constants.mdx @@ -24,7 +24,7 @@ contract MyContract { } ``` -## 虚拟常量和抽象常量 +## 虚拟常量和抽象常量 {#virtual-and-abstract-constants} 虚拟常量是可以在特质中定义但在合约中改变的常量。 当您需要在编译时配置某些特征时，它非常有用。 让我们定义一个虚拟常量和一个抽象常量： diff --git a/docs/src/content/docs/zh-cn/book/contracts.mdx b/docs/src/content/docs/zh-cn/book/contracts.mdx index f9692c109..ff7d10718 100644 --- a/docs/src/content/docs/zh-cn/book/contracts.mdx +++ b/docs/src/content/docs/zh-cn/book/contracts.mdx @@ -2,11 +2,11 @@ title: 合同 --- -Tact 中的合约类似于流行的面向对象语言中的类，只是它们的实例部署在区块链上，不能像 [Structs and Messages](/book/structs-and-messages) 那样被传递。 +Tact 中的合约类似于流行的面向对象语言中的类，只是它们的实例部署在区块链上，不能像 [Structs and Messages](/zh-cn/book/structs-and-messages) 那样被传递。 ## Self-references {#self} -契约和[特质][trait]有一个内置的[标识符](/book/expressions#identifiers) `self{:tact}`，用于引用它们的字段（持久状态[变量](#variables)和[常量](#constants)）和方法（[内部函数](#internal-functions)）： +契约和[特质][trait]有一个内置的[标识符](/zh-cn/book/expressions#identifiers) `self{:tact}`，用于引用它们的字段（持久状态[变量](#variables)和[常量](#constants)）和方法（[内部函数](#internal-functions)）： ```tact contract Example { @@ -34,7 +34,7 @@ contract Example { ### Inherited traits, `with{:tact}` {#traits} -契约可以继承[traits][trait]的所有声明和定义，并覆盖它们的某些默认行为。除此之外，每个契约和特质都隐式继承了特殊的[`BaseTrait{:tact}` trait](/ref/core-base)。 +契约可以继承[traits][trait]的所有声明和定义，并覆盖它们的某些默认行为。除此之外，每个契约和特质都隐式继承了特殊的[`BaseTrait{:tact}` trait](/zh-cn/ref/core-base)。 要继承[trait][trait]，请在合约声明中的关键字`with{:tact}`后指定其名称。要同时继承多个特质，请在逗号分隔的列表中指定它们的名称，并在后面加上逗号。 @@ -64,15 +64,15 @@ contract Vot with Supe { } ``` -如果在特质中声明或定义了内部函数和常量，则可将其标记为[虚拟或抽象](/book/functions#virtual-and-abstract-functions)，并在从特质继承的合约中重写。 +如果在特质中声明或定义了内部函数和常量，则可将其标记为[虚拟或抽象](/zh-cn/book/functions#virtual-and-abstract-functions)，并在从特质继承的合约中重写。 ### Supported interfaces, `@interface(…)` {#interfaces} 如果不查看源代码，就很难弄清一个合约是做什么的，有哪些[接收器](#receiver-functions)和[获取器](#getter-functions)。有时，无法获得或无法访问源代码，剩下的办法就是尝试拆解合同，并以这种方式对其进行反省，这是一种非常混乱且容易出错的方法，其收益会递减，而且没有真正的可重复性。 -为了解决这个问题，创建了[OTP-001：支持的接口](/ref/evolution/otp-001)。据此，Tact 合约[可以报告](/book/config#options-interfacesgetter)支持的接口列表，作为特殊的`supported_interfaces` [getter](#getter-functions)的返回值。使用任何 TON 区块链浏览器都可以在链外访问该获取器--只需指定"supported_interfaces"作为要执行的方法，即可获得十六进制值列表。 +为了解决这个问题，创建了[OTP-001：支持的接口](/zh-cn/ref/evolution/otp-001)。据此，Tact 合约[可以报告](/zh-cn/book/config#options-interfacesgetter)支持的接口列表，作为特殊的`supported_interfaces` [getter](#getter-functions)的返回值。使用任何 TON 区块链浏览器都可以在链外访问该获取器--只需指定"supported_interfaces"作为要执行的方法，即可获得十六进制值列表。 -这些十六进制值被截断为受支持接口的原始[`String{:tact}`][p]值的[SHA-256](https://en.wikipedia.org/wiki/SHA-2#Hash_standard)哈希值的前 128 位。该列表中的第一个值**必须**等于$\mathrm{0x5cec3d5d2cae7b1e84ec39d64a851b66}$（[十六进制符号](/book/integers#hexadecimal)），即`"org.ton.introspection.v0"{:tact}`的 SHA-256 哈希值的前半部分。如果第一个值是错误的，就必须停止反省合同，因为它不符合[支持的接口](/ref/evolution/otp-001)建议。 +这些十六进制值被截断为受支持接口的原始[`String{:tact}`][p]值的[SHA-256](https://en.wikipedia.org/wiki/SHA-2#Hash_standard)哈希值的前 128 位。该列表中的第一个值**必须**等于$\mathrm{0x5cec3d5d2cae7b1e84ec39d64a851b66}$（[十六进制符号](/zh-cn/book/integers#hexadecimal)），即`"org.ton.introspection.v0"{:tact}`的 SHA-256 哈希值的前半部分。如果第一个值是错误的，就必须停止反省合同，因为它不符合[支持的接口](/zh-cn/ref/evolution/otp-001)建议。 要声明支持某个接口，可在 contract 和[trait][trait]声明之前添加一个或多个`@interface("…"){:tact}`属性： @@ -91,19 +91,19 @@ trait Misc { Tact 有一小套在特定条件下提供的接口： -- `"org.ton.abi.ipfs.v0"{:tact}`，根据 [OTP-003: Self-ABI Reporting](/ref/evolution/otp-003) - 通过 [`ipfsAbiGetter`](/book/config#options-ipfsabigetter)配置属性选择加入 -- `"org.ton.deploy.lazy.v0"{:tact}`，符合[OTP-005：参数可寻址合约](/ref/evolution/otp-005) -- `"org.ton.debug.v0"{:tact}`，但只有在启用了[调试模式](/book/debug#debug-mode)时才会这样做 -- `"org.ton.chain.any.v0"{:tact}` 如果启用了 [masterchain](/book/masterchain) 支持，否则为 `"org.ton.chain.workchain.v0"{:tact}` +- `"org.ton.abi.ipfs.v0"{:tact}`，根据 [OTP-003: Self-ABI Reporting](/zh-cn/ref/evolution/otp-003) - 通过 [`ipfsAbiGetter`](/zh-cn/book/config#options-ipfsabigetter)配置属性选择加入 +- `"org.ton.deploy.lazy.v0"{:tact}`，符合[OTP-005：参数可寻址合约](/zh-cn/ref/evolution/otp-005) +- `"org.ton.debug.v0"{:tact}`，但只有在启用了[调试模式](/zh-cn/book/debug#debug-mode)时才会这样做 +- `"org.ton.chain.any.v0"{:tact}` 如果启用了 [masterchain](/zh-cn/book/masterchain) 支持，否则为 `"org.ton.chain.workchain.v0"{:tact}` -[标准库](/ref/standard-libraries)中的一些[traits][trait]也定义了它们的接口： +[标准库](/zh-cn/ref/standard-libraries)中的一些[traits][trait]也定义了它们的接口： -- [`Ownable{:tact}`](/ref/stdlib-ownable#ownable) trait 指定`"org.ton.ownable"{:tact}` -- [`OwnableTransferable{:tact}`](/ref/stdlib-ownable#ownabletransferable) trait 指定`"org.ton.ownable.transferable.v2"{:tact}` -- [`Stoppable{:tact}`](/ref/stdlib-stoppable#stoppable) trait 指定`"org.ton.stoppable"{:tact}` -- [`Resumable{:tact}`](/ref/stdlib-stoppable#resumable) trait 指定`"org.ton.resumable"{:tact}` +- [`Ownable{:tact}`](/zh-cn/ref/stdlib-ownable#ownable) trait 指定`"org.ton.ownable"{:tact}` +- [`OwnableTransferable{:tact}`](/zh-cn/ref/stdlib-ownable#ownabletransferable) trait 指定`"org.ton.ownable.transferable.v2"{:tact}` +- [`Stoppable{:tact}`](/zh-cn/ref/stdlib-stoppable#stoppable) trait 指定`"org.ton.stoppable"{:tact}` +- [`Resumable{:tact}`](/zh-cn/ref/stdlib-stoppable#resumable) trait 指定`"org.ton.resumable"{:tact}` -要启用 `supported_interfaces` [getter](#getter-functions) 生成并在 Tact 合约中使用 `@interface(){:tact}` 属性，请修改项目根目录下的 [`tact.config.json`](/book/config) 文件（如果该文件不存在，则创建该文件），并 [将 `interfacesGetter` 属性设置为 `true{:json}`](/book/config#options-interfacesgetter)。 +要启用 `supported_interfaces` [getter](#getter-functions) 生成并在 Tact 合约中使用 `@interface(){:tact}` 属性，请修改项目根目录下的 [`tact.config.json`](/zh-cn/book/config) 文件（如果该文件不存在，则创建该文件），并 [将 `interfacesGetter` 属性设置为 `true{:json}`](/zh-cn/book/config#options-interfacesgetter)。 如果您的项目基于 [Blueprint][bp]，您可以在合约的编译配置中启用`supported_interfaces`，这些配置位于名为`wrappers/`的目录中： @@ -119,7 +119,7 @@ export const compile：CompilerConfig = { }; ``` -除此之外，[蓝图][bp] 项目中仍可使用 [`tact.config.json`](/book/config)。 在这种情况下，除非在 `wrappers/` 中进行修改，否则 [`tact.config.json`](/book/config)中指定的值将作为默认值。 +除此之外，[蓝图][bp] 项目中仍可使用 [`tact.config.json`](/zh-cn/book/config)。 在这种情况下，除非在 `wrappers/` 中进行修改，否则 [`tact.config.json`](/zh-cn/book/config)中指定的值将作为默认值。 :::caution 请注意，添加接口并不能保证合约实际实现任何特定功能，也不能保证以任何特定方式实现这些功能。 这只是一种可验证的链外承诺，即合同中可能包含某些特定代码。 您应该相信但要核实这些说法。 @@ -129,7 +129,7 @@ export const compile：CompilerConfig = { ### Persistent state variables {#variables} -合约可以定义在合约调用之间持续存在的状态变量。 TON 中的合约[支付租金](https://docs.ton.org/develop/smart-contracts/fees#storage-fee) 与它们消耗的持久空间成正比，因此鼓励[通过序列化进行紧凑表示](/book/integers#serialization)。 +合约可以定义在合约调用之间持续存在的状态变量。 TON 中的合约[支付租金](https://docs.ton.org/develop/smart-contracts/fees#storage-fee) 与它们消耗的持久空间成正比，因此鼓励[通过序列化进行紧凑表示](/zh-cn/book/integers#serialization)。 ```tact contract Example { @@ -141,11 +141,11 @@ contract Example { } ``` -状态变量必须有默认值或在 [`init(){:tact}`](#init-function) 函数中初始化，该函数在部署合约时运行。唯一的例外是 [`map{:tact}`](/book/maps) 类型的持久状态变量，因为它们默认初始化为空。 +状态变量必须有默认值或在 [`init(){:tact}`](#init-function) 函数中初始化，该函数在部署合约时运行。唯一的例外是 [`map{:tact}`](/zh-cn/book/maps) 类型的持久状态变量，因为它们默认初始化为空。 :::note - 请注意，Tact 也支持非持续状态的局部变量，请参阅：[变量声明](/book/statements#let)。 + 请注意，Tact 也支持非持续状态的局部变量，请参阅：[变量声明](/zh-cn/book/statements#let)。 ::: @@ -159,7 +159,7 @@ contract Example { 您可以在 [接收器](#receiver-functions) 和 [获取器](#getter-functions) 中读取常量。 -与[合约变量](#variables)不同，**合约常量不会占用持久状态**的空间。 它们的值直接存储在合约的代码 [`单元格`](/book/cells#cells)中。 +与[合约变量](#variables)不同，**合约常量不会占用持久状态**的空间。 它们的值直接存储在合约的代码 [`单元格`](/zh-cn/book/cells#cells)中。 ```tact // 全局常量在编译时计算，不能更改 @@ -182,7 +182,7 @@ contract Example { } ``` -有关常量的更多信息，请访问其专门页面：[常量](/book/constants)。 +有关常量的更多信息，请访问其专门页面：[常量](/zh-cn/book/constants)。 ### Constructor function `init()` {#init-function} @@ -226,13 +226,13 @@ contract TheySeeMeTrailing { :::note - 要获取 [内部函数](#internal-functions)、[接收器](#receiver-functions) 或 [getters](#getter-functions) 中目标合约的初始状态，请使用 [`initOf{:tact}`](/book/expressions#initof)表达式。 + 要获取 [内部函数](#internal-functions)、[接收器](#receiver-functions) 或 [getters](#getter-functions) 中目标合约的初始状态，请使用 [`initOf{:tact}`](/zh-cn/book/expressions#initof)表达式。 ::: ### Getter functions -[获取函数](/book/functions#getter-functions) **不能从其他合约访问，只能导出到链外世界**。 +[获取函数](/zh-cn/book/functions#getter-functions) **不能从其他合约访问，只能导出到链外世界**。 此外，**获取器不能修改合约的状态变量**，只能读取它们的值并在表达式中使用。 @@ -251,15 +251,15 @@ contract HelloWorld { } ``` -请在其专门章节中阅读更多相关信息：[获取函数](/book/functions#getter-functions) +请在其专门章节中阅读更多相关信息：[获取函数](/zh-cn/book/functions#getter-functions) ### Receiver functions -Tact 中的[接收器函数](/book/functions#receiver-functions)可以是以下三种之一： +Tact 中的[接收器函数](/zh-cn/book/functions#receiver-functions)可以是以下三种之一： -- [`receive(){:tact}`](/book/receive)，用于接收内部消息（来自其他合约）。 -- [`bounced(){:tact}`](/book/bounced)，当该合约发出的消息被退回时会调用。 -- [`external(){:tact}`](/book/external)，没有发送者，世界上任何人都可以发送。 +- [`receive(){:tact}`](/zh-cn/book/receive)，用于接收内部消息（来自其他合约）。 +- [`bounced(){:tact}`](/zh-cn/book/bounced)，当该合约发出的消息被退回时会调用。 +- [`external(){:tact}`](/zh-cn/book/external)，没有发送者，世界上任何人都可以发送。 ```tact message CanBounce { @@ -339,9 +339,9 @@ contract Functions { } ``` :::note - 请注意，Tact 还支持其他类型的函数，请参阅[函数](/book/functions)。 + 请注意，Tact 还支持其他类型的函数，请参阅[函数](/zh-cn/book/functions)。 ::: -[p]: /book/types#primitive-types -[特质]: /book/types#traits +[p]: /zh-cn/book/types#primitive-types +[特质]: /zh-cn/book/types#traits [bp]: https://github.com/ton-org/blueprint diff --git a/docs/src/content/docs/zh-cn/book/debug.mdx b/docs/src/content/docs/zh-cn/book/debug.mdx index b53790668..1dcc46c20 100644 --- a/docs/src/content/docs/zh-cn/book/debug.mdx +++ b/docs/src/content/docs/zh-cn/book/debug.mdx @@ -61,7 +61,7 @@ import { LinkCard, CardGrid, Steps, Tabs, TabItem } from '@astrojs/starlight/com 目前，Tact 还没有步进式调试器。 尽管如此，仍然可以使用["printf 调试"](https://en.wikipedia.org/wiki/Debugging#printf_debugging) 方法。 -这包括在整个代码中主动调用 [`dump(){:tact}`][dump]和 [`dumpStack(){:tact}`](/ref/core-debug#dumpstack)函数，并观察特定时间点的变量状态。 请注意，这些函数只在 [调试模式]（#debug-mode）下工作，否则不会执行。 +这包括在整个代码中主动调用 [`dump(){:tact}`][dump]和 [`dumpStack(){:tact}`](/zh-cn/ref/core-debug#dumpstack)函数，并观察特定时间点的变量状态。 请注意，这些函数只在 [调试模式]（#debug-mode）下工作，否则不会执行。 :::note @@ -69,13 +69,13 @@ import { LinkCard, CardGrid, Steps, Tabs, TabItem } from '@astrojs/starlight/com ::: -除了转储值之外，使用 [`require(){:tact}`](/ref/core-debug#require)、[`nativeThrowIf(){:tact}`](/ref/core-debug#nativethrowif)和 [`nativeThrowUnless(){:tact}`](/ref/core-debug#nativethrowunless)等自信的函数通常也很有帮助。 它们有助于明确说明你的假设，并方便设置 "绊线"，以便在将来发现问题。 +除了转储值之外，使用 [`require(){:tact}`](/zh-cn/ref/core-debug#require)、[`nativeThrowIf(){:tact}`](/zh-cn/ref/core-debug#nativethrowif)和 [`nativeThrowUnless(){:tact}`](/zh-cn/ref/core-debug#nativethrowunless)等自信的函数通常也很有帮助。 它们有助于明确说明你的假设，并方便设置 "绊线"，以便在将来发现问题。 如果您没有找到或无法解决您的问题，请尝试在 Tact 的[Telegram 聊天][tg]中询问社区；如果您的问题或疑问与 TON 的关系大于与 Tact 的关系，请进入[TON Dev Telegram 聊天](https://t.me/tondev_eng)。 ## 常用调试功能 {#debug-functions} -Tact 提供了大量对调试有用的各种函数：[核心库 → 调试](/ref/core-debug)。 +Tact 提供了大量对调试有用的各种函数：[核心库 → 调试](/zh-cn/ref/core-debug)。 ## 在编译选项中启用调试模式 {#debug-mode} @@ -99,7 +99,7 @@ export const compile：CompilerConfig = { 请注意，从 0.20.0 开始的 [Blueprint][bp] 版本会自动为新合约启用 `wrappers/` 中的调试模式。 -除此之外，[蓝图][bp] 项目中仍可使用 [`tact.config.json`](/book/config)。 在这种情况下，除非在 `wrappers/` 中修改，否则 [`tact.config.json`](/book/config)中指定的值将作为默认值。 +除此之外，[蓝图][bp] 项目中仍可使用 [`tact.config.json`](/zh-cn/book/config)。 在这种情况下，除非在 `wrappers/` 中修改，否则 [`tact.config.json`](/zh-cn/book/config)中指定的值将作为默认值。 :::note @@ -139,7 +139,7 @@ Ton Emulator allows you to have a small virtual blockchain in your Node.js code. :::note - 强烈建议不要修改 `beforeEach(){:tact}` 中的内容，除非您确实需要为每个测试闭包设置某些特定行为，或者 [`init(){:tact}`](/book/contracts#init-function)函数的参数发生了变化。 + 强烈建议不要修改 `beforeEach(){:tact}` 中的内容，除非您确实需要为每个测试闭包设置某些特定行为，或者 [`init(){:tact}`](/zh-cn/book/contracts#init-function)函数的参数发生了变化。 ::: @@ -160,7 +160,7 @@ it('should deploy', async () => { 1. 在代码的相关位置调用 [`dump(){:tact}`][dump]和其他[常用调试函数](#debug-functions)。 2. 运行 [Jest][jest]测试，这些测试将调用目标函数并向目标接收器发送信息。 -假设你已经创建了一个 [新计数器合约项目](/#start)，让我们来看看它是如何实际运行的。 +假设你已经创建了一个 [新计数器合约项目](/zh-cn/#start)，让我们来看看它是如何实际运行的。 首先，让我们在 `contracts/simple_counter.tact` 中调用 [`dump(){:tact}`][dump]，这将把 `msg{:tact}` [Struct][struct] 中传递的 `amount` 输出到合约的调试控制台： @@ -185,7 +185,7 @@ it('should dump', async () => { })； ``` -它向我们合约的 `receive(msg: Add){:tact}` [接收器](/book/receive) 发送信息，而不存储[发送结果](#tests-send)。 +它向我们合约的 `receive(msg: Add){:tact}` [接收器](/zh-cn/book/receive) 发送信息，而不存储[发送结果](#tests-send)。 现在，如果我们使用 `yarn build{:shell}` 构建我们的合约，并使用 `yarn test{:shell}` 运行我们的测试套件，我们将在测试日志中看到以下内容： @@ -277,7 +277,7 @@ expect(res.transactions).toHaveTransaction({ #### toEqualCell -方法 `expect(…).toEqualCell(){:typescript}` 检查两个 [单元格](/book/cells#cells)是否相等： +方法 `expect(…).toEqualCell(){:typescript}` 检查两个 [单元格](/zh-cn/book/cells#cells)是否相等： ```typescript {3} expect(oneCell).toEqualCell(anotherCell)； @@ -285,7 +285,7 @@ expect(oneCell).toEqualCell(anotherCell)； #### 对等切片 -方法 `expect(…).toEqualSlice(){:typescript}` 检查两个 [slices](/book/cells#slices) 是否相等： +方法 `expect(…).toEqualSlice(){:typescript}` 检查两个 [slices](/zh-cn/book/cells#slices) 是否相等： ```typescript {3} expect(oneSlice).toEqualSlice(anotherSlice)； @@ -293,7 +293,7 @@ expect(oneSlice).toEqualSlice(anotherSlice)； #### toEqualAddress -方法 `expect(…).toEqualAddress(){:typescript}` 检查两个 [地址](/book/types#primitive-types)是否相等： +方法 `expect(…).toEqualAddress(){:typescript}` 检查两个 [地址](/zh-cn/book/types#primitive-types)是否相等： ```typescript {3} expect(oneAddress).toEqualAddress(anotherAddress)； @@ -317,7 +317,7 @@ await yourContractName.send( )； ``` -消息体可以是简单的字符串，也可以是指定 [消息](/book/structs-and-messages#messages)类型字段的对象： +消息体可以是简单的字符串，也可以是指定 [消息](/zh-cn/book/structs-and-messages#messages)类型字段的对象： ```typescript {4-8} await yourContractName.send( @@ -403,7 +403,7 @@ expect( ### 有故意错误的交易 {#tests-errors} -有时，进行负面测试也很有用，它可以故意出错并抛出特定的[退出代码](/book/exit-codes)。 +有时，进行负面测试也很有用，它可以故意出错并抛出特定的[退出代码](/zh-cn/book/exit-codes)。 [蓝图][bp]中此类[Jest][jest]测试闭包的示例： @@ -466,13 +466,13 @@ it('your test clause title', async () => { ## 通过 `emit` 记录 {#logging} -[全局静态函数](/book/functions#global-static-functions) [`emit(){:tact}`](/ref/core-common#emit)向外部世界发送信息--它没有特定的接收者。 +[全局静态函数](/zh-cn/book/functions#global-static-functions) [`emit(){:tact}`](/zh-cn/ref/core-common#emit)向外部世界发送信息--它没有特定的接收者。 -该功能对于记录和分析链外数据非常方便，只需查看合约生成的 [external messages](/book/external) 即可。 +该功能对于记录和分析链外数据非常方便，只需查看合约生成的 [external messages](/zh-cn/book/external) 即可。 ### 本地沙箱测试中的日志 {#logging-local} -在 [Sandbox][sb] 中部署时，您可以从 [receiver function](/book/contracts#receiver-functions) 中调用 [`emit(){:tact}`](/ref/core-common#emit)，然后观察已发送的 [external messages](/book/external) 列表： +在 [Sandbox][sb] 中部署时，您可以从 [receiver function](/zh-cn/book/contracts#receiver-functions) 中调用 [`emit(){:tact}`](/zh-cn/ref/core-common#emit)，然后观察已发送的 [external messages](/zh-cn/book/external) 列表： ```typescript {9-10} it('emits', async () => { @@ -492,7 +492,7 @@ it('emits', async () => { TON 区块链上的每笔交易都[包含`out_msgs`](https://docs.ton.org/develop/data-formats/transaction-layout#transaction) - 这是一个字典，保存着执行交易时创建的传出消息列表。 -要查看字典中 [`emit(){:tact}`](/ref/core-common#emit)的日志，请查找没有收件人的外部消息。 在各种 TON 区块链探索器中，此类交易将被标记为 "外部输出"，目的地指定为"-"或 "空"。 +要查看字典中 [`emit(){:tact}`](/zh-cn/ref/core-common#emit)的日志，请查找没有收件人的外部消息。 在各种 TON 区块链探索器中，此类交易将被标记为 "外部输出"，目的地指定为"-"或 "空"。 请注意，有些探索者会为你反序列化发送的信息体，而有些则不会。 不过，您可以随时在本地[自行解析]（#logging-parsing）。 @@ -533,7 +533,7 @@ it('emits', async () => { })； ``` -在这里，`res` 对象的`externals`字段将包含已发送的[外部信息]（/book/external）列表。 让我们访问它，以解析通过调用 Tact 代码中的 [`emit(){:tact}`](/ref/core-common#emit)（或简称 _emitted_）发送的第一条信息： +在这里，`res` 对象的`externals`字段将包含已发送的[外部信息]（/book/external）列表。 让我们访问它，以解析通过调用 Tact 代码中的 [`emit(){:tact}`](/zh-cn/ref/core-common#emit)（或简称 _emitted_）发送的第一条信息： ```typescript /body/ it('emits', async () => { @@ -586,7 +586,7 @@ it('emits', async () => { ## 处理退回的邮件 {#bounced} -当 [send](/book/send) 带有 `bounce: true{:tact}` 时，信息会在出错时反弹。确保编写相关的 [`bounced(){:tact}`](/book/bounced) 消息[接收器](/book/contracts#receiver-functions)，并优雅地处理被退回的消息： +当 [send](/zh-cn/book/send) 带有 `bounce: true{:tact}` 时，信息会在出错时反弹。确保编写相关的 [`bounced(){:tact}`](/zh-cn/book/bounced) 消息[接收器](/zh-cn/book/contracts#receiver-functions)，并优雅地处理被退回的消息： ```tact bounced(msg: YourMessage) { @@ -596,7 +596,7 @@ bounced(msg: YourMessage) { 请记住，在 TON 中被退回的邮件正文中只有 $224$ 个可用数据位，而且没有任何引用，因此无法从中恢复很多数据。 不过，您仍然可以看到邮件是否被退回，从而可以创建更稳健的合同。 -了解更多有关退信和收信人的信息：[退信](/book/bounced)。 +了解更多有关退信和收信人的信息：[退信](/zh-cn/book/bounced)。 ## 实验实验室设置 {#lab} @@ -669,7 +669,7 @@ bounced(msg: YourMessage) { } ``` - 此设置的基本思想是将要测试的代码放入 [receiver function](/book/contracts#receiver-functions) 中，以响应 [string](/book/types#primitive-types) 消息 `"plays"{:tact}`。 + 此设置的基本思想是将要测试的代码放入 [receiver function](/zh-cn/book/contracts#receiver-functions) 中，以响应 [string](/zh-cn/book/types#primitive-types) 消息 `"plays"{:tact}`。 请注意，您仍然可以在[接收器]（/book/contracts#receiver-functions）之外编写任何有效的 Tact 代码。 但为了测试它，你需要在其中编写相关的测试逻辑。 @@ -714,11 +714,11 @@ bounced(msg: YourMessage) { -[转储]: /ref/core-debug#dump +[转储]: /zh-cn/ref/core-debug#dump [结构]: [信息]: -[电池]: /book/cells#cells -[一片]: /book/cells#slices +[电池]: /zh-cn/book/cells#cells +[一片]: /zh-cn/book/cells#slices [tg]: https://t.me/tactlang [bp]: https://github.com/ton-org/blueprint [某人]: https://github.com/ton-org/sandbox diff --git a/docs/src/content/docs/zh-cn/book/exit-codes.mdx b/docs/src/content/docs/zh-cn/book/exit-codes.mdx index 1dd9c39cc..bda221e3f 100644 --- a/docs/src/content/docs/zh-cn/book/exit-codes.mdx +++ b/docs/src/content/docs/zh-cn/book/exit-codes.mdx @@ -167,7 +167,7 @@ send(SendParameters{to: context().sender, value: ton("10")})； ### 128：空引用异常 {#128} -如果有一个非空断言，例如 [`!!{:tact}`](/book/operators#unary-non-null-assert)操作符，而检查值是 [`null{:tact}`](/book/optionals)，则会抛出一个退出代码为 $128$ 的错误："空引用异常"。 +如果有一个非空断言，例如 [`!!{:tact}`](/zh-cn/book/operators#unary-non-null-assert)操作符，而检查值是 [`null{:tact}`](/zh-cn/book/optionals)，则会抛出一个退出代码为 $128$ 的错误："空引用异常"。 ```tact let gotcha: String? = null; diff --git a/docs/src/content/docs/zh-cn/book/expressions.mdx b/docs/src/content/docs/zh-cn/book/expressions.mdx index 2ef28534e..50a7662bd 100644 --- a/docs/src/content/docs/zh-cn/book/expressions.mdx +++ b/docs/src/content/docs/zh-cn/book/expressions.mdx @@ -8,7 +8,7 @@ Tact 中的每个运算符都能构成一个表达式，但 Tact 还提供了更 字面表示 Tact 中的值。 这些是固定值，而不是变量，是您在代码中实际提供的。 Tact 中的所有字面量都是表达式本身。 -您还可以调用定义在某些 [基元类型][p]上的 [扩展函数](/book/functions#extension-function)，这些 [基元类型][p] 与字面值相对应： +您还可以调用定义在某些 [基元类型][p]上的 [扩展函数](/zh-cn/book/functions#extension-function)，这些 [基元类型][p] 与字面值相对应： ```tact // 在整数字面量上调用为 Int 定义的 toString() 函数： @@ -20,15 +20,15 @@ Tact 中的每个运算符都能构成一个表达式，但 Tact 还提供了更 ### Integer literals -整数字面可以用[十进制](/book/integers#decimal)（基 $10$）、[十六进制](/book/integers#hexadecimal)（基 $16$）、[八进制](/book/integers#octal)（基 $8$）和[二进制](/book/integers#binary)（基 $2$）符号书写： +整数字面可以用[十进制](/zh-cn/book/integers#decimal)（基 $10$）、[十六进制](/zh-cn/book/integers#hexadecimal)（基 $16$）、[八进制](/zh-cn/book/integers#octal)（基 $8$）和[二进制](/zh-cn/book/integers#binary)（基 $2$）符号书写： -- 一个 [_decimal_ integer](/book/integers#decimal) 字面量是一串数字（$\mathrm{0 - 9}$）。 +- 一个 [_decimal_ integer](/zh-cn/book/integers#decimal) 字面量是一串数字（$\mathrm{0 - 9}$）。 -- 前导 $\mathrm{0x}$（或 $\mathrm{0X}$）表示[十六进制整数](/book/integers#hexadecimal) 字面量。 它们可以包括数字（$\mathrm{0 - 9}$）和字母 $\mathrm{a - f}$ 和 $\mathrm{A - F}$。 请注意，字符的大小写不会改变其值。 因此：$\mathrm{0xa}$ = $\mathrm{0xA}$ = $10$ 和 $\mathrm{0xf}$ = $\mathrm{0xF}$ = $15$。 +- 前导 $\mathrm{0x}$（或 $\mathrm{0X}$）表示[十六进制整数](/zh-cn/book/integers#hexadecimal) 字面量。 它们可以包括数字（$\mathrm{0 - 9}$）和字母 $\mathrm{a - f}$ 和 $\mathrm{A - F}$。 请注意，字符的大小写不会改变其值。 因此：$\mathrm{0xa}$ = $\mathrm{0xA}$ = $10$ 和 $\mathrm{0xf}$ = $\mathrm{0xF}$ = $15$。 -- 前导 $\mathrm{0o}$（或 $\mathrm{0O}$）表示 [octal integer](/book/integers#octal) 字面量。 它们只能包括数字 $\mathrm{0 - 7}$。 +- 前导 $\mathrm{0o}$（或 $\mathrm{0O}$）表示 [octal integer](/zh-cn/book/integers#octal) 字面量。 它们只能包括数字 $\mathrm{0 - 7}$。 -- 前导 $\mathrm{0b}$（或 $\mathrm{0B}$）表示 [二进制整数](/book/integers#binary) 字面量。 它们只能包括数字 $0$ 和 $1$。 +- 前导 $\mathrm{0b}$（或 $\mathrm{0B}$）表示 [二进制整数](/zh-cn/book/integers#binary) 字面量。 它们只能包括数字 $0$ 和 $1$。 :::caution 需要注意的是，在 Tact 中，以 $0$ 为前导的整数字面量仍被视为小数，而在 JavaScript/TypeScript 中，以 $0$ 为前导的整数字面量表示八进制！ @@ -50,18 +50,18 @@ Tact 中的每个运算符都能构成一个表达式，但 Tact 还提供了更 0b01111001_01101111_01110101_00100000_01100001_01110010_01100101_00100000_01100001_01110111_01100101_01110011_01101111_01101101_01100101 ``` -有关整数和 [`Int{:tact}`](/book/integers)类型的更多信息，请访问专门页面：[整数](/book/integers)。 +有关整数和 [`Int{:tact}`](/zh-cn/book/integers)类型的更多信息，请访问专门页面：[整数](/zh-cn/book/integers)。 ### Boolean literals -[`Bool{:tact}`](/book/types#booleans)类型只有两个字面值：`true{:tact}`和`false{:tact}`。 +[`Bool{:tact}`](/zh-cn/book/types#booleans)类型只有两个字面值：`true{:tact}`和`false{:tact}`。 ```tact true == true; true != false； ``` -有关布尔和 [`Bool{:tact}`](/book/types#booleans)类型的更多信息，请参阅专门章节：[布尔](/book/types#booleans)。 +有关布尔和 [`Bool{:tact}`](/zh-cn/book/types#booleans)类型的更多信息，请参阅专门章节：[布尔](/zh-cn/book/types#booleans)。 ### String literals @@ -127,7 +127,7 @@ Tact 字符串支持一系列从反斜杠字符开始的[转义序列](https://e 阅读更多关于字符串和[`字符串{:tact}`][p]类型：\ [书中的原始类型][p]\ - [参考资料中的字符串和字符串构造器](/ref/core-strings)的内容 + [参考资料中的字符串和字符串构造器](/zh-cn/ref/core-strings)的内容 ::: @@ -143,15 +143,15 @@ if (var != null) { } ``` -有关使用 `null{:tact}`的更多信息，请访问专门页面：[选项](/book/optionals)。 +有关使用 `null{:tact}`的更多信息，请访问专门页面：[选项](/zh-cn/book/optionals)。 ## Identifiers -标识符是代码中的一串字符，用于标识[变量](/book/statements#let)、[常量](/book/constants)、[映射](/book/maps)和[函数](/book/functions)，以及[结构][s]、[消息][m]、[契约](/book/contracts)、[特质](/book/types#traits)或它们的字段和方法。 标识符区分大小写，不加引号。 +标识符是代码中的一串字符，用于标识[变量](/zh-cn/book/statements#let)、[常量](/zh-cn/book/constants)、[映射](/zh-cn/book/maps)和[函数](/zh-cn/book/functions)，以及[结构][s]、[消息][m]、[契约](/zh-cn/book/contracts)、[特质](/zh-cn/book/types#traits)或它们的字段和方法。 标识符区分大小写，不加引号。 在 Tact 中，标识符可以包含拉丁小写字母 (`a-z`)、拉丁大写字母 (`A-Z`)、下划线 (`_`)和数字 ($\mathrm{0 - 9}$)，但不能以数字开头。 标识符与 [字符串]（#string-literals）的区别在于，字符串是数据，而标识符是代码的一部分。 -请注意，当[基元类型][p]的标识符以大写字母开头时。 已使用定义的 [复合类型](/book/types#composite-types)，如 [Structs][s] 和 [Messages][m] 也必须大写。 +请注意，当[基元类型][p]的标识符以大写字母开头时。 已使用定义的 [复合类型](/zh-cn/book/types#composite-types)，如 [Structs][s] 和 [Messages][m] 也必须大写。 ## Instantiation @@ -201,7 +201,7 @@ fun example()：Int { ## Extension function call -[扩展函数](/book/functions#extension-function)仅在特定类型中定义。 它们的调用方式类似于许多其他语言中的方法调用： +[扩展函数](/zh-cn/book/functions#extension-function)仅在特定类型中定义。 它们的调用方式类似于许多其他语言中的方法调用： ```tact 42.toString(); // toString() 是针对 Int 类型定义的 stdlib 函数。 @@ -209,7 +209,7 @@ fun example()：Int { ## Static function call -在函数体的任何位置，都可以调用全局 [static function](/book/functions#global-static-functions) 或 [contract](/book/contracts) 的内部函数： +在函数体的任何位置，都可以调用全局 [static function](/zh-cn/book/functions#global-static-functions) 或 [contract](/zh-cn/book/contracts) 的内部函数： ```tact contract ExampleContract { @@ -226,7 +226,7 @@ contract ExampleContract { ## `initOf` -表达式 `initOf{:tact}` 计算 [contract](/book/contracts) 的初始状态 (`StateInit{:tact}`)： +表达式 `initOf{:tact}` 计算 [contract](/zh-cn/book/contracts) 的初始状态 (`StateInit{:tact}`)： ```tact // 合同的 init() 函数的参数值 @@ -247,10 +247,10 @@ initOf ExampleContract( | 现场 | 类型 | 说明 | | :-- | :------------------ | :------------------------------------------------ | -| 代码 | [`单元格{:tact}`][单元格] | [合同](/book/contracts)的初始代码（编译后的字节码 | -| 数据 | [`单元格{:tact}`][单元格] | [合同](/book/contracts)的初始数据（合同的 `init(){:tact}`函数参数 | +| 代码 | [`单元格{:tact}`][单元格] | [合同](/zh-cn/book/contracts)的初始代码（编译后的字节码 | +| 数据 | [`单元格{:tact}`][单元格] | [合同](/zh-cn/book/contracts)的初始数据（合同的 `init(){:tact}`函数参数 | -[p]: /book/types#primitive-types -[cell]: /book/cells#cells -[s]: /book/structs-and-messages#structs -[m]: /book/structs-and-messages#messages \ No newline at end of file +[p]: /zh-cn/book/types#primitive-types +[cell]: /zh-cn/book/cells#cells +[s]: /zh-cn/book/structs-and-messages#structs +[m]: /zh-cn/book/structs-and-messages#messages \ No newline at end of file diff --git a/docs/src/content/docs/zh-cn/book/func.mdx b/docs/src/content/docs/zh-cn/book/func.mdx index 2daa2ec75..6faffa6ea 100644 --- a/docs/src/content/docs/zh-cn/book/func.mdx +++ b/docs/src/content/docs/zh-cn/book/func.mdx @@ -4,19 +4,19 @@ title: 与 func 的兼容性 Tact 本身编译为 FunC，并将其所有实体直接映射到各种 FunC 和 TL-B 类型。 -## 转换类型 +## 转换类型 {#convert-types} -Tact 中的 [原始类型](/book/types#primitive-types)可直接映射到 FunC 中的类型。 +Tact 中的 [原始类型](/zh-cn/book/types#primitive-types)可直接映射到 FunC 中的类型。 -所有关于复制变量的规则都是一样的。其中一个最大的不同是，在 Tact 中没有可见的突变操作符，大多数 [`切片{:tact}`](/book/cells#slices)操作都是就地突变变量。 +所有关于复制变量的规则都是一样的。其中一个最大的不同是，在 Tact 中没有可见的突变操作符，大多数 [`切片{:tact}`](/zh-cn/book/cells#slices)操作都是就地突变变量。 -## 转换序列化 +## 转换序列化 {#convert-serialization} -在 Tact 中，[Structs](/book/structs-and-messages#structs)和[Messages](/book/structs-and-messages#messages)的序列化是自动进行的，不像 FunC 需要手动定义序列化逻辑。 +在 Tact 中，[Structs](/zh-cn/book/structs-and-messages#structs)和[Messages](/zh-cn/book/structs-and-messages#messages)的序列化是自动进行的，不像 FunC 需要手动定义序列化逻辑。 Tact 的自动布局算法是贪婪的。这意味着它会获取下一个变量，计算其大小，并尝试将其放入当前单元格。如果不合适，它就会创建一个新单元格并继续。所有用于自动布局的内部结构都会在分配前被扁平化。 -除了 [`Address{:tact}`](/book/types#primitive-types) 以外，所有可选类型在 TL-B 中都序列化为 `Maybe`。 +除了 [`Address{:tact}`](/zh-cn/book/types#primitive-types) 以外，所有可选类型在 TL-B 中都序列化为 `Maybe`。 没有对 `Either` 的支持，因为它没有定义在某些情况下序列化时应选择什么。 @@ -100,7 +100,7 @@ struct SomeValue { } ``` -## 将收到的信息转换为 `op` 操作 +## 将收到的信息转换为 `op` 操作 {#convert-received-messages-to-op-operations} Tact 会为每条接收到的键入信息生成一个唯一的 `op`，但它可以被覆盖。 @@ -177,7 +177,7 @@ get fun seqno(): Int { 在 FunC 中，张量类型 `(int, int){:func}` 和 `(int, (int)){:func}` 是有区别的，但对于 TVM 来说没有区别，它们都表示两个整数的堆栈。 -要转换从 FunC `get` 方法返回的张量，需要定义一个 [Struct](/book/structs-and-messages#structs)，它与张量的字段类型相同，顺序也相同。 +要转换从 FunC `get` 方法返回的张量，需要定义一个 [Struct](/zh-cn/book/structs-and-messages#structs)，它与张量的字段类型相同，顺序也相同。 下面是 FunC 中的代码 @@ -265,7 +265,7 @@ contract StatefulContract { ### 参数 制图 -获取 "方法参数的转换非常简单。每个参数都_原样_映射到 FunC one，每个元组都映射到 [结构](/book/structs-and-messages#structs)。 +获取 "方法参数的转换非常简单。每个参数都_原样_映射到 FunC one，每个元组都映射到 [结构](/zh-cn/book/structs-and-messages#structs)。 下面是 FunC 中的代码 diff --git a/docs/src/content/docs/zh-cn/book/functions.mdx b/docs/src/content/docs/zh-cn/book/functions.mdx index f75355245..8abd57b11 100644 --- a/docs/src/content/docs/zh-cn/book/functions.mdx +++ b/docs/src/content/docs/zh-cn/book/functions.mdx @@ -27,7 +27,7 @@ fun bar() { } ``` -## 全局静态函数 +## 全局静态函数 {#global-static-functions} 您可以在程序的任何地方定义全局函数： @@ -41,9 +41,9 @@ fun pow(a: Int, c: Int): Int { } ``` -## 虚拟和抽象函数 +## 虚拟和抽象函数 {#virtual-and-abstract-functions} -如果 [traits](/book/types#traits) 有 `virtual{:tact}` 关键字，则可以使用 `override{:tact}` 允许继承 [traits](/book/types#traits) 的合约修改内部函数。 函数也可以标记为 `抽象{:tact}`，在这种情况下，继承合约必须定义其实现： +如果 [traits](/zh-cn/book/types#traits) 有 `virtual{:tact}` 关键字，则可以使用 `override{:tact}` 允许继承 [traits](/zh-cn/book/types#traits) 的合约修改内部函数。 函数也可以标记为 `抽象{:tact}`，在这种情况下，继承合约必须定义其实现： ```tact trait FilterTrait with Ownable { @@ -67,7 +67,7 @@ contract Filter with FilterTrait { } ``` -## 扩展功能 +## 扩展功能 {#extension-function} 扩展函数允许你为任何可能的类型实现扩展。 @@ -84,7 +84,7 @@ extends fun customPow(self: Int, c: Int): Int { } ``` -## 可变函数 +## 可变函数 {#mutation-functions} 可变函数是对数值进行变异，用执行结果代替数值。 要执行突变，函数必须改变 `self` 值。 @@ -98,7 +98,7 @@ extends mutates fun customPow(self: Int, c: Int) { } ``` -## 本地功能 +## 本地功能 {#native-functions} 本地函数是 FunC 函数的直接绑定： @@ -113,7 +113,7 @@ native storeUint(s: Builder, value: Int, bits: Int): Builder; extends mutates native loadInt(self: Slice, l: Int): Int; ``` -## Receiver functions +## Receiver functions {#receiver-functions} 接收器函数是负责在合约中接收信息的特殊函数，只能在合约或特质中定义。 @@ -126,7 +126,7 @@ contract Treasure { } ``` -## 获取器函数 +## 获取器函数 {#getter-functions} 获取器函数定义智能合约上的获取器，只能在合约或特征中定义。 @@ -169,4 +169,4 @@ contract ManualMethodId { 用户指定的方法 ID 是 19 位有符号整数，因此可以使用从 $-2^{18}$ 到 $-5$ 以及从 $2^{14}$ 到 $2^{18}$ 的整数。- 1$. -此外，还有一些方法 ID 是为 Tact 编译器在编译过程中插入的获取器保留的，它们是 113617、115390 和 121275。 \ No newline at end of file +此外，还有一些方法 ID 是为 Tact 编译器在编译过程中插入的获取器保留的，它们是 113617、115390 和 121275。 diff --git a/docs/src/content/docs/zh-cn/book/import.mdx b/docs/src/content/docs/zh-cn/book/import.mdx index 73814226c..3840e458b 100644 --- a/docs/src/content/docs/zh-cn/book/import.mdx +++ b/docs/src/content/docs/zh-cn/book/import.mdx @@ -4,7 +4,7 @@ title: 导入代码 Tact 允许您导入 Tact 和 [FunC](https://docs.ton.org/develop/func/overview) 代码--任何给定的 `.tact` 或 `.fc`/`.func` 文件都可以使用 `import{:tact}` 关键字导入到您的项目中。 -此外，Tact 编译器还拥有一套通用的标准库，这些标准库捆绑在 Tact 编译器中，但并不立即包含在 Tact 编译器中，请参阅 [标准库概述](/ref/standard-libraries)。 +此外，Tact 编译器还拥有一套通用的标准库，这些标准库捆绑在 Tact 编译器中，但并不立即包含在 Tact 编译器中，请参阅 [标准库概述](/zh-cn/ref/standard-libraries)。 :::caution @@ -38,7 +38,7 @@ import "./relative/path/to/the/target/func/file.fc"; import "../subfolder/imported/func/file.fc"; ``` -但要使用此类文件中的函数，必须先将它们声明为 "本地 "函数。 For example, when standard library [@stdlib/dns](/ref/stdlib-dns) uses a `dns.fc` FunC file, it maps FunC functions to Tact ones like so: +但要使用此类文件中的函数，必须先将它们声明为 "本地 "函数。 For example, when standard library [@stdlib/dns](/zh-cn/ref/stdlib-dns) uses a `dns.fc` FunC file, it maps FunC functions to Tact ones like so: ```tact // FunC 代码位于当前 Tact 代码旁边的文件中： @@ -51,4 +51,4 @@ native dnsStringToInternal(str: String)：Slice? ## 标准图书馆 -See [Standard libraries overview](/ref/standard-libraries). +See [Standard libraries overview](/zh-cn/ref/standard-libraries). diff --git a/docs/src/content/docs/zh-cn/book/index.mdx b/docs/src/content/docs/zh-cn/book/index.mdx index 306b5aeb2..16d338945 100644 --- a/docs/src/content/docs/zh-cn/book/index.mdx +++ b/docs/src/content/docs/zh-cn/book/index.mdx @@ -12,7 +12,7 @@ Here are it's main contents: 1. #### Guides - [Cheatsheets](/book/cs/from-func) 是关于 Tact 语法和习语的快速介绍，并与其他区块链语言（如 FunC（也在 TON 上）和 Solidity（以太坊区块链））进行了比较。 利用这些优势尽快过渡到战术。 + [Cheatsheets](/zh-cn/book/cs/from-func) 是关于 Tact 语法和习语的快速介绍，并与其他区块链语言（如 FunC（也在 TON 上）和 Solidity（以太坊区块链））进行了比较。 利用这些优势尽快过渡到战术。 {:tact}` 用于将 `K{:tact}` 类型的键与 `V{:tact}` 类型的相应值关联起来。 +[复合类型](/zh-cn/book/types#composite-types) `map{:tact}` 用于将 `K{:tact}` 类型的键与 `V{:tact}` 类型的相应值关联起来。 例如，`map{:tact}` 的键和值使用 [`英特{:tact}`][英特] 类型： @@ -14,7 +14,7 @@ struct IntToInt { } ``` -## 允许的类型 +## 允许的类型 {#allowed-types} 允许的密钥类型 @@ -24,24 +24,24 @@ struct IntToInt { 允许的值类型： - [`Int{:tact}`][int]。 -- [`Bool{:tact}`](/book/types#booleans) +- [`Bool{:tact}`](/zh-cn/book/types#booleans) - [`单元格{:tact}`][单元格] - [`地址{:tact}`][p] -- [结构](/book/structs-and-messages#structs) -- [消息](/book/structs-and-messages#messages) +- [结构](/zh-cn/book/structs-and-messages#structs) +- [消息](/zh-cn/book/structs-and-messages#messages) ## 业务 ### 声明，`emptyMap()` {#emptymap} -作为[局部变量](/book/statements#let)，使用标准库的 `emptyMap(){:tact}` 函数： +作为[局部变量](/zh-cn/book/statements#let)，使用标准库的 `emptyMap(){:tact}` 函数： ```tact let fizz: map = emptyMap(); let fizz: map = null; // 与前一行相同，但描述性较弱 ``` -作为 [持久状态变量](/book/contracts#variables)： +作为 [持久状态变量](/zh-cn/book/contracts#variables)： ```tact contract Example { @@ -52,11 +52,11 @@ contract Example { } ``` -请注意，类型为 `map{:tact}` 的 [持久状态变量](/book/contracts#variables) 默认为空，不需要默认值，也不需要在 [`init(){:tact}` 函数](/book/contracts#init-function)中进行初始化。 +请注意，类型为 `map{:tact}` 的 [持久状态变量](/zh-cn/book/contracts#variables) 默认为空，不需要默认值，也不需要在 [`init(){:tact}` 函数](/zh-cn/book/contracts#init-function)中进行初始化。 ### 设置值，`.set()` {#set} -要设置或替换键下的值，请调用 `.set(){:tact}` [方法](/book/functions#extension-function)，所有地图都可以使用该方法。 +要设置或替换键下的值，请调用 `.set(){:tact}` [方法](/zh-cn/book/functions#extension-function)，所有地图都可以使用该方法。 ```tact // 空 map @@ -72,7 +72,7 @@ fizz.set(7, 68); // 键 7 现在指向值 68 ### 获取值，`.get()` {#get} -通过调用 `.get(){:tact}` [方法](/book/functions#extension-function)，检查是否在地图中找到了键，所有地图都可以访问该方法。 如果键丢失，则返回 `null{:tact}`；如果键找到，则返回值。 +通过调用 `.get(){:tact}` [方法](/zh-cn/book/functions#extension-function)，检查是否在地图中找到了键，所有地图都可以访问该方法。 如果键丢失，则返回 `null{:tact}`；如果键找到，则返回值。 ```tact // Empty map @@ -97,7 +97,7 @@ if (gotButUnsure != null) { ### 删除条目，`.del()` {#del} -要删除单个键值对（单个条目），请使用 `.del(){:tact}` [方法](/book/functions#extension-function)。 如果删除成功，则返回 `true{:tact}`，否则返回 `false{:tact}`。 +要删除单个键值对（单个条目），请使用 `.del(){:tact}` [方法](/zh-cn/book/functions#extension-function)。 如果删除成功，则返回 `true{:tact}`，否则返回 `false{:tact}`。 ```tact // 空 map @@ -138,7 +138,7 @@ fizz = null; // 与上一行相同，但描述性较弱

-映射上的 `.exists(){:tact}` [方法](/book/functions#extension-function)，如果给定键下的值在映射中存在，则返回 `true{:tact}`，否则返回 `false{:tact}`。 +映射上的 `.exists(){:tact}` [方法](/zh-cn/book/functions#extension-function)，如果给定键下的值在映射中存在，则返回 `true{:tact}`，否则返回 `false{:tact}`。 ```tact let fizz: map = emptyMap(); @@ -165,7 +165,7 @@ if (fizz.get(1 / 2) != null) { // also true, but consumes more gas ### 检查是否为空，`.isEmpty()` {#isempty} -地图上的 `.isEmpty(){:tact}` [方法](/book/functions#extension-function) 如果地图为空，则返回 `true{:tact}`，否则返回 `false{:tact}`： +地图上的 `.isEmpty(){:tact}` [方法](/zh-cn/book/functions#extension-function) 如果地图为空，则返回 `true{:tact}`，否则返回 `false{:tact}`： ```tact let fizz: map = emptyMap(); @@ -183,7 +183,7 @@ if (fizz == null) { ### 转换为 `Cell`, `.asCell()` {#ascell} -在地图上使用 `.asCell(){:tact}` [方法](/book/functions#extension-function)，将其所有值转换为 [`单元格{:tact}`][单元格] 类型。 请注意，[`Cell{:tact}`][单元格] 类型最多只能存储 1023 位，因此将更大的映射转换为单元格会导致错误。 +在地图上使用 `.asCell(){:tact}` [方法](/zh-cn/book/functions#extension-function)，将其所有值转换为 [`单元格{:tact}`][单元格] 类型。 请注意，[`Cell{:tact}`][单元格] 类型最多只能存储 1023 位，因此将更大的映射转换为单元格会导致错误。 例如，这种方法适用于在回复正文中直接发送小地图： @@ -212,7 +212,7 @@ contract Example { ### 遍历条目 {#traverse} -要遍历地图条目，有一个 [`foreach{:tact}`](/book/statements#foreach-loop)循环语句： +要遍历地图条目，有一个 [`foreach{:tact}`](/zh-cn/book/statements#foreach-loop)循环语句： ```tact // Empty map @@ -228,7 +228,7 @@ foreach (key, value in fizz) { } ``` -了解更多相关信息：[`foreach{:tact}` loop in Book→Statements](/book/statements#foreach-loop). +了解更多相关信息：[`foreach{:tact}` loop in Book→Statements](/zh-cn/book/statements#foreach-loop). 请注意，也可以将映射作为简单数组使用，只要定义一个 `map{:tact}`，键为 [`Int{:tact}`][int] 类型，值为任何允许的 `V{:tact}` 类型，并跟踪单独变量中的项数即可： @@ -285,7 +285,7 @@ contract Iteration { :::caution - 请注意，手动记录项目数或检查此类地图的长度非常容易出错，一般不建议使用。 相反，请尝试将您的地图封装到 [Struct](/book/structs-and-messages#structs) 中，并在其上定义 [extension functions](/book/functions#extension-function) 。 参见 Cookbook 中的示例：[如何使用包裹在 Struct 中的 map 来模拟数组](/cookbook/data-structures#array)。 + 请注意，手动记录项目数或检查此类地图的长度非常容易出错，一般不建议使用。 相反，请尝试将您的地图封装到 [Struct](/zh-cn/book/structs-and-messages#structs) 中，并在其上定义 [extension functions](/zh-cn/book/functions#extension-function) 。 参见 Cookbook 中的示例：[如何使用包裹在 Struct 中的 map 来模拟数组](/zh-cn/cookbook/data-structures#array)。 ::: @@ -294,14 +294,14 @@ contract Iteration { 本例改编自 [howardpen9/while-example-tact](https://github.com/howardpen9/while-example-tact/blob/de5807fcd20dba5f6a3748d112511477fb22bfcc/contracts/awesome.tact#L19C10-L19C10). 查看 Cookbook 中有关 map 使用的其他示例：\ - [如何使用包裹在 Struct 中的 map 来模拟堆栈](/cookbook/data-structures#stack)\ - [如何使用包裹在 Struct 中的 map 来模拟循环缓冲区](/cookbook/data-structures#circular-buffer) + [如何使用包裹在 Struct 中的 map 来模拟堆栈](/zh-cn/cookbook/data-structures#stack)\ + [如何使用包裹在 Struct 中的 map 来模拟循环缓冲区](/zh-cn/cookbook/data-structures#circular-buffer) ::: ## 序列化 -可以对映射键、值或两者进行[整数序列化](/zh-cn/book/integers#serialization-types)，以[保留空间并降低存储成本](/book/integers#serialization)： +可以对映射键、值或两者进行[整数序列化](/zh-cn/book/integers#serialization-types)，以[保留空间并降低存储成本](/zh-cn/book/integers#serialization)： ```tact struct SerializedMapInside { @@ -313,7 +313,7 @@ struct SerializedMapInside { :::note - 了解其他序列化选项：[与 FunC 兼容](/book/func#convert-serialization)。 + 了解其他序列化选项：[与 FunC 兼容](/zh-cn/book/func#convert-serialization)。 ::: @@ -357,6 +357,6 @@ contract Example { TODO：添加对分片页面的引用，如： https://github.com/tact-lang/tact-docs/issues/155 */} -[p]: /book/types#primitive-types -[int]: /book/integers -[电池]: /book/cells#cells +[p]: /zh-cn/book/types#primitive-types +[int]: /zh-cn/book/integers +[电池]: /zh-cn/book/cells#cells diff --git a/docs/src/content/docs/zh-cn/book/masterchain.mdx b/docs/src/content/docs/zh-cn/book/masterchain.mdx index fc24dda14..b168765bb 100644 --- a/docs/src/content/docs/zh-cn/book/masterchain.mdx +++ b/docs/src/content/docs/zh-cn/book/masterchain.mdx @@ -4,19 +4,19 @@ title: 主链 :::caution - 除非将[配置文件](/book/config)中的 "masterchain "选项设置为 `true{:json}`，否则主链地址将被视为无效。 + 除非将[配置文件](/zh-cn/book/config)中的 "masterchain "选项设置为 `true{:json}`，否则主链地址将被视为无效。 ::: 在 TON 区块链中，一条名为["主链"](https://docs.ton.org/learn/overviews/ton-blockchain#masterchain-blockchain-of-blockchains) 的特殊链用于同步消息路由和交易执行，因此网络中的节点可以固定多链状态中的某个特定点，并就该状态达成共识。 -主链存储 [网络配置](/ref/core-advanced#getconfigparam) 和所有 [工作链] 的最终状态(https://docs.ton.org/learn/overviews/ton-blockchain#workchain-blockchain-with-your-own-rules)。 它承载着基本的协议信息，包括当前设置、活动验证器及其赌注列表、活动工作链以及相关的[分块链](https://docs.ton.org/develop/blockchain/shards)。 最重要的是，它为所有工作链和分块链维护最新的区块哈希值记录，从而在整个网络中达成共识。 +主链存储 [网络配置](/zh-cn/ref/core-advanced#getconfigparam) 和所有 [工作链] 的最终状态(https://docs.ton.org/learn/overviews/ton-blockchain#workchain-blockchain-with-your-own-rules)。 它承载着基本的协议信息，包括当前设置、活动验证器及其赌注列表、活动工作链以及相关的[分块链](https://docs.ton.org/develop/blockchain/shards)。 最重要的是，它为所有工作链和分块链维护最新的区块哈希值记录，从而在整个网络中达成共识。 ## 主链如何保护合约 Tact 强制所有合约使用 [basechain](https://docs.ton.org/develop/blockchain/shards)，即 ID 为 $0$ 的默认工作链。这样做是为了防止在合约中使用主链地址。 -在未[启用主链支持](#support)的情况下，任何指向主链或以其他方式与之交互的尝试都会产生异常，并显示[退出代码 137](/book/exit-codes#137)： 此合约未启用 “主链支持”。 +在未[启用主链支持](#support)的情况下，任何指向主链或以其他方式与之交互的尝试都会产生异常，并显示[退出代码 137](/zh-cn/book/exit-codes#137)： 此合约未启用 “主链支持”。 也就是说，意外部署到主链、从主链账户接收消息、向此类账户发送消息以及使用主链地址或其链 ID ($-1$) 都是默认禁止的。 @@ -28,7 +28,7 @@ Tact 强制所有合约使用 [basechain](https://docs.ton.org/develop/blockchai ::: -如果您确实需要主链支持，最简单也是最推荐的方法是修改项目根目录下的 [`tact.config.json`](/book/config) 文件（如果还不存在，则创建该文件），并 [将 `masterchain` 属性设置为 `true{:json}`](/book/config#options-masterchain)。 +如果您确实需要主链支持，最简单也是最推荐的方法是修改项目根目录下的 [`tact.config.json`](/zh-cn/book/config) 文件（如果还不存在，则创建该文件），并 [将 `masterchain` 属性设置为 `true{:json}`](/zh-cn/book/config#options-masterchain)。 如果您正在开发基于 [Blueprint][bp] 的项目，可以在合约的编译配置中启用主链支持，这些配置位于名为 `wrappers/` 的目录中： @@ -44,6 +44,6 @@ export const compile：CompilerConfig = { }; ``` -不过，[蓝图][bp] 项目中仍可使用 [`tact.config.json`](/book/config)。 在这种情况下，除非在 `wrappers/` 中修改，否则 [`tact.config.json`](/book/config)中指定的值将作为默认值。 +不过，[蓝图][bp] 项目中仍可使用 [`tact.config.json`](/zh-cn/book/config)。 在这种情况下，除非在 `wrappers/` 中修改，否则 [`tact.config.json`](/zh-cn/book/config)中指定的值将作为默认值。 [bp]: https://github.com/ton-org/blueprint diff --git a/docs/src/content/docs/zh-cn/book/message-mode.mdx b/docs/src/content/docs/zh-cn/book/message-mode.mdx index fc466018f..e028c903c 100644 --- a/docs/src/content/docs/zh-cn/book/message-mode.mdx +++ b/docs/src/content/docs/zh-cn/book/message-mode.mdx @@ -23,9 +23,9 @@ title: Message `mode` | $+16$ | SendBounceIfActionFail | 如果在操作阶段出现任何错误，则退回交易。 Has no effect if flag $+2$, SendIgnoreErrors is used. | | $+32$ | SendDestroyIfZero | Current account must be destroyed if its resulting balance is zero (often used with mode $128$, SendRemainingBalance). | -## 将模式与标志相结合 +## 将模式与标志相结合 {#combining-modes-with-flags} -要为 `SendParameters{:tact}` 的 `mode` 字段创建 [`Int{:tact}`][int] 值，只需通过 [bitwise OR](/book/operators#binary-bitwise-or) 运算将基本模式与可选标记结合起来。 +要为 `SendParameters{:tact}` 的 `mode` 字段创建 [`Int{:tact}`][int] 值，只需通过 [bitwise OR](/zh-cn/book/operators#binary-bitwise-or) 运算将基本模式与可选标记结合起来。 例如，如果您想分别发送普通信息和支付转账费用，请使用模式 $0$（默认）和标志 $+1$，以获得 `mode` $= 1$，这等同于使用 `SendPayGasSeparately{:tact}` 常量。 @@ -46,7 +46,7 @@ send(SendParameters{ :::caution - 请注意，虽然可以将（[`+{:tact}`](/book/operators#binary-add)）基本模式与可选标志一起添加，但由于可能会出现多余的值，因此不鼓励这样做。 请使用位wise OR ([`|{:tact}`](/book/operators#binary-bitwise-or))，因为它是为处理此类标志和对 `mode` 的位操作而设计的。 + 请注意，虽然可以将（[`+{:tact}`](/zh-cn/book/operators#binary-add)）基本模式与可选标志一起添加，但由于可能会出现多余的值，因此不鼓励这样做。 请使用位wise OR ([`|{:tact}`](/zh-cn/book/operators#binary-bitwise-or))，因为它是为处理此类标志和对 `mode` 的位操作而设计的。 ::: @@ -56,4 +56,4 @@ send(SendParameters{ ::: -[int]: /book/integers +[int]: /zh-cn/book/integers diff --git a/docs/src/content/docs/zh-cn/book/operators.mdx b/docs/src/content/docs/zh-cn/book/operators.mdx index 30d41cbfa..3f8b78715 100644 --- a/docs/src/content/docs/zh-cn/book/operators.mdx +++ b/docs/src/content/docs/zh-cn/book/operators.mdx @@ -8,7 +8,7 @@ title: 操作员 :::note - 需要注意的是，Tact 中没有隐式类型转换，因此运算符不能用来添加不同类型的值，或者在不明确转换为相同类型的情况下比较它们的相等性。 这是通过标准库中的某些函数实现的。 请参阅 [`Int.toString(){:tact}`](/ref/core-strings#inttostring)，了解此类函数的示例。 + 需要注意的是，Tact 中没有隐式类型转换，因此运算符不能用来添加不同类型的值，或者在不明确转换为相同类型的情况下比较它们的相等性。 这是通过标准库中的某些函数实现的。 请参阅 [`Int.toString(){:tact}`](/zh-cn/ref/core-strings#inttostring)，了解此类函数的示例。 ::: @@ -95,11 +95,11 @@ title: 操作员 ### 非空断言，`!!` {#unary-non-null-assert} -一元双叹号（_非空断言_）运算符 `!{:tact}`是一个后缀运算符，它强制执行非`null{:tact}`值，如果可选变量不是`null{:tact}`，则允许直接访问可选变量的值。 否则，如果编译器可以跟踪，则引发编译错误；如果不能跟踪，则抛出[退出代码 128](/book/exit-codes#128)异常：空引用异常"。 可应用于任何可选变量，无论其类型是`非空{:tact}`。 +一元双叹号（_非空断言_）运算符 `!{:tact}`是一个后缀运算符，它强制执行非`null{:tact}`值，如果可选变量不是`null{:tact}`，则允许直接访问可选变量的值。 否则，如果编译器可以跟踪，则引发编译错误；如果不能跟踪，则抛出[退出代码 128](/zh-cn/book/exit-codes#128)异常：空引用异常"。 可应用于任何可选变量，无论其类型是`非空{:tact}`。 :::note - 点击此处了解更多有关可选变量和字段的信息：[可选变量](/book/optionals) + 点击此处了解更多有关可选变量和字段的信息：[可选变量](/zh-cn/book/optionals) ::: @@ -152,7 +152,7 @@ let answer：Int = 42; #### 乘法，`*` {#binary-multiply} -二进制星号 (_multiplication_) 运算符 `*{:tact}` 用于两个值的乘法运算。 可能导致 [整数溢出](/book/integers#operations)。 +二进制星号 (_multiplication_) 运算符 `*{:tact}` 用于两个值的乘法运算。 可能导致 [整数溢出](/zh-cn/book/integers#operations)。 只能应用于 [`Int{:tact}`][int]类型的值： @@ -169,7 +169,7 @@ pow(2, 255) * pow(2, 255); // build error: integer overflow！ 二进制斜线 (_division_) 运算符 `/{:tact}` 用于两个值的整除，如果结果为正，则向零截断，如果结果为负，则从零截断。这也叫[向下舍入](https://en.wikipedia.org/wiki/Rounding#Rounding_down)（或向 $-\infty$ 舍入）。 -如果尝试除以零，则会出现[退出代码 4](/book/exit-codes#4)错误：整数溢出。 +如果尝试除以零，则会出现[退出代码 4](/zh-cn/book/exit-codes#4)错误：整数溢出。 只能应用于 [`Int{:tact}`][int] 类型的值： @@ -214,7 +214,7 @@ two % 1; // 1 -1 % -5; // -1 ``` -避免两者混淆的最简单方法是通过 [`abs(x: Int){:tact}`](/ref/core-math#abs)优先使用正值： +避免两者混淆的最简单方法是通过 [`abs(x: Int){:tact}`](/zh-cn/ref/core-math#abs)优先使用正值： ```tact abs(-1) % abs(-5); // 1 @@ -234,7 +234,7 @@ abs(-1) % abs(-5); // 1 #### 添加，`+` {#binary-add} -二进制加法运算符 `+{:tact}` 用于将数字相加。 超出 [`Int{:tact}`][int]的最大值将导致[退出代码 4](/book/exit-codes#4)错误：整数溢出"。 +二进制加法运算符 `+{:tact}` 用于将数字相加。 超出 [`Int{:tact}`][int]的最大值将导致[退出代码 4](/zh-cn/book/exit-codes#4)错误：整数溢出"。 只能应用于 [`Int{:tact}`][int]类型的值： @@ -250,7 +250,7 @@ pow(2, 255) - 1 + pow(2, 255); // 2^256 - 1，Tact 中任何整数的最大值 #### 减去，`-` {#binary-subtract} -二进制减号（_subtraction_）运算符 `-{:tact}` 用于将数字相减。 超出 [`Int{:tact}`][int]的最小值将导致[退出代码 4](/book/exit-codes#4)错误：整数溢出。 +二进制减号（_subtraction_）运算符 `-{:tact}` 用于将数字相减。 超出 [`Int{:tact}`][int]的最小值将导致[退出代码 4](/zh-cn/book/exit-codes#4)错误：整数溢出。 只能应用于 [`Int{:tact}`][int]类型的值： @@ -292,7 +292,7 @@ pow(2, 254) >> 254; // 1 #### 左移，`<<` {#binary-bitwise-shift-left} -二进制双小于号（_bitwise shift left_）运算符 `<<{:tact}` 返回一个整数，其二进制表示为*左操作数*的值向左移动*右操作数*的位数。向左移位的多余比特被丢弃，零比特从右边移入。这是一种更有效的方法，可以将*左操作数*乘以 $2^n$，其中 $n$ 等于*右操作数*。超出 [`Int{:tact}`][int] 的最大值将导致[退出代码 4](/book/exit-codes#4)错误：整数溢出。 +二进制双小于号（_bitwise shift left_）运算符 `<<{:tact}` 返回一个整数，其二进制表示为*左操作数*的值向左移动*右操作数*的位数。向左移位的多余比特被丢弃，零比特从右边移入。这是一种更有效的方法，可以将*左操作数*乘以 $2^n$，其中 $n$ 等于*右操作数*。超出 [`Int{:tact}`][int] 的最大值将导致[退出代码 4](/zh-cn/book/exit-codes#4)错误：整数溢出。 只能应用于 [`Int{:tact}`][int] 类型的值： @@ -374,8 +374,8 @@ two <= 2; // true - [`单元格{:tact}`][单元格]，通过`.hash(){:tact}`隐式比较 - [`片{:tact}`][片]，通过`.hash(){:tact}`隐式比较 - [`字符串{:tact}`][p] -- [`map{:tact}`](/book/maps)，但前提是它们的键和值类型相同 -- [选项和 `null{:tact}` 值](/book/optionals) +- [`map{:tact}`](/zh-cn/book/maps)，但前提是它们的键和值类型相同 +- [选项和 `null{:tact}` 值](/zh-cn/book/optionals) ```tact // Int: @@ -474,7 +474,7 @@ two ^ 3; // 1 二进制条形 (_bitwise OR_) 运算符 `|{:tact}` 应用 [bitwise OR](https://en.wikipedia.org/wiki/Bitwise_operation#OR)，对操作数的每一对相应位执行 [logical OR](#binary-logical-or) 运算。 当我们要应用特定的 [bitmask](https://en.wikipedia.org/wiki/Mask_(computing)) 时，这很有用。 -例如，_bitwise OR_ 通常用于 Tact 中的[将基本模式与可选标记结合](/book/message-mode#combining-modes-with-flags)，方法是将特定位屏蔽到 $1$ ，以构建目标[信息`模式`](/book/message-mode)。 +例如，_bitwise OR_ 通常用于 Tact 中的[将基本模式与可选标记结合](/zh-cn/book/message-mode#combining-modes-with-flags)，方法是将特定位屏蔽到 $1$ ，以构建目标[信息`模式`](/zh-cn/book/message-mode)。 只能应用于 [`Int{:tact}`][int]类型的值： @@ -524,7 +524,7 @@ true || iLikeSnails; // true, didn't evaluate iLikeSnails ## 三元，`?:` {#ternary} -条件（_ternary_）运算符是唯一一个包含三个操作数的 Tact 运算符：一个条件，后面跟一个问号（`?{:tact}`），然后是如果条件被评估为`true{:tact}`时要执行的表达式，后面跟一个冒号（`:{:tact}`），最后是如果条件被评估为`false{:tact}`时要执行的表达式。 该运算符常用于替代 [`if...else{:tact}`](/book/statements#if-else) 语句。 +条件（_ternary_）运算符是唯一一个包含三个操作数的 Tact 运算符：一个条件，后面跟一个问号（`?{:tact}`），然后是如果条件被评估为`true{:tact}`时要执行的表达式，后面跟一个冒号（`:{:tact}`），最后是如果条件被评估为`false{:tact}`时要执行的表达式。 该运算符常用于替代 [`if...else{:tact}`](/zh-cn/book/statements#if-else) 语句。 条件必须解析为 [`布尔{:tact}`][布尔] 类型： @@ -557,7 +557,7 @@ true ?(false ? 1 : 2) : 3; // 2 ## 赋值，`=` {#assignment} -赋值操作符 `={:tact}` 用于为变量或 [Message](/book/structs-and-messages#messages) 或 [Struct](/book/structs-and-messages#structs) 的属性赋值。 赋值是一个语句，不返回值。 +赋值操作符 `={:tact}` 用于为变量或 [Message](/zh-cn/book/structs-and-messages#messages) 或 [Struct](/zh-cn/book/structs-and-messages#structs) 的属性赋值。 赋值是一个语句，不返回值。 ```tact let someVar：Int = 5; // 这里使用了赋值运算符 =... @@ -635,8 +635,8 @@ value = value | 5; // 位似 OR 5 并返回结果 value |= 5; // 也是位似 OR 5 并返回结果 ``` -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers -[电池]: /book/cells#cells -[一片]: /book/cells#slices +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers +[电池]: /zh-cn/book/cells#cells +[一片]: /zh-cn/book/cells#slices diff --git a/docs/src/content/docs/zh-cn/book/optionals.mdx b/docs/src/content/docs/zh-cn/book/optionals.mdx index 48e13b234..1b52aa082 100644 --- a/docs/src/content/docs/zh-cn/book/optionals.mdx +++ b/docs/src/content/docs/zh-cn/book/optionals.mdx @@ -2,15 +2,15 @@ title: 可选项 --- -[类型系统概述](/book/types#optionals)中提到，所有[原始类型](/book/types#primitive-types)、[结构体](/book/structs-and-messages#structs)和[消息](/book/structs-and-messages#messages)都可以为空。也就是说，除了 `null{:tact}`（一种特殊值，表示故意没有任何其他值）之外，它们不一定持有任何值。 +[类型系统概述](/zh-cn/book/types#optionals)中提到，所有[原始类型](/zh-cn/book/types#primitive-types)、[结构体](/zh-cn/book/structs-and-messages#structs)和[消息](/zh-cn/book/structs-and-messages#messages)都可以为空。也就是说，除了 `null{:tact}`（一种特殊值，表示故意没有任何其他值）之外，它们不一定持有任何值。 -[变量](/book/statements#let)或[结构](/book/structs-and-messages#structs)和[消息](/book/structs-and-messages#messages)中可容纳 `null{:tact}` 的字段被称为"可选项"。当变量不一定被使用时，它们对减少状态大小很有用。 +[变量](/zh-cn/book/statements#let)或[结构](/zh-cn/book/structs-and-messages#structs)和[消息](/zh-cn/book/structs-and-messages#messages)中可容纳 `null{:tact}` 的字段被称为"可选项"。当变量不一定被使用时，它们对减少状态大小很有用。 -在变量或字段的类型声明后添加问号 (`?{:tact}`)，就可以将其设为可选变量或字段。唯一的例外是 [`map{:tact}`](/book/maps)和 [`bounced{:tact}`](/book/bounced)，你不能让它们、内部键/值类型（如果是 map）或内部[消息](/book/structs-and-messages#messages)（如果是 bounced）成为可选项。 +在变量或字段的类型声明后添加问号 (`?{:tact}`)，就可以将其设为可选变量或字段。唯一的例外是 [`map{:tact}`](/zh-cn/book/maps)和 [`bounced{:tact}`](/zh-cn/book/bounced)，你不能让它们、内部键/值类型（如果是 map）或内部[消息](/zh-cn/book/structs-and-messages#messages)（如果是 bounced）成为可选项。 -未定义的可选变量或可选字段默认为 `null{:tact}` 值。如果不先检查 `null{:tact}`，就无法访问它们。但如果你确定它们在某一时刻不是 `null{:tact}`，可以使用[非空断言操作符 `!!{:tact}`](/book/operators#unary-non-null-assert)访问它们的值。 +未定义的可选变量或可选字段默认为 `null{:tact}` 值。如果不先检查 `null{:tact}`，就无法访问它们。但如果你确定它们在某一时刻不是 `null{:tact}`，可以使用[非空断言操作符 `!!{:tact}`](/zh-cn/book/operators#unary-non-null-assert)访问它们的值。 -在未使用 [`!!{:tact}`](/book/operators#unary-non-null-assert)或未事先检查 `null{:tact}` 的情况下尝试访问可选变量或可选字段的值，如果编译器可以跟踪，则会导致编译错误；如果不能跟踪，则会导致[退出代码 128](/book/exit-codes#128)异常：空引用异常。 +在未使用 [`!!{:tact}`](/zh-cn/book/operators#unary-non-null-assert)或未事先检查 `null{:tact}` 的情况下尝试访问可选变量或可选字段的值，如果编译器可以跟踪，则会导致编译错误；如果不能跟踪，则会导致[退出代码 128](/zh-cn/book/exit-codes#128)异常：空引用异常。 可选项举例： diff --git a/docs/src/content/docs/zh-cn/book/send.mdx b/docs/src/content/docs/zh-cn/book/send.mdx index 922270973..de6996634 100644 --- a/docs/src/content/docs/zh-cn/book/send.mdx +++ b/docs/src/content/docs/zh-cn/book/send.mdx @@ -4,19 +4,19 @@ title: 发送信息 TON 区块链是基于消息的--要与其他合约通信和部署新合约，您需要发送消息。 -Tact 中的消息通常使用内置[Struct](/book/structs-and-messages#structs) `SendParameters{:tact}`组成，它由以下部分组成： +Tact 中的消息通常使用内置[Struct](/zh-cn/book/structs-and-messages#structs) `SendParameters{:tact}`组成，它由以下部分组成： | 现场 | 类型 | 说明 | | :---- | :---------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 弹跳 | [`Bool{:tact}`][p] | `bounce` - if set to `true` (default) then the message will be bounced back to the sender if the receiver contract doesn't exist or wasn't able to process the message. | | 到 | [`地址{:tact}`][p] | TON 区块链中的内部接收器 [`地址{:tact}`][p]。 | | 值 | [`Int{:tact}`][int]。 | `value` in TON - the amount of TON you want to send with the message. This value is used to cover gas fees on the receiver side. | -| 模式 | [`Int{:tact}`][int]。 | 一个 8 位值，用于配置发送信息的方式，默认值为 $0$。 参见：[消息`模式`](/book/message-mode)。 | +| 模式 | [`Int{:tact}`][int]。 | 一个 8 位值，用于配置发送信息的方式，默认值为 $0$。 参见：[消息`模式`](/zh-cn/book/message-mode)。 | | 身体 | [`Cell?{:tact}`][单元格] | [可选][选项]信息正文作为[`单元格{:tact}`][单元格] | | 代码 | [`Cell?{:tact}`][单元格] | [可选][opt] 合同的初始代码（编译后的字节码） | -| 数据 | [`Cell?{:tact}`][单元格] | [可选][选项]合同的初始数据（合同的[`init(){:tact}`函数](/book/contracts#init-function)的参数） | +| 数据 | [`Cell?{:tact}`][单元格] | [可选][选项]合同的初始数据（合同的[`init(){:tact}`函数](/zh-cn/book/contracts#init-function)的参数） | -字段 `code` 和 `data` 被称为 [初始包](/book/expressions#initof)，用于部署新合约。 +字段 `code` 和 `data` 被称为 [初始包](/zh-cn/book/expressions#initof)，用于部署新合约。 ## 发送简单回复 {#send-simple-reply} @@ -28,9 +28,9 @@ receive() { } ``` -## 发送信息 +## 发送信息 {#send-message} -如果需要更高级的逻辑，可以直接使用 `send(){:tact}` 函数和 `SendParameters{:tact}` [Struct](/book/structs-and-messages#structs) 。 +如果需要更高级的逻辑，可以直接使用 `send(){:tact}` 函数和 `SendParameters{:tact}` [Struct](/zh-cn/book/structs-and-messages#structs) 。 事实上，前面使用 [`.reply(){:tact}`](#send-simple-reply)的示例可以通过调用下面的`send(){:tact}`函数来实现： @@ -60,7 +60,7 @@ send(SendParameters{ }); ``` -[可选标记](/book/message-mode#optional-flags) `SendIgnoreErrors{:tact}`表示即使在发送信息过程中发生错误，也会继续发送下一条信息。**发送阶段的任何错误都不会导致事务逆转**。 +[可选标记](/zh-cn/book/message-mode#optional-flags) `SendIgnoreErrors{:tact}`表示即使在发送信息过程中发生错误，也会继续发送下一条信息。**发送阶段的任何错误都不会导致事务逆转**。 ## 发送打字信息 @@ -80,7 +80,7 @@ send(SendParameters{ ## 部署合约 -要部署一个合约，你需要用 [`initOf{:tact}`](/book/expressions#initof)计算它的地址和初始状态，然后在初始化信息中发送它们： +要部署一个合约，你需要用 [`initOf{:tact}`](/zh-cn/book/expressions#initof)计算它的地址和初始状态，然后在初始化信息中发送它们： ```tact let init: StateInit = initOf SecondContract(arg1, arg2); @@ -97,7 +97,7 @@ send(SendParameters{ }); ``` -## 外发信息处理 +## 外发信息处理 {#outbound-message-processing} TON 区块链上的每笔交易都由 [多个阶段][阶段] 组成。 出站报文在[计算阶段][计算]中进行评估，但\*\*\*不在该阶段发送。 在[计算阶段][compute]中列出的所有操作，如外向消息或[储备请求]（/ref/core-advanced#nativereserve），都会在[操作阶段][phases]中执行。 @@ -131,29 +131,29 @@ contract FailureIsNothingButAnotherStep { - [计算阶段][计算]结束后，计算合约的剩余价值 $\mathrm{R}$。 -- 在出站信息处理过程中，假设入站信息中提供了足够的价值，第一条信息会在余额上留下 $\mathrm{R} - (0.042 + \mathrm{forward\_fees})$ [nanoToncoins](/book/integers#nanotoncoin) 。 +- 在出站信息处理过程中，假设入站信息中提供了足够的价值，第一条信息会在余额上留下 $\mathrm{R} - (0.042 + \mathrm{forward\_fees})$ [nanoToncoins](/zh-cn/book/integers#nanotoncoin) 。 -- 处理第二条信息时，合约会尝试发送 $\mathrm{R}$ [纳米通币](/book/integers#nanotoncoin)，但发送失败，因为剩余的金额已经较少。 +- 处理第二条信息时，合约会尝试发送 $\mathrm{R}$ [纳米通币](/zh-cn/book/integers#nanotoncoin)，但发送失败，因为剩余的金额已经较少。 :::note 有关所有信息发送功能的更多信息，请参阅参考资料： -- [`send(){:tact}`](/ref/core-common#send) -- [`emit(){:tact}`](/ref/core-common#emit) -- [`self.notify(){:tact}`](/ref/core-base#self-notify) -- [`self.reply(){:tact}`](/ref/core-base#self-reply) -- [`self.forward(){:tact}`](/ref/core-base#self-forward) -- [`nativeSendMessage(){:tact}`](/ref/core-advanced#nativesendmessage) +- [`send(){:tact}`](/zh-cn/ref/core-common#send) +- [`emit(){:tact}`](/zh-cn/ref/core-common#emit) +- [`self.notify(){:tact}`](/zh-cn/ref/core-base#self-notify) +- [`self.reply(){:tact}`](/zh-cn/ref/core-base#self-reply) +- [`self.forward(){:tact}`](/zh-cn/ref/core-base#self-forward) +- [`nativeSendMessage(){:tact}`](/zh-cn/ref/core-advanced#nativesendmessage) ::: -[p]: /book/types#primitive-types -[int]: /book/integers -[电池]: /book/cells#cells -[选择]: /book/optionals +[p]: /zh-cn/book/types#primitive-types +[int]: /zh-cn/book/integers +[电池]: /zh-cn/book/cells#cells +[选择]: /zh-cn/book/optionals [阶段]: https://docs.ton.org/learn/tvm-instructions/tvm-overview#transactions-and-phases [算]: https://docs.ton.org/learn/tvm-instructions/tvm-overview#compute-phase -[纳米]: /book/integers#nanotoncoin +[纳米]: /zh-cn/book/integers#nanotoncoin [fwdfee]: https://docs.ton.org/develop/howto/fees-low-level#forward-fees diff --git a/docs/src/content/docs/zh-cn/book/statements.mdx b/docs/src/content/docs/zh-cn/book/statements.mdx index 92e61efd7..9cf0a4e95 100644 --- a/docs/src/content/docs/zh-cn/book/statements.mdx +++ b/docs/src/content/docs/zh-cn/book/statements.mdx @@ -2,7 +2,7 @@ title: 发言 --- -以下语句可出现在 [function](/book/functions) 主体的任何位置。 +以下语句可出现在 [function](/zh-cn/book/functions) 主体的任何位置。 ## `let`语句 {#let} @@ -18,7 +18,7 @@ let vExplicitCtx：Context = context(); // 显式类型 Context，内置结构 let vCtx = context(); // 推断类型 Context ``` -请注意，`null{:tact}`的初始值既可以指具有任意 `K{:tact}`和 `V{:tact}`类型的空[`map{:tact}`](/book/maps)，也可以指故意不为[optional](/book/optionals)类型设置任何其他值。 这就是为什么在声明 [optional](/book/optionals) 或 [`map{:tact}`](/book/maps)时，需要明确指定类型，因为无法推断： +请注意，`null{:tact}`的初始值既可以指具有任意 `K{:tact}`和 `V{:tact}`类型的空[`map{:tact}`](/zh-cn/book/maps)，也可以指故意不为[optional](/zh-cn/book/optionals)类型设置任何其他值。 这就是为什么在声明 [optional](/zh-cn/book/optionals) 或 [`map{:tact}`](/zh-cn/book/maps)时，需要明确指定类型，因为无法推断： ```tact let vOptional: Int? = null; // explicit type Int or null @@ -40,7 +40,7 @@ dump(_); // COMPILATION ERROR！无法访问 _ ## `return` 语句 {#return} -`return{:tact}` 语句结束 [function](/book/functions) 的执行，并指定要返回给 [function](/book/functions) 调用者的值。 +`return{:tact}` 语句结束 [function](/zh-cn/book/functions) 的执行，并指定要返回给 [function](/zh-cn/book/functions) 调用者的值。 ```tact // Simple wrapper over stdlib function now() @@ -81,7 +81,7 @@ dump(2 + 2); // stdlib 函数 ## 任务 -赋值语句使用 [赋值运算符](/book/operators#assignment) (`={:tact}`)或 [增强赋值运算符](/book/operators#augmented-assignment) (赋值与运算相结合)： +赋值语句使用 [赋值运算符](/zh-cn/book/operators#assignment) (`={:tact}`)或 [增强赋值运算符](/zh-cn/book/operators#augmented-assignment) (赋值与运算相结合)： ```tact let value：Int; // 声明 @@ -91,7 +91,7 @@ value += 5; // 增强赋值（众多赋值之一，见下文） :::note - 有关赋值和增强赋值的更多信息，请参阅其专门章节：[赋值运算符](/book/operators#assignment)。 + 有关赋值和增强赋值的更多信息，请参阅其专门章节：[赋值运算符](/zh-cn/book/operators#assignment)。 ::: @@ -154,13 +154,13 @@ if (2 + 2 == 3) { :::note - Tact 也有一个三元表达式 `?:{:tact}`，在本书前面已有介绍：[三元表达式](/book/operators#ternary)。 + Tact 也有一个三元表达式 `?:{:tact}`，在本书前面已有介绍：[三元表达式](/zh-cn/book/operators#ternary)。 ::: ### `try...catch` {#try-catch} -`try...catch{:tact}`语句由一个 `try{:tact}`块和一个可选的 `catch{:tact}`块组成，它接收一个 [`Int{:tact}`][int][退出代码](/book/exit-codes)作为唯一参数。 首先执行 `try{:tact}`块中的代码，如果失败，则执行`catch{:tact}`块中的代码，并尽可能回滚`try{:tact}` 块中的更改。 +`try...catch{:tact}`语句由一个 `try{:tact}`块和一个可选的 `catch{:tact}`块组成，它接收一个 [`Int{:tact}`][int][退出代码](/zh-cn/book/exit-codes)作为唯一参数。 首先执行 `try{:tact}`块中的代码，如果失败，则执行`catch{:tact}`块中的代码，并尽可能回滚`try{:tact}` 块中的更改。 :::note @@ -217,7 +217,7 @@ try { } ``` -请注意，与 [`let{:tact}` 语句](#let)类似，在 `catch (){:tact}` 子句中捕获的[退出代码](/book/exit-codes)可以通过指定下划线 `_{:tact}` 来丢弃： +请注意，与 [`let{:tact}` 语句](#let)类似，在 `catch (){:tact}` 子句中捕获的[退出代码](/zh-cn/book/exit-codes)可以通过指定下划线 `_{:tact}` 来丢弃： ```tact try { @@ -229,7 +229,7 @@ try { :::note - 在专用页面上阅读更多有关退出代码的信息：[图书中的出口代码](/book/exit-codes)。 + 在专用页面上阅读更多有关退出代码的信息：[图书中的出口代码](/zh-cn/book/exit-codes)。 ::: @@ -239,7 +239,7 @@ try { ### `repeat` {#repeat-loop} -`repeat复{:tact}`循环执行指定次数的代码块。重复次数应该是一个正的 $32$ 位 [`Int{:tact}`][int]，范围从 $1$ 到 $2^{31} - 1$。如果数值大于这个范围，将出现 [exit code 5](/book/exit-codes#5)，“Integer out of the expected range ”的错误。 +`repeat复{:tact}`循环执行指定次数的代码块。重复次数应该是一个正的 $32$ 位 [`Int{:tact}`][int]，范围从 $1$ 到 $2^{31} - 1$。如果数值大于这个范围，将出现 [exit code 5](/zh-cn/book/exit-codes#5)，“Integer out of the expected range ”的错误。 如果指定的重复次数等于 $0$ 或包含范围 $-2^{256}$ 至 $-1$ 中的任何负数，则忽略该值，不执行代码块。 @@ -287,9 +287,9 @@ do { ### `foreach` {#foreach-loop} -`foreach{:tact}` 循环按顺序对 [`map{:tact}`](/book/maps) 类型的键值对（条目）进行操作：从 map 的最小键到最大键。 +`foreach{:tact}` 循环按顺序对 [`map{:tact}`](/zh-cn/book/maps) 类型的键值对（条目）进行操作：从 map 的最小键到最大键。 -该循环为给定映射中的每个条目执行一个代码块，每次迭代都会捕获键和值。 当您事先不知道地图中有多少个条目，或不想明确地使用地图的 [`.get(){:tact}`](/book/maps#get) [method](/book/functions#extension-function) 查找每个条目时，这将非常方便。 +该循环为给定映射中的每个条目执行一个代码块，每次迭代都会捕获键和值。 当您事先不知道地图中有多少个条目，或不想明确地使用地图的 [`.get(){:tact}`](/zh-cn/book/maps#get) [method](/zh-cn/book/functions#extension-function) 查找每个条目时，这将非常方便。 请注意，每次迭代时捕获的键和值对的名称是任意的，可以是任何有效的 Tact 标识符，只要它们是当前作用域的新标识符即可。 最常见的选项是k "和 "v"，或 "key "和 "value"。 @@ -316,7 +316,7 @@ foreach (key, value in cells) { // or just k, v dump(sum); // 1000 ``` -还可以遍历合约存储中的映射，以及作为 [Struct](/book/structs-and-messages#structs) 或 [Message](/book/structs-and-messages#messages) 类型实例成员的映射： +还可以遍历合约存储中的映射，以及作为 [Struct](/zh-cn/book/structs-and-messages#structs) 或 [Message](/zh-cn/book/structs-and-messages#messages) 类型实例成员的映射： ```tact import "@stdlib/deploy"; @@ -394,7 +394,7 @@ foreach (k, v in emptyMap()) { } ``` - 试图遍历函数返回的 [Struct](/book/structs-and-messages#structs)的 map 成员也是行不通的，因为函数调用是一种表达式，而不是标识符或嵌套标识符访问： + 试图遍历函数返回的 [Struct](/zh-cn/book/structs-and-messages#structs)的 map 成员也是行不通的，因为函数调用是一种表达式，而不是标识符或嵌套标识符访问： ```tact foreach (k, v in genCoolStruct().map) { @@ -413,4 +413,4 @@ foreach (k, v in genCoolStruct().map) { ::: -[initOf]: /book/integers +[initOf]: /zh-cn/book/integers diff --git a/docs/src/content/docs/zh-cn/book/structs-and-messages.mdx b/docs/src/content/docs/zh-cn/book/structs-and-messages.mdx index 8c0a026b3..2b7ef902d 100644 --- a/docs/src/content/docs/zh-cn/book/structs-and-messages.mdx +++ b/docs/src/content/docs/zh-cn/book/structs-and-messages.mdx @@ -2,7 +2,7 @@ title: 结构和信息 --- -Tact 支持许多专为智能合约使用而定制的 [原始数据类型](/book/types#primitive-types)。 不过，使用单独的存储方式往往会变得繁琐，因此有 [Structs](#structs) 和 [Messages](#messages)可以将类型组合在一起。 +Tact 支持许多专为智能合约使用而定制的 [原始数据类型](/zh-cn/book/types#primitive-types)。 不过，使用单独的存储方式往往会变得繁琐，因此有 [Structs](#structs) 和 [Messages](#messages)可以将类型组合在一起。 :::caution @@ -116,7 +116,7 @@ message(0x7362d09c) TokenNotification { :::note 更深入的信息请参见： - [Convert received messages to `op` operations](/book/func#convert-received-messages-to-op-operations)\ + [Convert received messages to `op` operations](/zh-cn/book/func#convert-received-messages-to-op-operations)\ [Internal message body layout in TON Docs](https://docs.ton.org/develop/smart-contracts/guidelines/internal-messages#internal-message-body)\ [Messages of the Jetton implementation in Tact](https://github.com/howardpen9/jetton-implementation-in-tact/blob/9eee917877a92af218002874a9f2bd3f9c619229/sources/messages.tact)\ [Jetton Standard in Tact on Tact-by-Example](https://tact-by-example.org/07-jetton-standard) @@ -127,7 +127,7 @@ message(0x7362d09c) TokenNotification { ### 实例化 -创建 [Struct](#structs) 和 [Message](#messages) 实例类似于 [function calls](/book/expressions#static-function-call)，但需要用大括号 `{}{:tact}`（大括号）代替小括号 `(){:tact}`指定参数： +创建 [Struct](#structs) 和 [Message](#messages) 实例类似于 [function calls](/zh-cn/book/expressions#static-function-call)，但需要用大括号 `{}{:tact}`（大括号）代替小括号 `(){:tact}`指定参数： ```tact struct StA { @@ -183,13 +183,13 @@ fun example() { :::note - 因为实例化是 Tact 中的一个表达式，所以在相关页面中也有描述：[实例化表达式](/book/expressions#instantiation)。 + 因为实例化是 Tact 中的一个表达式，所以在相关页面中也有描述：[实例化表达式](/zh-cn/book/expressions#instantiation)。 ::: ### 转换为 `Cell`, `.toCell()` {#tocell} -通过使用 `.toCell(){:tact}` [扩展函数](/book/functions#extension-function)，可以将任意 [Struct](#structs) 或 [Message](#messages) 转换为 [`单元格{:tact}`][单元格] 类型： +通过使用 `.toCell(){:tact}` [扩展函数](/zh-cn/book/functions#extension-function)，可以将任意 [Struct](#structs) 或 [Message](#messages) 转换为 [`单元格{:tact}`][单元格] 类型： ```tact struct Big { @@ -212,16 +212,16 @@ fun conversionFun() { :::note 参见参考资料中的扩展函数： - [`Struct.toCell(){:tact}`](/ref/core-cells#structtocell)/ - [`Message.toCell(){:tact}`](/ref/core-cells#messagetocell)。 + [`Struct.toCell(){:tact}`](/zh-cn/ref/core-cells#structtocell)/ + [`Message.toCell(){:tact}`](/zh-cn/ref/core-cells#messagetocell)。 ::: ### 从 `Cell` 或 `Slice` 获取，`.fromCell()` 和 `.fromSlice()` {#fromcellslice} -无需通过一系列相关的 `.loadSomething(){:tact}` 函数调用来手动解析 [`Cell{:tact}`][cell] 或 [`Slice{:tact}`][slice]，而是可以使用 `.fromCell(){:tact}` 和 `.fromSlice(){:tact}` [扩展函数](/book/functions#extension-function)。这些扩展函数将所提供的 [`Cell{:tact}`][cell] 或 [`Slice{:tact}`][slice] 转换为所需的 [Struct](#structs) 或 [Message](#messages)。 +无需通过一系列相关的 `.loadSomething(){:tact}` 函数调用来手动解析 [`Cell{:tact}`][cell] 或 [`Slice{:tact}`][slice]，而是可以使用 `.fromCell(){:tact}` 和 `.fromSlice(){:tact}` [扩展函数](/zh-cn/book/functions#extension-function)。这些扩展函数将所提供的 [`Cell{:tact}`][cell] 或 [`Slice{:tact}`][slice] 转换为所需的 [Struct](#structs) 或 [Message](#messages)。 -这些扩展函数仅尝试根据 [Struct](#structs) 或 [Message](#messages) 的结构解析 [`Cell{:tact}`][cell] 或 [`Slice{:tact}`][slice]。如果布局不匹配，可能会抛出各种异常——确保用 [`try...catch{:tact}`](/book/statements#try-catch) 块封装代码，以防止意外结果。 +这些扩展函数仅尝试根据 [Struct](#structs) 或 [Message](#messages) 的结构解析 [`Cell{:tact}`][cell] 或 [`Slice{:tact}`][slice]。如果布局不匹配，可能会抛出各种异常——确保用 [`try...catch{:tact}`](/zh-cn/book/statements#try-catch) 块封装代码，以防止意外结果。 ```tact struct Fizz { foo: Int } @@ -292,10 +292,10 @@ fun lawTwo() { } ``` -[st-fc]: /ref/core-cells#structfromcell -[st-fs]: /ref/core-cells#structfromslice -[msg-fc]: /ref/core-cells#messagefromcell -[msg-fs]: /ref/core-cells#messagefromslice -[p]: /book/types#primitive-types -[电池]: /book/cells#cells -[一片]: /book/cells#slices +[st-fc]: /zh-cn/ref/core-cells#structfromcell +[st-fs]: /zh-cn/ref/core-cells#structfromslice +[msg-fc]: /zh-cn/ref/core-cells#messagefromcell +[msg-fs]: /zh-cn/ref/core-cells#messagefromslice +[p]: /zh-cn/book/types#primitive-types +[电池]: /zh-cn/book/cells#cells +[一片]: /zh-cn/book/cells#slices diff --git a/docs/src/content/docs/zh-cn/book/types.mdx b/docs/src/content/docs/zh-cn/book/types.mdx index 78b1532b4..90aed3128 100644 --- a/docs/src/content/docs/zh-cn/book/types.mdx +++ b/docs/src/content/docs/zh-cn/book/types.mdx @@ -5,7 +5,7 @@ title: 类型系统概述 Tact 程序中的每个变量、项目和值都有一个类型。 它们可以是 - [原始类型](#primitive-types) 之一 -- 或 [复合类型](#复合类型) +- 或 [复合类型](#composite-types) Additionally, many of those types [can be made nullable](#optionals). @@ -13,10 +13,10 @@ Additionally, many of those types [can be made nullable](#optionals). Tact 支持许多专为智能合约定制的原始数据类型： -- `Int{:tact}` — Tact 中的所有数字都是 257 位有符号整数，但可以使用[较小的表示方法](/book/integers#serialization)来减少存储成本。 +- `Int{:tact}` — Tact 中的所有数字都是 257 位有符号整数，但可以使用[较小的表示方法](/zh-cn/book/integers#serialization)来减少存储成本。 - `Bool{:tact}` — 经典布尔类型，具有 `true{:tact}` 和 `false{:tact}` 值。 - `Address{:tact}` — TON 区块链中的标准[智能合约地址](https://docs.ton.org/learn/overviews/addresses#address-of-smart-contract)。 -- [`Cell{:tact}`](/book/cells#cells)、[`Builder{:tact}`](/book/cells#builders)、[`Slice{:tact}`](/book/cells#slices) — [TVM][tvm] 的底层基元。 +- [`Cell{:tact}`](/zh-cn/book/cells#cells)、[`Builder{:tact}`](/zh-cn/book/cells#builders)、[`Slice{:tact}`](/zh-cn/book/cells#slices) — [TVM][tvm] 的底层基元。 - `String{:tact}` — 不可变的文本字符串。 - `StringBuilder{:tact}` — 辅助类型，允许以节省 gas 的方式连接字符串。 @@ -26,17 +26,17 @@ Tact 支持许多专为智能合约定制的原始数据类型： 原始类型 `Bool{:tact}` 是经典的布尔类型，只能容纳两个值：`true{:tact}` 和 `false{:tact}`。它便于布尔和逻辑运算，也便于存储标志。 -Tact 中没有隐式类型转换，因此两个布尔值的加法（[`+{:tact}`](/book/operators#binary-add)）是不可能的。这里有许多比较[运算符](/book/operators)，例如： +Tact 中没有隐式类型转换，因此两个布尔值的加法（[`+{:tact}`](/zh-cn/book/operators#binary-add)）是不可能的。这里有许多比较[运算符](/zh-cn/book/operators)，例如： -- `&&{:tact}` 为 [logical AND](/book/operators#binary-logical-and) -- `||{:tact}` 为 [logical OR](/book/operators#binary-logical-or) -- `!{:tact}` 为 [logical inversion](/book/operators#unary-inverse) -- `=={:tact}` 和 `!={:tact}` 用于检查[相等](/book/operators#binary-equality) -- `!{:tact}` 表示[非空断言](/book/optionals) +- `&&{:tact}` 为 [logical AND](/zh-cn/book/operators#binary-logical-and) +- `||{:tact}` 为 [logical OR](/zh-cn/book/operators#binary-logical-or) +- `!{:tact}` 为 [logical inversion](/zh-cn/book/operators#unary-inverse) +- `=={:tact}` 和 `!={:tact}` 用于检查[相等](/zh-cn/book/operators#binary-equality) +- `!{:tact}` 表示[非空断言](/zh-cn/book/optionals) 将 bools 持久化为状态非常节省空间，因为它们只占用 1 位。 每年在州[花费](https://ton.org/docs/develop/smart-contracts/fees#how-to-calculate-fees)存储 1000 个布尔约需 $0.00072$ ton 。 -## 复合类型 +## 复合类型 {#composite-types} 使用单独的存储手段往往会变得繁琐，因此有办法将多个[原始类型](#primitive-types)组合在一起，创建复合类型： @@ -44,9 +44,9 @@ Tact 中没有隐式类型转换，因此两个布尔值的加法（[`+{:tact}`] - 复合类型，如[结构体和消息](#structs-and-messages) - [可选项](#optionals) - [结构体和消息](#structs-and-messages)变量或字段的`null{:tact}`值。 -除上述复合类型外，Tact 还提供了一种特殊的类型构造函数[`bounced{:tact}`](/book/bounced)，它只能在[弹回消息接收器](/book/bounced)中指定。 +除上述复合类型外，Tact 还提供了一种特殊的类型构造函数[`bounced{:tact}`](/zh-cn/book/bounced)，它只能在[弹回消息接收器](/zh-cn/book/bounced)中指定。 -请注意，虽然[合约](#contracts)和[特质](#traits)也被视为Tact类型系统的一部分，但我们不能像[结构体和消息](#structs-and-messages)那样传递它们。相反，我们可以使用[`initOf{:tact}`](/book/expressions#initof)表达式来获取给定合约的初始状态。 +请注意，虽然[合约](#contracts)和[特质](#traits)也被视为Tact类型系统的一部分，但我们不能像[结构体和消息](#structs-and-messages)那样传递它们。相反，我们可以使用[`initOf{:tact}`](/zh-cn/book/expressions#initof)表达式来获取给定合约的初始状态。 ### 映射 {#maps} @@ -58,7 +58,7 @@ let mapExample: map = emptyMap(); // 带有 Int 键和值的空地图 在专门页面了解更多信息：[地图][地图]。 -[[Maps](#maps)]: /book/maps +[[Maps](#maps)]: /zh-cn/book/maps ### 结构和信息 {#structs-and-messages} @@ -88,9 +88,9 @@ message(0x11111111) SetValue { 有关它们的更多信息，请访问专门页面：[结构和信息][s-n-m]。 -[s-n-m]: /book/structs-and-messages -[structs]: /book/structs-and-messages#structs -[messages]: /book/structs-and-messages#messages +[s-n-m]: /zh-cn/book/structs-and-messages +[structs]: /zh-cn/book/structs-and-messages#structs +[messages]: /zh-cn/book/structs-and-messages#messages ### 可选项 {#optionals} @@ -104,13 +104,13 @@ let opt: Int? = null; // Int or null, with explicitly assigned null Learn more about them on a dedicated page: [Optionals][optionals]. -[选修课]: /book/optionals +[选修课]: /zh-cn/book/optionals ### 合同 {#contracts} Contracts are the main entry of a smart contract on the TON blockchain. It holds all functions, getters, and receivers of a TON contract. -[合同示例](/book/contracts)： +[合同示例](/zh-cn/book/contracts)： ```tact contract HelloWorld { @@ -138,11 +138,11 @@ or [Contracts](#contracts) and [Traits](#traits) ### 特质 {#traits} -Tact 不支持经典的类继承，而是引入了**特质**（traits）的概念。它们的结构与[合约](#contracts)相同，但不能[初始化持久状态变量](/book/contracts#init-function)。 +Tact 不支持经典的类继承，而是引入了**特质**（traits）的概念。它们的结构与[合约](#contracts)相同，但不能[初始化持久状态变量](/zh-cn/book/contracts#init-function)。 -特质还可以让继承它的契约重写其[函数](/book/functions#virtual-and-abstract-functions)的行为和[常量](/book/constants#virtual-and-abstract-constants)的值。 +特质还可以让继承它的契约重写其[函数](/zh-cn/book/functions#virtual-and-abstract-functions)的行为和[常量](/zh-cn/book/constants#virtual-and-abstract-constants)的值。 -来自 [`@stdlib/ownable`](/ref/stdlib-ownable) 的 trait [`Ownable`](/ref/stdlib-ownable#ownable) 示例： +来自 [`@stdlib/ownable`](/zh-cn/ref/stdlib-ownable) 的 trait [`Ownable`](/zh-cn/ref/stdlib-ownable#ownable) 示例： ```tact trait Ownable { @@ -161,7 +161,7 @@ trait Ownable { } ``` -而 [contract](#contracts) 使用了 trait [`Ownable{:tact}`](/ref/stdlib-ownable#ownable)： +而 [contract](#contracts) 使用了 trait [`Ownable{:tact}`](/zh-cn/ref/stdlib-ownable#ownable)： ```tact contract Treasure with Ownable { diff --git a/docs/src/content/docs/zh-cn/cookbook/access.mdx b/docs/src/content/docs/zh-cn/cookbook/access.mdx index 013ad9fb6..76053d144 100644 --- a/docs/src/content/docs/zh-cn/cookbook/access.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/access.mdx @@ -41,7 +41,7 @@ Deployable, Ownable 的 SenderChecker 合约 { :::note[Useful links:] - [核心库中的 `trait Ownable{:tact}`](/ref/stdlib-ownable#ownable) + [核心库中的 `trait Ownable{:tact}`](/zh-cn/ref/stdlib-ownable#ownable) ::: diff --git a/docs/src/content/docs/zh-cn/cookbook/data-structures.mdx b/docs/src/content/docs/zh-cn/cookbook/data-structures.mdx index ab76104e0..1b1399cf5 100644 --- a/docs/src/content/docs/zh-cn/cookbook/data-structures.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/data-structures.mdx @@ -8,11 +8,11 @@ title: 数据结构 这里列出的所有数据结构都是使用内置的 [`map{:tact}`][map]类型制作的。 有关地图的描述和基本用法，请参阅[本书专页][地图]。 -## 数组 +## Array [数组](https://en.wikipedia.org/wiki/Array_(data_structure)) 是一种数据结构，由连续的内存块组成，代表相同内存大小的元素集合，每个元素至少由一个数组键或_index_标识。 -下面的示例使用[结构](/book/structs-and-messages#structs)包装的[`map{:tact}`][map]模拟数组，其中`V{:tact}`可以是 map 的任何[允许值类型](/book/maps#allowed-types)： +下面的示例使用[结构](/zh-cn/book/structs-and-messages#structs)包装的[`map{:tact}`][map]模拟数组，其中`V{:tact}`可以是 map 的任何[允许值类型](/zh-cn/book/maps#allowed-types)： ```tact import "@stdlib/deploy"; // for Deployable trait @@ -158,14 +158,14 @@ contract MapAsArray with Deployable { } ``` -## 堆栈 +## Stack [堆栈](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)) 是一种由元素集合组成的数据结构，主要有两种操作： - 推送，将一个元素添加到集合的末尾 - 弹出，移除最近添加的元素 -下面的示例使用[结构](/book/structs-and-messages#structs)包装的[`map{:tact}`][map]模拟堆栈，其中 `V{:tact}`可以是 map 的任何[允许值类型](/book/maps#allowed-types)： +下面的示例使用[结构](/zh-cn/book/structs-and-messages#structs)包装的[`map{:tact}`][map]模拟堆栈，其中 `V{:tact}`可以是 map 的任何[允许值类型](/zh-cn/book/maps#allowed-types)： ```tact import "@stdlib/deploy"; // for Deployable trait @@ -262,11 +262,11 @@ contract MapAsStack with Deployable { } ``` -## 圆形缓冲区 +## Circular buffer [循环缓冲区](https://en.wikipedia.org/wiki/Circular_buffer)（循环队列、循环缓冲区或环形缓冲区）是一种数据结构，它使用单个固定大小的[缓冲区](https://en.wikipedia.org/wiki/Data_buffer)，就像端对端连接一样。 -下面的示例使用包裹在 [Struct](/book/structs-and-messages#structs) 中的 [`map{:tact}`][map]模拟循环缓冲区，其中 `V{:tact}` 可以是 map 的任何 [允许值类型](/book/maps#allowed-types)： +下面的示例使用包裹在 [Struct](/zh-cn/book/structs-and-messages#structs) 中的 [`map{:tact}`][map]模拟循环缓冲区，其中 `V{:tact}` 可以是 map 的任何 [允许值类型](/zh-cn/book/maps#allowed-types)： ```tact import "@stdlib/deploy"; // for Deployable trait @@ -374,4 +374,4 @@ fun emptyCircularBuffer()：CircularBuffer { ::: -[地图]: /book/maps +[地图]: /zh-cn/book/maps diff --git a/docs/src/content/docs/zh-cn/cookbook/jettons.mdx b/docs/src/content/docs/zh-cn/cookbook/jettons.mdx index 1bf076fda..66ae7d1fc 100644 --- a/docs/src/content/docs/zh-cn/cookbook/jettons.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/jettons.mdx @@ -17,7 +17,7 @@ message(0x7362d09c) JettonTransferNotification { } ``` -使用 [receiver](/book/receive) 功能接受令牌通知信息。 +使用 [receiver](/zh-cn/book/receive) 功能接受令牌通知信息。 :::caution @@ -26,7 +26,7 @@ message(0x7362d09c) JettonTransferNotification { ::: 可使用 jetton 钱包状态初始值和计算 jetton 地址进行验证。 -请注意，通知来自您的合约的 jetton 钱包，因此所有者地址栏应使用 [`myAddress()`](/ref/core-common#myaddress)。 +请注意，通知来自您的合约的 jetton 钱包，因此所有者地址栏应使用 [`myAddress()`](/zh-cn/ref/core-common#myaddress)。 钱包的初始数据布局如下所示，但有时会有所不同。 请注意，"myJettonWalletAddress "也可以存储在合约存储中，以便在每次交易中减少 gas 使用量。 @@ -69,7 +69,7 @@ contract Sample { ## 发送 jetton 转送 -要发送 jetton 传输，请使用 [`send(){:tact}`](/book/send)函数。 +要发送 jetton 传输，请使用 [`send(){:tact}`](/zh-cn/book/send)函数。 请注意，"myJettonWalletAddress" 也可以存储在合约存储中，以便在每次交易中减少 gas 使用量。 ```tact diff --git a/docs/src/content/docs/zh-cn/cookbook/misc.mdx b/docs/src/content/docs/zh-cn/cookbook/misc.mdx index 9f615a92e..6b3dfb11a 100644 --- a/docs/src/content/docs/zh-cn/cookbook/misc.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/misc.mdx @@ -25,7 +25,7 @@ nativeThrowUnless(39, number == 198)； :::note[Useful links:] - [核心库中的 `throw(){:tact}`](/ref/core-debug#throw)/ + [核心库中的 `throw(){:tact}`](/zh-cn/ref/core-debug#throw)/ [Tact-By-Example中的错误](https://tact-by-example.org/03-errors) ::: diff --git a/docs/src/content/docs/zh-cn/cookbook/random.mdx b/docs/src/content/docs/zh-cn/cookbook/random.mdx index 98e557e1b..847e9787b 100644 --- a/docs/src/content/docs/zh-cn/cookbook/random.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/random.mdx @@ -19,8 +19,8 @@ number = random(1, 12)； :::note[Useful links:] - [`randomInt(){:tact}` in Core library](/ref/core-random#randomint)\ - [`random(){:tact}` in Core library](/ref/core-random#random) + [`randomInt(){:tact}` in Core library](/zh-cn/ref/core-random#randomint)\ + [`random(){:tact}` in Core library](/zh-cn/ref/core-random#random) ::: diff --git a/docs/src/content/docs/zh-cn/cookbook/single-communication.mdx b/docs/src/content/docs/zh-cn/cookbook/single-communication.mdx index c367a54fd..a28aed8aa 100644 --- a/docs/src/content/docs/zh-cn/cookbook/single-communication.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/single-communication.mdx @@ -4,7 +4,7 @@ title: 单项合同通信 本页列出了单个已部署合约与区块链上其他合约进行通信的示例。 -有关多个已部署合同之间的通信示例，请参阅：[多合约通信](/cookbook/multi-communication)。 +有关多个已部署合同之间的通信示例，请参阅：[多合约通信](/zh-cn/cookbook/multi-communication)。 ## 如何进行基本回复 {#how-to-make-a-basic-reply} @@ -69,7 +69,7 @@ send(SendParameters{ ## 如何发送带有长文本注释的信息 -如果我们需要发送一条带有冗长文本注释的信息，我们应该创建一个 [`String{:tact}`](/book/types#primitive-types)，由超过 $127$ 个字符组成。 为此，我们可以利用 [`StringBuilder{:tact}`](/book/types#primitive-types)原始类型及其名为 `beginComment(){:tact}` 和 `append(){:tact}` 的方法。 在发送之前，我们应该使用 `toCell(){:tact}` 方法将字符串转换为单元格。 +如果我们需要发送一条带有冗长文本注释的信息，我们应该创建一个 [`String{:tact}`](/zh-cn/book/types#primitive-types)，由超过 $127$ 个字符组成。 为此，我们可以利用 [`StringBuilder{:tact}`](/zh-cn/book/types#primitive-types)原始类型及其名为 `beginComment(){:tact}` 和 `append(){:tact}` 的方法。 在发送之前，我们应该使用 `toCell(){:tact}` 方法将字符串转换为单元格。 ```tact let comment: StringBuilder = beginComment(); @@ -87,10 +87,10 @@ send(SendParameters{ :::note[Useful links:] - ["Sending messages" in the Book](/book/send#send-message)\ - ["Message `mode`" in the Book](/book/message-mode) - [`StringBuilder{:tact}` in the Book](/book/types#primitive-types) - [`Cell{:tact}` in Core library](/ref/core-cells) + ["Sending messages" in the Book](/zh-cn/book/send#send-message)\ + ["Message `mode`" in the Book](/zh-cn/book/message-mode) + [`StringBuilder{:tact}` in the Book](/zh-cn/book/types#primitive-types) + [`Cell{:tact}` in Core library](/zh-cn/ref/core-cells) ::: diff --git a/docs/src/content/docs/zh-cn/cookbook/time.mdx b/docs/src/content/docs/zh-cn/cookbook/time.mdx index 9a3a40eea..ae4e40801 100644 --- a/docs/src/content/docs/zh-cn/cookbook/time.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/time.mdx @@ -6,7 +6,7 @@ title: 时间和日期 使用 `now(){:tact}` 方法获取当前标准[Unix 时间](https://en.wikipedia.org/wiki/Unix_time)。 -如果需要在状态中存储时间或在信息中编码时间，请使用下面的 [serialization](/book/integers#serialization)：`Int as uint32{:tact}`。 +如果需要在状态中存储时间或在信息中编码时间，请使用下面的 [serialization](/zh-cn/book/integers#serialization)：`Int as uint32{:tact}`。 ```tact let currentTime: Int = now(); @@ -18,7 +18,7 @@ if (currentTime > 1672080143) { :::note[Useful links:] - [核心库中的 `now(){:tact}`](/ref/core-common#now)/ + [核心库中的 `now(){:tact}`](/zh-cn/ref/core-common#now)/ [Tact-By-Example中的 "当前时间"](https://tact-by-example.org/04-current-time) ::: diff --git a/docs/src/content/docs/zh-cn/cookbook/type-conversion.mdx b/docs/src/content/docs/zh-cn/cookbook/type-conversion.mdx index f28880e0a..5cda9999b 100644 --- a/docs/src/content/docs/zh-cn/cookbook/type-conversion.mdx +++ b/docs/src/content/docs/zh-cn/cookbook/type-conversion.mdx @@ -2,11 +2,11 @@ title: 类型转换 --- -本页展示了在[原始类型][p]之间进行转换以及从[复合类型](/book/types#composite-types)中获取这些类型的示例。 +本页展示了在[原始类型][p]之间进行转换以及从[复合类型](/zh-cn/book/types#composite-types)中获取这些类型的示例。 ## `Int` ↔ `String` {#int-string} -### 如何将 "字符串 "转换为 "整数 +### 如何将 "字符串 "转换为 "整数 {#how-to-convert-a-string-to-an-int} ```tact // 为 String 类型定义一个新的扩展函数，返回 Int 类型的值 @@ -59,9 +59,9 @@ dump(coinsString); // "0.261119911" :::note[Useful links:] - [`Int.toString(){:tact}` 在核心库中](/ref/core-strings#inttostring)/ - [`Int.toFloatString(){:tact}` 在核心库中](/ref/core-strings#inttofloatstring)/ - [`Int.toCoinsString(){:tact}` 在核心库中](/ref/core-strings#inttocoinsstring) + [`Int.toString(){:tact}` 在核心库中](/zh-cn/ref/core-strings#inttostring)/ + [`Int.toFloatString(){:tact}` 在核心库中](/zh-cn/ref/core-strings#inttofloatstring)/ + [`Int.toCoinsString(){:tact}` 在核心库中](/zh-cn/ref/core-strings#inttocoinsstring) ::: @@ -98,8 +98,8 @@ fun convert() { :::note[Useful links:] - [`Struct.toCell(){:tact}` 在核心库中](/ref/core-cells#structtocell)/ - [`Message.toCell(){:tact}` 在核心库中](/ref/core-cells#messagetocell) + [`Struct.toCell(){:tact}` 在核心库中](/zh-cn/ref/core-cells#structtocell)/ + [`Message.toCell(){:tact}` 在核心库中](/zh-cn/ref/core-cells#messagetocell) ::: @@ -134,10 +134,10 @@ fun convert() { :::note[Useful links:] - [`Struct.fromCell(){:tact}` in Core library](/ref/core-cells#structfromcell)\ - [`Struct.fromSlice(){:tact}` in Core library](/ref/core-cells#structfromslice)\ - [`Message.fromCell(){:tact}` 在核心库中](/ref/core-cells#messagefromcell)/ - [`Message.fromSlice(){:tact}` 在核心库中](/ref/core-cells#messagefromslice) + [`Struct.fromCell(){:tact}` in Core library](/zh-cn/ref/core-cells#structfromcell)\ + [`Struct.fromSlice(){:tact}` in Core library](/zh-cn/ref/core-cells#structfromslice)\ + [`Message.fromCell(){:tact}` 在核心库中](/zh-cn/ref/core-cells#messagefromcell)/ + [`Message.fromSlice(){:tact}` 在核心库中](/zh-cn/ref/core-cells#messagefromslice) ::: @@ -147,4 +147,4 @@ fun convert() { ::: -[p]: /book/types#primitive-types +[p]: /zh-cn/book/types#primitive-types diff --git a/docs/src/content/docs/zh-cn/ref/core-advanced.mdx b/docs/src/content/docs/zh-cn/ref/core-advanced.mdx index 3284b6c53..f4c875f4c 100644 --- a/docs/src/content/docs/zh-cn/ref/core-advanced.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-advanced.mdx @@ -16,9 +16,9 @@ title: 高级 extends fun readForwardFee(self: Context)：Int ``` -[`Context{:tact}`](/ref/core-common#context) 的扩展函数。 +[`Context{:tact}`](/zh-cn/ref/core-common#context) 的扩展函数。 -读取 [forward fee](https://docs.ton.org/develop/smart-contracts/guidelines/processing)，并以 [`Int{:tact}`][int] 的形式返回 [nanoToncoins](/book/integers#nanotoncoin) 的金额。 +读取 [forward fee](https://docs.ton.org/develop/smart-contracts/guidelines/processing)，并以 [`Int{:tact}`][int] 的形式返回 [nanoToncoins](/zh-cn/book/integers#nanotoncoin) 的金额。 使用示例 @@ -26,7 +26,7 @@ extends fun readForwardFee(self: Context)：Int let fwdFee: Int = context().readForwardFee()； ``` -## 获取配置参数 +## getConfigParam ```tact fun getConfigParam(id: Int)：Cell? @@ -46,15 +46,15 @@ let dataStorageFeeConfig: Cell = getConfigParam(18)!!; :::note - 标准库 [`@stdlib/config`](/ref/stdlib-config) 提供了两个相关的辅助函数：\ - [`getConfigAddress(){:tact}`](/ref/stdlib-config#getconfigaddress)，用于获取配置 [`Address{:tact}`][p]/ - [`getElectorAddress(){:tact}`](/ref/stdlib-config#getconfigaddress)，用于获取选区 [`地址{:tact}`][p]。 + 标准库 [`@stdlib/config`](/zh-cn/ref/stdlib-config) 提供了两个相关的辅助函数：\ + [`getConfigAddress(){:tact}`](/zh-cn/ref/stdlib-config#getconfigaddress)，用于获取配置 [`Address{:tact}`][p]/ + [`getElectorAddress(){:tact}`](/zh-cn/ref/stdlib-config#getconfigaddress)，用于获取选区 [`地址{:tact}`][p]。 了解有关其他参数的更多信息：[TON 文档中的配置参数](https://docs.ton.org/develop/howto/blockchain-configs)。 ::: -## 接受消息 +## acceptMessage ```tact fun acceptMessage()； @@ -86,7 +86,7 @@ contract Timeout { ::: -## 承诺 +## commit ```tact fun commit()； @@ -101,13 +101,13 @@ commit(); // 现在，事务被视为 "成功" throw(42); // 这样就不会失败了 ``` -## nativePrepareRandom {#nativePrepareRandom} +## nativePrepareRandom {#nativepreparerandom} ```tact fun nativePrepareRandom()； ``` -使用 [`nativeRandomizeLt(){:tact}`](#本机随机化)准备随机数生成器。 由 [`randomInt(){:tact}`](/ref/core-random#randomint) 和 [`random(){:tact}`](/ref/core-random#random) 函数自动调用。 +使用 [`nativeRandomizeLt(){:tact}`](#nativerandomizelt)准备随机数生成器。 由 [`randomInt(){:tact}`](/zh-cn/ref/core-random#randomint) 和 [`random(){:tact}`](/zh-cn/ref/core-random#random) 函数自动调用。 使用示例 @@ -116,7 +116,7 @@ nativePrepareRandom(); // prepare the RNG // ... do your random things ... ``` -## 本机随机化 +## nativeRandomize ```tact fun nativeRandomize(x: Int)； @@ -131,7 +131,7 @@ nativeRandomize(); // 现在，随机数的可预测性降低了 let idk：Int = randomInt(); // ????, it's random！ ``` -## 本机随机化 +## nativeRandomizeLt ```tact fun nativeRandomizeLt()； @@ -148,55 +148,55 @@ nativeRandomizeLt(); // 现在，随机数对用户来说是不可预测的， let idk：Int = randomInt(); // ???，它是随机的！ ``` -## 本机随机 +## nativeRandom ```tact fun nativeRandom()：Int； ``` -生成并返回 $256$-bit 随机数，就像 [`randomInt(){:tact}`](/ref/core-random#randomint)，但不会事先用 [`nativePrepareRandom(){:tact}`](#nativePrepareRandom)初始化随机生成器。 +生成并返回 $256$-bit 随机数，就像 [`randomInt(){:tact}`](/zh-cn/ref/core-random#randomint)，但不会事先用 [`nativePrepareRandom(){:tact}`](#nativepreparerandom)初始化随机生成器。 :::note - 不要直接使用该函数，而应使用 [`randomInt(){:tact}`](/ref/core-random#randomint)。 + 不要直接使用该函数，而应使用 [`randomInt(){:tact}`](/zh-cn/ref/core-random#randomint)。 ::: -## 本机随机时间间隔 +## nativeRandomInterval ```tact fun nativeRandomInterval(max: Int)：Int； ``` -生成并返回 $256$-bit 的随机数，范围从 $0$ 到 `max`，类似于 [`random(){:tact}`](/ref/core-random#random)，但不会事先用 [`nativePrepareRandom(){:tact}`](#nativePrepareRandom)初始化随机生成器。 +生成并返回 $256$-bit 的随机数，范围从 $0$ 到 `max`，类似于 [`random(){:tact}`](/zh-cn/ref/core-random#random)，但不会事先用 [`nativePrepareRandom(){:tact}`](#nativepreparerandom)初始化随机生成器。 :::note - 不要直接使用该函数，而应使用 [`random(){:tact}`](/ref/core-random#random)。 + 不要直接使用该函数，而应使用 [`random(){:tact}`](/zh-cn/ref/core-random#random)。 ::: -## 本机发送消息 +## nativeSendMessage ```tact fun nativeSendMessage(cell: Cell, mode: Int)； ``` -通过指定完整的 "单元格 "和[信息 "模式"](/book/message-mode)，[排队发送信息](/book/send#outbound-message-processing)。 +通过指定完整的 "单元格 "和[信息 "模式"](/zh-cn/book/message-mode)，[排队发送信息](/zh-cn/book/send#outbound-message-processing)。 :::note - 除非您有无法以其他方式表达的复杂逻辑，否则请优先使用更常见、更方便用户使用的 [`send(){:tact}`](/ref/core-common#send)函数。 + 除非您有无法以其他方式表达的复杂逻辑，否则请优先使用更常见、更方便用户使用的 [`send(){:tact}`](/zh-cn/ref/core-common#send)函数。 ::: -## 本地储备金 +## nativeReserve ```tact fun nativeReserve(amount: Int, mode: Int)； ``` -以指定的金额和模式调用本地 `raw_reserve` 函数。 raw_reserve "是一个函数，用于创建输出操作，从账户余额中储备特定数量的[nanoToncoins](/book/integers#nanotoncoin)。 +以指定的金额和模式调用本地 `raw_reserve` 函数。 raw_reserve "是一个函数，用于创建输出操作，从账户余额中储备特定数量的[nanoToncoins](/zh-cn/book/integers#nanotoncoin)。 它在 FunC 中的签名如下 @@ -206,10 +206,10 @@ raw_reserve(int amount, int mode) impure asm "RAWRESERVE"； 该函数有两个参数： -- 金额：要储备的 [nanoToncoins](/book/integers#nanotoncoin)的数量。 +- 金额：要储备的 [nanoToncoins](/zh-cn/book/integers#nanotoncoin)的数量。 - 模式决定预订行为。 -函数 "raw_reserve "大致等同于创建一个向外发送的消息，将指定的 "金额"[nanoToncoins](/book/integers#nanotoncoin)（或 "b " $-$ "金额"[nanoToncoins](/book/integers#nanotoncoin)，其中 "b "为余额）发送给自己。 这就确保了后续产出行动所花费的资金不会超过剩余资金。 +函数 "raw_reserve "大致等同于创建一个向外发送的消息，将指定的 "金额"[nanoToncoins](/zh-cn/book/integers#nanotoncoin)（或 "b " $-$ "金额"[nanoToncoins](/zh-cn/book/integers#nanotoncoin)，其中 "b "为余额）发送给自己。 这就确保了后续产出行动所花费的资金不会超过剩余资金。 您可以使用原始的 [`Int{:tact}`][int]值，并手动为 `mode` 提供这些值，但为了方便起见，您可以使用一组常量来轻松构建复合 `mode`。 有关基本模式和可选标记的更多信息，请参阅下表。 @@ -225,9 +225,9 @@ raw_reserve(int amount, int mode) impure asm "RAWRESERVE"； | 模式值 | 恒定名称 | 说明 | | ---------: | :---------------------------- | ------------------------------------------------------------------------------------ | -| $0$ | `ReserveExact{:tact}` | 精确保留指定数量的 [纳顿币](/book/integers#nanotoncoin)。 | +| $0$ | `ReserveExact{:tact}` | 精确保留指定数量的 [纳顿币](/zh-cn/book/integers#nanotoncoin)。 | | $1$ | `ReserveAllExcept{:tact}` | 保留所有 [纳米通币]（/book/integers#nanotoncoin），但保留指定数量的 [纳米通币]（/book/integers#nanotoncoin）。 | -| $2$ | `ReserveAtMost{:tact}` | 最多保留指定 "数量 "的 [纳顿币](/book/integers#nanotoncoin)。 | +| $2$ | `ReserveAtMost{:tact}` | 最多保留指定 "数量 "的 [纳顿币](/zh-cn/book/integers#nanotoncoin)。 | ### 可选标记 {#nativereserve-optional-flags} @@ -241,7 +241,7 @@ raw_reserve(int amount, int mode) impure asm "RAWRESERVE"； ### 使用标志组合模式 {#nativereserve-combining-modes-with-flags} -要为 `mode` 参数创建 [`Int{:tact}`][int]值，只需通过 [bitwise OR](/book/operators#binary-bitwise-or)操作将基本模式与可选标志结合起来： +要为 `mode` 参数创建 [`Int{:tact}`][int]值，只需通过 [bitwise OR](/zh-cn/book/operators#binary-bitwise-or)操作将基本模式与可选标志结合起来： ```tact nativeReserve(ton("0.1"), ReserveExact | ReserveBounceIfActionFail); @@ -251,6 +251,6 @@ nativeReserve(ton("0.1"), ReserveExact | ReserveBounceIfActionFail); // 要预订的纳吨币数量 ``` -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers diff --git a/docs/src/content/docs/zh-cn/ref/core-base.mdx b/docs/src/content/docs/zh-cn/ref/core-base.mdx index b96ad6705..ecfa671e6 100644 --- a/docs/src/content/docs/zh-cn/ref/core-base.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-base.mdx @@ -2,7 +2,7 @@ title: 基本特质 --- -Tact 中的每个 [contract](/book/contracts) 和 [trait](/book/types#traits) 都隐式 [继承](/book/contracts#traits) `BaseTrait{:tact}` trait，该 trait 包含大量对任何类型的 contract 最有用的 [internal functions](/book/contracts#internal-functions) 以及一个针对 Tact 高级用户的常量 `self.storageReserve{:tact}`。 +Tact 中的每个 [contract](/zh-cn/book/contracts) 和 [trait](/zh-cn/book/types#traits) 都隐式 [继承](/zh-cn/book/contracts#traits) `BaseTrait{:tact}` trait，该 trait 包含大量对任何类型的 contract 最有用的 [internal functions](/zh-cn/book/contracts#internal-functions) 以及一个针对 Tact 高级用户的常量 `self.storageReserve{:tact}`。 ## 常数 @@ -79,7 +79,7 @@ self.notify("Beware, this is my reply to you!".asComment()); virtual fun forward(to: Address, body: Cell?, bounce: Bool, init: StateInit?)； ``` -[将信息](/book/send#outbound-message-processing)（可跳转或不可跳转）发送到指定地址 `to`。 您可以选择提供信息的 "body "和[`init`包](/book/expressions#initof)。 +[将信息](/zh-cn/book/send#outbound-message-processing)（可跳转或不可跳转）发送到指定地址 `to`。 您可以选择提供信息的 "body "和[`init`包](/zh-cn/book/expressions#initof)。 当[`self.storageReserve{:tact}`](#self-storagereserve)常量被覆盖为$> 0$时，在发送信息之前，它也会尝试从剩余余额中预留`self.storageReserve{:tact}`的[nanoToncoins][nano]金额，然后再以[`SendRemainingBalance{:tact}`](https://docs.tact-lang.org/book/message-mode#base-modes)($128$) 模式发送信息。 @@ -88,7 +88,7 @@ virtual fun forward(to: Address, body: Cell?, bounce: Bool, init: StateInit?)； :::note 请注意，`self.forward(){:tact}` 不会在余额上可用的[nanoToncoins][nano]之外发送额外的[nanoToncoins][nano]。 - 要想用一条信息发送更多的[nanoToncoins][nano]，请使用[`send(){:tact}`](/ref/core-common#send)函数。 + 要想用一条信息发送更多的[nanoToncoins][nano]，请使用[`send(){:tact}`](/zh-cn/ref/core-common#send)函数。 ::: @@ -124,4 +124,4 @@ message PayoutOk { } ``` -[nano]: /book/integers#nanotoncoin +[nano]: /zh-cn/book/integers#nanotoncoin diff --git a/docs/src/content/docs/zh-cn/ref/core-cells.mdx b/docs/src/content/docs/zh-cn/ref/core-cells.mdx index bf2f5438a..83aca63ce 100644 --- a/docs/src/content/docs/zh-cn/ref/core-cells.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-cells.mdx @@ -12,7 +12,7 @@ title: 细胞、建造者和切片 为此，建议高级用户使用[类型语言 - 二进制（TL-B）模式][tlb]。 - 建议每位用户使用 [Structs][struct] 及其 [方法](/book/functions#extension-function)，如 [`Struct.toCell(){:tact}`](#structtocell) 和 [`Struct.fromCell(){:tact}`](#structfromcell)，而不是手动构建和解析单元格，因为 [Structs][struct] 和 [Messages][message] 最接近于[您的合约的活 TL-B 架构](/book/cells#cnp-structs)。 + 建议每位用户使用 [Structs][struct] 及其 [方法](/zh-cn/book/functions#extension-function)，如 [`Struct.toCell(){:tact}`](#structtocell) 和 [`Struct.fromCell(){:tact}`](#structfromcell)，而不是手动构建和解析单元格，因为 [Structs][struct] 和 [Messages][message] 最接近于[您的合约的活 TL-B 架构](/zh-cn/book/cells#cnp-structs)。 ::: @@ -30,7 +30,7 @@ fun beginCell()：生成器 让 fizz：Builder = beginCell()； ``` -## 空单元格 +## emptyCell ```tact fun emptyCell()：单元格； @@ -47,7 +47,7 @@ let buzz：Cell = beginCell().endCell(); fizz == buzz; // true ``` -## 空切片 +## emptySlice ```tact fun emptySlice()：Slice； @@ -81,7 +81,7 @@ extends fun beginParse(self: Cell)：Slice； let fizz：Slice = c.beginParse()； ``` -## 单元格哈希值 +## Cell.hash ```tact extends fun hash(self: Cell)：Int； @@ -142,7 +142,7 @@ extends fun storeUint(self: Builder, value: Int, bits: Int)：Builder； 将 $0 \leq \text{bits} \leq 256$ 的无符号 `bits` 位 `value` 存储到 [`Builder{:tact}`][builder] 的副本中。返回该副本。 -试图存储负 `value` 或提供不足或超界 `bits` 数时，会出现 [退出代码 5](/book/exit-codes#5) 异常："整数超出预期范围"。 +试图存储负 `value` 或提供不足或超界 `bits` 数时，会出现 [退出代码 5](/zh-cn/book/exit-codes#5) 异常："整数超出预期范围"。 使用示例 @@ -161,7 +161,7 @@ extends fun storeInt(self: Builder, value: Int, bits: Int)：Builder； 将$0 ≤$ `bits` $≤ 257$的有符号`bits`-位`值`存储到[`builder{:tact}`][builder]的副本中。 返回该副本。 -试图提供一个不足或超出范围的`比特`数时，会出现[退出代码5](/book/exit-codes#5)的异常：整数超出预期范围"。 +试图提供一个不足或超出范围的`比特`数时，会出现[退出代码5](/zh-cn/book/exit-codes#5)的异常：整数超出预期范围"。 使用示例 @@ -216,7 +216,7 @@ extends fun storeCoins(self: Builder, value: Int)：Builder； 存储（序列化）一个范围为 $0 \ldots 2^{120} - 1$ 的无符号 [`Int{:tact}`][int] `value` 到 [`Builder{:tact}`][builder] 的副本中。`value` 的序列化由 $4$ 位无符号大端整数 $l$ 组成，它是最小的整数 $l \geq 0$，使得 $\text{value} < 2^{8l}$，然后是 `value` 的 $8l$ 位无符号大端表示。返回 [`Builder{:tact}`][builder] 的副本。 -试图存储一个超出范围的`值`时，会出现[退出代码5](/book/exit-codes#5)的异常：超出预期范围的`整数`。 +试图存储一个超出范围的`值`时，会出现[退出代码5](/zh-cn/book/exit-codes#5)的异常：超出预期范围的`整数`。 这是最常见的[纳米通币]存储方式（/book/integers#nanotoncoin）。 @@ -229,7 +229,7 @@ let fizz：Builder = b.storeCoins(42)； :::note[Useful links:] - [特殊的 "硬币 "序列化类型](/book/integers#serialization-coins) + [特殊的 "硬币 "序列化类型](/zh-cn/book/integers#serialization-coins) ::: @@ -260,7 +260,7 @@ extends fun storeRef(self: Builder, cell: Cell)：Builder； 将引用 `cell` 存储到[`Builder{:tact}`][builder]的副本中。 返回该副本。 -由于单个 [`单元格{:tact}`][单元格] 最多可存储 $4$ 引用，如果尝试存储更多引用，则会出现[退出代码 8](/book/exit-codes#8)异常：单元格溢出"。 +由于单个 [`单元格{:tact}`][单元格] 最多可存储 $4$ 引用，如果尝试存储更多引用，则会出现[退出代码 8](/zh-cn/book/exit-codes#8)异常：单元格溢出"。 使用示例 @@ -269,7 +269,7 @@ let b: Builder = beginCell(); let fizz：Builder = b.storeRef(emptyCell())； ``` -## 建造者参考资料 +## Builder.refs ```tact extends fun refs(self: Builder)：Int； @@ -286,7 +286,7 @@ let b: Builder = beginCell(); let fizz：Int = b.refs(); // 0 ``` -## 构建器位 +## Builder.bits ```tact extends fun bits(self: Builder)：Int； @@ -347,9 +347,9 @@ extends mutates fun loadUint(self: Slice, l: Int)：Int； 从 [`Slice{:tact}`][slice]中加载并返回一个无符号的 `l` 位 [`Int{:tact}`][int]，条件是 $0 ≤$ `l` $≤ 256$。 -试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/book/exit-codes#5)异常：超出预期范围的整数。 +试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：超出预期范围的整数。 -尝试加载的数据超过 [`片{:tact}`][片] 包含的数据时，会出现 [exit code 9](/book/exit-codes#9) 异常：单元格下溢"。 +尝试加载的数据超过 [`片{:tact}`][片] 包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：单元格下溢"。 使用示例 @@ -368,9 +368,9 @@ extends fun preloadUint(self: Slice, l: Int)：Int； 为 $0 ≤$ `l` $≤ 256$ 从 [`Slice{:tact}`][slice]中预载并返回一个无符号的 `l` 位 [`Int{:tact}`][int]。 不会修改 [`切片{:tact}`][切片]。 -试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/book/exit-codes#5)异常：超出预期范围的整数。 +试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：超出预期范围的整数。 -尝试预载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9)异常：单元格下溢"。 +尝试预载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：单元格下溢"。 使用示例 @@ -389,9 +389,9 @@ extends mutates fun loadInt(self: Slice, l: Int)：Int； 从 [`Slice{:tact}`][slice]中加载并返回一个有符号的 `l` 位 [`Int{:tact}`][int]，值为 $0 ≤$ `l` $≤ 257$。 -试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/book/exit-codes#5)异常：超出预期范围的整数。 +试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：超出预期范围的整数。 -尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9) 异常：单元格下溢"。 +尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：单元格下溢"。 使用示例 @@ -410,9 +410,9 @@ extends fun preloadInt(self: Slice, l: Int)：Int； 为 $0 ≤$ `l` $≤ 257$ 从 [`Slice{:tact}`][slice]中预载并返回一个有符号的 `l` 位 [`Int{:tact}`][int]。 不会修改 [`切片{:tact}`][切片]。 -试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/book/exit-codes#5)异常：超出预期范围的整数。 +试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：超出预期范围的整数。 -尝试预载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9)异常：单元格下溢"。 +尝试预载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：单元格下溢"。 使用示例 @@ -431,9 +431,9 @@ extends mutates fun loadBits(self: Slice, l: Int)：Slice； 从 [`片{:tact}`][片] 中加载 $0 ≤$ `l` $≤ 1023$ 位，并作为单独的 [`片{:tact}`][片] 返回。 -试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/book/exit-codes#5)异常：超出预期范围的整数。 +试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：超出预期范围的整数。 -尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9) 异常：单元格下溢"。 +尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：单元格下溢"。 使用示例 @@ -452,9 +452,9 @@ extends fun preloadBits(self: Slice, l: Int)：Slice； 从 [`片{:tact}`][片] 中预载 $0 ≤$ `l` $≤ 1023$ 位，并将其作为单独的 [`片{:tact}`][片] 返回。 不修改原始 [`切片{:tact}`][切片]。 -试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/book/exit-codes#5)异常：超出预期范围的整数。 +试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：超出预期范围的整数。 -尝试预载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9)异常：单元格下溢"。 +尝试预载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：单元格下溢"。 使用示例 @@ -473,9 +473,9 @@ extends mutates fun skipBits(self: Slice, l: Int)； 从 [`片{:tact}`][片] 中加载除第一个 0 ≤$ `l` $≤ 1023$ 位以外的所有位。 -试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/book/exit-codes#5)异常：超出预期范围的整数。 +试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：超出预期范围的整数。 -尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9) 异常：单元格下溢"。 +尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：单元格下溢"。 使用示例 @@ -495,9 +495,9 @@ extends mutates fun loadBool(self: Slice)：Bool； 从[`Slice{:tact}`][slice]加载单个位并返回[`Bool{:tact}`][bool]值。 如果加载的位等于 $1$，则读取 `true{:tact}`，否则读取 `false{:tact}`。 -当 [`Bool{:tact}`][bool][`slice{:tact}`][slice]不包含它时，尝试加载此类 [`Bool `][bool]会产生异常，[退出代码 8](/book/exit-codes#8)：单元格溢出"。 +当 [`Bool{:tact}`][bool][`slice{:tact}`][slice]不包含它时，尝试加载此类 [`Bool `][bool]会产生异常，[退出代码 8](/zh-cn/book/exit-codes#8)：单元格溢出"。 -尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9) 异常：单元格下溢"。 +尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：单元格下溢"。 使用示例 @@ -514,11 +514,11 @@ extends mutates fun loadCoins(self: Slice)：Int； [`切片{:tact}`][切片]的扩展突变函数。 -加载并返回[序列化](#builderstorecoins)的一个范围为 $0 ... 2^{120} - 1$ 的无符号 [`Int{:tact}`][int]值，来自 [`片{:tact}`][片]。该值通常代表以[纳吨币](/book/integers#nanotoncoin)为单位的金额。 +加载并返回[序列化](#builderstorecoins)的一个范围为 $0 ... 2^{120} - 1$ 的无符号 [`Int{:tact}`][int]值，来自 [`片{:tact}`][片]。该值通常代表以[纳吨币](/zh-cn/book/integers#nanotoncoin)为单位的金额。 -当 [`Slice{:tact}`][slice]中不包含[`Int{:tact}`][int]时，尝试加载此类[`Int`][int]会产生异常，[退出代码为 8](/book/exit-codes#8)："单元格溢出"。 +当 [`Slice{:tact}`][slice]中不包含[`Int{:tact}`][int]时，尝试加载此类[`Int`][int]会产生异常，[退出代码为 8](/zh-cn/book/exit-codes#8)："单元格溢出"。 -尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9) 异常："单元格下溢"。 +尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常："单元格下溢"。 使用示例 @@ -529,7 +529,7 @@ let fizz：Int = s.loadCoins()； :::note[Useful links:] - [特殊的 "硬币 "序列化类型](/book/integers#serialization-coins) + [特殊的 "硬币 "序列化类型](/zh-cn/book/integers#serialization-coins) ::: @@ -543,9 +543,9 @@ extends mutates fun loadAddress(self: Slice)：地址； 从[`Slice{:tact}`][slice]加载并返回一个[`Address{:tact}`][address]。 -当[`Slice{:tact}`][slice]不包含该地址时，尝试加载该[`Address{:tact}`][address]会产生异常，[退出代码 8](/book/exit-codes#8)："单元格溢出"。 +当[`Slice{:tact}`][slice]不包含该地址时，尝试加载该[`Address{:tact}`][address]会产生异常，[退出代码 8](/zh-cn/book/exit-codes#8)："单元格溢出"。 -尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [退出代码 9](/book/exit-codes#9) 异常："单元格下溢"。 +尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [退出代码 9](/zh-cn/book/exit-codes#9) 异常："单元格下溢"。 使用示例 @@ -564,9 +564,9 @@ extends mutates fun loadRef(self: Slice)：Cell； 从 [`切片{:tact}`][切片] 中加载下一个引用作为 [`单元格{:tact}`][单元格]。 -当 [`切片{:tact}`][切片]不包含该引用时，尝试加载该引用会产生异常，[退出代码 8](/book/exit-codes#8)："单元格溢出"。 +当 [`切片{:tact}`][切片]不包含该引用时，尝试加载该引用会产生异常，[退出代码 8](/zh-cn/book/exit-codes#8)："单元格溢出"。 -尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9) 异常：单元格下溢"。 +尝试加载的数据超过 [`片{:tact}`][片] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：单元格下溢"。 使用示例 @@ -686,7 +686,7 @@ extends fun endParse(self: Slice)； [`切片{:tact}`][切片]的扩展函数。 -检查 [`片{:tact}`][片] 是否为空（即不包含数据位和单元格引用）。 如果不是，则抛出异常[退出代码 9](/book/exit-codes#9)：单元格下溢。 +检查 [`片{:tact}`][片] 是否为空（即不包含数据位和单元格引用）。 如果不是，则抛出异常[退出代码 9](/zh-cn/book/exit-codes#9)：单元格下溢。 使用示例 @@ -737,7 +737,7 @@ let buzz：Cell = beginCell().storeSlice(s).endCell(); fizz == buzz; // true ``` -## 地址.asSlice +## Address.asSlice ```tact extends fun asSlice(self: Address)：Slice； @@ -793,7 +793,7 @@ extends fun fromCell(self: Struct, cell: Cell)：Struct； 将 [`单元格{:tact}`][单元格] 转换为指定的 [结构体][struct]，并返回该 [结构体][struct]。 -试图传递布局与指定 [Struct][struct] 不同的 [`单元格{:tact}`][单元格]，或加载的数据超过 [`单元格{:tact}`][单元格] 所包含的数据时，会出现 [exit code 9](/book/exit-codes#9)异常：单元格下溢"。 +试图传递布局与指定 [Struct][struct] 不同的 [`单元格{:tact}`][单元格]，或加载的数据超过 [`单元格{:tact}`][单元格] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：单元格下溢"。 使用示例 @@ -828,7 +828,7 @@ extends fun fromSlice(self: Struct, cell: Slice)：Struct； 将 [`片{:tact}`][slice]转换为指定的 [Struct][struct]，并返回该 [Struct][struct]。 -尝试传递布局与指定 [结构][struct]不同的 [`片{:tact}`][片]，或加载比 [`片{:tact}`][片] 包含的数据更多的数据时，会出现[退出代码 9](/book/exit-codes#9)异常：单元下溢"。 +尝试传递布局与指定 [结构][struct]不同的 [`片{:tact}`][片]，或加载比 [`片{:tact}`][片] 包含的数据更多的数据时，会出现[退出代码 9](/zh-cn/book/exit-codes#9)异常：单元下溢"。 使用示例 @@ -889,7 +889,7 @@ extends fun fromCell(self: Message, cell: Cell)：消息； 将 [`单元格{:tact}`][单元格] 转换为指定的 [信息][消息]，并返回该 [信息][消息]。 -尝试传递布局与指定[信息][message]不同的[`单元格{:tact}`][单元格]，或加载的数据超过[`单元格{:tact}`][单元格]所包含的数据时，会出现[退出代码 9](/book/exit-codes#9)的异常：单元格下溢"。 +尝试传递布局与指定[信息][message]不同的[`单元格{:tact}`][单元格]，或加载的数据超过[`单元格{:tact}`][单元格]所包含的数据时，会出现[退出代码 9](/zh-cn/book/exit-codes#9)的异常：单元格下溢"。 使用示例 @@ -923,7 +923,7 @@ extends fun fromSlice(self: Message, cell: Slice)：消息； 将 [`片{:tact}`][片] 转换为指定的 [信息][消息]，并返回该 [信息][消息]。 -试图传递布局不同于指定[信息][消息]的[`片{:tact}`][片]，或加载的数据多于[`片{:tact}`][片]所包含的数据时，会出现[退出代码 9](/book/exit-codes#9)的异常：单元下溢"。 +试图传递布局不同于指定[信息][消息]的[`片{:tact}`][片]，或加载的数据多于[`片{:tact}`][片]所包含的数据时，会出现[退出代码 9](/zh-cn/book/exit-codes#9)的异常：单元下溢"。 使用示例 @@ -947,17 +947,17 @@ fun cautiousParse(payload: Slice)：TripleAxe?{ } ``` -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers -[cell]: /book/cells#cells -[builder]: /book/cells#builders -[slice]: /book/cells#slices -[map]: /book/maps -[struct]: /book/structs-and-messages#structs -[message]: /book/structs-and-messages#messages +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers +[cell]: /zh-cn/book/cells#cells +[builder]: /zh-cn/book/cells#builders +[slice]: /zh-cn/book/cells#slices +[map]: /zh-cn/book/maps +[struct]: /zh-cn/book/structs-and-messages#structs +[message]: /zh-cn/book/structs-and-messages#messages -[std-repr]: /book/cells#cells-representation +[std-repr]: /zh-cn/book/cells#cells-representation [tlb]: https://docs.ton.org/develop/data-formats/tl-b-language [sha-2]: https://en.wikipedia.org/wiki/SHA-2#Hash_standard diff --git a/docs/src/content/docs/zh-cn/ref/core-common.mdx b/docs/src/content/docs/zh-cn/ref/core-common.mdx index d752c719b..f30147f6b 100644 --- a/docs/src/content/docs/zh-cn/ref/core-common.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-common.mdx @@ -6,7 +6,7 @@ title: 常见问题 ## 语境 -### 现在 +### now ```tact fun now()：Int @@ -20,13 +20,13 @@ fun now()：Int let timeOffset：Int = now() + 1000; // 距离 now() 千秒 ``` -### 我的余额 +### myBalance ```tact fun myBalance()：Int； ``` -返回当前交易的 [计算阶段](https://docs.ton.org/learn/tvm-instructions/tvm-overview#compute-phase) 开始时智能合约的 [纳米通币](/book/integers#nanotoncoin) 余额。 +返回当前交易的 [计算阶段](https://docs.ton.org/learn/tvm-instructions/tvm-overview#compute-phase) 开始时智能合约的 [纳米通币](/zh-cn/book/integers#nanotoncoin) 余额。 使用示例 @@ -36,11 +36,11 @@ fun myBalance()：Int； :::caution - 请注意，Tact 的 [所有信息发送函数](/book/send) 可以更改_实际_合约的余额，但不会_更新此函数返回的值。 + 请注意，Tact 的 [所有信息发送函数](/zh-cn/book/send) 可以更改_实际_合约的余额，但不会_更新此函数返回的值。 ::: -### 我的地址 +### myAddress ```tact fun myAddress()：地址； @@ -72,7 +72,7 @@ receive() { :::caution - 对于 [getter 函数](/book/contracts#getter-functions)，行为是未定义的，因为它们不能有发送者，也不能发送信息。 + 对于 [getter 函数](/zh-cn/book/contracts#getter-functions)，行为是未定义的，因为它们不能有发送者，也不能发送信息。 ::: @@ -88,13 +88,13 @@ receive() { fun context()：Context； ``` -Returns `Context{:tact}` [Struct](/book/structs-and-messages#structs), that consists of： +Returns `Context{:tact}` [Struct](/zh-cn/book/structs-and-messages#structs), that consists of： | 现场 | 类型 | 说明 | | :----- | :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | 宣布 | [`Bool{:tact}`][bool]。 | [退信](https://ton.org/docs/learn/overviews/addresses#bounceable-vs-non-bounceable-addresses) 标志。 | | 发件人 | [`地址{:tact}`][p] | 发送方在 TON 区块链上的内部地址。 | -| 值 | [`Int{:tact}`][int]。 | 信息中 [nanoToncoins](/book/integers#nanotoncoin) 的数量。 | +| 值 | [`Int{:tact}`][int]。 | 信息中 [nanoToncoins](/zh-cn/book/integers#nanotoncoin) 的数量。 | | 生 | [`切片{:tact}`][切片] | 信息的其余部分作为 [`片{:tact}`][片]。 它遵循 TON 的[内部报文布局](https://docs.ton.org/develop/smart-contracts/messages#message-layout)，从目的地[`地址{:tact}`][p]（[TL-B 符号](https://docs.ton.org/develop/data-formats/tl-b-language) 中的`dest:MsgAddressInt`）开始。 | 使用示例 @@ -112,15 +112,15 @@ require(ctx.value != 68 + 1, "Invalid amount of nanoToncoins, bye!")； ## 地址 -### 新地址 +### newAddress ```tact fun newAddress(chain: Int, hash: Int)：地址； ``` -根据[`链`id](https://ton-blockchain.github.io/docs/#/overviews/TON_blockchain_overview)和[SHA-256](/ref/core-math#sha256)编码的[`哈希`值](https://docs.ton.org/learn/overviews/addresses#account-id)创建一个新的[`地址{:tact}`][p]。 +根据[`链`id](https://ton-blockchain.github.io/docs/#/overviews/TON_blockchain_overview)和[SHA-256](/zh-cn/ref/core-math#sha256)编码的[`哈希`值](https://docs.ton.org/learn/overviews/addresses#account-id)创建一个新的[`地址{:tact}`][p]。 -该函数尽可能在[编译时](/ref/core-comptime)解析常量值。 +该函数尽可能在[编译时](/zh-cn/ref/core-comptime)解析常量值。 使用示例 @@ -135,7 +135,7 @@ let oldTonFoundationAddr: Address = :::caution - 如果 `chain` 无效，该方法会抛出错误[退出代码 136](/book/exit-codes#136)；如果 `chain` 指向主链 ($-1$) 且未启用[主链支持](/book/masterchain)，该方法会抛出错误[退出代码 137](/book/exit-codes#137)。 + 如果 `chain` 无效，该方法会抛出错误[退出代码 136](/zh-cn/book/exit-codes#136)；如果 `chain` 指向主链 ($-1$) 且未启用[主链支持](/zh-cn/book/masterchain)，该方法会抛出错误[退出代码 137](/zh-cn/book/exit-codes#137)。 ::: @@ -143,17 +143,17 @@ let oldTonFoundationAddr: Address = [TON文档中的`chain`（工作链ID）](https://docs.ton.org/learn/overviews/addresses#workchain-id)\ [TON文档中的`hash`（账户ID）](https://docs.ton.org/learn/overviews/addresses#account-id)\ - [合约的初始包（`StateInit{:tact}`）](/book/expressions#initof) + [合约的初始包（`StateInit{:tact}`）](/zh-cn/book/expressions#initof) ::: -### 合同地址 +### contractAddress ```tact fun contractAddress(s: StateInit)：地址； ``` -根据智能合约的 [`StateInit{:tact}`](/book/expressions#initof)，计算智能合约在工作链 $0$ 中的 [`地址{:tact}`][p]。 +根据智能合约的 [`StateInit{:tact}`](/zh-cn/book/expressions#initof)，计算智能合约在工作链 $0$ 中的 [`地址{:tact}`][p]。 使用示例 @@ -161,13 +161,13 @@ fun contractAddress(s: StateInit)：地址； 让 foundMeSome：Address = contractAddress(initOf SomeContract())； ``` -### 合同地址扩展 +### contractAddressExt ```tact fun contractAddressExt(chain: Int, code: Cell, data: Cell)：地址； ``` -根据 "链 "id、合约 "代码 "和合约初始状态 "数据 "计算智能合约的[`地址{:tact}`][p]。 使用 [`initOf{:tact}`](/book/expressions#initof)表达式获取给定合约的初始 `code` 和初始 `data` 。 +根据 "链 "id、合约 "代码 "和合约初始状态 "数据 "计算智能合约的[`地址{:tact}`][p]。 使用 [`initOf{:tact}`](/zh-cn/book/expressions#initof)表达式获取给定合约的初始 `code` 和初始 `data` 。 使用示例 @@ -178,26 +178,26 @@ let hereBeDragons：Address = contractAddressExt(0, initPkg.code, initPkg.data) :::caution - 如果 `chain` 无效，该方法会抛出错误[退出代码 136](/book/exit-codes#136)；如果 `chain` 指向主链 ($-1$) 且未启用[主链支持](/book/masterchain)，该方法会抛出错误[退出代码 137](/book/exit-codes#137)。 + 如果 `chain` 无效，该方法会抛出错误[退出代码 136](/zh-cn/book/exit-codes#136)；如果 `chain` 指向主链 ($-1$) 且未启用[主链支持](/zh-cn/book/masterchain)，该方法会抛出错误[退出代码 137](/zh-cn/book/exit-codes#137)。 ::: :::note - 要使用该功能，必须在 [configuration file](/book/config). - 中为当前项目将编译器选项 `debug` 设置为 `true{:tact}`：[调试](/book/debug)。 + 要使用该功能，必须在 [configuration file](/zh-cn/book/config). + 中为当前项目将编译器选项 `debug` 设置为 `true{:tact}`：[调试](/zh-cn/book/debug)。 ::: ## 交流 -### 发送 +### send ```tact fun send(params: SendParameters)； ``` -使用 [`发送参数{:tact}`](/book/send)[结构](/book/structs-and-messages#structs)发送[队列信息](/book/send#outbound-message-processing)。 +使用 [`发送参数{:tact}`](/zh-cn/book/send)[结构](/zh-cn/book/structs-and-messages#structs)发送[队列信息](/zh-cn/book/send#outbound-message-processing)。 使用示例 @@ -211,19 +211,19 @@ send(SendParameters{ :::note[Useful links:] - [Sending messages in the Book](/book/send)/ - [Message`mode` in the Book](/book/message-mode)/ - [Single-contract communication in the Cookbook](/cookbook/single-communication) + [Sending messages in the Book](/zh-cn/book/send)/ + [Message`mode` in the Book](/zh-cn/book/message-mode)/ + [Single-contract communication in the Cookbook](/zh-cn/cookbook/single-communication) ::: -### 发出 +### emit ```tact fun emit(body: Cell)； ``` -将[信息排队](/book/send#outbound-message-processing) `body` 发送到外部世界，以便在链外进行记录和分析。 该信息没有收件人，与使用 Tact 的其他信息发送功能相比更省油。 +将[信息排队](/zh-cn/book/send#outbound-message-processing) `body` 发送到外部世界，以便在链外进行记录和分析。 该信息没有收件人，与使用 Tact 的其他信息发送功能相比更省油。 使用示例 @@ -233,13 +233,13 @@ emit("Catch me if you can, Mr. Holmes".asComment()); // asComment() 将字符串 :::note - 要分析 `emit(){:tact}` 调用，必须查看合约产生的 [外部信息](/book/external)。 + 要分析 `emit(){:tact}` 调用，必须查看合约产生的 [外部信息](/zh-cn/book/external)。 - 了解更多信息：[通过 `emit(){:tact}`记录日志](/book/debug#logging)。 + 了解更多信息：[通过 `emit(){:tact}`记录日志](/zh-cn/book/debug#logging)。 ::: -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers -[一片]: /book/cells#slices +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers +[一片]: /zh-cn/book/cells#slices diff --git a/docs/src/content/docs/zh-cn/ref/core-comptime.mdx b/docs/src/content/docs/zh-cn/ref/core-comptime.mdx index ef491aa09..034738eff 100644 --- a/docs/src/content/docs/zh-cn/ref/core-comptime.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-comptime.mdx @@ -2,7 +2,7 @@ title: 编译时 --- -本页列出了所有内置 [全局静态函数](/book/functions#global-static-functions)，这些函数在构建 Tact 项目时进行评估，无法处理非恒定的运行时数据。 这些函数通常被称为 "编译时函数"。 +本页列出了所有内置 [全局静态函数](/zh-cn/book/functions#global-static-functions)，这些函数在构建 Tact 项目时进行评估，无法处理非恒定的运行时数据。 这些函数通常被称为 "编译时函数"。 ## 地址 @@ -53,7 +53,7 @@ contract Example { fun ton(value: String)：Int； ``` -编译时函数，将给定的通币`值`从人类可读格式[`String{:tact}`][p]转换为[nanoToncoin](/book/integers#nanotoncoin)[`Int{:tact}`][int]格式。 +编译时函数，将给定的通币`值`从人类可读格式[`String{:tact}`][p]转换为[nanoToncoin](/zh-cn/book/integers#nanotoncoin)[`Int{:tact}`][int]格式。 使用示例 @@ -67,7 +67,7 @@ contract Example { } ``` -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers -[电池]: /book/cells#cells +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers +[电池]: /zh-cn/book/cells#cells diff --git a/docs/src/content/docs/zh-cn/ref/core-debug.mdx b/docs/src/content/docs/zh-cn/ref/core-debug.mdx index 111c409c7..09e47d7ec 100644 --- a/docs/src/content/docs/zh-cn/ref/core-debug.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-debug.mdx @@ -6,17 +6,17 @@ Tact 中调试智能合约常用的函数列表。 :::note - 有关调试的更多信息，请访问专用页面：[调试](/book/debug)。 + 有关调试的更多信息，请访问专用页面：[调试](/zh-cn/book/debug)。 ::: -## 要求 +## require ```tact fun require(condition: Bool, error: String)； ``` -检查 `condition` 并抛出错误，如果 `condition` 为 `false{:tact}`，则从 `error` 消息中生成 [exit code](/book/exit-codes)。 除此之外，别无其他作用。 +检查 `condition` 并抛出错误，如果 `condition` 为 `false{:tact}`，则从 `error` 消息中生成 [exit code](/zh-cn/book/exit-codes)。 除此之外，别无其他作用。 生成退出代码的算法如下： @@ -24,7 +24,7 @@ fun require(condition: Bool, error: String)； - 然后，按此顺序将其值读作一个 32 位 [big-endian](https://en.wikipedia.org/wiki/Endianness) 数字 modulo $63000$ 加 $1000$。 - 最后，它将被放入 `.md` 编译报告文件，该文件与其他编译工件一起存放在项目的 `outputs/` 或 `build/` 目录中。 -保证生成的退出代码不在为 TVM 和 Tact 合同错误保留的常用 $0 - 255$ 范围内，这样就可以将退出代码与 `require(){:tact}` 和任何其他 [标准退出代码](/book/exit-codes) 区分开来。 +保证生成的退出代码不在为 TVM 和 Tact 合同错误保留的常用 $0 - 255$ 范围内，这样就可以将退出代码与 `require(){:tact}` 和任何其他 [标准退出代码](/zh-cn/book/exit-codes) 区分开来。 使用示例 @@ -41,13 +41,13 @@ try { } ``` -## 转储 +## dump ```tact fun dump(arg)； ``` -将参数 `arg` 打印到合约的调试控制台。 仅当[配置文件](/book/config) 中的 "debug "选项设置为 `true{:json}`时才进行评估，否则不执行任何操作。 +将参数 `arg` 打印到合约的调试控制台。 仅当[配置文件](/zh-cn/book/config) 中的 "debug "选项设置为 `true{:json}`时才进行评估，否则不执行任何操作。 可应用于下列类型和值： @@ -56,8 +56,8 @@ fun dump(arg)； - [`地址{:tact}`][p] - [`单元格{:tact}`][单元格]、[`构建器{:tact}`][构建器]或[`切片{:tact}`][切片] - [`String{:tact}`][p] 或 [`StringBuilder{:tact}`][p] -- [`map{:tact}`](/book/maps) -- [选项和 `null{:tact}` 值](/book/optionals) +- [`map{:tact}`](/zh-cn/book/maps) +- [选项和 `null{:tact}` 值](/zh-cn/book/optionals) - void"，当函数没有定义返回值时隐式返回 使用示例 @@ -94,7 +94,7 @@ dump(emit("msg".asComment())); // 由于 emit() 函数不返回值，dump() 将 :::note[Useful links:] - [使用 `dump(){:tact}` 调试](/book/debug#tests-dump) + [使用 `dump(){:tact}` 调试](/zh-cn/book/debug#tests-dump) ::: @@ -104,7 +104,7 @@ dump(emit("msg".asComment())); // 由于 emit() 函数不返回值，dump() 将 fun dumpStack()； ``` -将 [持久状态变量](/book/contracts#variables)的所有值打印到合约的调试控制台。 仅当[配置文件](/book/config) 中的 "debug "选项设置为 `true{:json}`时才进行评估，否则不执行任何操作。 +将 [持久状态变量](/zh-cn/book/contracts#variables)的所有值打印到合约的调试控制台。 仅当[配置文件](/zh-cn/book/config) 中的 "debug "选项设置为 `true{:json}`时才进行评估，否则不执行任何操作。 使用示例 @@ -121,11 +121,11 @@ contract DumpsterFire { :::note[Useful links:] - [使用 `dump(){:tact}` 调试](/book/debug#tests-dump) + [使用 `dump(){:tact}` 调试](/zh-cn/book/debug#tests-dump) ::: -## 丢 +## throw ```tact fun throw(code: Int)； @@ -133,15 +133,15 @@ fun throw(code: Int)； 是 [`nativeThrow(){:tact}`](#nativethrow)的别名。 -## nativethrow +## nativeThrow ```tact fun nativeThrow(code: Int)； ``` -抛出错误代码等于 `code` 的异常。 当前上下文的执行将停止（"nativeThrow "后的语句将不会执行），控制权将传递给调用栈中的第一个[`try...catch{:tact}`块](/book/statements#try-catch)。 如果调用者函数中不存在 `try{:tact}`或 `try...catch{:tact}`块，[TVM](https://docs.ton.org/learn/tvm-instructions/tvm-overview)将终止事务。 +抛出错误代码等于 `code` 的异常。 当前上下文的执行将停止（"nativeThrow "后的语句将不会执行），控制权将传递给调用栈中的第一个[`try...catch{:tact}`块](/zh-cn/book/statements#try-catch)。 如果调用者函数中不存在 `try{:tact}`或 `try...catch{:tact}`块，[TVM](https://docs.ton.org/learn/tvm-instructions/tvm-overview)将终止事务。 -试图在 $0 - 65535$ 范围之外指定 `code` 时，会出现 [exit code 5](/book/exit-codes#5)异常：整数超出预期范围"。 +试图在 $0 - 65535$ 范围之外指定 `code` 时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：整数超出预期范围"。 使用示例 @@ -159,7 +159,7 @@ fun butThisDoesNot() { } ``` -## 原生抛出条件 +## nativeThrowIf ```tact fun nativeThrowIf(code: Int, condition: Bool)； @@ -167,7 +167,7 @@ fun nativeThrowIf(code: Int, condition: Bool)； 类似于 [`nativeThrow(){:tact}`](#nativethrow)，但会在 `condition` 等于 `true{:tact}` 时有条件地抛出异常。 否则不会扔。 -试图在 $0 - 65535$ 范围之外指定 `code` 时，会出现 [exit code 5](/book/exit-codes#5) 异常：整数超出预期范围"。 +试图在 $0 - 65535$ 范围之外指定 `code` 时，会出现 [exit code 5](/zh-cn/book/exit-codes#5) 异常：整数超出预期范围"。 使用示例 @@ -184,7 +184,7 @@ fun butThisDoesNot() { } ``` -## 本机无投掷 +## nativeThrowUnless ```tact fun nativeThrowUnless(code: Int, condition: Bool)； @@ -192,7 +192,7 @@ fun nativeThrowUnless(code: Int, condition: Bool)； 类似于 [`nativeThrow(){:tact}`](#nativethrow)，但会在 `condition` 等于 `false{:tact}` 时有条件地抛出异常。 否则不会扔。 -试图在 $0 - 65535$ 范围之外指定 `code` 时，会出现 [exit code 5](/book/exit-codes#5) 异常：整数超出预期范围"。 +试图在 $0 - 65535$ 范围之外指定 `code` 时，会出现 [exit code 5](/zh-cn/book/exit-codes#5) 异常：整数超出预期范围"。 使用示例 @@ -209,9 +209,9 @@ fun butThisDoesNot() { } ``` -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers -[电池]: /book/cells#cells -[建筑工人]: /book/cells#builders -[一片]: /book/cells#slices +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers +[电池]: /zh-cn/book/cells#cells +[建筑工人]: /zh-cn/book/cells#builders +[一片]: /zh-cn/book/cells#slices diff --git a/docs/src/content/docs/zh-cn/ref/core-math.mdx b/docs/src/content/docs/zh-cn/ref/core-math.mdx index 4cb2aeffe..c2d5d5a49 100644 --- a/docs/src/content/docs/zh-cn/ref/core-math.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-math.mdx @@ -4,7 +4,7 @@ title: 数学 各种数学辅助功能 -## 分钟 +## min ```tact fun min(x: Int, y: Int)：Int； @@ -23,7 +23,7 @@ min(0x45, 3_0_0); // 69, nice // 69 300 ``` -## 最大 +## max ```tact fun max(x: Int, y: Int)：Int； @@ -42,7 +42,7 @@ max(0x45, 3_0_0); // 300 // 69 300 ``` -## 腹肌 +## abs ```tact fun abs(x: Int)：Int @@ -64,7 +64,7 @@ abs(-(-(-42))); // 42 fun log(num: Int, base: Int)：Int； ``` -计算并返回数字 `num` $> 0$ 以 `base` $≥1$ 为底的 [logarithm](https://en.wikipedia.org/wiki/Logarithm) 值。 结果[四舍五入](https://en.wikipedia.org/wiki/Rounding#Rounding_down)。 传入一个非正数`num`值或`base`小于 $1$ 会产生错误[退出代码 5](/book/exit-codes#5)：整数超出预期范围"。 +计算并返回数字 `num` $> 0$ 以 `base` $≥1$ 为底的 [logarithm](https://en.wikipedia.org/wiki/Logarithm) 值。 结果[四舍五入](https://en.wikipedia.org/wiki/Rounding#Rounding_down)。 传入一个非正数`num`值或`base`小于 $1$ 会产生错误[退出代码 5](/zh-cn/book/exit-codes#5)：整数超出预期范围"。 使用示例 @@ -118,7 +118,7 @@ log2(1024); // 10，因为 2^10 是 1024 fun pow(base: Int, exp: Int)：Int； ``` -计算并返回涉及两个数的 [幂级数](https://en.wikipedia.org/wiki/Exponentiation)："基数 "和指数（或_幂_）"exp"。 指数 `exp` 必须是非负数，否则将产生[退出代码 5](/book/exit-codes#5)错误：`整数超出预期范围`。 +计算并返回涉及两个数的 [幂级数](https://en.wikipedia.org/wiki/Exponentiation)："基数 "和指数（或_幂_）"exp"。 指数 `exp` 必须是非负数，否则将产生[退出代码 5](/zh-cn/book/exit-codes#5)错误：`整数超出预期范围`。 请注意，该函数在运行时和［编译时］（/ref/core-comptime）均有效。 @@ -147,7 +147,7 @@ contract Example { :::note - 仅在编译时有效的函数列表：[API 编译时间](/ref/core-comptime)。 + 仅在编译时有效的函数列表：[API 编译时间](/zh-cn/ref/core-comptime)。 ::: @@ -184,11 +184,11 @@ contract Example { :::note - 仅在编译时有效的函数列表：[API 编译时间](/ref/core-comptime)。 + 仅在编译时有效的函数列表：[API 编译时间](/zh-cn/ref/core-comptime)。 ::: -## checksignature +## checkSignature ```tact fun checkSignature(hash: Int, signature: Slice, public_key: Int)：Bool； @@ -229,13 +229,13 @@ contract Showcase { } ``` -## 检查数据签名 +## checkDataSignature ```tact fun checkDataSignature(data: Slice, signature: Slice, public_key: Int)：Bool； ``` -使用 "公钥 "检查 "数据 "的[Ed25519][ed]"签名"，类似于[`checkSignature(){:tact}`](#checksignature)。 如果 `data` 的位长不能被 $8$整除，该函数将产生错误[退出代码 9](/book/exit-codes#9)：单元格下溢。 验证本身是间接进行的：根据 "数据 "的[SHA-256][sha-2] 哈希值进行验证。 +使用 "公钥 "检查 "数据 "的[Ed25519][ed]"签名"，类似于[`checkSignature(){:tact}`](#checksignature)。 如果 `data` 的位长不能被 $8$整除，该函数将产生错误[退出代码 9](/zh-cn/book/exit-codes#9)：单元格下溢。 验证本身是间接进行的：根据 "数据 "的[SHA-256][sha-2] 哈希值进行验证。 如果签名有效，则返回 `true{:tact}`，否则返回 `false{:tact}`。 @@ -260,7 +260,7 @@ fun sha256(data: String)：Int； 如果 `data` 是一个 [`字符串{:tact}`][p]，它的位数应能被 $8$除，如果它是一个 [`片{:tact}`][片]，它也必须\*\*\*没有引用（即总共最多只有 1023 位数据）。 -该函数尽可能在 [编译时](/ref/core-comptime) 解析常量字符串值。 +该函数尽可能在 [编译时](/zh-cn/ref/core-comptime) 解析常量字符串值。 使用示例 @@ -271,9 +271,9 @@ sha256(someVariableElsewhere); // 将尝试在编译时解析， // 并回退到运行时评估 ``` -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers -[一片]: /book/cells#slices +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers +[一片]: /zh-cn/book/cells#slices [编辑]: https://en.wikipedia.org/wiki/EdDSA#Ed25519 [屏蔽-2]: https://en.wikipedia.org/wiki/SHA-2#Hash_standard diff --git a/docs/src/content/docs/zh-cn/ref/core-random.mdx b/docs/src/content/docs/zh-cn/ref/core-random.mdx index d92359473..af4aaf131 100644 --- a/docs/src/content/docs/zh-cn/ref/core-random.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-random.mdx @@ -4,7 +4,7 @@ title: 随机数生成 为 Tact 智能合约生成随机数。 -## 随机的 +## random ```tact fun random(min: Int, max: Int)：Int； @@ -19,7 +19,7 @@ random(42, 43); // 42, always random(0, 42); // 0-41, but never a 42 ``` -## 随机常数 +## randomInt ```tact fun randomInt()：Int； @@ -37,8 +37,8 @@ let allYourRandomBelongsToUs：Int = randomInt(); // ????, it's random :) :::caution - 用于处理随机数的高级函数列在一个专门页面上：[高级应用程序接口](/ref/core-advanced)。 + 用于处理随机数的高级函数列在一个专门页面上：[高级应用程序接口](/zh-cn/ref/core-advanced)。 ::: -[int]: /book/integers +[int]: /zh-cn/book/integers diff --git a/docs/src/content/docs/zh-cn/ref/core-strings.mdx b/docs/src/content/docs/zh-cn/ref/core-strings.mdx index 15baa333a..a05044d91 100644 --- a/docs/src/content/docs/zh-cn/ref/core-strings.mdx +++ b/docs/src/content/docs/zh-cn/ref/core-strings.mdx @@ -6,7 +6,7 @@ title: 字符串和字符串构造器 要以省 gas 的方式连接字符串，请使用 [`字符串生成器{:tact}`][p]。 -要直接使用 [`字符串{:tact}`][p]字面量，请参阅：[字符串字面量](/book/expressions#string-literals)。 +要直接使用 [`字符串{:tact}`][p]字面量，请参阅：[字符串字面量](/zh-cn/book/expressions#string-literals)。 ## beginString @@ -144,7 +144,7 @@ extends fun toSlice(self: StringBuilder)：Slice； [`字符串生成器{:tact}`][p]的扩展函数。 -从 [`StringBuilder{:tact}`][p]返回一个组装好的 [`单元格{:tact}`][单元格] 作为 [`片{:tact}`][片]。 别名为 [`self.toCell().asSlice(){:tact}`](/ref/core-cells#cellasslice)。 +从 [`StringBuilder{:tact}`][p]返回一个组装好的 [`单元格{:tact}`][单元格] 作为 [`片{:tact}`][片]。 别名为 [`self.toCell().asSlice(){:tact}`](/zh-cn/ref/core-cells#cellasslice)。 使用示例 @@ -180,7 +180,7 @@ fizz == buzz; // true, 但要小心，因为并非总是如此。 :::note - 查看 `String.asSlice{:tact}` 函数如何实际使用：[如何将 `String` 转换为 `Int`](/cookbook/type-conversion#how-to-convert-a-string-to-an-int). + 查看 `String.asSlice{:tact}` 函数如何实际使用：[如何将 `String` 转换为 `Int`](/zh-cn/cookbook/type-conversion#how-to-convert-a-string-to-an-int). ::: @@ -219,7 +219,7 @@ extends fun fromBase64(self: String)：Slice； 请注意，该函数是有限制的，只能从给定的 [`字符串{:tact}`][p] 中获取前 $1023$ 位数据，当 [`字符串{:tact}`][p] 较大（即包含超过 $1023$ 位数据）时，不会抛出异常。 -如果给定的 [`String{:tact}`][p] 包含不属于 Base64 集的字符，则会出现[退出代码 134](/book/exit-codes#134)异常："无效参数"。 +如果给定的 [`String{:tact}`][p] 包含不属于 Base64 集的字符，则会出现[退出代码 134](/zh-cn/book/exit-codes#134)异常："无效参数"。 使用示例 @@ -265,7 +265,7 @@ extends fun fromBase64(self: Slice)：Slice； 请注意，该函数是有限制的，只能从给定的 [`片{:tact}`][片] 中获取前 $1023$ 位数据，如果 [`片{:tact}`][片] 有更多数据（即有任何引用），则不会抛出异常。 -如果给定的 [`Slice{:tact}`][p]包含不属于 Base64 集的字符，将产生[退出代码 134](/book/exit-codes#134)异常："无效参数"。 +如果给定的 [`Slice{:tact}`][p]包含不属于 Base64 集的字符，将产生[退出代码 134](/zh-cn/book/exit-codes#134)异常："无效参数"。 使用示例 @@ -300,7 +300,7 @@ extends fun toFloatString(self: Int, digits: Int)：String； 使用小数的[定点表示](https://en.wikipedia.org/wiki/Fixed-point_arithmetic)从[`Int{:tact}`][int]值返回[`String{:tact}`][p]，其中`self`是数字的有效部分，`digits`是小数部分的位数。 -更确切地说，"digits "是 $10^{-\mathrm{digits}}$ 表达式的指数化参数，它给出了实际 [`Int{:tact}`][int]值乘以后所代表的小数。 参数 `digits` 必须在封闭区间内：$0 <$ `digits` $< 78$，否则会出现 [exit code 134](/book/exit-codes#134)异常："无效参数"。 +更确切地说，"digits "是 $10^{-\mathrm{digits}}$ 表达式的指数化参数，它给出了实际 [`Int{:tact}`][int]值乘以后所代表的小数。 参数 `digits` 必须在封闭区间内：$0 <$ `digits` $< 78$，否则会出现 [exit code 134](/zh-cn/book/exit-codes#134)异常："无效参数"。 使用示例 @@ -318,7 +318,7 @@ extends fun toCoinsString(self: Int)：String； 使用小数的[定点表示法](https://en.wikipedia.org/wiki/Fixed-point_arithmetic)从[`Int{:tact}`][int]值返回[`String{:tact}`][p]。 别名为 `self.toFloatString(9){:tact}`。 -用于用字符串表示 [纳米通币](/book/integers#nanotoncoin) [`Int{:tact}`][int]值。 +用于用字符串表示 [纳米通币](/zh-cn/book/integers#nanotoncoin) [`Int{:tact}`][int]值。 使用示例 @@ -347,8 +347,8 @@ extends fun toString(self: Address)：String； let fizz：String = community.toString()； ``` -[p]: /book/types#primitive-types -[bool]: /book/types#booleans -[int]: /book/integers -[电池]: /book/cells#cells -[一片]: /book/cells#slices +[p]: /zh-cn/book/types#primitive-types +[bool]: /zh-cn/book/types#booleans +[int]: /zh-cn/book/integers +[电池]: /zh-cn/book/cells#cells +[一片]: /zh-cn/book/cells#slices diff --git a/docs/src/content/docs/zh-cn/ref/index.mdx b/docs/src/content/docs/zh-cn/ref/index.mdx index d3379ca18..684f98dfe 100644 --- a/docs/src/content/docs/zh-cn/ref/index.mdx +++ b/docs/src/content/docs/zh-cn/ref/index.mdx @@ -12,7 +12,7 @@ import { LinkCard, CardGrid, Steps } from '@astrojs/starlight/components'; 1. #### 核心图书馆 - [核心库](/ref/core-base)提供了自动包含的函数、特质和其他结构体的完整列表及其使用示例。 + [核心库](/zh-cn/ref/core-base)提供了自动包含的函数、特质和其他结构体的完整列表及其使用示例。