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

riyad

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


, q* U( f) `" |) v9 ]% D2 v. T
! _5 Z+ E+ y. b1 @5 N2 k' M: o结构
结构体可以定义包含多个不同类型字段的复杂数据类型。 它们还可以嵌套。 它们还可以嵌套。

1. struct Point {
   & r* |3 s' S( x( w
2.     x: Int as int64;
   % i+ c- e# |1 v4 S: z6 U7 Y3 y! X  ~
3.     y: Int as int64;
   5 n1 }; z" e: Z5 T" i
4. }
   ! p2 Y) i' @( t- G* t' g' [
5. 
   ' o7 H7 d, a9 W3 J
6. struct Line {
   
7.     start: Point;
   1 j  p; w% n- p/ e+ L( \
8.     end: Point;
   5 H& K6 n2 I* o9 k! n1 ~& j  K
9. }

复制代码

结构体还可以包含默认字段，并定义可选类型的字段。 结构体还可以包含默认字段和定义[可选类型]字段（/book/optionals）。 如果您有很多字段，但又不想一直在 new instances 中为它们指定通用值，那么这将非常有用。
! s0 y/ P  G9 F2 O1 F

1. struct Params {
   ! M1 M$ j* P# @
2.     name: String = "Satoshi"; // default value
   
3. 
   2 x4 ]. U+ H' W: A; g$ M
4.     age: Int?; // field with an optional type Int?
   
5.                // and default value of null
   " e5 Z8 P4 w; F5 F9 A. k$ b
6. 
   
7.     point: Point; // nested Structs
   % M1 y7 Q* V; A7 M5 F" A
8. }

复制代码

字段的顺序很重要，因为它与TL-B 模式 中的内存布局一致。 不过，与某些采用手动内存管理的语言不同，Tact 在字段之间没有任何填充。


" Y. K; h- L/ I# h7 {) ~+ m
消息
消息中可以包含 结构体：

1. struct Point {
   1 z9 G' k# Z( |, i8 N, F# w! I
2.     x: Int;
   $ ?. Z  f$ W3 k( R* U
3.     y: Int;
   
4. }
   * d3 K& i/ `2 O9 I1 n- W
5. 
   
6. message Add {
   0 L6 y& ~# n9 b2 @
7.     point: Point; // holds a struct Point
   
8. }

复制代码

1. // This Message overwrites its unique id with 0x7362d09c
     X! h4 G9 c( V. y, Z
2. message(0x7362d09c) TokenNotification {
   7 E( i( R, ~  U- C# u7 p4 f0 ^* Z
3.     forwardPayload: Slice as remaining;
   
4. }

复制代码

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

$ e( L; P9 N2 v4 k- S, l( [1 c7 J9 I
( |: n: k' i1 }4 Z  u. Q' T操作
实例化
2 T2 w0 q( o/ P* R创建 Struct 和 Message 实例类似于 function calls，但需要用大括号 {}（大括号）代替小括号 ()指定参数：

1. struct StA {
   
2.     field1: Int;
   
3.     field2: Int;
   . K& E6 M' v: G5 K% c# R
4. }
   4 m# B# {5 S" o3 y' e5 V; M& @( j
5. 
   
6. message MsgB {
   
7.     field1: String;
   
8.     field2: String;
   
9. }
   ) c8 W# r8 L, I- U6 j% X
10. 
    3 J( i- E" a% \, ?
11. fun example() {
    
12.     // Instance of a Struct StA
    ( d% p3 U  }2 e3 m
13.     StA{
    6 }& L* C1 S2 g1 z6 q
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",
    3 x. n2 U  o! v
21.         field2: "be with you!", // trailing comma is allowed
      N% l0 `& s  q+ S* t6 f/ U3 i
22.     };
    % z3 ]9 s" _2 M) j+ O5 h. j
23. }

复制代码

1. struct PopQuiz {
     r$ {! p3 i) P2 w. P7 p$ `
2.     vogonsCount: Int;
   7 K) M* v: k# {$ t$ j
3.     nicestNumber: Int;
     M* ]- R1 [, U% `8 x" ]
4. }
   
5. 
   $ I9 m8 d9 Z# x0 E! |3 d3 Y
6. fun example() {
   * N* Y& H& L* w/ |
7.     // Let's introduce a couple of variables
   
8.     let vogonsCount: Int = 42;
   
9.     let nicestNumber: Int = 68 + 1;
   - ?6 U5 t- u' w& U0 ^! E
10. 
    6 F2 m+ b' T4 R& _+ M/ A
11.     // You may instantiate the Struct as usual and assign variables to fields,
    
12.     // but that is a bit repetitive and tedious at times
    
13.     PopQuiz{ vogonsCount: vogonsCount, nicestNumber: nicestNumber };
    : |/ v4 I  p. V. o5 ]% `: r' M
14. 
    # p3 b2 f( J" O; {8 u
15.     // Let's use field punning and type less,
    
16.     // because our variable names happen to be the same as field names
    
17.     PopQuiz{
    " p, M+ o3 ~, \" X  d7 X
18.         vogonsCount,
    
19.         nicestNumber, // trailing comma is allowed here too!
    9 a* D% y: A! }& x7 N4 Q
20.     };
    2 f9 H; C6 Q$ {8 v: v* S( X  w
21. }

复制代码

1. struct Big {
   , S6 s  q0 Y: A8 \& t3 X. \  O8 C" A
2.     f1: Int;
   
3.     f2: Int;
   
4.     f3: Int;
   
5.     f4: Int;
   % Z  u# a, T4 W( w
6.     f5: Int;
   
7.     f6: Int;
   6 M1 C# Q* E3 [; e9 H' J
8. }
   
9. 
   
10. fun conversionFun() {
    
11.     dump(Big{
    
12.         f1: 10000000000, f2: 10000000000, f3: 10000000000,
    , b% t! K/ E% R' {
13.         f4: 10000000000, f5: 10000000000, f6: 10000000000,
    
14.     }.toCell()); // x{...cell with references...}
    8 A* B. g; N2 H- B
15. }

复制代码

1. struct Fizz { foo: Int }
   
2. message(100) Buzz { bar: Int }
     \& @  l2 o! R' k6 j4 x
3. 
   4 ^7 j2 D3 {9 ~1 a" M: c) R7 |; U2 c' E
4. fun constructThenParse() {
   6 y! V" A9 _3 v6 n: ^0 Q7 }  ~8 T
5.     let fizzCell = Fizz{foo: 42}.toCell();
   & k! G0 G4 l3 u& b5 e! n8 ?
6.     let buzzCell = Buzz{bar: 27}.toCell();
   1 x0 Z7 q/ `- f" }
7. 
   
8.     let parsedFizz: Fizz = Fizz.fromCell(fizzCell);
   8 \* Z) p5 Z  W
9.     let parsedBuzz: Buzz = Buzz.fromCell(buzzCell);
     x, B6 Q3 u8 \! \' g# @$ i$ f) n6 K
10. }

复制代码

1. struct ArbitraryStruct {}
   
2. message(0x2A) ArbitraryMessage {}
   
3. 
   ) m' n5 I/ u- V  w/ D! v+ T
4. fun lawOne() {
   3 E6 p2 K! K7 M$ ~0 P8 |0 d$ i
5.     let structInst = ArbitraryStruct{};
   
6.     let messageInst = ArbitraryMessage{};
   
7. 
   
8.     ArbitraryStruct.fromCell(structInst.toCell());   // = structInst
   3 Q6 `/ ~; Y* R/ ~. U) D* Y
9.     ArbitraryMessage.fromCell(messageInst.toCell()); // = messageInst
   
10. 
    . ]2 t- {0 Z$ y
11.     // Same goes for Slices, with .toCell().asSlice() and .fromSlice()
    
12. 
    
13.     ArbitraryStruct.fromSlice(structInst.toCell().asSlice());   // = structInst
    3 u  Y8 ~9 h% R  _5 {! m+ h
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 }
   4 s2 ]! G" n7 M+ `1 y6 V" u4 u
2. message(0x2A) ArbitraryMessage {}
   
3. 
   % [0 {" L( ~! W
4. fun lawTwo() {
   8 R5 A# ^" p) U& h! M
5.     // Using 32 bits to store 42 just so this cellInst can be
   ; p3 K$ v; ?' J) q' J
6.     // re-used for working with both ArbitraryStruct and ArbitraryMessage
   , G5 L& u! C3 k' c; X( g8 L* B
7.     let cellInst = beginCell().storeUint(42, 32).endCell();
   , n1 E/ b: h$ g
8. 
   
9.     ArbitraryStruct.fromCell(cellInst).toCell();  // = cellInst
   - Y. F/ C3 P% r" S' z# ^
10.     ArbitraryMessage.fromCell(cellInst).toCell(); // = cellInst
    
11. 
      x1 ?5 `1 w# M; N( x/ }  }- h
12.     // Same goes for Slices, with .fromSlice() and .toCell().asSlice()
    
13.     let sliceInst = cellInst.asSlice();
    
14. 
    
15.     ArbitraryStruct.fromSlice(sliceInst).toCell().asSlice();  // = sliceInst
    $ U0 z% H0 {( f
16.     ArbitraryMessage.fromSlice(sliceInst).toCell().asSlice(); // = sliceInst
    
17. }

复制代码

5 \4 S$ r6 Q7 E' R1 F" f