---
title: Cells, Builders 和 Slices
description: Tact 核心库中的各种 Cell、Builder 和 Slice 函数
---

import { Badge } from '@astrojs/starlight/components';

[`Cell{:tact}`][cell] 是一个低级别的 [原始类型][p]，表示 TON 区块链中的数据。 cell由 $1023$ 位数据组成，最多可 $4$ 引用另一个cell。 它们是只读的、不可变的，并且不能循环引用。

[`Builder{:tact}`][builder] 是一个不可变的 [原始类型][p]，用于构建单元格，而 [`Slice{:tact}`][slice] 是一个可变的 [原始类型][p]，用于解析单元格。

:::note

  在手动构建和解析单元格时要非常小心，并始终确保记录其所需的布局：用于序列化和反序列化的值和类型的严格顺序。

  为此，建议高级用户使用[类型语言 - 二进制（TL-B）模式][tlb]。

  每个用户都建议使用 [结构体][struct] 及其 [方法](/zh-cn/book/functions#extension-function)，例如 [`Struct.toCell(){:tact}`](#structtocell) 和 [`Struct.fromCell(){:tact}`](#structfromcell)，而不是手动构建和解析单元格，因为 [结构体][struct] 和 [消息][message] 最接近于作为你合约的 [活的 TL-B 模式](/zh-cn/book/cells#cnp-structs)。

:::

## beginCell

```tact
fun beginCell(): Builder;
```

创建一个新的空[`Builder{:tact}`][builder]。

示例用法：

```tact
let fizz: Builder = beginCell();
```

## emptyCell

```tact
fun emptyCell(): Cell;
```

创建并返回空 [`cell{:tact}`][cell](不含数据和引用）。 别名为 `beginCell().endCell(){:tact}`。

示例用法：

```tact
let fizz: Cell = emptyCell();
let buzz: Cell = beginCell().endCell();

fizz == buzz; // true
```

## emptySlice

```tact
fun emptySlice(): Slice;
```

创建并返回一个空的 [`Slice{:tact}`][slice] (没有数据和引用)。 与 `emptyCell().asSlice(){:tact}` 同名。

示例用法：

```tact
let fizz: Slice = emptySlice();
let buzz: Slice = emptyCell().asSlice();

fizz == buzz; // true
```

## Cell.beginParse

```tact
extends fun beginParse(self: Cell): Slice;
```

[`Cell{:tact}`][cell] 的扩展函数。

打开 [`Cell{:tact}`][cell] 进行解析，并以 [`Cell{:tact}`][cell] 的形式返回。

示例用法：

```tact
let c: Cell = emptyCell();
let fizz: Slice = c.beginParse();
```

## Cell.hash

```tact
extends fun hash(self: Cell): Int;
```

[`Cell{:tact}`][cell] 的扩展函数。

计算并返回给定 [`Cell{:tact}`][cell] 的 [标准 `Cell{:tact}` 表示][std-repr] 的 [SHA-256][sha-2] 哈希值的 [`Int{:tact}`][int]。

示例用法：

```tact
let c: Cell = emptyCell();
let fizz: Int = c.hash();
```

## Cell.asSlice

```tact
extends fun asSlice(self: Cell): Slice;
```

[`Cell{:tact}`][cell] 的扩展函数。

将cell转换为[`Slice{:tact}`][slice]并返回。 `self.beginParse(){:tact}` 的别名。

示例用法：

```tact
let c: Cell = emptyCell();
let fizz: Slice = c.asSlice();
```

## Builder.endCell

```tact
extends fun endCell(self: Builder): Cell;
```

[`Builder{:tact}`][builder] 的扩展函数。

将 [`Builder{:tact}`][builder] 转换为普通的 [`cell{:tact}`][cell]。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Cell = b.endCell();
```

## Builder.storeUint

```tact
extends fun storeUint(self: Builder, value: Int, bits: Int): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将一个无符号的 `bits` 位 `value` 存储到 [`Builder{:tact}`][builder] 的副本中，范围为 $0 ≤$ `bits` $≤ 256$。 返回该副本。

尝试存储一个负数 `value` 或提供一个不足或超出范围的 `bits` 数量会抛出异常，错误代码为 [退出代码 5](/zh-cn/book/exit-codes#5): `Integer out of expected range`。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Builder = b.storeUint(42, 6);
```

## Builder.storeInt

```tact
extends fun storeInt(self: Builder, value: Int, bits: Int): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将一个有符号的 `bits` 位的 `value` 存储到 [`Builder{:tact}`][builder] 的副本中，范围是 $0 ≤$ `bits` $≤ 257$。 返回该副本。

试图提供一个不足或超出范围的`比特`数时，会出现[退出码5](/zh-cn/book/exit-codes#5)的异常：`Integer out of expected range`。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Builder = b.storeUint(42, 7);
```

## Builder.storeBool

```tact
extends fun storeBool(self: Builder, value: Bool): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将[`Bool{:tact}`][bool]`value`存储到[`Builder{:tact}`][builder]的副本中。 如果 `value` 是 `true{:tact}`，则写入 $1$ 作为单个位，否则写入 $0$。 返回 [`Builder{:tact}`][builder] 的副本。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Builder = b.storeBool(true);  // writes 1
let buzz: Builder = b.storeBool(false); // writes 0
```

## Builder.storeBit

<Badge text="Available since Tact 1.5" variant="tip" size="medium"/><p/>

```tact
extends fun storeBit(self: Builder, value: Bool): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。 [`Builder.storeBool(){:tact}`](#builderstorebool) 的别名。

用法示例：

```tact
let b: Builder = beginCell();
let fizz: Builder = b.storeBit(true);  // writes 1
let buzz: Builder = b.storeBit(false); // writes 0
```

## Builder.storeBuilder

```tact
extends fun storeBuilder(self: Builder, other: Builder): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将 [`Builder{:tact}`][builder] `cell` 中的所有数据添加到[`Builder{:tact}`][builder] 的副本中。 返回该副本。

示例用法：

```tact
let b: Builder = beginCell().storeCoins(42);
let fizz: Builder = beginCell().storeBuilder(b);
b.endCell() == fizz.endCell(); // true
```

## Builder.storeSlice

```tact
extends fun storeSlice(self: Builder, cell: Slice): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将[`slice{:tact}`][slice]`cell`存储到[`builder{:tact}`][builder]的副本中。 返回该副本。

示例用法：

```tact
let b: Builder = beginCell();
let s: Slice = emptyCell().asSlice();
let fizz: Builder = b.storeSlice(s);
```

## Builder.storeCoins

```tact
extends fun storeCoins(self: Builder, value: Int): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将一个无符号的 [`Int{:tact}`][int] `value` 存储（序列化）到范围 $0 .. 2^{120} - 1$ 到 [`Builder{:tact}`][builder] 的副本中。 `value` 的序列化由一个 4 位无符号大端整数 `l` 组成，`l` 是满足 `value` $< 2^{8 _ l}$ 的最小整数 $l ≥ 0$，然后是一个 8 _ l 位无符号大端表示的 `value`。 返回 [`Builder{:tact}`][builder] 的副本。

试图存储一个超出范围的`值`时，会出现[退出码5](/zh-cn/book/exit-codes#5)的异常：`Integer out of expected range`。

这是保存 [nanoToncoins](/zh-cn/book/integers#nanotoncoin) 的最常见方式。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Builder = b.storeCoins(42);
```

:::note[Useful links:]

  [特殊的 `coins` 序列化类型](/zh-cn/book/integers#serialization-coins)

:::

## Builder.storeAddress

```tact
extends fun storeAddress(self: Builder, address: Address): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将地址存储在 [`Builder{:tact}`][builder] 的副本中。 返回该副本。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Builder = b.storeAddress(myAddress());
```

## Builder.storeRef

```tact
extends fun storeRef(self: Builder, cell: Cell): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

将引用 `cell` 存储到 [`Builder{:tact}`][builder] 的副本中。 返回该副本。

由于单个 [`cell{:tact}`][cell] 最多可存储 $4$ 引用，如果尝试存储更多引用，则会出现[退出码 8](/zh-cn/book/exit-codes#8)异常：`Cell overflow`。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Builder = b.storeRef(emptyCell());
```

## Builder.storeMaybeRef

<Badge text="Available since Tact 1.5" variant="tip" size="medium"/><p/>

```tact
extends fun storeMaybeRef(self: Builder, cell: Cell?): Builder;
```

[`Builder{:tact}`][builder] 的扩展函数。

如果`cell`不是`null{:tact}`, 把 $1$ 作为一个位存储，然后在[`Builder{:tact}`][builder] 中使用 `cell` 。 返回此复制。

如果 `cell` 是 `null{:tact}`，则只将 $0$ 作为单个位存储到 [`Builder{:tact}`][builder] 的副本中。 返回此复制。

由于单个 [`Cell{:tact}`][cell] 最多可以存储 $4$ 个引用，尝试存储更多引用将抛出异常，错误码为 [exit code 8](/zh-cn/book/exit-codes#8)：`Cell overflow`。

用法示例：

```tact
let b: Builder = beginCell();
let fizz: Builder = b
    .storeMaybeRef(emptyCell()) // stores a single 1 bit, then an empty cell
    .storeMaybeRef(null);       // stores only a single 0 bit
```

## Builder.refs

```tact
extends fun refs(self: Builder): Int;
```

[`Builder{:tact}`][builder] 的扩展函数。

以 [`Int{:tact}`][int] 形式返回已存储在 [`Builder{:tact}`][builder] 中的cell引用的数目。

用法示例：

```tact
let b: Builder = beginCell();
let fizz: Int = b.refs(); // 0
```

## Builder.bits

```tact
extends fun bits(self: Builder): Int;
```

[`Builder{:tact}`][builder] 的扩展函数。

以[`Int{:tact}`][int]形式返回已存储在[`builder{:tact}`][builder]中的数据位数。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Int = b.bits(); // 0
```

## Builder.asSlice

```tact
extends fun asSlice(self: Builder): Slice;
```

[`Builder{:tact}`][builder] 的扩展函数。

将[`builder{:tact}`][builder]转换为[`slice{:tact}`][slice]并返回。 `self.endCell().beginParse(){:tact}` 的别名。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Slice = b.asSlice();
```

## Builder.asCell

```tact
extends fun asCell(self: Builder): Cell;
```

[`Builder{:tact}`][builder] 的扩展函数。

将[`Builder{:tact}`][builder]转换为[`Cell{:tact}`][cell]并返回。 `self.endCell(){:tact}` 的别名。

示例用法：

```tact
let b: Builder = beginCell();
let fizz: Cell = b.asCell();
```

## Slice.loadUint

```tact
extends mutates fun loadUint(self: Slice, l: Int): Int;
```

[`Slice{:tact}`][slice] 的扩展突变函数。

从 [`Slice{:tact}`][slice]中加载并返回一个无符号的 `l` 位 [`Int{:tact}`][int]，条件是 $0 ≤$ `l` $≤ 256$。

试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：`Integer out of expected range`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeUint(42, 7).asSlice();
let fizz: Int = s.loadUint(7);
```

## Slice.preloadUint

```tact
extends fun preloadUint(self: Slice, l: Int): Int;
```

[`Slice{:tact}`][slice] 的扩展函数。

为 $0 ≤$ `l` $≤ 256$ 从 [`Slice{:tact}`][slice]中预载并返回一个无符号的 `l` 位 [`Int{:tact}`][int]。 不会修改 [`Slice{:tact}`][slice]。

试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：`Integer out of expected range`。

尝试预载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeUint(42, 7).asSlice();
let fizz: Int = s.preloadUint(7);
```

## Slice.loadInt

```tact
extends mutates fun loadInt(self: Slice, l: Int): Int;
```

[`Slice{:tact}`][slice] 的扩展突变函数。

从 [`Slice{:tact}`][slice] 中加载并返回一个有符号的 `l` 位 [`Int{:tact}`][int]，值为 $0 ≤$ `l` $≤ 257$。

试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：`Integer out of expected range`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeInt(42, 7).asSlice();
let fizz: Int = s.loadInt(7);
```

## Slice.preloadInt

```tact
extends fun preloadInt(self: Slice, l: Int): Int;
```

[`Slice{:tact}`][slice] 的扩展函数。

为 $0 ≤$ `l` $≤ 257$ 从 [`Slice{:tact}`][slice]中预载并返回一个有符号的 `l` 位 [`Int{:tact}`][int]。 不会修改 [`slice{:tact}`][slice]。

试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：`Integer out of expected range`。

尝试预载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeInt(42, 7).asSlice();
let fizz: Int = s.preloadInt(7);
```

## Slice.loadBits

```tact
extends mutates fun loadBits(self: Slice, l: Int): Slice;
```

[`Slice{:tact}`][slice] 的扩展突变函数。

从 [`Slice{:tact}`][slice] 中加载 $0 ≤$ `l` $≤ 1023$ 位，并作为单独的  [`Slice{:tact}`][slice] 返回。

试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：`Integer out of expected range`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeInt(42, 7).asSlice();
let fizz: Slice = s.loadBits(7);
```

## Slice.preloadBits

```tact
extends fun preloadBits(self: Slice, l: Int): Slice;
```

[`Slice{:tact}`][slice] 的扩展函数。

从 [`Slice{:tact}`][slice] 中预载 $0 ≤$ `l` $≤ 1023$ 位，并将其作为单独的 [`Slice{:tact}`][slice] 返回。 不修改原始 [`slice{:tact}`][slice]。

试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：`Integer out of expected range`。

尝试预载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeInt(42, 7).asSlice();
let fizz: Slice = s.preloadBits(7);
```

## Slice.skipBits

```tact
extends mutates fun skipBits(self: Slice, l: Int);
```

[`Slice{:tact}`][slice]的扩展突变函数。

从 [`Slice{:tact}`][slice] 中加载除第一个 0 ≤$ `l` $≤ 1023$ 位以外的所有位。

试图指定一个超出范围的 `l` 值时，会出现 [exit code 5](/zh-cn/book/exit-codes#5)异常：`Integer out of expected range`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeInt(42, 7).asSlice();
s.skipBits(5);                   // all but first 5 bits
let fizz: Slice = s.loadBits(1); // load only 1 bit
```

## Slice.loadBool

```tact
extends mutates fun loadBool(self: Slice): Bool;
```

[`Slice{:tact}`][slice]的扩展突变函数。

从[`Slice{:tact}`][slice]加载单个位并返回[`Bool{:tact}`][bool]值。 如果加载的位等于 $1$，则读取 `true{:tact}`，否则读取 `false{:tact}`。

当 [`Bool{:tact}`][bool][`slice{:tact}`][slice]不包含它时，尝试加载此类 [`Bool `][bool]会产生异常，[退出码 8](/zh-cn/book/exit-codes#8)：`Cell overflow`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeBool(true).asSlice();
let fizz: Bool = s.loadBool(); // true
```

## Slice.loadBit

<Badge text="Available since Tact 1.5" variant="tip" size="medium"/><p/>

```tact
extends mutates fun loadBit(self: Slice): Bool;
```

[`Slice{:tact}`][slice] 的扩展突变函数。 别名为 [`Slice.loadBool(){:tact}`](#sliceloadbool)。

示例用法：

```tact
let s: Slice = beginCell().storeBit(true).asSlice();
let fizz: Bool = s.loadBit(); // true
```

## Slice.loadCoins

```tact
extends mutates fun loadCoins(self: Slice): Int;
```

[`Slice{:tact}`][slice] 的扩展突变函数。

从[`Slice{:tact}`][slice]中加载并返回一个[序列化的](#builderstorecoins)无符号[`Int{:tact}`][int]值，范围为 $0 .. 2^{120} - 1$。此值通常代表 [nanoToncoins](/zh-cn/book/integers#nanotoncoin) 的金额。

当 [`Slice{:tact}`][slice]中不包含[`Int{:tact}`][int]时，尝试加载此类[`Int `][int]会产生异常，[退出码为 8](/zh-cn/book/exit-codes#8)：`Cell overflow`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell overflow`。

用法示例：

```tact
let s: Slice = beginCell().storeCoins(42).asSlice();
let fizz: Int = s.loadCoins();
```

:::note[Useful links:]

  [特殊的 "coin" 序列化类型](/zh-cn/book/integers#serialization-coins)

:::

## Slice.loadAddress

```tact
extends mutates fun loadAddress(self: Slice): Address;
```

[`Slice{:tact}`][slice] 的扩展突变函数。

从 [`Slice{:tact}`][slice] 加载并返回一个[`Address{:tact}`][p]。

当[`Address{:tact}`][p][[`Slice{:tact}`][slice]不包含该地址时，尝试加载该[`地址 `][p]会产生异常，[退出码 8](/zh-cn/book/exit-codes#8)：`Cell overflow`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell underflow`。

示例用法：

```tact
let s: Slice = beginCell().storeAddress(myAddress()).asSlice();
let fizz: Address = s.loadAddress();
```

## Slice.loadRef

```tact
extends mutates fun loadRef(self: Slice): Cell;
```

[`Slice{:tact}`][slice] 的扩展突变函数。

从 [`Slice{:tact}`][slice] 中加载下一个引用作为 [`cell{:tact}`][cell]。

当 [`Cell{:tact}`][cell][`slice{:tact}`][slice]不包含该引用时，尝试加载该引用会产生异常，[退出码 8](/zh-cn/book/exit-codes#8)：`Cell overflow`。

尝试加载的数据超过 [`Slice{:tact}`][slice] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9) 异常：`Cell underflow`。

示例用法：

```tact
let s1: Slice = beginCell().storeRef(emptyCell()).asSlice();
let fizz: Cell = s1.loadRef();

let s2: Slice = beginCell()
    .storeRef(emptyCell())
    .storeRef(s1.asCell())
    .asSlice();
let ref1: Cell = s2.loadRef();
let ref2: Cell = s2.loadRef();
ref1 == ref2; // false
```

## Slice.preloadRef

```tact
extends fun preloadRef(self: Slice): Cell;
```

[`Slice{:tact}`][slice] 的扩展函数。

预加载下一个引用从 [`Slice{:tact}`][slice] 为 [`cell{:tact}`][cell] 没有修改原来的 [`Slice{:tact}`][slice]

试图在 [`Slice{:tact}`][slice] 时预加载此引用 [`slice{:tact}`][slice] 不包含一个异常[退出码 8](/zh-cn/book/exit-codes#8)：`Cell overflow`。

试图预加载更多数据超过 [`Slice{:tact}`][slice] 含有异常[export code 9](/zh-cn/book/exit-codes#9)：`Cell underflow`。

示例用法：

```tact
let s1: Slice = beginCell().storeRef(emptyCell()).asSlice();
let fizz: Cell = s1.preloadRef(); // didn't modify s1

let s2: Slice = beginCell()
    .storeRef(emptyCell())
    .storeRef(s1.asCell())
    .asSlice();
let ref1: Cell = s2.preloadRef();
let ref2: Cell = s2.preloadRef();
ref1 == ref2; // true
```

## Slice.refs

```tact
extends fun refs(self: Slice): Int;
```

[`Slice{:tact}`][slice] 的扩展函数。

以 [`Int{:tact}`][int]形式返回 [`Slice{:tact}`][slice] 中引用的个数。

示例用法：

```tact
let s: Slice = beginCell().storeRef(emptyCell()).asSlice();
let fizz: Int = s.refs();
```

## Slice.bits

```tact
extends fun bits(self: Slice): Int;
```

[`slice{:tact}`][slice]的扩展函数。

以 [`Int{:tact}`][int]形式返回 [`Slice{:tact}`][slice] 中的数据位数。

用法示例：

```tact
let s: Slice = beginCell().storeRef(emptyCell()).asSlice();
let fizz: Int = s.bits();
```

## Slice.empty

```tact
extends fun empty(self: Slice): Bool;
```

[`Slice{:tact}`][slice] 的扩展函数。

检查 [`Slice{:tact}`][slice] 是否为空（即不包含数据位和cell引用）。 如果为空，则返回 `true{:tact}`，否则返回 `false{:tact}`。

用法示例：

```tact
let s: Slice = beginCell().storeRef(emptyCell()).asSlice();
let fizz: Bool = s.empty();                     // false
let buzz: Bool = beginCell().asSlice().empty(); // true
```

:::note

  与 [`Slice.endParse(){:tact}`](#sliceendparse)不同，即使 [`Slice{:tact}`][slice]为空，该函数也不会抛出任何异常。

:::

## Slice.dataEmpty

```tact
extends fun dataEmpty(slice: Slice): Bool;
```

[`Slice{:tact}`][slice] 的扩展函数。

检查[`slice{:tact}`][slice] 是否没有任何比特的数据。 如果没有数据，则返回 `true{:tact}`，否则返回 `false{:tact}`。

使用示例

```tact
let s: Slice = beginCell().storeRef(emptyCell()).asSlice();
let fizz: Bool = s.dataEmpty();  // true

let s2: Slice = beginCell().storeInt(42, 7).asSlice();
let buzz: Bool = s2.dataEmpty(); // false
```

## Slice.refsEmpty

```tact
extends fun refsEmpty(slice: Slice): Bool;
```

[`Slice{:tact}`][slice]的扩展函数。

检查 [`Slice{:tact}`][slice] 是否没有引用。 如果没有引用，则返回 `true{:tact}`，否则返回 `false{:tact}`。

用法示例：

```tact
let s: Slice = beginCell().storeRef(emptyCell()).asSlice();
let fizz: Bool = s.refsEmpty();                     // false
let buzz: Bool = beginCell().asSlice().refsEmpty(); // true
```

## Slice.endParse

```tact
extends fun endParse(self: Slice);
```

[`Slice{:tact}`][slice] 的扩展函数。

检查 [`Slice{:tact}`][slice] 是否为空（即不包含数据位和cell引用）。 如果不是，则抛出异常[退出码 9](/zh-cn/book/exit-codes#9)：`Cell underflow`。

使用示例：

```tact {2,6}
let emptyOne: Slice = emptySlice();
emptyOne.endParse(); // nothing, as it's empty

let paul: Slice = "Fear is the mind-killer".asSlice();
try {
    paul.endParse(); // throws exit code 9
}
```

## Slice.hash

```tact
extends fun hash(self: Slice): Int;
```

[`Slice{:tact}`][slice] 的扩展函数。

计算并返回给定[`Slice{:tact}`][slice]的 [标准 `Cell{:tact}` 表示][std-repr] 的[SHA-256][sha-2]哈希值的[`Int{:tact}`][int]值。

用法示例：

```tact
let s: Slice = beginCell().asSlice();
let fizz: Int = s.hash();
```

## Slice.asCell

```tact
extends fun asCell(self: Slice): Cell;
```

[`Slice{:tact}`][slice] 的扩展函数。

将 [`Slice{:tact}`][slice]转换为 [`Cell{:tact}`][cell]并返回。 别名为 `beginCell().storeSlice(self).endCell(){:tact}`。

用法示例：

```tact
let s: Slice = beginCell().asSlice();
let fizz: Cell = s.asCell();
let buzz: Cell = beginCell().storeSlice(s).endCell();

fizz == buzz; // true
```

## Address.asSlice

```tact
extends fun asSlice(self: Address): Slice;
```

[`Address{:tact}`][p] 的扩展函数。

将 [`Address{:tact}`][p] 转换为[`Slice{:tact}`][slice]并返回。 别名为 `beginCell().storeAddress(self).asSlice(){:tact}`。

用法示例：

```tact
let a: Address = myAddress();
let fizz: Slice = a.asSlice();
let buzz: Slice = beginCell().storeAddress(a).asSlice();

fizz == buzz; // true
```

## Struct.toCell

```tact
extends fun toCell(self: Struct): Cell;
```

任何结构类型 [Struct][struct] 的扩展函数。

将 [Struct][struct] 转换为 [`cell{:tact}`][cell]并返回。

用法示例：

```tact
struct GuessCoin {
    probably: Int as coins;
    nothing: Int as coins;
}

fun coinCell(): Cell {
    let s: GuessCoin = GuessCoin{ probably: 42, nothing: 27 };
    let fizz: Cell = s.toCell();

    return fizz; // "x{12A11B}"
}
```

## Struct.toSlice

<Badge text="Available since Tact 1.5" variant="tip" size="medium"/><p/>

```tact
extends fun toSlice(self: Struct): Slice;
```

任何结构类型 [Struct][struct]的扩展函数。

将 [Struct][struct] 转换为 [`Slice{:tact}`][slice] 并返回它。 别名为`self.toCell().asSlice(){:tact}`。

用法示例：

```tact
struct GuessCoin {
    probably: Int as coins;
    nothing: Int as coins;
}

fun coinSlice(): Slice {
    let s: GuessCoin = GuessCoin{ probably: 42, nothing: 27 };
    let fizz: Slice = s.toSlice();

    return fizz; // "CS{Cell{000612a11b} bits: 0..24; refs: 0..0}"
}
```

## Struct.fromCell

```tact
extends fun fromCell(self: Struct, cell: Cell): Struct;
```

任何结构类型 [Struct][struct] 的扩展函数。

将 [`cell{:tact}`][cell] 转换为指定的 [结构体][struct]，并返回该 [结构体][struct]。

试图传递布局与指定 [Struct][struct] 不同的 [`cell{:tact}`][cell]，或加载的数据超过 [`cell{:tact}`][cell] 所包含的数据时，会出现 [exit code 9](/zh-cn/book/exit-codes#9)异常：`Cell underflow`。

使用示例：

```tact
struct GuessCoin {
    probably: Int as coins;
    nothing: Int as coins;
}

fun directParse(payload: Cell): GuessCoin {
    return GuessCoin.fromCell(payload);
}

fun cautiousParse(payload: Cell): GuessCoin? {
    let coin: GuessCoin? = null;
    try {
        coin = GuessCoin.fromCell(payload);
    } catch (e) {
        dump("Cell payload doesn't match GuessCoin Struct!");
    }
    return coin;
}
```

## Struct.fromSlice

```tact
extends fun fromSlice(self: Struct, cell: Slice): Struct;
```

任何结构类型 [Struct][struct] 的扩展函数。

将 [`Slice{:tact}`][slice] 转换为指定的 [Struct][struct]，并返回该 [Struct][struct]。

尝试传递布局与指定 [结构][struct] 不同的 [`Slice{:tact}`][slice]，或加载比 [`Slice{:tact}`][slice] 包含的数据更多的数据时，会出现[退出码 9](/zh-cn/book/exit-codes#9)异常：`Cell underflow`。

使用示例：

```tact
struct GuessCoin {
    probably: Int as coins;
    nothing: Int as coins;
}

fun directParse(payload: Slice): GuessCoin {
    return GuessCoin.fromSlice(payload);
}

fun cautiousParse(payload: Slice): GuessCoin? {
    let coin: GuessCoin? = null;
    try {
        coin = GuessCoin.fromSlice(payload);
    } catch (e) {
        dump("Slice payload doesn't match GuessCoin Struct!");
    }
    return coin;
}
```

## Message.toCell

```tact
extends fun toCell(self: Message): Cell;
```

任何消息类型 [Message][message] 的扩展函数。

将 [Message][message] 转换为[`cell{:tact}`][cell]并返回。

用法示例：

```tact
message GuessCoin {
    probably: Int as coins;
    nothing: Int as coins;
}

fun coinCell(): Cell {
    let s: GuessCoin = GuessCoin{ probably: 42, nothing: 27 };
    let fizz: Cell = s.toCell();

    return fizz; // "x{AB37107712A11B}"
}
```

## Message.toSlice

<Badge text="Available since Tact 1.5" variant="tip" size="medium"/><p/>

```tact
extends fun toSlice(self: Message): Slice;
```

任何 [Message][message] 类型的扩展函数。

将 [Message][message] 转换为 [`Slice{:tact}`][slice] 并返回它。 别名为`self.toCell().asSlice(){:tact}`。

用法示例：

```tact
message GuessCoin {
    probably: Int as coins;
    nothing: Int as coins;
}

fun coinSlice(): Slice {
    let s: GuessCoin = GuessCoin{ probably: 42, nothing: 27 };
    let fizz: Slice = s.toSlice();

    return fizz; // "CS{Cell{000eab37107712a11b} bits: 0..56; refs: 0..0}"
}
```

## Message.fromCell

```tact
extends fun fromCell(self: Message, cell: Cell): Message;
```

任何消息类型 [Message][message] 的扩展函数。

将 [`cell{:tact}`][cell] 转换为指定的 [Message][message]，并返回该 [Message][message]。

尝试传递布局与指定 [Message][message] 不同的[`cell{:tact}`][cell]，或加载的数据超过[`cell{:tact}`][cell]所包含的数据时，会出现[退出码 9](/zh-cn/book/exit-codes#9)的异常：`Cell underflow`。

使用示例：

```tact
message(0x777) TripleAxe {
    prize: Int as uint32;
}

fun directParse(payload: Cell): TripleAxe {
    return TripleAxe.fromCell(payload);
}

fun cautiousParse(payload: Cell): TripleAxe? {
    let coin: TripleAxe? = null;
    try {
        coin = TripleAxe.fromCell(payload);
    } catch (e) {
        dump("Cell payload doesn't match TripleAxe Message!");
    }
    return coin;
}
```

## Message.fromSlice

```tact
extends fun fromSlice(self: Message, cell: Slice): Message;
```

任何 [Message][message] 类型的扩展函数。

将 [`Slice{:tact}`][slice] 转换为指定的 [Message][message]，并返回该 [Message][message]。

试图传递布局不同于指定 [Message][message] 的[`Slice{:tact}`][slice]，或加载的数据多于[`Slice{:tact}`][slice]所包含的数据时，会出现[退出码 9](/zh-cn/book/exit-codes#9)的异常：`Cell underflow`。

使用示例

```tact
message(0x777) TripleAxe {
    prize: Int as uint32;
}

fun directParse(payload: Slice): TripleAxe {
    return TripleAxe.fromSlice(payload);
}

fun cautiousParse(payload: Slice): TripleAxe? {
    let coin: TripleAxe? = null;
    try {
        coin = TripleAxe.fromSlice(payload);
    } catch (e) {
        dump("Slice payload doesn't match TripleAxe Message!");
    }
    return coin;
}
```

[p]: /zh-cn/book/types#primitive-types
[bool]: /zh-cn/book/types#booleans
[int]: /zh-cn/book/integers
[cell]: /zh-cn/book/cells#cells
[builder]: /zh-cn/book/cells#builders
[slice]: /zh-cn/book/cells#slices
[map]: /zh-cn/book/maps
[struct]: /zh-cn/book/structs-and-messages#structs
[message]: /zh-cn/book/structs-and-messages#messages
[std-repr]: /zh-cn/book/cells#cells-representation
[tlb]: https://docs.ton.org/develop/data-formats/tl-b-language
[sha-2]: https://en.wikipedia.org/wiki/SHA-2#Hash_standard
