Tact 语言基础 | 类型系统概述

riyad

Tact 程序中的每个变量、项目和值都有一个类型。 它们可以是

• 原始类型 之一
• 或 复合类型
  

此外，这些类型中的许多类型可以变为空值。
: H% f9 e/ y' S" Z8 P! `
  f3 R3 N" P6 t: Y( ]. q' M# V; M& [原始类型
Tact 支持许多专为智能合约定制的原始数据类型：

• Int — Tact 中的所有数字都是 257 位有符号整数，但可以使用较小的表示方法来减少存储成本。
• Bool — 经典布尔类型，具有 true 和 false 值。
• Address — TON 区块链中的标准智能合约地址。
• Cell、Builder、Slice — TVM 的底层基元。
• String — 不可变的文本字符串。
• StringBuilder — 辅助类型，允许以节省 gas 的方式连接字符串。
  

$ X: T+ M1 U1 m! G# p
% G$ m# v) ]) Z. O
, [, Q% H5 [; w# @% ]布尔值
6 P# d8 I9 W( V" b9 `. o+ G
( |6 I! |0 {# Y* k$ e原始类型 Bool 是经典的布尔类型，只能容纳两个值：true 和 false。它便于布尔和逻辑运算，也便于存储标志。 它便于布尔和逻辑运算，也便于存储标志。
+ g5 N2 b6 d, h# O
' j3 ?- c# }3 |* }- e3 l9 j) xTact 中没有隐式类型转换，因此两个布尔值的加法（+）是不可能的。这里有许多比较运算符，例如： 这里有许多比较运算符，例如：
0 J0 Y( r2 v( G( o! b! p; X7 M

• && 为 logical AND
• || 为 logical OR
• ! 为 logical inversion
• == 和 != 用于检查相等
• ! 表示非空断言
  & C' w: [3 N1 H. z% N

$ D5 t; b) N1 X& v; Z将布尔值持久化到状态中非常节省空间，因为它们只占用1位。 在状态中存储 1000 个布尔值每年大约花费
3 w4 L: r1 y8 f6 k, n0.00072
3 N/ g: D, m3 ]# Y+ o/ P+ t. a8 t0.00072 TON。
) A4 z- |4 J8 i+ Z
5 ]" _1 _$ ^6 O

; q  ]- Q9 S4 @7 U- F- F" Y复合类型
使用单独的存储手段往往会变得繁琐，因此有办法将多个原始类型组合在一起，创建复合类型：

• Maps - 键与值的关联。
• 复合类型，如结构体和消息
• 可选项 - 结构体和消息变量或字段的null值。
  

  i- |  P; f1 k7 b$ e  K& R

  p* L  g3 M' x) O3 ^
6 \2 f* _. U2 F) e8 i除上述复合类型外，Tact 还提供了一种特殊的类型构造函数bounced<T>，它只能在回退消息接收器(bounced message receivers)中指定。

; ]+ _. w1 d* q% D, G3 Y" j请注意，虽然合约和trait也被视为Tact类型系统的一部分，但我们不能像结构体和消息那样传递它们。 相反，我们可以使用 initOf表达式来获取给定合约的初始状态。
3 t/ Z+ X! ~  h# D: m* j  ]

Maps
类型map<K, V>用于将类型K的键与类型V的相应值关联起来。
. N. t. C8 V/ s" m* d+ g, w. n$ U
示例map<K, V>
8 k) N1 A4 B  q( d

1. let mapExample: map<Int, Int> = emptyMap(); // empty map with Int keys and values

复制代码

$ C# ^. S7 P& w; `- p8 h
% G0 Y; s* _: H% V
7 `) G: V; \, v! a1 W结构和消息
; l) D: r0 X7 U3 o2 a结构和消息是将多个原始类型组合成复合类型的两种主要方式。
' G2 r! J8 O$ `  J, X
Struct 示例：
7 F0 V* p- f2 E6 }1 K- y" n

1. struct Point {
   
2.     x: Int;
   
3.     y: Int;
   2 F$ @9 M4 K- n6 l5 p
4. }

复制代码

Message 示例：
- v3 D" o# [( p

1. // Custom numeric id of the Message
   
2. message(0x11111111) SetValue {
   * D$ y) f; e1 r& s. `0 Z
3.     key: Int;
   7 p' c' n- O: f% {
4.     value: Int?; // Optional, Int or null
   : m1 ]& w5 ~/ L, U/ a" D% g8 h' F
5.     coins: Int as coins; // Serialization into TL-B types
   + ?9 E. b# E1 `( ~/ s9 D7 G  H
6. }

复制代码

1. let opt: Int? = null; // Int or null, with explicitly assigned null

复制代码

在专门页面了解更多信息：可选项。
! t2 p5 L+ |6 Y1 @! V, Z
9 g9 u" }& ~$ i  K4 }- [/ ]
: K3 G4 o8 n# k; c合约
TON区块链上的合约在Tact中作为智能合约的主要入口。 它包含了一个TON合约的所有functions、getters和receivers等多种内容。
$ f& d2 R0 `+ l* {9 P; K
合约示例：

" y5 `' F3 _1 [* ^0 t0 {; i; w

1. contract HelloWorld {
   
2.     // Persistent state variable
   2 v; v* e' z8 v  j3 d8 Z
3.     counter: Int;
   $ |8 a1 X* u9 l, W
4. 
   0 r4 k! Y* C7 ^' w# r0 h7 J6 W7 d
5.     // Constructor function init(), where all the variables are initialized
   
6.     init() {
   
7.         self.counter = 0;
   . w* e  w# o( d1 C/ d2 ]
8.     }
   * c6 y( d7 P4 Q2 p: |
9. 
   : }* H5 ?! ]& }6 h
10.     // Internal message receiver, which responds to a string message "increment"
    6 E9 `5 V* Z9 H+ A* h  M# n1 b; _" K
11.     receive("increment") {
    
12.         self.counter += 1;
    / I8 n% W: }5 \5 v) F- O
13.     }
    
14. 
    
15.     // Getter function with return type Int
    * p4 X3 f$ C7 v, ?
16.     get fun counter(): Int {
    
17.         return self.counter;
    - H1 t0 k2 F" v1 O, J! l
18.     }
    
19. }

复制代码

1. trait Ownable {
   & k9 T3 M; A1 \: j% R9 f
2.     // Persistent state variable, which cannot be initialized in the trait
   
3.     owner: Address;
   
4. 
   
5.     // Internal function
   
6.     fun requireOwner() {
   % `( i2 w! P; J4 C  U0 ^% t  ^
7.         throwUnless(132, context().sender == self.owner);
   
8.     }
   # a* h) ]% n" ]+ T$ j% |8 k3 x
9. 
   4 j$ w+ c( W/ e7 ~0 I
10.     // Getter function with return type Address
    & ?9 T$ w3 u7 H
11.     get fun owner(): Address {
    & j/ ^! C3 v+ A; {- s& f; G. m) Y
12.         return self.owner;
    
13.     }
    
14. }

复制代码

# H  y2 q  `) C