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

riyad

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

' x0 w2 l/ s2 g4 [5 M% I% t  {
) V  B  H4 f  g7 c, B- `
结构
/ H" b% B: b! F) }& E8 g; W  |结构体可以定义包含多个不同类型字段的复杂数据类型。 它们还可以嵌套。 它们还可以嵌套。

1. struct Point {
   ) [8 ]0 H+ z0 C2 ^. I- l' q
2.     x: Int as int64;
   , N7 |3 a, ^" `" U5 t# Y& t: ?7 Y
3.     y: Int as int64;
   
4. }
   8 D+ L# u5 [& B% M- o# A
5. 
   
6. struct Line {
   9 B6 j  q. J  ]) _, \
7.     start: Point;
   
8.     end: Point;
   4 ]% O6 C6 X' j: [
9. }

复制代码

结构体还可以包含默认字段，并定义可选类型的字段。 结构体还可以包含默认字段和定义[可选类型]字段（/book/optionals）。 如果您有很多字段，但又不想一直在 new instances 中为它们指定通用值，那么这将非常有用。
* ?7 h; X% ^2 Q& P; O" C) C

1. struct Params {
   ; q4 G  }+ b% O2 j3 K6 J
2.     name: String = "Satoshi"; // default value
   
3. 
   
4.     age: Int?; // field with an optional type Int?
   " o: s( U6 M# k5 Q, ]
5.                // and default value of null
   
6. 
   
7.     point: Point; // nested Structs
   * Y  }) J( m; _( s8 f) z3 s
8. }

复制代码

字段的顺序很重要，因为它与TL-B 模式 中的内存布局一致。 不过，与某些采用手动内存管理的语言不同，Tact 在字段之间没有任何填充。
1 a. m% Z( p8 G. |0 J+ V

/ D6 q6 ?( [9 V3 n9 a6 ^) Q! p
+ i1 R0 x3 X) W+ Y5 L9 v消息
消息中可以包含 结构体：

1. struct Point {
   
2.     x: Int;
   4 A. t( Y. T4 [3 f! }7 ?) L9 v
3.     y: Int;
   
4. }
   & ?! @9 W  V3 C' r
5. 
   
6. message Add {
   - |1 ?# l& W# m2 f$ a
7.     point: Point; // holds a struct Point
   ' Q' D& d2 \. Q
8. }

复制代码

1. // This Message overwrites its unique id with 0x7362d09c
   
2. message(0x7362d09c) TokenNotification {
   , |) S5 r& [+ I6 X( v6 n, g
3.     forwardPayload: Slice as remaining;
   ' d6 z' y5 w) K; X/ g' A
4. }

复制代码

这对于要处理特定智能合约的某些操作码（如 Jetton standard）的情况非常有用。 该合约能够处理的操作码简表为此处以 FunC 表示。 它们是智能合约的接口。


操作
实例化
创建 Struct 和 Message 实例类似于 function calls，但需要用大括号 {}（大括号）代替小括号 ()指定参数：
$ _- S0 p9 V$ N' b3 k5 v

1. struct StA {
   : |; w2 I1 b6 L3 x* x
2.     field1: Int;
   " O7 C: V. ?% T
3.     field2: Int;
   8 K4 p0 x- \/ }! x+ b/ u6 S
4. }
   
5. 
   
6. message MsgB {
   4 `! D) k! K5 s
7.     field1: String;
   
8.     field2: String;
   5 u, G/ y4 H" ^/ T2 L( s
9. }
   9 D( N: S, N- h9 M/ W) l
10. 
    
11. fun example() {
    . Z1 A, Y+ M4 W& Y5 Y) I9 u
12.     // Instance of a Struct StA
    
13.     StA{
    ' k; A; H7 J' O. {# Z
14.         field1: 42,
    
15.         field2: 68 + 1, // trailing comma is allowed
    
16.     };
    
17. 
    
18.     // Instance of a Message MsgB
    
19.     MsgB{
    
20.         field1: "May the 4th",
    
21.         field2: "be with you!", // trailing comma is allowed
    2 f; Z! u6 @4 W  f; [5 W" H9 [
22.     };
    8 Z9 r; o; g& `% ]& O& g: s1 G! C% Z
23. }

复制代码

1. struct PopQuiz {
   
2.     vogonsCount: Int;
   
3.     nicestNumber: Int;
   % u) @+ x/ I/ U. g1 y
4. }
   . u8 B* x- o" `) O3 X
5. 
   2 ?) T; A4 P" d! M" w* j8 O! {$ `
6. fun example() {
   
7.     // Let's introduce a couple of variables
   3 @- I2 \. j% R+ u
8.     let vogonsCount: Int = 42;
   
9.     let nicestNumber: Int = 68 + 1;
     ?1 ~( i( n* R1 \3 o- A
10. 
    
11.     // You may instantiate the Struct as usual and assign variables to fields,
    
12.     // but that is a bit repetitive and tedious at times
    & M4 ?0 Q% I8 B& O
13.     PopQuiz{ vogonsCount: vogonsCount, nicestNumber: nicestNumber };
    8 I+ H0 N* Y7 g* i* r7 ~& D
14. 
    9 \. H2 ]+ `4 O% r- }' ]  x
15.     // Let's use field punning and type less,
    + _- J0 O3 V$ A2 t# s! p
16.     // because our variable names happen to be the same as field names
    , ?+ E  C1 i6 J! ]7 o  B4 U
17.     PopQuiz{
    
18.         vogonsCount,
    
19.         nicestNumber, // trailing comma is allowed here too!
    
20.     };
    ) d0 m1 l$ E$ I* F
21. }

复制代码

1. struct Big {
   / o7 A6 T1 J8 a- f" ^9 H& V
2.     f1: Int;
   
3.     f2: Int;
   * J" E6 C( S0 q' O' l6 u. \
4.     f3: Int;
   
5.     f4: Int;
   
6.     f5: Int;
   
7.     f6: Int;
   ! G$ y& Q( V, [5 }- \0 l, j8 P
8. }
   # M+ `7 ]' u7 N. S7 }
9. 
   0 R+ r& s% [8 G7 m# ?, t  E
10. fun conversionFun() {
    
11.     dump(Big{
    
12.         f1: 10000000000, f2: 10000000000, f3: 10000000000,
    
13.         f4: 10000000000, f5: 10000000000, f6: 10000000000,
    
14.     }.toCell()); // x{...cell with references...}
    + g2 }$ G" k5 Q% v6 v9 A
15. }

复制代码

1. struct Fizz { foo: Int }
   - I. x/ e; `1 ~$ g% Q- Z. _& H! r
2. message(100) Buzz { bar: Int }
   6 Q% Z, k$ V; j- T  d4 o
3. 
   
4. fun constructThenParse() {
   + R1 d) N) E9 x- ^3 o+ j6 r
5.     let fizzCell = Fizz{foo: 42}.toCell();
   8 y7 m' e* q. ]+ d/ y7 m/ g7 [  q
6.     let buzzCell = Buzz{bar: 27}.toCell();
   
7. 
   9 Z4 V* t  V) T/ z
8.     let parsedFizz: Fizz = Fizz.fromCell(fizzCell);
   / S! @: {  ]9 M& `' L- z$ J
9.     let parsedBuzz: Buzz = Buzz.fromCell(buzzCell);
   0 ]/ O0 \  \6 k7 u4 m% @6 x: Y
10. }

复制代码

1. struct ArbitraryStruct {}
   
2. message(0x2A) ArbitraryMessage {}
   
3. 
   + y9 F) K$ B: G7 s7 r
4. fun lawOne() {
   ; @, `7 H, L" l8 x+ T! ]. r
5.     let structInst = ArbitraryStruct{};
   
6.     let messageInst = ArbitraryMessage{};
   
7. 
   4 v$ Z: b/ H4 x2 d
8.     ArbitraryStruct.fromCell(structInst.toCell());   // = structInst
   
9.     ArbitraryMessage.fromCell(messageInst.toCell()); // = messageInst
   
10. 
    
11.     // Same goes for Slices, with .toCell().asSlice() and .fromSlice()
    1 {# c) n& U$ D. W  K1 s
12. 
    
13.     ArbitraryStruct.fromSlice(structInst.toCell().asSlice());   // = structInst
    6 E! r6 j! k+ P) n! S
14.     ArbitraryMessage.fromSlice(messageInst.toCell().asSlice()); // = messageInst
    $ c3 m7 f+ n( m; \! h
15. }

复制代码

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

1. struct ArbitraryStruct { val: Int as uint32 }
   
2. message(0x2A) ArbitraryMessage {}
   
3. 
   % |8 _+ R' T. S) e/ I
4. fun lawTwo() {
   7 V# c+ i* i' o7 N7 z, M, Q( I
5.     // Using 32 bits to store 42 just so this cellInst can be
   
6.     // re-used for working with both ArbitraryStruct and ArbitraryMessage
   
7.     let cellInst = beginCell().storeUint(42, 32).endCell();
   
8. 
   
9.     ArbitraryStruct.fromCell(cellInst).toCell();  // = cellInst
   
10.     ArbitraryMessage.fromCell(cellInst).toCell(); // = cellInst
    
11. 
    
12.     // Same goes for Slices, with .fromSlice() and .toCell().asSlice()
    
13.     let sliceInst = cellInst.asSlice();
    
14. 
    
15.     ArbitraryStruct.fromSlice(sliceInst).toCell().asSlice();  // = sliceInst
    / q" ^. q/ a2 p( v' A# m: K
16.     ArbitraryMessage.fromSlice(sliceInst).toCell().asSlice(); // = sliceInst
    4 M- R% d$ ~9 @& `8 k( i7 P
17. }

复制代码

3 y( y3 q" @* q9 @1 r7 P% V