Rust 快速入門60分① 看完這篇就能寫代碼了

這篇具有很好參考價(jià)值的文章主要介紹了Rust 快速入門60分① 看完這篇就能寫代碼了。希望對(duì)大家有所幫助。如果存在錯(cuò)誤或未考慮完全的地方，請(qǐng)大家不吝賜教，您也可以點(diǎn)擊"舉報(bào)違法"按鈕提交疑問。

Rust 一門賦予每個(gè)人構(gòu)建可靠且高效軟件能力的語言https://hannyang.blog.csdn.net/article/details/130467813?spm=1001.2014.3001.5502關(guān)于Rust安裝等內(nèi)容請(qǐng)參考上文鏈接，寫完上文就在考慮寫點(diǎn)關(guān)于Rust的入門文章，本專輯將直接從Rust基礎(chǔ)入門內(nèi)容開始講起。標(biāo)題《快速入門60分》并不指60分鐘，而是希望自己寫完這個(gè)專輯后，可以得個(gè)60分，也能掌握Rust60%上下的內(nèi)容，請(qǐng)看第一章《變量與常量》：

一、變量與常量

1.1 變量

1.1.1. 變量命名

1.1.2. 變量聲明、賦值

1.1.3. Snake case

1.1.4. 禁止使用和避免使用

1.1.5 匿名變量

1.2?基本數(shù)據(jù)類型

1.2.1 整型

1.2.2?浮點(diǎn)型?

1.2.3 字符型

1.2.4 布爾型

1.3 變量的可變和不可變

1.3.1?不可變變量

1.3.2?可變變量

1.3.3 變量遮蔽

1.3.4 靜態(tài)變量（全局變量）

1.4 常量

1.4.1 常量命名

1.4.2 常量用法

1.4.3 標(biāo)準(zhǔn)庫常量

1.5 本章小結(jié)

一、變量與常量

1.1 變量

1.1.1. 變量命名

變量名由字母、數(shù)字或下劃線組成，應(yīng)該具有描述性，能夠清楚地表達(dá)變量的含義。命名的基本規(guī)則和大多數(shù)編程語言基本相同，有些細(xì)節(jié)上稍微有所不同。規(guī)則如下：

變量名必須以字母或下劃線開頭。
變量名不能以數(shù)字開頭。
變量名區(qū)分大小寫，推薦使用 snake_case 規(guī)則（字母全部小寫和下劃線）。
禁止使用和 Rust 關(guān)鍵字同名的變量名。
避免使用和 Rust 標(biāo)準(zhǔn)庫中已有的函數(shù)、類型或模塊同名的變量名。
對(duì)于私有變量 (private variables)，可以使用 _ 作為前綴，區(qū)分開公共變量和私有變量。

1.1.2. 變量聲明、賦值

Rust 變量聲明使用 let 關(guān)鍵字，有些早期版本的basic語言也用LET（現(xiàn)在通常是DIM）。

示例：

fn main() {
    let x = 323;
    let y = 3.23;
    print!("x: {}, ", x);
    println!("y: {}", y);
    //輸出 x: 323, y: 3.23
}

上面示例中，fn 是函數(shù) function 的縮寫，表示 main() 是這個(gè)rust程序的主函數(shù)；

let 變量名 = 常數(shù)；就是一個(gè)變量聲明、賦值語句；

print!() 和 println!() 是打印的“宏”，宏不是函數(shù)，但功能也就相近于Java中的System.out.print()函數(shù)和System.out.println()函數(shù)的功能，兩者輸出差一個(gè)換行符。

// 表示注釋語句，注釋與C++相同，行注釋用 //，塊注釋用 /*? */；Rust另外還有文檔注釋。

函數(shù)體中每一行都是一個(gè)語句（當(dāng)然語句也可以跨多行表達(dá)），語句由各種表達(dá)式組成。第一條語句必須有標(biāo)點(diǎn)符號(hào)分號(hào)作結(jié)尾，表達(dá)式一般沒有符號(hào)作結(jié)尾的。關(guān)于Rust中的“宏”，它和C/C++中的“宏”還是不同的，更多函數(shù)相關(guān)內(nèi)容，放到之后的函數(shù)章節(jié)再講。

let 語句也可以分成兩行，先聲明再分配值（賦值綁定）：

fn main() {
    let x;
    x = 100;
    println!("x: {}", x); 
}

let 語句還可以一行賦值多個(gè)變量，但要加上括號(hào)（其實(shí)是復(fù)合數(shù)據(jù)類型之一的元組）：

fn main() {
    let (x, y) = (3, 4);
    let z = (x*x+y*y) as f64;
    let z = z.sqrt().round() as i32;
    println!("{},{},{}", x, y, z); // 3,4,5
    let (a, b, c) = (1, 2, 3);
    println!("{},{},{}", a, b, c); // 1,2,3
}

其中，as 也是Rust關(guān)鍵字之一，在這里用于強(qiáng)制轉(zhuǎn)換數(shù)據(jù)類型。?

sqrt()、round() 分別為平方根、取整函數(shù)。

1.1.3. Snake case

Snake case 是一種命名規(guī)范，它使用小寫字母，單詞之間用下劃線 "_" 連接。

Rust不推薦在變量中有大寫字母，示例如下：

fn main() {
    let Int = 100;
    let My_Integer = 200;
    let my_integer = 300;
    
    println!("{} {} {}", Int, My_Integer, my_integer)
}

以上代碼可以編譯執(zhí)行，但會(huì)有警告出現(xiàn)：

···Rust
warning: variable `Int` should have a snake case name
?--> D:\Rust\hello.rs:2:9
? ?|
2 | ? ? let Int = 100;
? ?| ? ? ? ? ^^^ help: convert the identifier to snake case (notice the capitalization): `int`
? ?|
? = note: `#[warn(non_snake_case)]` on by default

warning: variable `My_Integer` should have a snake case name
?--> D:\Rust\hello.rs:3:9
? ?|
3 | ? ? let My_Integer = 200;
? ?| ? ? ? ? ^^^^^^^^^^ help: convert the identifier to snake case: `my_integer`

warning: 2 warnings emitted

100 200 300
···

1.1.4. 禁止使用和避免使用

變量命名使用關(guān)鍵字，報(bào)錯(cuò)通不過編譯，所以是禁止使用；但與標(biāo)準(zhǔn)庫中已有的函數(shù)、類型同名，只是容易混淆，但編譯不警告不報(bào)錯(cuò)，所以只能說是避免使用。如：

fn main() {
    //let fn = 10; //禁止使用
    //let let = 2; //禁止使用
    let u8 = 10u8; //避免使用
    let pow;       //避免使用
    pow = u8.pow(2);
    println!("{} {}", u8, pow)  //輸出 10 100
}

其中， u8 的變量類型是8位無符號(hào)整型，pow()?是標(biāo)準(zhǔn)庫函數(shù)平方冪函數(shù)。

函數(shù)名、類型名稱作變量名不會(huì)報(bào)錯(cuò)，而fn, let關(guān)鍵字作變量名則報(bào)錯(cuò)：

```Rust
expected identifier, found keyword
? |
help: escape `fn` to use it as an identifier?
```

1.1.5 匿名變量

下劃線 _ 是一個(gè)特殊的變量名，更確切地說是變量名稱的缺失，就稱它為匿名變量。它的基本意思是舍棄，可以理解為廢紙簍，這個(gè)變量扔掉不要了，不能被再次調(diào)用。（Go, Python里也有??_ 用作匿名變量，但細(xì)節(jié)各不相同，而且在python里 “_ = 5;print(_)” 是合法的）

fn main() {
    let (a,_) = (6,2);
    println!("{}", a);
    //println!("{}", _); //報(bào)錯(cuò)^ `_` not allowed here
}

1.2?基本數(shù)據(jù)類型

1.2.1 整型

Rust整型 分為有符號(hào)整型（signed，標(biāo)記 in）和無符號(hào)整型（unsigned，標(biāo)記?un），區(qū)別在于數(shù)字是否有負(fù)數(shù)。帶符號(hào)整型的安全存儲(chǔ)范圍為 -2^(n-1)?到 2^(n-1) - 1，無符號(hào)整型的安全存儲(chǔ)范圍為 0 到 2^n，n 為數(shù)據(jù)位長(zhǎng)度，見下表：

位長(zhǎng)度	有符號(hào)	無符號(hào)
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
arch 由系統(tǒng)構(gòu)架而定	isize	usize

isize 和 usize 是根據(jù)系統(tǒng)架構(gòu)決定的，例如帶符號(hào)整型，如果系統(tǒng)是 64 位，類型為 i64，如果系統(tǒng)是 32 位，類型為 i32。（這和C++中的size_t類型相似）

指定類型和默認(rèn)類型

變量聲明時(shí)，可以先指定類型，再分配綁定數(shù)值，變量名后面使用冒號(hào)跟隨類型來明確指定變量的類型，稱為顯式指定；Rust 是強(qiáng)類型語言，具有自動(dòng)判斷變量類型的能力，可理解為這是隱式指定。以下示例中聲明的變量 z 并沒有明確指定其具體類型，則默認(rèn)為 i32 類型，這也是 Rust 的特性之一類型推斷。

fn main() {
    let x: u8;
    x = 123;
    let y = -1000i64;
    let z = -323;  //不指定類型，默認(rèn)為i32
    println!("x: {}, y: {}, z: {}", x, y, z);
}

1.2.2?浮點(diǎn)型?

Rust浮點(diǎn)型 分為 32 位浮點(diǎn)數(shù)（f32）和 64 位浮點(diǎn)數(shù)（f64）。浮點(diǎn)型若不指定具體類型，則默認(rèn)為 f64 浮點(diǎn)數(shù)，現(xiàn)在的高性能CPU對(duì)兩種浮點(diǎn)數(shù)計(jì)算的速度幾乎相同，但 64 位浮點(diǎn)數(shù)精度更高。

fn main() {
    let x: f32;
    x = 1.23;
    let y: f64 = 3.23;
    let z = -3.23;  //不指定類型，默認(rèn)為f64
    println!("x: {}, y: {}, z: {}", x, y, z);
}

1.2.3 字符型

Rust字符型 是一個(gè)4字節(jié) Unicode 碼，支持中文等非英文字符，使用單引號(hào)''包括。

fn main() {
    let a = 'a';
    let b: char = '字';
    let c = '??';
    println!("a: {}, b: {}, c: {}", a, b, c); 
}

1.2.4 布爾型

Rust布爾型 用 bool 表示，占用1個(gè)字節(jié)，值只能為 true 或 false，全小寫非大寫字母開頭。（輸出與聲明同形，不像C/C++只能輸出1和0）

fn main() {
    let x = true;
    let y: bool = false;
    println!("x: {}, y: {}", x, y); //輸出 x: true, y: false
}

1.3 變量的可變和不可變

1.3.1?不可變變量

先看一個(gè)實(shí)例：

fn main() {
    let x = 6;
    x = x + 1;  // 報(bào)錯(cuò)
    println!("{}", x)
}

在大多數(shù)編程語言中，上述實(shí)例應(yīng)該打印出 7，但在Rust語言里卻是報(bào)錯(cuò)：?

```Rust
error[E0384]: cannot assign twice to immutable variable `x`
?--> D:\Rust\hello.rs:3:5
? ?|
2 | ? ? let x = 6;
? ?| ? ? ? ? -
? ?| ? ? ? ? |
? ?| ? ? ? ? first assignment to `x`
? ?| ? ? ? ? help: consider making this binding mutable: `mut x`
3 | ? ? x = x + 1;
? ?| ? ? ^^^^^^^^^ cannot assign twice to immutable variable
```

意思就是：?不能為不可變變量`x賦值兩次`，并提示考慮綁定可變：`mut x`

特別之處： Rust變量是不可變的！

通常來說變量將是可變的，但是在 Rust 中預(yù)設(shè)變量卻是不可變的。Rust 鼓勵(lì)使用不可變變量，當(dāng)然如果明確知道該變量是可變得，就得用關(guān)鍵字 mut 附加說明它是可變的變量。

1.3.2?可變變量

可變變量要用 let mut 兩個(gè)關(guān)鍵字來聲明，示例如下：

fn main() {
    let mut x = 6;  // 可變變量聲明要在let后附加mut關(guān)鍵字
    x = x + 1;
    println!("{}", x)  // 輸出 7
}

1.3.3 變量遮蔽

Rust可以定義一個(gè)與之前變量同名的新變量，稱之為第一個(gè)變量被第二個(gè) Shadowing?了，官方用的這個(gè)詞 Shadowing，有時(shí)被翻譯成隱藏有時(shí)被翻譯成遮蔽，還有的翻譯為重影。它的意思就是當(dāng)使用相同變量的名稱時(shí)，編譯器將“看到”第二個(gè)變量。實(shí)際上，第二個(gè)變量 “遮蔽” 了第一個(gè)變量，此時(shí)任何使用該變量名的行為中都會(huì)視為是在使用第二個(gè)變量，直到第二個(gè)變量自己也被隱藏或第二個(gè)變量的作用域結(jié)束?？梢杂孟嗤兞棵Q來隱藏一個(gè)變量，以及重復(fù)使用 let 關(guān)鍵字來多次隱藏?？傊?，它和可變變量不是同一個(gè)概念。

fn main() {
    let x = 6;
    let x = x + 1;
    println!("{}", x);  // 7
    let x = x * x;
    println!("{}", x);  // 49
}

1.3.4 靜態(tài)變量（全局變量）

靜態(tài)變量用 static 聲明的變量的生命周期是整個(gè)程序，從啟動(dòng)到退出。這也是Rust中唯一的聲明全局變量的方法。它的生命周期永遠(yuǎn)是'static，它占用的內(nèi)存空間也不會(huì)在執(zhí)行過程中回收。?

注意點(diǎn)：

1. 全局變量必須在聲明的時(shí)候馬上初始化；
2.?命名時(shí)字母要全部大寫，否則編譯有警告信息；
3. 全局變量的初始化必須是編譯期就能確定的常量；
4. 帶有?mut?修飾的全局變量，在使用的時(shí)候必須使用 unsafe 關(guān)鍵字；
5. 全局變量可以寫到函數(shù)外面，被任意一個(gè)函數(shù)使用。

fn main() {
    static G1 : i32 = 3;
    println!("{}, {}", G1, G1 + 20);

    static mut G2 : i32 = 4;
    unsafe {
        // G1 = 2; // cannot assign to immutable static item `G1`
        G2 = G1 + 5;
        println!("{}, {}", G1, G2);
    }
}

/* 輸出
3, 23
3, 8
*/

1.4 常量

常量，和變量一樣都是用來存儲(chǔ)數(shù)據(jù)的標(biāo)識(shí)符，常量使用 const 關(guān)鍵字聲明。常量的值是不可變的，不允許使用mut關(guān)鍵字修飾這個(gè)變量綁定。

1.4.1 常量命名

常量的命名規(guī)則和方法與靜態(tài)變量基本類似，命名時(shí)字母也要全部大寫。

錯(cuò)誤示例：常量字母不全部大寫可以通過編譯，但有警告信息。

const pi:f32 = 3.14159; //報(bào)錯(cuò)
const Pi:f32 = 3.14159; //報(bào)錯(cuò)

fn main() {
    println!("{}", pi);
    println!("{}", Pi);
}

```
warning: constant `pi` should have an upper case name
?--> D:\Cpp\hello.rs:1:7
? ?|
1 | const pi:f32 = 3.14159;
? ?| ? ? ? ^^ help: convert the identifier to upper case: `PI`
? ?|
? = note: `#[warn(non_upper_case_globals)]` on by default

warning: constant `Pi` should have an upper case name
?--> D:\Cpp\hello.rs:2:7
? ?|
2 | const Pi:f32 = 3.14159;
? ?| ? ? ? ^^ help: convert the identifier to upper case (notice the capitalization): `PI`

warning: 2 warnings emitted

3.14159
3.14159

```

1.4.2 常量用法

常量必須顯式指定類型以及聲明同時(shí)就賦值，并且常量的值必須是編譯時(shí)可確定的常數(shù)或者是常量表達(dá)式。示例如下：

const PI: f64 = 3.14159;
const FLAG: bool = true;
const HOURS: u32 = 12;
const SECONDS: u32 = 60 * 60 * HOURS;
const MIN_NUM: i32 = 1 << 31;
const MAX_NUM: i32 = -(1 + MIN_NUM);

fn main() {
    println!("{}", PI);
    println!("{}", FLAG);
    println!("{}", HOURS);
    println!("{}", SECONDS);
    println!("{}", MIN_NUM);
    println!("{}", MAX_NUM);
}

/* 輸出：
3.14159
true
12
43200
-2147483648
2147483647
*/

錯(cuò)誤示例：常量不可以隱式賦值，或者先聲明后賦值。

const PI = 3.14159; //報(bào)錯(cuò)
const FLAG:bool;  //報(bào)錯(cuò)

fn main() {
    FLAG = true;  //報(bào)錯(cuò)
    println!("{}", PI);
    println!("{}", FLAG);
}

```
error: free constant item without body
?--> D:\Cpp\hello.rs:2:1
? ?|
2 | const FLAG:bool;
? ?| ^^^^^^^^^^^^^^^-
? ?| ? ? ? ? ? ? ? ?|
? ?| ? ? ? ? ? ? ? ?help: provide a definition for the constant: `= <expr>;`

error: missing type for `const` item
?--> D:\Cpp\hello.rs:1:9
? ?|
1 | const PI = 3.14159;
? ?| ? ? ? ? ^ help: provide a type for the constant: `: f64`

error[E0070]: invalid left-hand side of assignment
?--> D:\Cpp\hello.rs:5:10
? ?|
5 | ? ? FLAG = true;
? ?| ? ? ---- ^
? ?| ? ? |
? ?| ? ? cannot assign to this expression

error: aborting due to 3 previous errors

For more information about this error, try `rustc --explain E0070`.?

```?

1.4.3 標(biāo)準(zhǔn)庫常量

引用標(biāo)準(zhǔn)庫中的常量，使用關(guān)鍵字 use 來導(dǎo)入。（類似 java和python 中 import）

比如std::f32或std::f64中的一些數(shù)學(xué)常量：

use std::f32::consts::PI;
use std::f32::consts::FRAC_1_PI;
use std::f32::consts::FRAC_2_PI;
use std::f32::consts::SQRT_2;
use std::f32::consts::FRAC_1_SQRT_2;
use std::f32::consts::E;
use std::f32::consts::LN_2;
use std::f32::consts::LOG2_E;
use std::f32::consts::LOG10_E;
fn main() {
    println!("{}", PI); 
    println!("{}", FRAC_1_PI);
    println!("{}", FRAC_2_PI);
    println!("{}", SQRT_2);
    println!("{}", FRAC_1_SQRT_2);
    println!("{}", E);
    println!("{}", LN_2);
    println!("{}", LOG2_E);
    println!("{}", LOG10_E);
}

/* 輸出
3.1415927
0.31830987
0.63661975
1.4142135
0.70710677
2.7182817
0.6931472
1.442695
0.4342945
改std::f64，則輸出
3.141592653589793
0.3183098861837907
0.6366197723675814
1.4142135623730951
0.7071067811865476
2.718281828459045
0.6931471805599453
1.4426950408889634
0.4342944819032518
*/

1.5 本章小結(jié)

1. 變量（Variables）：在 Rust 中，變量默認(rèn)是不可變的（immutable），也就是說，一旦被賦值后，就不能再修改其值。如果需要修改變量的值，需要使用 `mut` 關(guān)鍵字來聲明可變變量。

2. 常量（Constants）：與變量不同，常量在聲明后就不能再修改其值。在 Rust 中，使用 `const` 關(guān)鍵字來聲明常量，常量的命名規(guī)則與變量相同，但必須使用大寫字母命名，并且必須在聲明時(shí)就賦值。

3. 可變綁定（Mutable bindings）：除了使用 `mut` 關(guān)鍵字來聲明可變變量外，還可以使用 `let` 關(guān)鍵字來聲明一個(gè)可變綁定?？勺兘壎ㄔ试S我們?cè)诓桓淖兘壎ū旧淼那闆r下修改綁定所指向的值。

4. 類型推斷（Type inference）：Rust 支持類型推斷，也就是說，可以在聲明變量或常量時(shí)省略類型，由編譯器自動(dòng)推斷類型。例如，可以使用 `let x = 42;` 來聲明一個(gè)整數(shù)變量，編譯器會(huì)自動(dòng)推斷出 x 的類型為 i32。

5. 變量遮蔽（Variable shadowing）：Rust 中可以使用相同的名稱來聲明一個(gè)新的變量或常量，這會(huì)遮蔽之前的變量或常量。這個(gè)特性可以用來在不改變?cè)写a的情況下修改變量的值或類型。

6. 變量的作用域由聲明的位置開始，直到當(dāng)前作用域的結(jié)束；變量在離開作用域后會(huì)被自動(dòng)銷毀。常量在整個(gè)程序運(yùn)行期間都存在。

注：本文中所有代碼都可以在Rust官方線上編譯器里編譯通過。

Rust PlaygroundA browser interface to the Rust compiler to experiment with the languagehttps://play.rust-lang.org/?version=stable&mode=debug&edition=2021作者水平有限，如有不當(dāng)之處，敬請(qǐng)指正。

本章完文章來源地址http://www.zghlxwxcb.cn/news/detail-440469.html

到了這里，關(guān)于Rust 快速入門60分① 看完這篇就能寫代碼了的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！