在 上一篇 關(guān)于 Rust 編程語言的文章中，我們提到了變量、常量和 遮蔽shadowing

現(xiàn)在來講解數(shù)據(jù)類型是再自然不過的了。

數(shù)據(jù)類型是什么？

將這個詞匯展開些單詞的順序改變一下你就會得到答案了；“數(shù)據(jù)類型” -> “數(shù)據(jù)的類型”。

計算機使用 0 和 1 來存儲數(shù)據(jù)，但是為了讓數(shù)據(jù)在讀取時有意義，我們使用數(shù)據(jù)類型來表示這些 0 和 1 的含義。

Rust 有兩種數(shù)據(jù)類型：

• 標(biāo)量數(shù)據(jù)類型：只能存儲單個值的類型。
• 復(fù)合數(shù)據(jù)類型：可以存儲多個值，甚至是不同類型的值。

在本文中，我將講解標(biāo)量數(shù)據(jù)類型。我將在下一篇文章中講解第二類數(shù)據(jù)類型。

接下來是 Rust 中四種主要標(biāo)量數(shù)據(jù)類型的簡要概述：

• 整型：存儲整數(shù)。有每種特定情況下使用的子類型。
• 浮點數(shù)：存儲帶有小數(shù)部分的數(shù)字。有兩種基于大小的子類型。
• 字符：使用 UTF-8 編碼存儲單個字符。（是的，你可以在字符中存儲表情符號*。）
• 布爾值： 存儲 true 或 false。（給那些無法就 0 是 true 還是 0 是 false 達成一致的開發(fā)者。）

整型

在編程語言中，整型指的是一個整數(shù)。Rust 中的整型要么是有符號的，要么是無符號的。無符號整型只能存儲 0 和正數(shù)，而有符號整型可以存儲負數(shù)、0 和正數(shù)。

?? 一個有符號整型的范圍從 -(2n-1) 開始，以 (2n-1)-1 結(jié)束。同樣，無符號整型的范圍從 0 開始，以 (2n)-1 結(jié)束。

這是根據(jù)符號和長度可用的整型：

Rust 中的整型數(shù)據(jù)類型

正如你所見，Rust 有 8、16、32、64 甚至 128 位的有符號和無符號整型！

使用 *size 的整型根據(jù)計算機的架構(gòu)而變化。在 8 位微控制器上，它是 *8，在 32 位的舊計算機上，它是 *32，在現(xiàn)代 64 位系統(tǒng)上，它是 *64。

使用 *size 是為了存儲與內(nèi)存（這與裸機相關(guān)）有關(guān)的數(shù)據(jù)，比如指針、偏移量等。

?? 當(dāng)你沒有顯式地指定整型的子類型時，Rust 編譯器會默認推斷為 i32。顯然，如果值比 i32 能存儲的值大或小，Rust 編譯器會禮貌地報錯并要求你手動指定類型。

Rust 不僅允許你以十進制形式存儲整數(shù)，還允許你以二進制、八進制和十六進制形式存儲整數(shù)。

為了更好的可讀性，你可以使用下劃線 _ 來代替逗號來書寫/讀取大數(shù)。

fn main() {
    let bin_value = 0b100_0101; // 使用前綴“0b”表示二進制
    let oct_value = 0o105; // 使用前綴“0o”表示八進制
    let hex_value = 0x45; // 使用前綴“0x”表示十六進制
    let dec_value = 1_00_00_000; // 和寫一克若（1,00,00,000）一樣
    println!("二進制值: {bin_value}");
    println!("八進制值: {oct_value}");
    println!("十六進制值: {hex_value}");
    println!("十進制值: {dec_value}");
}

我使用二進制、八進制和十六進制分別將十進制數(shù) 69 存儲在變量 bin_value、oct_value 和 hex_value 中。在變量 dec_value 中，我存儲了數(shù)字 1 克若1 Crore（一千萬），并且使用了下劃線替代逗號，這是印度的書寫系統(tǒng)。對于那些更熟悉國際計數(shù)系統(tǒng)的人來說，你可以將其寫成 10_000_000。

在編譯并運行這個二進制文件后，我得到了如下輸出：

二進制值: 69
八進制值: 69
十六進制值: 69
十進制值: 10000000

浮點數(shù)

浮點數(shù)是一種存儲帶有小數(shù)部分的數(shù)字的數(shù)據(jù)類型。

與 Rust 中的整型不同，浮點數(shù)只有兩種子類型：

• f32: 單精度浮點數(shù)類型
• f64: 雙精度浮點數(shù)類型

和 Rust 中的整型一樣，當(dāng) Rust 推斷一個變量的類型時，如果它看起來像一個浮點數(shù)，那么它就會被賦予 f64 類型。這是因為 f64 類型比 f32 類型有更高的精度，并且在大多數(shù)計算操作中幾乎和 f32 類型一樣快。請注意，浮點數(shù)據(jù)類型（f32 和 f64）都是有符號的。

?? Rust 編程語言按照 IEEE 754 二進制浮點數(shù)表示與算術(shù)標(biāo)準存儲浮點數(shù)。

fn main() {
    let pi: f32 = 3.1400; // f32
    let golden_ratio = 1.610000; // f64
    let five = 5.00; // 小數(shù)點表示它必須被推斷為浮點數(shù)
    let six: f64 = 6.; // 盡管類型說明被顯式的添加了，小數(shù)點也是**必須**的
    println!("pi: {pi}");
    println!("黃金比例: {golden_ratio}");
    println!("五: {five}");
    println!("六: {six}");
}

仔細看第 5 行。盡管我已經(jīng)為變量 six 指定了類型，但我必須至少加上一個小數(shù)點。小數(shù)點之后有什么就由你決定了。

程序的輸出是相當(dāng)可預(yù)測的... 嗎？

pi: 3.14
黃金比例: 1.61
五: 5
六: 6

在上面的輸出中，你可能已經(jīng)注意到，當(dāng)顯示變量 pi、golden_ratio 和 five 中存儲的值時，我在變量聲明時在結(jié)尾增加的零已經(jīng)消失了。

就算這些零沒有被 移除，它們也會在通過 println 宏輸出值時被省略。所以，不，Rust 沒有篡改你的變量值。

字符

你可以在一個變量中存儲一個字符，類型是 char。像 80 年代的傳統(tǒng)編程語言一樣，你可以存儲一個 ASCII 字符。但是 Rust 還擴展了字符類型，以存儲一個有效的 UTF-8 字符。這意味著你可以在一個字符中存儲一個表情符號 ??

?? 一些表情符號實際上是兩個已有表情符號的組合。一個很好的例子是“燃燒的心”表情符號：????。這個表情符號是通過使用 零寬度連接器 來組合兩個表情符號構(gòu)成的：?? + ?? = ????

Rust 的字符類型無法存儲這樣的表情符號。

fn main() {
    let a = 'a';
    let p: char = 'p'; // 帶有顯性類型說明
    let crab = '??';
    println!("Oh look, {} {}! :{}", a, crab, p);
}

正如你所見，我已經(jīng)將 ASCII 字符 'a' 和 'p' 存儲在變量 a 和 p 中。我還在變量 crab 中存儲了一個有效的 UTF-8 字符，即螃蟹表情符號。然后我打印了存儲在每個變量中的字符。

這是輸出：

Oh look, a ??! :p

布爾值

在 Rust 中，布爾值類型只存儲兩個可能的值之一：true 或 false。如果你想顯性指定類型，請使用 bool。

fn main() {
    let val_t: bool = true;
    let val_f = false;
    println!("val_t: {val_t}");
    println!("val_f: {val_f}");
}

編譯并執(zhí)行上述代碼后，結(jié)果如下：

val_t: true
val_f: false

額外內(nèi)容：顯性類型轉(zhuǎn)換

在上一篇講述 Rust 編程語言中的變量的文章中，我展示了一個非?；A(chǔ)的 溫度轉(zhuǎn)換程序。在那里，我提到 Rust 不允許隱式類型轉(zhuǎn)換。

但這不代表 Rust 也不允許 顯性 類型轉(zhuǎn)換 ; )

要進行顯性類型轉(zhuǎn)換，使用 as 關(guān)鍵字，后面跟著要轉(zhuǎn)換的數(shù)據(jù)類型。

這是一個示例程序：

fn main() {
    let a = 3 as f64; // f64
    let b = 3.14159265359 as i32; // i32
    println!("a: {a}");
    println!("b: ");
}

在第二行，我沒有使用 3.0，而是在 3 后面寫上 as f64，以表示我希望編譯器將 3（一個整數(shù)）轉(zhuǎn)換為 64 位浮點數(shù)的類型轉(zhuǎn)換。第三行也是一樣。但是這里，類型轉(zhuǎn)換是有損的。這意味著小數(shù)部分 完全消失。它不是存儲為 3.14159265359，而是存儲為簡單的 3。

程序的輸出可以驗證這一點：

a: 3
b: 3

總結(jié)

本文介紹了 Rust 中的原始/標(biāo)量數(shù)據(jù)類型。主要有四種這樣的數(shù)據(jù)類型：整型、浮點數(shù)、字符和布爾值。

整型用于存儲整數(shù)，它們有幾種子類型，基于它們是有符號還是無符號以及長度。浮點數(shù)用于存儲帶有小數(shù)的數(shù)字，根據(jù)長度有兩種子類型。字符數(shù)據(jù)類型用于存儲單個有效的 UTF-8 編碼字符。最后，布爾值用于存儲 true 或 false 值。

在下一章中，我將討論數(shù)組和元組等復(fù)合數(shù)據(jù)類型。敬請關(guān)注。