基本類型

Rust 的語言有很多被認為是基本的數(shù)據(jù)類型。這意味著他們是語言內(nèi)置的。Rust 是結(jié)構(gòu)化的語言，并且標準庫在這些類型至上提供了一些有用的其他的類型，但是這些是最基礎(chǔ)的類型。

Booleans

Rust 擁有內(nèi)置的 boolean 類型，名稱為 bool。這種類型的變量能夠被賦值為 true 或者 false：

let x = true;

let y: bool = false;

booleans 比較類型常用的方式是在 if 條件中。

在標準庫文檔說明中查看更多的關(guān)于 bool 的說明信息。

char

char 類型代表的是一個 Unicode 標量值。你可以使用單引號來創(chuàng)建 char 類型變量：

let x = 'x';
let two_hearts = '????';

不像其他語言，這意味著在 Rust 中，char 類型不是單個字節(jié)而是由四個字節(jié)表示。

同樣，你可以在標準庫文檔中查看更多關(guān)于 char 的說明。

數(shù)值類型

Rust 中有各種數(shù)值類型，可以分為這幾類：有符號數(shù)和無符號數(shù)、固定長度和可變長度、浮點數(shù)和整數(shù)。

這些類型包括兩個部分：類別和大小。例如，u16是一個 16 位的無符號類型。更多的比特位能夠表示更大的數(shù)字。

如果一個數(shù)字不能從它字面值推斷出他的類型，那么就會默認如下：

let x = 42; // x has type i32
let y = 1.0; // y has type f64

下面列出了不同的數(shù)值類型，同時連接到標準庫中的文檔說明:

• i8
• i16
• i32
• i64
• u8
• u16
• u32
• u64
• isize
• usize
• f32
• f64

接下來讓我們?nèi)タ纯此麄兊念悇e：

有符號和無符號數(shù)

整數(shù)類型有兩種：有符號和無符號。為了理解他們的差異，首先讓我們看一個四位長度的數(shù)字。對于有符號數(shù)，四位數(shù)字能夠表示的數(shù)據(jù)范圍是 -8 ～ +7。有符號數(shù)用二進制補碼表示。對于無符號的四位數(shù)字，因為它不需要存儲負值，所以可以存儲從 0 到 +15。

無符號類型使用 u 表示數(shù)據(jù)的類別，而有符號數(shù)使用 i 表示。i 指的是“整數(shù)”。所以 u8 表示的是無符號的 8 位整數(shù)，i8 表示的是有符號的 8 位整數(shù)。

固定大小類型

固定大小的類型由特定數(shù)量的比特位數(shù)表示。有效位數(shù)是 8、16、32、64 位。u32 表示的是無符號 32 位整型數(shù)，而 i64 表示的是有符號的 64 位數(shù)。

可變大小類型

Rust 還提供了大小取決于底層機器指針的大小的類型。這些類型根據(jù)大小分為不同的類別，同樣有有符號和無符號的類型。比如這兩種類型：isize 和 usize。

浮點類型

Rust 也有兩種浮點類型：f32 和 f64。這些符合于 IEEE-754 單、雙精度浮點數(shù)的標準。

數(shù)組

像許多編程語言一樣，Rust 有許多類型能夠表示順序?qū)ο?。最基本的是?shù)組，相同類型的元素和固定大小的順序?qū)ο?。默認情況下，數(shù)組元素是不可變的。

let a = [1, 2, 3]; // a: [i32; 3]
let mut m = [1, 2, 3]; // m: [i32; 3]

數(shù)組有 [T；N] 類型。我們將在泛型部分談?wù)撨@個 T 符號。N 是一個編譯時常量，表示數(shù)組的長度。

有一個快捷的方式用相同的值初始化數(shù)組的每個元素。在這個例子中，每個元素將被初始化為0：

let a = [0; 20]; // a: [i32; 20]

你可以利用 a.len() 得到數(shù)組中元素的個數(shù)：

let a = [1, 2, 3];

println!("a has {} elements", a.len());

你可以使用數(shù)組下標訪問數(shù)組中某個特定的元素：

let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3]

println!("The second name is: {}", names[1]);

下標從 0 開始，就像在大多數(shù)編程語言中，第一個元素是 names[0]，第二個元素是 names[1]。上面的示例輸出 the second name is: Brian。如果您嘗試使用一個不在數(shù)組范圍內(nèi)的下標，你會得到一個錯誤：在運行期訪問數(shù)組下標越界。這樣的訪問錯誤是其他許多編程語言程序中 bug 的來源。

你可以在標準庫文檔中找到更多關(guān)于數(shù)組的說明。

切片

“切片”指的是對另一個數(shù)據(jù)結(jié)構(gòu)的索引(或“視圖”)。他們是用于允許安全，高效的訪問數(shù)組的一部分而不需復制數(shù)組的內(nèi)容。例如，您可能只是想索引文件中某一行并將其讀入內(nèi)存中。從本質(zhì)上說，切片不是直接創(chuàng)建的，而是來自于現(xiàn)有的變量。切片擁有長度，是可變的也可以設(shè)置不可變，并且在許多方面像數(shù)組是相似的：

let a = [0, 1, 2, 3, 4];
let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
let complete = &a[..]; // A slice containing all of the elements in a

切片有 &[T] 類型。我們將會在泛型部分講解 T。

你可以在標準庫文檔中找到更多關(guān)于切片的內(nèi)容。

str

Rust 的 str 類型是最基本的字符串類型。作為一種無固定大小類型，它本身不是很有用，但是當將其使用在引用符號之后它會會變得作用更大，類似于 &str。這里我們不會進一步講解這個。

你可以在標準庫文檔中找到更多關(guān)于 str 的說明。

元組

元組是有固定大小的有序列表。類似于：

let x = (1, "hello");

括號和逗號構(gòu)成了長度為 2 的元組。如下是相同的代碼，但是有類型說明：

let x: (i32, &str) = (1, "hello");

正如你所看到的，元組的類型看上去和元組一樣，但每個位置都有一個類型名稱而不是元素值。細心的讀者會注意到，元組是異構(gòu)：在該元組中有一個 i32 類型和一個 &str 類型的元素。在系統(tǒng)編程語言中，字符串比其他語言稍微更復雜點。當下，我們把 &str 當作字符串切片，之后我們會了解更多的。

如果兩個元組有相同的元素類型和相同的參數(shù)數(shù)量，那么你可以將一個元組賦值給另外一個。,當元組有相同的長度時，他們具有相同的參數(shù)數(shù)量。

let mut x = (1, 2); // x: (i32, i32)
let y = (2, 3); // y: (i32, i32)

x = y;

你可以使用解析符來訪問元組中的字段。如下：

let (x, y, z) = (1, 2, 3);

println!("x is {}", x);

記得以前我們曾說過左邊操作符 let 語句比賦值綁定有強的能力嗎？現(xiàn)在我們就可以解釋了，我們可以在左邊的 let 之后編寫一個 pattern，如果它和右邊的語句相匹配，那么我們就可以同時進行多個元素的賦值綁定。在這種情況下，let “析構(gòu)”或者 “分解” 元組，接著進行三個元素的賦值。

這種模式是非常強大的，我們將會在后面的章節(jié)再次看到。

你可以在括號中使用逗號來消除是單個元素還是不是單元素的二義性。

(0,); // single-element tuple
(0); // zero in parentheses

元組索引

你還可以使用索引的方式訪問元組的字段：

let tuple = (1, 2, 3);

let x = tuple.0;
let y = tuple.1;
let z = tuple.2;

println!("x is {}", x);

類似于數(shù)組索引，下標從零開始，但與數(shù)組索引不同的是它使用一個 . 而不是 [] 進行訪問。

你可以在標準庫文檔中找到更多的關(guān)于元組的說明。

函數(shù)

函數(shù)同樣也是一個類型！如下所示：

fn foo(x: i32) -> i32 { x }

let x: fn(i32) -> i32 = foo;

在這種情況下，x 是帶一個 i32 類型的參數(shù)和返回值為 i32 類型的函數(shù)指針。