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

riyad

Tact 支持许多专为智能合约使用而定制的 原始数据类型。 不过，使用单独的存储方式往往会变得繁琐，因此有 Structs 和 Messages可以将类型组合在一起。 不过，使用单独的存储方式往往会变得繁琐，因此有 Structs 和 Messages可以将类型组合在一起。
% U/ u( |# `. @  x- c* J6 s

$ z/ s8 v. i: x% R
结构
结构体可以定义包含多个不同类型字段的复杂数据类型。 它们还可以嵌套。 它们还可以嵌套。
* r; F7 N4 p7 `9 R) Z& C3 I- T  U8 \

1. struct Point {
   / Z" s$ x6 _8 g" z3 u) s
2.     x: Int as int64;
   
3.     y: Int as int64;
   
4. }
   9 ~7 @5 `, I% v  o: h* z
5. 
   * K2 J) Q& s  e: q( Z% V+ b* V
6. struct Line {
   2 Q$ U* H8 I% T! C' i) i$ _
7.     start: Point;
   
8.     end: Point;
   $ I) k. X' K) i8 {) r
9. }

复制代码

结构体还可以包含默认字段，并定义可选类型的字段。 结构体还可以包含默认字段和定义[可选类型]字段（/book/optionals）。 如果您有很多字段，但又不想一直在 new instances 中为它们指定通用值，那么这将非常有用。
/ W- m/ ]. W( D1 g7 Q  J

1. struct Params {
   3 ^' y2 [, J% e2 c0 l* P1 R
2.     name: String = "Satoshi"; // default value
   
3. 
   & r3 w. {: I- b9 ^8 b( @/ ]
4.     age: Int?; // field with an optional type Int?
   
5.                // and default value of null
   
6. 
   . R' l3 D7 J; f3 G+ Y8 {
7.     point: Point; // nested Structs
   
8. }

复制代码

字段的顺序很重要，因为它与TL-B 模式 中的内存布局一致。 不过，与某些采用手动内存管理的语言不同，Tact 在字段之间没有任何填充。
+ ^3 f1 Q! M) N& J" `; x+ O
+ V: F8 w: O, l3 b$ J" Z# P

消息
消息中可以包含 结构体：

1. struct Point {
   
2.     x: Int;
   
3.     y: Int;
   6 j" b7 A' U, I0 V( q- l- v) v
4. }
   6 p* c) I% J; O' K
5. 
   
6. message Add {
   
7.     point: Point; // holds a struct Point
   
8. }

复制代码

1. // This Message overwrites its unique id with 0x7362d09c
   
2. message(0x7362d09c) TokenNotification {
   
3.     forwardPayload: Slice as remaining;
   1 t# u0 x% Q* k  n8 M
4. }

复制代码

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


操作
! b8 Q% y" s# s7 a. }实例化
% K* e' t0 _& L( a+ j% \2 ]2 `创建 Struct 和 Message 实例类似于 function calls，但需要用大括号 {}（大括号）代替小括号 ()指定参数：

1. struct StA {
   
2.     field1: Int;
   $ P/ \6 Y! k, F5 y. z% v
3.     field2: Int;
   4 P/ P5 B) B( v9 H- J
4. }
   # T1 Y- B* _, p4 r5 P
5. 
   
6. message MsgB {
   8 N) b: R  ^( e4 M
7.     field1: String;
   " ?" z6 c. A# q1 D  H
8.     field2: String;
   ) R1 x2 p4 H% w: @5 D  i- I: E0 Y2 u
9. }
   2 g4 p4 a7 N- E$ `5 @
10. 
    
11. fun example() {
    
12.     // Instance of a Struct StA
    
13.     StA{
    
14.         field1: 42,
    . G2 U9 ~2 J; H/ ?# Q
15.         field2: 68 + 1, // trailing comma is allowed
    ! o5 v% u" U  u3 C, d" \
16.     };
    - {- g. N3 h, R6 u( g
17. 
    / w: g. J/ `( ?4 l' ]: f; G
18.     // Instance of a Message MsgB
    % h) T$ H. a0 q5 C
19.     MsgB{
    
20.         field1: "May the 4th",
    / Z- z! g4 {" E6 }, t" B- E" @( d
21.         field2: "be with you!", // trailing comma is allowed
    " @: w0 B" |! u7 @6 n1 ~) z* j0 o
22.     };
    . i) z4 V/ J$ H
23. }

复制代码

1. struct PopQuiz {
   
2.     vogonsCount: Int;
   
3.     nicestNumber: Int;
   
4. }
   ) S8 p/ R$ T. \- s, M1 Q; s$ d% n
5. 
   2 L/ g( Q" B. G
6. fun example() {
   
7.     // Let's introduce a couple of variables
   
8.     let vogonsCount: Int = 42;
   
9.     let nicestNumber: Int = 68 + 1;
   " Z1 f9 Q/ U! P4 `! w
10. 
    
11.     // You may instantiate the Struct as usual and assign variables to fields,
    9 \1 I8 o& g$ x  J
12.     // but that is a bit repetitive and tedious at times
    : b8 Q; d9 ~- h# f9 e
13.     PopQuiz{ vogonsCount: vogonsCount, nicestNumber: nicestNumber };
    
14. 
    
15.     // Let's use field punning and type less,
    
16.     // because our variable names happen to be the same as field names
    - O" P, D6 _& Z3 j+ Q
17.     PopQuiz{
    
18.         vogonsCount,
    & B6 a. L5 Z* V1 Y% q5 E& l- F4 ?
19.         nicestNumber, // trailing comma is allowed here too!
    
20.     };
    ) L& C" ^, ~! G
21. }

复制代码

1. struct Big {
   ( i) n$ ]4 {4 I* I$ U  Z
2.     f1: Int;
   9 g. e+ @9 T* b; s6 l# @0 k) S
3.     f2: Int;
   
4.     f3: Int;
   
5.     f4: Int;
   + N! p' {; }9 B+ _9 o
6.     f5: Int;
   ' O1 S& d' q: ^$ e
7.     f6: Int;
   
8. }
   7 j% n( A! k$ m# [, R
9. 
   ; K4 `8 N& A$ o9 B
10. fun conversionFun() {
    ; M; ]' w; M  `: a8 x6 A
11.     dump(Big{
    4 f# z' e+ g1 o# y: X) m2 x' l
12.         f1: 10000000000, f2: 10000000000, f3: 10000000000,
    0 h0 m3 @' P6 d; L& g/ ^
13.         f4: 10000000000, f5: 10000000000, f6: 10000000000,
    8 s! _1 D- i1 L" }  S7 Z) j
14.     }.toCell()); // x{...cell with references...}
    
15. }

复制代码

1. struct Fizz { foo: Int }
   4 ~& e4 D9 {$ C6 b
2. message(100) Buzz { bar: Int }
   
3. 
   * p; Q5 N) F, D" C# f$ A
4. fun constructThenParse() {
   1 H. f, o1 G- o7 o" R) s- j6 X
5.     let fizzCell = Fizz{foo: 42}.toCell();
   
6.     let buzzCell = Buzz{bar: 27}.toCell();
   
7. 
   
8.     let parsedFizz: Fizz = Fizz.fromCell(fizzCell);
   
9.     let parsedBuzz: Buzz = Buzz.fromCell(buzzCell);
   
10. }

复制代码

1. struct ArbitraryStruct {}
   
2. message(0x2A) ArbitraryMessage {}
   4 M7 O  k2 k/ c. Q/ s+ ]3 Q
3. 
   
4. fun lawOne() {
   
5.     let structInst = ArbitraryStruct{};
   : G- Z1 k4 C& E- W) O4 g
6.     let messageInst = ArbitraryMessage{};
   0 Z+ V) S* z! h" L' F7 m- O
7. 
   * L) b/ k3 U9 k0 f) N- w! m+ C
8.     ArbitraryStruct.fromCell(structInst.toCell());   // = structInst
   8 N! Z6 [4 e# D. L: ~$ g' B
9.     ArbitraryMessage.fromCell(messageInst.toCell()); // = messageInst
   
10. 
    
11.     // Same goes for Slices, with .toCell().asSlice() and .fromSlice()
    
12. 
    6 r- i' P$ O* N* |( B
13.     ArbitraryStruct.fromSlice(structInst.toCell().asSlice());   // = structInst
    
14.     ArbitraryMessage.fromSlice(messageInst.toCell().asSlice()); // = messageInst
    
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. 
   
4. fun lawTwo() {
   
5.     // Using 32 bits to store 42 just so this cellInst can be
   ( N( _) Z8 `; I4 q0 Q
6.     // re-used for working with both ArbitraryStruct and ArbitraryMessage
   / J- I  g* J+ h" @& a9 X$ P8 L
7.     let cellInst = beginCell().storeUint(42, 32).endCell();
   
8. 
   0 F/ n" x* z7 b- n  B: K# {
9.     ArbitraryStruct.fromCell(cellInst).toCell();  // = cellInst
   
10.     ArbitraryMessage.fromCell(cellInst).toCell(); // = cellInst
    0 K+ a4 q; r4 R" _
11. 
    
12.     // Same goes for Slices, with .fromSlice() and .toCell().asSlice()
    
13.     let sliceInst = cellInst.asSlice();
    
14. 
    & V/ ]9 |9 L) [. b' p5 x
15.     ArbitraryStruct.fromSlice(sliceInst).toCell().asSlice();  // = sliceInst
    $ n/ o8 N: Z" g; o- a/ V, P
16.     ArbitraryMessage.fromSlice(sliceInst).toCell().asSlice(); // = sliceInst
    
17. }

复制代码