1.Rust數(shù)據(jù)類型

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

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

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

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

2.標(biāo)量類型

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

2.1 整型

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

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

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

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

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

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

2.2 浮點型

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

以下是浮點數(shù)的代碼例子：

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

浮點數(shù)采用 IEEE-754 標(biāo)準(zhǔn)表示。f32 是單精度浮點數(shù)，f64 是雙精度浮點數(shù)。

2.3 布爾型

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

布爾型的使用例子如下:

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

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

2.4 字符類型

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

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

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

3.復(fù)合類型

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

3.1 元組類型

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

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

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

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

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

    let (x, y, z) = tup;

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

程序首先創(chuàng)建了一個元組并綁定到 tup 變量上。接著使用了 let 和一個模式將 tup 分成了三個不同的變量，x、y 和 z。這叫做 解構(gòu)（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;
}

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

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

3.2 數(shù)組類型

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

我們將數(shù)組的值寫成在方括號內(nèi)，用逗號分隔：

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

當(dāng)你想要在棧（stack）而不是在堆（heap）上為數(shù)據(jù)分配空間，或者是想要確?？偸怯泄潭〝?shù)量的元素時，數(shù)組非常有用。但是數(shù)組并不如 vector 類型靈活。vector 類型是標(biāo)準(zhǔn)庫提供的一個 允許 增長和縮小長度的類似數(shù)組的集合類型。當(dāng)不確定是應(yīng)該使用數(shù)組還是 vector 的時候，那么很可能應(yīng)該使用 vector。

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

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

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

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

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

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

let a = [3; 5];

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

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

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

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

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

如果我們訪問數(shù)組結(jié)尾之后的元素會發(fā)生什么呢？比如執(zhí)行以下代碼：

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，程序?qū)⒃跀?shù)組中的索引處打印出相應(yīng)的值。如果你輸入一個超過數(shù)組末端的數(shù)字，如 10，你會看到這樣的輸出：
0
1
2
3
4

此代碼編譯成功。如果運行此代碼并輸入 0、1、2、3 或 4，程序?qū)⒃跀?shù)組中的索引處打印出相應(yīng)的值。如果你輸入一個超過數(shù)組末端的數(shù)字，如 10，你會看到這樣的輸出：

圖片

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

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

4.總結(jié)

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

在下篇文章中,我們將一起學(xué)習(xí)Rust的函數(shù)和控制流。