# 初探 Rust 數值型態，史上最精簡的命名

Rust 的數值資料型態名稱，可以說是我在各種程式語言裡頭看過最簡練的。

在許多靜態型別、重視性能的程式語言當中，我們時常會需要給變數顯式地指定數值型態的大小。比方說，當我們使用 Java 寫遊戲，需要宣告一個變數來儲存玩家通關次數的時候，我們可能會考慮到一個玩家不可能累積通關數萬次，因而選擇使用最適合的 `short` 型態，而不是更大的 `int` 或 `long` 型態，以節省更多的記憶體空間。

然而，對於一個程式設計師而言，想分清楚這些資料型態的個別長度，多少還是需要一點記憶成本的。程式設計師難以單從 `short` 這個名字看出它佔 2 bytes 大小，且若遇上了像 C++ 那樣「`int` 長度因編譯器和平台而異」的情況，則更是折磨人。

<br/>

## ► Rust 的數值型態

對於 Rust 使用者而言，這種難題不存在──你只需要記得 Rust 的內建的數值型態分為整數、無號整數、浮點數，接下來就只剩長度大小的事了。

事實上，Rust 不是唯一一個給資料型態採用長度命名的程式語言。就我能查到的資料來看，Nim（2008）、Golang（2009）、Rust（2010）、Swift（2014）、Zig（2016）都原生使用長度來給基本數值型態命名。

以 Golang 作例，它就給整數分成了 `int`、`int8`、`int16`、`int32`、`int64`，正整數則有 `uint`、`uint8`、`uint16`、`uint32`、`uint64`，以及浮點數 `float32` 和 `float64`，而 Rust 在這方面把資料型態的名稱省略得更極致：它的數值型態分為整數的 `isize`、`i8`、`i16`、`i32`、`i64`、`i128`，無號整數的 `usize`、`u8`、`u16`、`u32`、`u64`、`u128`，以及浮點數的 `f32`、`f64`。

i 代表的是整數（integer）：
* `isize`：長度大小取決於平台的整數，例如在 64 位元環境時，`isize` 就相當於 `i64`
* `i8`：佔用 8 位元的整數，可表示範圍是 -128 ~ 127
* `i16`：佔用 16 位元的整數 -32768 ~ 32767
* `i32`：佔用 32 位元的整數 -2147483648 ~ 2147483647
* `i64`：佔用 64 位元的整數 -9.2e18 ~ 9.2e18
* `i128`：佔用 128 位元的整數 -1.7e38 ~ 1.7e38

u 代表的是無號整數（unsigned integer）：
* `usize`：長度大小取決於平台的無號整數，例如在 32 位元環境時，`usize` 就相當於 `u32`
* `u8`：佔用 8 位元的無號整數，可表示範圍是 0 ~ 255
* `u16`：佔用 16 位元的無號整數，可表示範圍是 0 ~ 65535
* `u32`：佔用 32 位元的無號整數，可表示範圍是 0 ~ 4294967295
* `u64`：佔用 64 位元的無號整數，可表示範圍是 0 ~ 1.8e19
* `u128`：佔用 128 位元的無號整數，可表示範圍是 0 ~ 3.4e38

f 代表的是浮點數（float）：
* `f32`：佔用 32 位元的浮點數
* `f64`：佔用 64 位元的浮點數

這樣的命名方式已經短得無法再更短，卻能夠讓有一定底子的程式設計師一眼就曉得它的長度、確定它的範圍，即便是第一次接觸 Rust 語言。例如，我們透過 `u32` 這個名字就可以知道是無號整數 unsigned integer，佔用了 32 個位元，範圍是 0 ~ 4294967295；透過 `i16` 這個名字就可以知道是包含正負號的整數 integer，佔用了 16 個位元，範圍是 -32768 ~ 32767；透過 `f64` 就可以知道是佔用了 64 個位元的浮點數 float。

一般而言，`isize` 和 `usize` 型態是為了底層的指標操作而存在，通常在涉及記憶體分配的時候會比較容易用得到，像是我們給陣列指定長度的時候，編譯器預期輸入的形態就會是 `usize`，以確保在不同平台上存取記憶體位址的時候是安全的。在不涉及底層操作的情況下，我們通常不會使用 `isize` 或 `usize`。

如果你還記得我曾說過 Rust 語言會從各方面逼迫你寫出考慮周詳的程式碼，那你或許已經能從這樣的設計瞥見其中一角──當你需要定義變數欄位（包括函數、結構體）的時候，你必須清楚地寫出你使用的數值型態大小，而不是像其他語言一樣使用 `int` 這種依賴於慣例、由編譯器來決定的名稱，所有的選項細節都應該要是程式設計師自己也能清楚掌握的。

<br/>

## ► 宣告變數

在 Rust 當中，變數和函數都採 lower_snake_case 命名法。透過 let name: type = value 來宣告一個變數：

let var_1: u64 = 20000000000;
let var_2: u64 = 20_000_000_000;
let var_3: u64 = 0xDEADCAFE; // 十六進制的 DEADCAFE
let var_4: u32 = 0o455; // 八進制的 455
let var_5: u8 = 0b11101011; // 二進制的 11101011

println!("var_1: {var_1}");
println!("var_2: {var_2}");
println!("var_3: {var_3:X} in hexadecimal, {var_3} in decimal");
println!("var_4: {var_4:o} in octal, {var_4} in decimal");
println!("var_5: {var_5:b} in binary, {var_5} in decimal");

if var_1 == var_2 {
    println!("`var_1` equals to `var_2`!");
}

從「20_000_000_000」可以看見，我們可以利用底線來給較大的數值分位，這樣一來在上述的例子當中，一眼就可以看得出 `var_2` 的值是兩百億了。透過實際執行最後的 if 條件判斷句，我們可以得知分位底線無論加不加都不會對程式本身造成影響，但可以讓程式設計師更易於閱讀。

在一些特殊場合下，我們也許還會用到二進制或十六進制等表示方法（例如加密、檔案讀寫、資料校驗、字串轉碼等），這也可以直接透過在數值前加上 0b、0o、0x 來分別表示二進制、八進制、十六進制，省去自行使用計算機轉換的麻煩。在 `println!` 當中，則可以使用 :X、:x、:o、:b 來指定一個數值應該被以什麼樣的進位方式顯示出來。

一般而言，如果沒有特別指定型態的話，通常編譯器會透過前後文來推斷變數的形態，整數預設是 `i32`，浮點數預設是 `f64`：

let my_int = 123; // -> i32
let my_float = 456.0; // -> f64

println!("The value of `my_int` is: {my_int}"); // -> 123
println!("The value of `my_int` is: {my_int:?}"); // -> 123
println!("The value of `my_int` is: {}", my_int); // -> 123
println!("The value of `my_int` is: {:?}", my_int); // -> 123

println!("The value of `my_float` is: {my_float}"); // -> 456
println!("The value of `my_float` is: {my_float:?}"); // -> 456.0
println!("The value of `my_float` is: {}", my_float); // -> 456
println!("The value of `my_float` is: {:?}", my_float); // -> 456.0

這裡也趁機說說 `println!` 的用法：當你想要使用 `println!` 印出變數內容的時候，你可以選擇直接把變數包在大括號當中，或者是先放入大括號，再隨後把變數排在 format 字串的後面，就像 C 語言當中的 `printf` 一樣。原則上會推薦把變數包在大括號裡頭，會更利於直接閱讀。

在 Rust 當中，資料的顯示行為還分成 `Display` 和 `Debug`。我們通常會在 format 字串的大括號當中加上「:?」來表示我們是依照 `Debug` 特徵來處理，通常用來顯示更詳細的資訊給開發者閱讀。這個實際講起來大概要等到提及特徵（trait）和定義結構體（struct）的時候才會比較明白，就留到之後再特別拿出來講吧。

<br/>

## ► Rust 內建的 overflow 處理機制

Rust 是安全至上的語言──這樣的理念貫穿了 Rust 的原則，極大地反映在內建的函式庫和許多語法的設計上面。

我們都知道溢位可能會帶來預期以外的行為，甚至是災難性的後果：若有一個 `i32` 型態的變數（範圍：-2147483648 ~ 2147483647）值為 2147483647，當電腦試圖把它往上加 1 的時候，它就會從最小值開始循環，變成 -2147483648。如果這變數是發生在遊戲當中角色的持有金錢數上面，這就會導致非常有錢的角色因為太過富有而一瞬間破產，從而引發其他更多潛在的 bug（例如存檔整個廢掉、角色卡關）。

對於一個上古時代以來就這麼具備代表性的常見漏洞，Rust 提供了完整的內建函式庫來處理。像是我們可以使用飽和加法 `saturating_add` 來包裝那些「可能會引發溢位」的加法：

let x = i8::MAX; // 127
let y = x.saturating_add(1); // 計算 x+1，如果會導致溢位的話則維持在上限值
println!("x: {x}, y: {y}"); // x: 127, y:127

在某些特殊情況下，你也可以基於情境的需要而允許它產生 overflow，使用 `wrapping_add` 來向 Rust 保證「我很確定這裡發生的溢位是我刻意為之的，你不要阻止我」：

let x = i8::MAX; // 127
let y = x.wrapping_add(1); // 計算 x+1，如果會導致溢位則放任其溢位，得到 -128
println!("x: {x}, y: {y}"); // x: 127, y: -128

你還能透過 `overflowing_add` 來檢查是否發生溢位。因為得到的結果是一對沒有實現 `Display` 特徵的複合型態 `tuple`，我們需要用 :? 讓它能夠正常顯示：

let x = i8::MAX; // 127
let add_result = x.overflowing_add(1); // 計算 x+1，允許溢位的同時確認過程中是否有發生溢位
println!("add_result: {add_result:?}"); // -> (-128, true)

除了 add 以外，也有 sub（減法）、mul（乘法）、div（除法）、abs（絕對值）、pow（冪次）、neg（負數）……可以說是基本運算都能夠使用內建的溢位處理機制，你完全不需要自己從頭判斷它具體的計算過程。

在 Rust 編譯器的預設行為當中，如果你不使用任何的處理機制，直接執行加法：

let x = i8::MAX; // 127
let y = x + 1;
println!("x: {x}, y: {y}");

那麼當你使用 `cargo run` / `cargo build` 執行或編譯出來的程式，會在發生溢位的時候觸發 panic，使得程式強制中止；使用 `cargo run --release` / `cargo build --release` 執行或編譯出來的程式，則會允許溢位行為發生而得到 -128。

僅僅是內建的方法，我們就能從這些貼心的細節當中感受到 Rust 所散發出來的魅力了。在接下來的許多章節，我們還可以看見 Rust 是如何提供你豐富的選項和工具，讓你能夠依照需求精細地量身訂製。

<br/>

## ► 其他的基本資料型態

若要講起「Rust 的基本資料型態」，就有 `bool`、`char`、`tuple`、`array`、`fn`。其中 `bool` 實在是沒有必要單獨拿出來說，畢竟會來寫 Rust 的人通常都是已經具備程式設計基礎的人，而其他的型態涉及的東西又多得沒辦法一口氣說完，這也是為何這篇文只著重於「數值型態」，而不是「資料型態」了。

在本系列的下一篇文當中，就來說說變數的可變性，以及 Rust 的字串是如何設計的吧。

<br/>

###### tags: `Rust` `程式設計`