> For the complete documentation index, see [llms.txt](https://zenofchain.gitbook.io/sway-bian-cheng-yu-yan-geng-xin-zhong-the-sway-programming-languageupdatin/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://zenofchain.gitbook.io/sway-bian-cheng-yu-yan-geng-xin-zhong-the-sway-programming-languageupdatin/7.-yi-ban-ji-ju-common-collections/7.1-dui-shang-de-xiang-liang-vectors-on-the-heap.md).

# 7.1 堆上的向量(Vectors on the Heap)

The first collection type we’ll look at is `Vec<T>`, also known as a vector. Vectors allow you to store more than one value in a single data structure that puts all the values next to each other in memory. Vectors can only store values of the same type. They are useful when you have a list of items, such as the lines of text in a file or the prices of items in a shopping cart.

我们要看的第一个集聚类型是`Vec<T>`，也称为向量。向量允许您在单个数据结构中存储多个值，该数据结构将所有值在内存中并行放置。向量只能存储相同类型的值。当您有一个项目列表时，它们很有用，例如文件中的文本行或购物车中的项目价格。

`Vec<T>` is included in the [standard library prelude](https://fuellabs.github.io/sway/v0.38.0/book/introduction/standard_library.html#standard-library-prelude) which means that there is no need to import it manually.

`Vec<T>` 包含在 [标准库前置](https://fuellabs.github.io/sway/v0.38.0/book/introduction/standard_library.html#standard-library-prelude) 中，这意味着无需手动导入。

### 创建新向量 (Creating a New Vector)

To create a new empty vector, we call the `Vec::new` function, as shown below:

要创建一个新的空向量，我们调用`Vec::new` 函数，如下所示：

```
    let v: Vec<u64> = Vec::new();

```

Note that we added a type annotation here. Because we aren’t inserting any values into this vector, the Sway compiler doesn’t know what kind of elements we intend to store. Vectors are implemented using generics which means that the `Vec<T>` type provided by the standard library can hold any type. When we create a vector to hold a specific type, we can specify the type within angle brackets. In the example above, we’ve told the Sway compiler that the `Vec<T>` in `v` will hold elements of the `u64` type.

请注意，我们在此处添加了类型注释。因为我们没有向该向量中插入任何值，所以 Sway 编译器不知道存储何种元素。向量是用泛型实现的，这意味着标准库提供的`Vec<T>` 类可以包含任何类型。当我们创建一个向量来保存特定类型时，我们可以在尖括号中指定类型。在上面的示例中，我们已经告诉 Sway 编译器，`v` 中的`Vec<T>` 将保存 `u64` 类型的元素。

### 更新向量 (Updating a Vector)

To create a vector and then add elements to it, we can use the `push` method, as shown below:

要创建一个向量然后向其添加元素，我们可以使用 `push` 方法，如下所示：

```
    let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);

```

As with any variable, if we want to be able to change its value, we need to make it mutable using the `mut` keyword, as discussed in the section [Declaring a Variable](https://fuellabs.github.io/sway/v0.38.0/book/basics/variables.html#declaring-a-variable). The numbers we place inside are all of type `u64`, and the Sway compiler infers this from the data, so we don’t need the `Vec<u64>` annotation.

与任何变量一样，如果我们希望能够更改值，则需要使用 `mut` 关键字使其可变，如 [声明变量](https://fuellabs.github.io/摇摆/v0.38.0/book/basics/variables.html#declaring-a-variable)。我们放在里面的数字都是 `u64` 类型，Sway 编译器从数据中推断出这一点，所以我们不需要 `Vec<u64>` 注释。

### 读取向量的元素 (Reading Elements of Vectors)

To read a value stored in a vector at a particular index, you can use the `get` method as shown below:

要读取存储在特定索引处的向量中的值，您可以使用 `get` 方法，如下所示：

```
    let third = v.get(2);
    match third {
        Option::Some(third) => log(third),
        Option::None => revert(42),
    }

```

Note two details here. First, we use the index value of `2` to get the third element because vectors are indexed by number, starting at zero. Second, we get the third element by using the `get` method with the index passed as an argument, which gives us an `Option<T>`.

这里注意两个细节。首先，我们使用 `2` 的索引值来获取第三个元素，因为向量是按数字索引，即从0开始。其次，我们通过使用 `get` 方法将索引作为参数传递来获取第三个元素，这为我们提供了 `Option<T>`。

When the `get` method is passed an index that is outside the vector, it returns `None` without panicking. This is particularly useful if accessing an element beyond the range of the vector may happen occasionally under normal circumstances. Your code will then have logic to handle having either `Some(element)` or `None`. For example, the index could be coming as a contract method argument. If the argument passed is too large, the method `get` will return a `None` value, and the contract method may then decide to revert when that happens or return a meaningful error that tells the user how many items are in the current vector and give them another chance to pass a valid value.

当向 `get` 方法传递一个向量外部的索引时，它会返回 `None`(不会出现慌乱)。如果在正常情况下偶尔会访问超出向量范围的元素，这将特别有用。然后，您的代码将具有处理`Some(element)`或`None`的逻辑。例如，索引可以作为合约方法参数出现。如果传递的参数太大，方法 `get` 将返回一个 `None` 值，然后合约方法可能决定在这种情况发生时恢复或返回一个有意义的错误，告诉用户当前向量中有多少项并给他们另一次传递有效值的机会。

### 迭代向量中的值 (Iterating over the Values in a Vector)

To access each element in a vector in turn, we would iterate through all of the valid indices using a `while` loop and the `len` method as shown below:

要依次访问向量中的每个元素，我们将使用 while 循环和 len 方法遍历所有有效索引，如下所示：

```
    let mut i = 0;
    while i < v.len() {
        log(v.get(i).unwrap());
        i += 1;
    }

```

Note two details here. First, we use the method `len` which returns the length of the vector. Second, we call the method `unwrap` to extract the `Option` returned by `get`. We know that `unwrap` will not fail (i.e. will not cause a revert) because each index `i` passed to `get` is known to be smaller than the length of the vector.

这里注意两个细节。首先，我们使用 `len` 方法返回向量的长度。其次，我们调用方法 `unwrap` 来提取 `get` 返回的 `Option` 。我们知道 `unwrap` 不会失败（即不会导致回撤），因为已知传递给 `get` 的每个索引 `i` 都小于向量的长度。

### 使用穷举存储多种类型 (Using an Enum to store Multiple Types)

Vectors can only store values that are the same type. This can be inconvenient; there are definitely use cases for needing to store a list of items of different types. Fortunately, the variants of an enum are defined under the same enum type, so when we need one type to represent elements of different types, we can define and use an enum!

向量只能存储相同类型的值。这可能很不方便；肯定有需要存储不同类型项目列表的用例。幸运的是，一个穷举的变体是在同一个穷举类型下定义的，所以当我们需要一个类型来表示不同类型的元素时，我们可以定义并使用一个穷举！

For example, say we want to get values from a row in a table in which some of the columns in the row contain integers, some `b256` values, and some Booleans. We can define an enum whose variants will hold the different value types, and all the enum variants will be considered the same type: that of the enum. Then we can create a vector to hold that enum and so, ultimately, holds different types. We’ve demonstrated this below:

例如，假设我们要从表中的一行中获取值，其中一些行的某些列包含整数、一些 `b256` 值和一些布尔值。我们可以定义一个穷举，其变体将包含不同的值类型，并且所有穷举变体将被视为同一类型：即穷举的类型。然后我们可以创建一个向量来保存该穷举，因此最终保存不同的类型。我们在下面证明了这一点：

```
    enum TableCell {
        Int: u64,
        B256: b256,
        Boolean: bool,
    }

    let mut row = Vec::new();
    row.push(TableCell::Int(3));
    row.push(TableCell::B256(0x0101010101010101010101010101010101010101010101010101010101010101));
    row.push(TableCell::Boolean(true));

```

Now that we’ve discussed some of the most common ways to use vectors, be sure to review the API documentation for all the many useful methods defined on `Vec<T>` by the standard library. For now, these can be found in the [source code for `Vec<T>`](https://github.com/FuelLabs/sway/blob/master/sway-lib-std/src/vec.sw). For example, in addition to `push`, a `pop` method removes and returns the last element, a `remove` method removes and returns the element at some chosen index within the vector, an `insert` method inserts an element at some chosen index within the vector, etc.

现在我们已经讨论了使用向量的一些最常见方法，请务必查看 API 文档来了解标准库在 `Vec<T>` 上定义的所有有用方法。目前，这些可以在[`Vec<T>` 的源代码](https://github.com/FuelLabs/sway/blob/master/sway-lib-std/src/vec.sw) 中找到。例如，除了 `push` 之外，`pop` 方法删除并返回最后一个元素，`remove` 方法删除并返回向量中某个选定索引处的元素，`insert` 方法在某个位置插入一个元素向量中选择的索引等。


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://zenofchain.gitbook.io/sway-bian-cheng-yu-yan-geng-xin-zhong-the-sway-programming-languageupdatin/7.-yi-ban-ji-ju-common-collections/7.1-dui-shang-de-xiang-liang-vectors-on-the-heap.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.