Tact 语言基础 ｜结构(Structs)和消息(Messages)

riyad

Tact 支持许多专为智能合约使用而定制的 原始数据类型。 不过，使用单独的存储方式往往会变得繁琐，因此有 Structs 和 Messages可以将类型组合在一起。 不过，使用单独的存储方式往往会变得繁琐，因此有 Structs 和 Messages可以将类型组合在一起。

  h( C7 y. z1 `/ }

结构
结构体可以定义包含多个不同类型字段的复杂数据类型。 它们还可以嵌套。 它们还可以嵌套。
; O' b( Z& j" k9 K) y- L

1. struct Point {
   
2.     x: Int as int64;
   
3.     y: Int as int64;
   
4. }
   3 l: Z0 T9 Q& r$ l2 R1 T( {& {. r
5. 
   
6. struct Line {
   + M& D7 k2 W$ E" ]" b7 Z
7.     start: Point;
   6 t3 I) i4 u9 F
8.     end: Point;
   ! O2 y8 R/ _( W4 s7 O
9. }

复制代码

结构体还可以包含默认字段，并定义可选类型的字段。 结构体还可以包含默认字段和定义[可选类型]字段（/book/optionals）。 如果您有很多字段，但又不想一直在 new instances 中为它们指定通用值，那么这将非常有用。
# s( H2 t# C; |9 L$ N

1. struct Params {
   
2.     name: String = "Satoshi"; // default value
   9 y  B( j- I" p) O  L* V; i5 e
3. 
   * o) @3 }" }/ h3 Y. Q/ w9 L+ W% w
4.     age: Int?; // field with an optional type Int?
   8 H, [) B5 e/ N( U
5.                // and default value of null
   
6. 
   
7.     point: Point; // nested Structs
   & [; b! N+ |/ ]  H7 U* ?+ L
8. }

复制代码

字段的顺序很重要，因为它与TL-B 模式 中的内存布局一致。 不过，与某些采用手动内存管理的语言不同，Tact 在字段之间没有任何填充。
" b. L4 Q8 ^; O% f& S6 }
5 O: o) i# F$ J0 l$ I& y4 x

消息
  S9 d8 ?6 {" \6 \- e消息中可以包含 结构体：
$ G. p4 O* K. b. r

1. struct Point {
   
2.     x: Int;
   
3.     y: Int;
   % c, S. M) E( h9 O( G; g
4. }
   ) `  m6 M2 t( R
5. 
   
6. message Add {
   
7.     point: Point; // holds a struct Point
   
8. }

复制代码

1. // This Message overwrites its unique id with 0x7362d09c
   # Y/ j% k0 S1 F- @
2. message(0x7362d09c) TokenNotification {
   
3.     forwardPayload: Slice as remaining;
   * H2 N/ G/ R  t5 b2 Z
4. }

复制代码

这对于要处理特定智能合约的某些操作码（如 Jetton standard）的情况非常有用。 该合约能够处理的操作码简表为此处以 FunC 表示。 它们是智能合约的接口。
6 H$ m, X9 H( R* Z1 z" I' I

8 O/ W4 g- w" p/ {+ x( y操作
实例化
创建 Struct 和 Message 实例类似于 function calls，但需要用大括号 {}（大括号）代替小括号 ()指定参数：

1. struct StA {
   
2.     field1: Int;
   - V& O/ p% m. @; y" r! s2 ^+ |3 ^3 X7 \
3.     field2: Int;
   / e" `% s% j4 K! \; H  O; \) s
4. }
   7 Y/ d0 s  Z, Z% s& ~( i* M
5. 
   " _2 a+ B, ?0 B; p
6. message MsgB {
   2 H, l( {9 F% V6 W% V# ^
7.     field1: String;
   
8.     field2: String;
   / K& x2 r  h0 P- r+ S
9. }
   
10. 
    
11. fun example() {
    2 c7 g* ]/ S' _: S6 H
12.     // Instance of a Struct StA
    ( s6 Y1 D/ c) l1 c6 U# h
13.     StA{
    9 P! y, h9 ~5 ]! Y0 P( i# ?) x+ a; W
14.         field1: 42,
    
15.         field2: 68 + 1, // trailing comma is allowed
    $ G- Q$ u% C8 M0 o
16.     };
    2 s7 c, C+ f1 @  y2 r8 H4 S$ u
17. 
    0 \( u) F# d0 }! [
18.     // Instance of a Message MsgB
    
19.     MsgB{
    
20.         field1: "May the 4th",
    
21.         field2: "be with you!", // trailing comma is allowed
    9 m0 f! o" n( Y/ o8 R0 }
22.     };
    
23. }

复制代码

1. struct PopQuiz {
   
2.     vogonsCount: Int;
   " x0 s" F6 q; x6 R" P7 P
3.     nicestNumber: Int;
     r( U: R- m" m3 O1 ?& u
4. }
   
5. 
   
6. fun example() {
   
7.     // Let's introduce a couple of variables
   
8.     let vogonsCount: Int = 42;
   - q4 n; x7 n8 ^
9.     let nicestNumber: Int = 68 + 1;
   
10. 
    ( @6 T! \3 g" h; ~/ S: v5 y: _
11.     // You may instantiate the Struct as usual and assign variables to fields,
    - G  ]: s- e6 T/ D: E
12.     // but that is a bit repetitive and tedious at times
    + v1 y" m. A' x' `4 X
13.     PopQuiz{ vogonsCount: vogonsCount, nicestNumber: nicestNumber };
    
14. 
    4 N& H, t" f; G8 y3 g# s1 D
15.     // Let's use field punning and type less,
    0 N/ ]8 H4 B2 k; g+ T2 D" }, M+ {
16.     // because our variable names happen to be the same as field names
    / D+ Y/ [) q+ K" _
17.     PopQuiz{
    9 a6 h/ q! T' V$ u' c
18.         vogonsCount,
    
19.         nicestNumber, // trailing comma is allowed here too!
    
20.     };
    $ j& `" G4 K8 w' y; @
21. }

复制代码

1. struct Big {
   
2.     f1: Int;
   
3.     f2: Int;
   
4.     f3: Int;
   ; x+ H4 R1 `8 t
5.     f4: Int;
   
6.     f5: Int;
   % R# s0 V" C9 L3 o
7.     f6: Int;
   1 {) `6 e- i; J, ?8 [, R
8. }
   6 c4 B( Z: e$ x5 s  z1 C
9. 
   9 e' B# [) M6 k: s5 D: ^2 Y, D
10. fun conversionFun() {
    & k5 q$ x5 t  g/ e% F$ R9 U
11.     dump(Big{
    
12.         f1: 10000000000, f2: 10000000000, f3: 10000000000,
    
13.         f4: 10000000000, f5: 10000000000, f6: 10000000000,
    
14.     }.toCell()); // x{...cell with references...}
    3 D( w+ [" M, `" `9 f
15. }

复制代码

1. struct Fizz { foo: Int }
   
2. message(100) Buzz { bar: Int }
   . U. q# b/ U! z: `+ U
3. 
   4 j* F5 U, _8 g
4. fun constructThenParse() {
   & _; D" x/ f1 u
5.     let fizzCell = Fizz{foo: 42}.toCell();
   
6.     let buzzCell = Buzz{bar: 27}.toCell();
   
7. 
   + Y" v) `' c2 V) g
8.     let parsedFizz: Fizz = Fizz.fromCell(fizzCell);
   
9.     let parsedBuzz: Buzz = Buzz.fromCell(buzzCell);
   
10. }

复制代码

1. struct ArbitraryStruct {}
   8 ~. _5 `5 `/ l9 W3 J, d4 |
2. message(0x2A) ArbitraryMessage {}
   
3. 
   
4. fun lawOne() {
   
5.     let structInst = ArbitraryStruct{};
   
6.     let messageInst = ArbitraryMessage{};
   + ?& g4 u5 t0 }; A. Q) B
7. 
   ' V, E3 T6 ]# s# o& n4 U) X1 x
8.     ArbitraryStruct.fromCell(structInst.toCell());   // = structInst
   1 K, k! I: W; t  I( r
9.     ArbitraryMessage.fromCell(messageInst.toCell()); // = messageInst
   
10. 
    0 ~( r3 F  W: x* V! {& b% t5 w6 d1 B
11.     // Same goes for Slices, with .toCell().asSlice() and .fromSlice()
    
12. 
    
13.     ArbitraryStruct.fromSlice(structInst.toCell().asSlice());   // = structInst
    : D/ M( h3 v5 q& k. z5 A# D5 j
14.     ArbitraryMessage.fromSlice(messageInst.toCell().asSlice()); // = messageInst
    , w; g* F! x, {( v
15. }

复制代码

对于任何与给定 Struct/Message 具有相同 TL-B 布局的 cell，调用 Struct.fromCell()（或 Message.fromCell()），然后通过 .toCell() 将结果转换为 Cell，就会得到原始 cell 的副本：

1. struct ArbitraryStruct { val: Int as uint32 }
   ' B5 o7 v$ }( B( @! k, x
2. message(0x2A) ArbitraryMessage {}
   
3. 
   7 w: [. t! q% ~3 h4 k
4. fun lawTwo() {
   , h4 D7 |# u$ J0 h
5.     // Using 32 bits to store 42 just so this cellInst can be
   3 z- }2 c5 |7 _) `2 J
6.     // re-used for working with both ArbitraryStruct and ArbitraryMessage
   
7.     let cellInst = beginCell().storeUint(42, 32).endCell();
   ! O1 N: S& @3 \, z8 P- c( ~7 V
8. 
   
9.     ArbitraryStruct.fromCell(cellInst).toCell();  // = cellInst
   
10.     ArbitraryMessage.fromCell(cellInst).toCell(); // = cellInst
    
11. 
    
12.     // Same goes for Slices, with .fromSlice() and .toCell().asSlice()
    8 W: ]8 z$ P8 ?" p
13.     let sliceInst = cellInst.asSlice();
    
14. 
    
15.     ArbitraryStruct.fromSlice(sliceInst).toCell().asSlice();  // = sliceInst
    
16.     ArbitraryMessage.fromSlice(sliceInst).toCell().asSlice(); // = sliceInst
    ) N4 @0 e5 W5 h+ N/ b
17. }

复制代码

2 p. k% b0 t+ X