Rust 基礎系列 #4: 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
一個切片由三個元素組成：
- 一個初始索引
- 切片運算符（
..或..=） - 一個結束索引
接下來是數組切片的一個示例：
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 程序中使用函數。敬請關注。
