[[396647]]

大家好，我是站長 polarisxu。

這是 Rust 勸退系列的第 4 個教程，探討 Rust 中的基本數據類型，或叫標量類型(scalar type)。

Rust 和 Go 一樣，都是靜態類型語言，這表示每個變量的類型必須明確。和 Go 類似，大多數情況下，Rust 編譯器能夠推斷出某個值的類型，不需要我們顯示指定，寫起來有點類似于弱類型似語言。但有些情況下，必須明確告知編譯器我們使用什么類型，在 Rust 中，這叫 「類型注解」(type annotations)。

對于類型注解，看一個常見的例子：

let guess = "42".parse().expect("Not a number!"); 

這是將字符串 "42" 轉為數字 42。在 Go 語言中，一般這么做：

guess, err := strconv.Atoi("42") 
if err != nil { 
  panic(err) 
} 

但上面的 Rust 代碼會報錯：

error[E0282]: type annotations needed 
 --> src/main.rs:2:9 
  | 
2 |     let guess = "42a".parse().expect("Not a number!"); 
  |         ^^^^^^ consider giving `guess` a type 

這和 Go 還是不太一樣。Go 中很多時候，數值類型會是 int。

為了修復這個問題，我們需要為 number 指定一個類型，比如 u32。

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

吐槽：在 Rust 中，類型注解和 Go 中一樣，放在變量后面。但 Rust 中變量和類型直接非得加一個冒號(:)，而且一般冒號緊跟著變量名(rustfmt 的建議)。不知道冒號有啥特殊需要?!

Rust 內置如下基本數據類型：

• 整數類型
  • 有符合整數：i8、i16、i32、i64、i128、isize
  • 無符號整數：u8、u16、u32、u64、u128、usize
• 浮點類型：f32、f64
• 布爾型：bool
• 字符型：char

01 整數類型

將整數類型整理為一張表，如下：(用 Go 語言對應的類型作對比)

吐槽：有時候 Rust 真的很節省，int、uint 直接省略為 i、u，function 省略為 fn。但有時候又很繁瑣(不簡潔)，比如前面說到的變量和類型之間的冒號。。。

這里用 u、i 的形式，也需要一段時間適應。。。

兩點說明：

• Go 中沒有 128 位長度的整數
• isize 和 usize 對應 Go 中的 int 和 uint，它們的長度依賴運行程序的計算機架構：64 位架構上它們是 64 位的， 32 位架構上它們是 32 位的

在 Go 中，整型變量默認類型是 int，以下代碼可以證明這一點：

x := 32 
fmt.Printf("%T\n", i) 
// 輸出：int 

那 Rust 中默認是什么類型呢?

我想在 Rust 中找到一種辦法，打印變量類型，網上找到了這樣的辦法(有點挫)：

// 打印變量類型的函數。該函數看不懂先放著。 
fn print_type_of<T>(_: &T) { 
  println!("{}", std::any::type_name::<T>()) 
} 
 
fn main() { 
    let x = 32; 
    print_type_of(&x); 
   // 輸出：i32 
} 

可見 Rust 中整型變量默認類型是 i32(即使在 64 位機器上，也是 i32)。這一定程度上說明，在 Go 中，整數一般建議用 int 類型;而 Rust 中，一般建議用 i32 類型。(所以，為什么開頭的 parse 不能默認推斷為 i32 類型呢?怕溢出?)

更智能的類型推斷

上文說 Rust 和 Go 一樣，支持類型推斷。不過 Rust 的推斷更智能，怎么個智能法?看下面的代碼：

// 打印變量類型的函數 
fn print_type_of<T>(_: &T) { 
    println!("{}", std::any::type_name::<T>()) 
} 
 
fn main() { 
    let x = 32; 
    let y: i8 = x; 
    print_type_of(&x); 
    print_type_of(&y) 
} 

根據上面的講解，x 應該是默認類型：i32。但實際上，x 和 y 的類型都是 i8。也就是說，因為 x 的類型沒有顯示的指定(類型注解)，Rust 編譯器會根據上下文(實際上是 let y: i8 = x 這句)推斷出 x 的類型應該和 y 一致，即 i8。

在 Go 中，int8 和 int 是不會進行隱式轉換的，Rust 也一樣，必須進行顯示轉換。但 Rust 的智能類型推斷，可以讓開發者少寫類型轉換的代碼。

比如上面代碼，在 Go 語言中是行不通的：

package main 
 
import ( 
 "fmt" 
) 
 
func main() { 
 x := 32 
 var y int8 = x 
 fmt.Printf("%T\n", x) 
 fmt.Printf("%T\n", y) 
} 

會報錯：

cannot use x (type int) as type int8 in assignment 

也就是說，Go 中的類型推斷不會考慮上下文，因此沒有 Rust 智能。

因為編譯器的強大，VSCode 中(安裝 rust-analyzer)會有類型提示，這樣上面的 print_type_of 函數也不需要了。做了一個動圖，注意上面 x 的類型變化：

此外，isize 和 usize 類型一般用作某些集合的索引，以后文章會看到。

關于各種類型的表示范圍我列出了，因為這個系列不是為無編程經驗的人準備的。這個系列更多是為 Go 愛好者準備的 Rust 教程，因此和 Go 一致的地方可能不會講。

02 浮點類型

和 Go 一樣，Rust 也有兩種浮點數類型：f32 和 f64，對應 Go 中的 float32 和 float64。和 Go 一樣，默認類型是 f64，可以通過類型注解指定具體的浮點類型。

let x = 2.0; // 默認是 f64 

一般地，整數類型和浮點類型都成為數值類型。

數值類型有一些共同的東西。比如都支持基本的數學運算。此外，除了通過類型注解指定類型，數值類型還可以在字面值后面帶上類型后綴指定類型，比如：

let x = 2.0f32; // f32 類型 
let y = 32i64; // i64 類型 

03 布爾型

和 Go 語言一樣，Rust 中的布爾類型使用 bool 表示(咋沒用 b、bl 之類的縮寫呢?哈哈哈)。有兩個可能的值：true 和 false。

fn main() { 
    let t = true; 
 
    let f: bool = false; // 顯式指定類型注解 
} 

04 字符型

Rust 中的 char 表示字符類型，是 Rust 的基本類型，字面值由單引號指定。

let a = 'a'; 
let b = '中'; 
let c = '🤣'; 

可見，Rust 中的 char 類型和 Go 中的 rune 一樣，表示的是 Unicode 碼點，占 4 個字節。

因為 Rust 中的字符串很復雜，而且不是基本類型，因此留在以后講解。

05 小結

本文介紹了 Rust 中的四種基本數據類型：整型、浮點型、布爾型和字符型。其中，浮點型、布爾型和字符型分別對應 Go 中的浮點型、布爾型和 rune 類型，但整型，Go 和 Rust 有些許不一樣，上文已經詳細介紹了。此外，Go 中復數也是基本數據類型：complex64 和 complex128，而 Rust 中沒有，復數通過第三方庫實現，比如：https://crates.io/crates/easy_complex。

此外，你可能會說 Go 中還有一個基本類型：byte，而 Rust 沒有。其實 Go 中的 byte 只是 uint8 的別名。另外，string 在 Go 中是基本數據類型，而在 Rust 中不是。

本文轉載自微信公眾號「polarisxu」，可以通過以下二維碼關注。轉載本文請聯系polarisxu公眾號。