Rust的基本數(shù)據(jù)類型有哪些

這篇文章主要講解了“Rust的基本數(shù)據(jù)類型有哪些”，文中的講解內(nèi)容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Rust的基本數(shù)據(jù)類型有哪些”吧！

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

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

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

這是將字符串 "42" 轉(zhuǎn)為數(shù)字 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 中很多時候，數(shù)值類型會是 int。

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

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

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

Rust 內(nèi)置如下基本數(shù)據(jù)類型：

• 整數(shù)類型

• 有符合整數(shù)：i8、i16、i32、i64、i128、isize

• 無符號整數(shù)：u8、u16、u32、u64、u128、usize

• 浮點類型：f32、f64

• 布爾型：bool

• 字符型：char

01 整數(shù)類型

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

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

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

兩點說明：

• Go 中沒有 128 位長度的整數(shù)

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

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

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

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

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

// 打印變量類型的函數(shù)。該函數(shù)看不懂先放著。 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 中，整數(shù)一般建議用 int 類型;而  Rust 中，一般建議用 i32 類型。(所以，為什么開頭的 parse 不能默認推斷為 i32 類型呢?怕溢出?)

更智能的類型推斷

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

// 打印變量類型的函數(shù) 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) }

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

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

比如上面代碼，在 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  函數(shù)也不需要了。做了一個動圖，注意上面 x 的類型變化：

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

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

02 浮點類型

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

let x = 2.0; // 默認是 f64

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

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

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 個字節(jié)。

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

感謝各位的閱讀，以上就是“Rust的基本數(shù)據(jù)類型有哪些”的內(nèi)容了，經(jīng)過本文的學習后，相信大家對Rust的基本數(shù)據(jù)類型有哪些這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！