1.Rust數據類型

在 Rust 中, 每一個值都屬于某一個 數據類型（data type）, 這告訴 Rust 它被指定為何種數據，以便明確數據處理方式。我們將看到兩類數據類型子集：標量（scalar）和復合（compound）。

Rust是靜態類型（statically typed）語言，也就是說在編譯時就必須知道所有變量的類型。根據值及其使用方式，編譯器通常可以推斷出我們想要用的類型。當多種類型均有可能時，必須增加類型注解，像這樣：

let u_number: u32 = "42".parse().expect("Not a number!");

如果不像上面的代碼這樣添加類型注解 : u32，Rust 會顯示如下錯誤，這說明編譯器需要我們提供更多信息，來了解想要的類型：

2.標量類型

標量（scalar）類型代表一個單獨的值。Rust 有四種基本的標量類型：整型、浮點型、布爾類型和字符類型。

2.1 整型

整數 是一個沒有小數部分的數字。下面表格展示了 Rust 內建的整數類型。我們可以使用其中的任一個來聲明一個整數值的類型。

每一個變體都可以是有符號或無符號的，并有一個明確的大小。有符號 和 無符號 代表數字能否為負值，換句話說，這個數字是否有可能是負數（有符號數），或者永遠為正而不需要符號（無符號數）。這有點像在紙上書寫數字：當需要考慮符號的時候，數字以加號或減號作為前綴；然而，可以安全地假設為正數時，加號前綴通常省略。有符號數以補碼形式存儲。

每一個有符號的變體可以儲存包含從 -(2n - 1) 到 2n - 1 - 1 在內的數字，這里 n 是變體使用的位數。所以 i8 可以儲存從 -(27) 到 27 - 1 在內的數字，也就是從 -128 到 127。無符號的變體可以儲存從 0 到 2n - 1 的數字，所以 u8 可以儲存從 0 到 28 - 1 的數字，也就是從 0 到 255。

另外，isize 和 usize 類型依賴運行程序的計算機架構：64 位架構上它們是 64 位的，32 位架構上它們是 32 位的。

可以使用以下表格的任何一種形式編寫數字字面值。請注意可以是多種數字類型的數字字面值允許使用類型后綴，例如 57u8 來指定類型，同時也允許使用 _ 作為分隔符以方便讀數，例如1_000，它的值與你指定的 1000 相同。

那么該使用哪種類型的數字呢？如果拿不定主意，Rust 的默認類型通常是個不錯的起點，數字類型默認是 i32。isize 或 usize 主要作為某些集合的索引。

2.2 浮點型

Rust 也有兩個原生的 浮點數（floating-point numbers）類型，它們是帶小數點的數字。Rust 的浮點數類型是 f32 和 f64，分別占 32 位和 64 位。默認類型是 f64，因為在現代 CPU 中，它與 f32 速度幾乎一樣，不過精度更高。所有的浮點型都是有符號的。

以下是浮點數的代碼例子：

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
}

浮點數采用 IEEE-754 標準表示。f32 是單精度浮點數，f64 是雙精度浮點數。

2.3 布爾型

正如其他大部分編程語言一樣，Rust 中的布爾類型有兩個可能的值：true 和 false。Rust 中的布爾類型使用 bool 表示。

布爾型的使用例子如下:

fn main() {
    let t = true;
    let f: bool = false;
}

使用布爾值的主要場景是條件表達式，例如 if 表達式。

2.4 字符類型

Rust 的 char 類型是語言中最原生的字母類型。下面是一些聲明 char 值的例子：

fn main() {
    let c = 'z';
    let z: char = '?';
    let heart_eyed_cat = '??';
}

注意，我們用單引號聲明 char 字面量，而與之相反的是，使用雙引號聲明字符串字面量。Rust 的 char 類型的大小為四個字節 (four bytes)，并代表了一個 Unicode 標量值（Unicode Scalar Value），這意味著它可以比 ASCII 表示更多內容。在 Rust 中，帶變音符號的字母（Accented letters），中文、日文、韓文等字符，emoji（繪文字）以及零長度的空白字符都是有效的 char 值。Unicode 標量值包含從 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF 在內的值。不過，“字符” 并不是一個 Unicode 中的概念，所以人直覺上的 “字符” 可能與 Rust 中的 char 并不符合。

3.復合類型

復合類型（Compound types）可以將多個值組合成一個類型。Rust 有兩個原生的復合類型：元組（tuple）和數組（array）。

3.1 元組類型

元組是一個將多個其他類型的值組合進一個復合類型的主要方式。元組長度固定：一旦聲明，其長度不會增大或縮小。

我們使用包含在圓括號中的逗號分隔的值列表來創建一個元組。元組中的每一個位置都有一個類型，而且這些不同值的類型也不必是相同的。例子如下:

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

tup 變量綁定到整個元組上，因為元組是一個單獨的復合元素。為了從元組中獲取單個值，可以使用模式匹配（pattern matching）來解構（destructure）元組值，像這樣：

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

程序首先創建了一個元組并綁定到 tup 變量上。接著使用了 let 和一個模式將 tup 分成了三個不同的變量，x、y 和 z。這叫做 解構（destructuring），因為它將一個元組拆成了三個部分。最后，程序打印出了 y 的值，也就是 6.4。

我們也可以使用點號（.）后跟值的索引來直接訪問它們。例如：

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

這個程序創建了一個元組，x，然后使用其各自的索引訪問元組中的每個元素。跟大多數編程語言一樣，元組的第一個索引值是 0。

不帶任何值的元組有個特殊的名稱，叫做 單元（unit） 元組。這種值以及對應的類型都寫作 ()，表示空值或空的返回類型。如果表達式不返回任何其他值，則會隱式返回單元值。

3.2 數組類型

另一個包含多個值的方式是 數組（array）。與元組不同，數組中的每個元素的類型必須相同。Rust 中的數組與一些其他語言中的數組不同，Rust 中的數組長度是固定的。

我們將數組的值寫成在方括號內，用逗號分隔：

fn main() {
    let a = [1, 2, 3, 4, 5];
}

當你想要在棧（stack）而不是在堆（heap）上為數據分配空間，或者是想要確保總是有固定數量的元素時，數組非常有用。但是數組并不如 vector 類型靈活。vector 類型是標準庫提供的一個 允許 增長和縮小長度的類似數組的集合類型。當不確定是應該使用數組還是 vector 的時候，那么很可能應該使用 vector。

然而，當你確定元素個數不會改變時，數組會更有用。例如，當你在一個程序中使用月份名字時，你更應趨向于使用數組而不是 vector，因為你確定只會有 12 個元素。

let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

可以像這樣編寫數組的類型：在方括號中包含每個元素的類型，后跟分號，再后跟數組元素的數量。

let a: [i32; 5] = [1, 2, 3, 4, 5];

這里，i32 是每個元素的類型。分號之后，數字 5 表明該數組包含五個元素。

你還可以通過在方括號中指定初始值加分號再加元素個數的方式來創建一個每個元素都為相同值的數組：

let a = [3; 5];

變量名為 a 的數組將包含 5 個元素，這些元素的值最初都將被設置為 3。這種寫法與 let a = [3, 3, 3, 3, 3]; 效果相同，但更簡潔。

數組是可以在棧 (stack) 上分配的已知固定大小的單個內存塊。可以使用索引來訪問數組的元素，像這樣：

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

在這個例子中，叫做 first 的變量的值是 1，因為它是數組索引 [0] 的值。變量 second 將會是數組索引 [1] 的值 2。

如果我們訪問數組結尾之后的元素會發生什么呢？比如執行以下代碼：

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Please enter an array index.");

    let mut index = String::new();

    io::stdin()
        .read_line(&mut index)
        .expect("Failed to read line");

    let index: usize = index
        .trim()
        .parse()
        .expect("Index entered was not a number");

    let element = a[index];

    println!("The value of the element at index {index} is: {element}");
}此代碼編譯成功。如果運行此代碼并輸入 0、1、2、3 或 4，程序將在數組中的索引處打印出相應的值。如果你輸入一個超過數組末端的數字，如 10，你會看到這樣的輸出：
0
1
2
3
4

此代碼編譯成功。如果運行此代碼并輸入 0、1、2、3 或 4，程序將在數組中的索引處打印出相應的值。如果你輸入一個超過數組末端的數字，如 10，你會看到這樣的輸出：

圖片

程序在索引操作中使用一個無效的值時導致 運行時 錯誤。程序帶著錯誤信息退出，并且沒有執行最后的 println! 語句。當嘗試用索引訪問一個元素時，Rust 會檢查指定的索引是否小于數組的長度。如果索引超出了數組長度，Rust 會 panic，這是 Rust 術語，它用于程序因為錯誤而退出的情況。這種檢查必須在運行時進行，特別是在這種情況下，因為編譯器不可能知道用戶在以后運行代碼時將輸入什么值。

這是第一個在實戰中遇到的 Rust 安全原則的例子。在很多底層語言中，并沒有進行這類檢查，這樣當提供了一個不正確的索引時，就會訪問無效的內存。通過立即退出而不是允許內存訪問并繼續執行，Rust會讓程序員避開此類錯誤。

4.總結

在本篇文章中,我們學習了Rust的基本數據類型,包括:整型、浮點型、布爾型、字符串、元祖類型和數組類型。

在下篇文章中,我們將一起學習Rust的函數和控制流。