Rust 基礎系列 #4: Rust 中的數組和元組

在 Rust 系列的第四篇中，學習複合數據類型、數組和元組。

在上一篇文章中，你學習到了 Rust 中的 標量數據類型。它們是整型、浮點數、字元和布爾值。

在本文中，我們將會看看 Rust 編程語言中的複合數據類型。

Rust 中的複合數據類型是什麼？

複合數據類型可以在一個變數中存儲多個值。這些值可以是相同的標量數據類型，也可以是不同的標量數據類型。

Rust 編程語言中有兩種這樣的數據類型：

• 數組 Array ：存儲相同類型的多個值。
• 元組 Tuple ：存儲多個值，可以是相同的類型，也可以是不同的類型。

讓我們了解一下它們吧！

Rust 中的數組

Rust 編程語言中的數組具有以下特性：

• 每一個元素都必須是相同的類型
• 數組有一個固定的長度
• 數組存儲在堆棧中，即其中存儲的數據可以被 迅速 訪問

創建數組的語法如下：

// 無類型聲明
let variable_name = [element1, element2, ..., elementn];

// 有類型聲明
let variable_name: [data_type; array_length] = [element1, element2, ..., elementn];

數組中的元素是在方括弧中聲明的。要訪問數組的元素，需要在方括弧中指定要訪問的索引。

來讓我們看一個例子來更好地理解這個。

fn main() {
    // 無類型聲明
    let greeting = ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!'];

    // 有類型聲明
    let pi: [i32; 10] = [1, 4, 1, 5, 9, 2, 6, 5, 3, 5];

    for character in greeting {
        print!("{}", character);
    }

    println!("nPi: 3.1{}{}{}{}", pi[0], pi[1], pi[2], pi[3]);
}

這裡，我定義了一個字元數組和另一個存儲 i32 類型的值的數組。greeting 數組以單獨字元的形式存儲了字元串 "Hello world!" 的字元。pi 數組以單獨數字的形式存儲了圓周率小數點後的前 10 位數字。

然後，我使用 for 循環列印了 greeting 數組的每個字元。（我很快就會講到循環。）然後，我列印了 pi 數組的前 4 個值。

Hello world!
Pi: 3.11415

如果你想創建一個數組，其中每個元素都是 y，並且出現 x 次，你可以使用以下快捷方式在 Rust 中實現：

let variable_name = [y; x];

來看一個演示……

fn main() {
    let a = [10; 5];

    for i in a {
        print!("{i} ");
    }
    println!("");
}

我創建了一個變數 a，它的長度為 5。數組中的每個元素都是 '10'。我通過使用 for 循環列印數組的每個元素來驗證這一點。

它的輸出如下：

10 10 10 10 10

? 作為練習，嘗試創建一個長度為 x 的數組，然後嘗試訪問數組的第 x+1 個元素。看看會發生什麼。

Rust 中的元組

Rust 中的元組具有以下特性：

• 就像數組一樣，元組的長度是固定的
• 元素可以是相同的/不同的標量數據類型
• 元組存儲在堆棧中，所以訪問速度更快

創建元組的語法如下：

// 無類型聲明
let variable_name = (element1, element2, ..., element3);

// 有類型聲明
let variable_name: (data_type, ..., data_type) = (element1, element2, ..., element3);

元組的元素寫在圓括弧中。要訪問元素，使用點運算符，後跟該元素的索引。

fn main() {
    let a = (38, 923.329, true);
    let b: (char, i32, f64, bool) = ('r', 43, 3.14, false);

    println!("a.0: {}, a.1: {}, a.2: {}", a.0, a.1, a.2);
    println!("b.0: {}, b.1: {}, b.2: {}, b.3: {}", b.0, b.1, b.2, b.3);

    // 元組解構
    let pixel = (50, 0, 200);
    let (red, green, blue) = pixel;
    println!("red: {}, green: {}, blue: {}", red, green, blue);
}

在上面的代碼中，我在第 2 行和第 3 行聲明了兩個元組。它們只包含我當時想到的隨機值。但是仔細看，兩個元組中每個元素的數據類型都不同。然後，在第 5 行和第 6 行，我列印了兩個元組的每個元素。

在第 9 行，我聲明了一個名為 pixel 的元組，它有 3 個元素。每個元素都是組成像素的顏色紅色、綠色和藍色的亮度值。這個範圍是從 0 到 255。所以，理想情況下，我會聲明類型為 (u8, u8, u8)，但是在學習代碼時不需要這樣優化 ; )

然後，在第 10 行，我「解構」了 pixel 元組的每個值，並將其存儲在單獨的變數 red、green 和 blue 中。然後，我列印了 red、green 和 blue 變數的值，而不是 pixel 元組的值。

讓我們看看輸出……

a.0: 38, a.1: 923.329, a.2: true
b.0: r, b.1: 43, b.2: 3.14, b.3: false
red: 50, green: 0, blue: 200

看起來不錯 : )

額外內容：切片

準確的來說， 切片 Slice 不是 Rust 中的複合數據類型。相反，切片是現有複合數據類型的 「切片」。

一個切片由三個元素組成：

• 一個初始索引
• 切片運算符（.. 或 ..=）
• 一個結束索引

接下來是數組切片的一個示例：

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..4];

    for element in my_slice {
        println!("{element}");
    }
}

就像 C 和 C++ 一樣，& 用於存儲變數的引用（而不是原始指針）。所以 &my_array 意味著對變數 my_array 的引用。

然後，來看看切片。切片由 [0..4] 表示。這裡，0 是切片開始的索引。而 4 是切片結束的索引。這裡的 4 是一個非包含索引。

這是程序輸出，以更好地理解正在發生的事情：

0
1
2
3

如果你想要一個 包含 範圍，你可以使用 ..= 作為包含範圍的切片運算符。

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..=4];

    for element in my_slice {
        println!("{element}");
    }
}

現在，這個範圍是從第 0 個元素到第 4 個元素，下面是輸出來證明這一點：

0
1
2
3
4

總結

本文講到了 Rust 編程語言中的複合數據類型。你學習了如何聲明和訪問存儲在數組和元組類型中的值。此外，你還了解了切片「類型」，以及如何解構元組。

在下一章中，你將學習如何在 Rust 程序中使用函數。敬請關注。

（題圖：MJ/22a0d143-2216-439f-8e1d-abd94cdfdbd0）

via: https://itsfoss.com/rust-arrays-tuples/

作者：Pratham Patel 選題：lkxed 譯者：Cubik65536 校對：wxy

本文由 LCTT 原創編譯，Linux中國 榮譽推出

本文轉載來自 Linux 中國: https://github.com/Linux-CN/archive