當前位置：首頁 > 科技 > 軟件

一網打盡 Rust 語法

來源：責編：時間：2024-04-26 08:51:50 235觀看

導讀1. 構建運行環境我們在Rust環境配置和入門指南中詳細介紹了如何安裝Rust環境構建一個Rust應用編譯和運行的區別使用Cargo構建Rust應用下面，我們就之間直入主題了。通過創建一個名為 main.rs 的文件并將以下代碼放入其

1. 構建運行環境

我們在Rust環境配置和入門指南中詳細介紹了

如何安裝Rust環境
構建一個Rust應用
編譯和運行的區別
使用Cargo構建Rust應用

下面，我們就之間直入主題了。

通過創建一個名為 main.rs 的文件并將以下代碼放入其中來編寫我們的第一個 Rust 代碼：

fn main() {    println!("Hello, Front789!");}

然后通過運行 rustc main.rs 和 ./main.exe 來運行這個程序，就像運行 C 程序一樣。

Cargo 是 Rust 的構建系統和包管理器

我們也可以使用 cargo 創建項目。

cargo new hello_cargo：初始化一個新項目。
cargo build：構建一個 cargo 項目。
cargo run：運行一個 cargo 項目，這將編譯并運行代碼。
cargo check：檢查是否有編譯錯誤，它比cargo build速度更快。
cargo build --release：這將使用優化進行編譯，用于最終生產構建。

2. 變量類型

在 Rust 中，默認情況下「變量是不可變」的，這意味著一旦給變量賦值，其值就不會改變。

所以如果想要一個可變的，即可改變的值，使用 mut。

let a = 5;let mut b = 5; // 可變的

整數：有各種大小的有符號和無符號整數（例如，i8、i16、i32、i64、u8、u16、u32、u64）

圖片

let number: i32 = 42;

浮點數：單精度和雙精度浮點數（例如，f32、f64）

圖片

let pi: f64 = 3.14159;

布爾值：Rust的布爾類型只擁有兩個可能的值true和false，它「只會占據單個字節的空間大小」。使用bool來表示一個布爾類型。

let is_rust_cool: bool = true;

字符：在Rust中char類型「占4字節」，是一個Unicode標量值，這意味著它可以表示比ASCII多的字符內容。使用char 類型表示一個字符類型

let heart_emoji: char = '?';

字符串：可變字符串

圖片

let mut s = String::from("front789");

字符串切片：不可變且借用的字符串切片

let s1: &str = "front789";

數組：數組中每一個元素都必須是「相同類型」。 Rust中「數組擁有固定的長度，一旦聲明就再也不能隨意更改大小」

let array: [i32; 3] = [1, 2, 3];let a = [3; 5]; // 用值 3 初始化大小為 5 的數組

元組

圖片

為了從元組中獲得單個的值，可以使用「模式匹配」來解構元組

還可以通過「索引」并使用點號(.)來訪問元組中的值

let tup = (500, 6.4, 1);let (x, y, z) = tup;let aa = tup.0; // 引用元組中的第一個項目

向量

圖片

指針和引用

指針是一個變量，它存儲了一個值的「內存地址」

Rust 中最常見的指針是引用。引用以 & 符號為標志并「借用了它們所指向的值」。除了引用數據沒有任何其他特殊功能。它們也沒有任何額外開銷，所以應用得最多。

fn main() {    // 標量類型    let number: i32 = 42;    let pi: f64 = 3.14159;    let is_rust_cool: bool = true;    let heart_emoji: char = '?';    // 復合類型    let array: [i32; 3] = [1, 2, 3];    let tuple: (i32, f64, char) = (10, 3.14, 'a');    let slice: &[i32] = &[1, 2, 3];    let string: String = String::from("Hello, Front789!");    let string_slice: &str = "Hello, Front789!";    // 特殊類型    let reference_to_number: &i32 = &number;    let optional_value: Option<i32> = Some(42);    let result_value: Result<i32, &str> = Ok(42);}

以上內容就是Rust中所涉及到的各種數據類型，我們可以從以下的鏈接中找到更為詳細的解釋

基礎概念
集合
智能指針

3. 操作數組

不可變數組：

不可變數組在 Rust 中用 [T; N] 語法來聲明,其中 T 表示數組元素的類型,而 N 表示數組的長度。

對于不可變數組,我們可以使用下標訪問其元素,但不能修改元素的值。

let array = [1, 2, 3, 4, 5];let first_element = array[0]; // 訪問第一個元素arr[0] = 6; // 這行代碼會導致編譯錯誤,因為數組是不可變的// 迭代// 使用 for 循環for &num in &array {    println!("{}", num);}// 另一種迭代器array.iter().for_each(|&num| {    println!("{}", num);});let slice = &array[1..3]; // 從索引 1 到索引 2（包括）切片

可變數組

Vec<T> 是 Rust 中可變長數組的實現,它允許您動態地增加或減少數組的大小。

let mut array = [1, 2, 3, 4, 5];array[0] = 10; // 修改第一個元素let mut vec = Vec::new(); // 創建一個空 Vecvec.push(1); // 向 Vec 中添加一個元素vec.push(2);vec.push(3);// 使用 iter() 遍歷元素for item in array.iter() {    println!("{}", item);}// iter_mut() 方法返回一個可變的迭代器,允許修改 Vec 中的元素for item in array.iter_mut() {    *item += 1; // 對每個元素加 1}// maplet doubled_array: Vec<_> =     array.iter()    .map(|&num| num * 2)    .collect();// filterlet even_elements: Vec<_> =     array.iter()    .filter(|&&num| num % 2 == 0)    .collect();// len() 方法返回 Vec 中元素的數量array.len()// remove() 方法移除指定索引位置的元素,并返回該元素。如果索引越界,它將導致 panic。let removed_item = array.remove(2) // removed_item 為3

4. 操作字符串

let s1 = String::from("Hello, ");let s2 = String::from("Front789!");let combined = s1 + &s2; // 注意：s1 在這里被移動，之后不能再使用println!("{}", combined); // 打印 "Hello, Front789!"let mut s = String::from("Hello, ");s.push_str("Front789!");println!("{}", s); // 打印 "Hello, Front789!"http:// 獲取字符let s = String::from("hello");let first_char = s.chars().nth(0); // 訪問第一個字符// 子字符串let s = String::from("hello Front789");let substring = &s[0..5]; // 提取 "hello"http:// len()let s = String::from("hello");let length = s.len(); // 字符串的長度// replacelet s = String::from("hello");let replaced = s.replace("l", "z"); // 替換 "l" 為 "z"http:// splitlet s = String::from("hello Front789");let words: Vec<&str> = s.split_whitespace().collect(); // 分割成單詞// 轉換 &str 和 Stringlet s = String::from("hello");let s_ref: &str = &s; // 將 String 轉換為 &strlet s_copy: String = s_ref.into(); // 將 &str 轉換為 String

5. 操作向量

let mut v1 = vec![1, 2, 3]; // 使用 vec![] 宏let mut v2: Vec<i32> = Vec::new(); // 使用 Vec::new() 構造函數let mut v = Vec::new();v.push(1);v.push(2);let first_element = v[0]; // 訪問第一個元素// 迭代// 使用 for 循環for num in &v {    println!("{}", num);}// 使用迭代器v.iter().for_each(|&num| {    println!("{}", num);});// slicelet slice = &v[1..3]; // 從索引 1 到索引 2（包括）提取元素// removelet removed_element = v.remove(1); // 移除索引為 1 的元素（返回被移除的元素）// sort()v.sort();// joinlet tt= vec!["hello", "Front789"];let joined_string = tt.join(", "); // 使用逗號和空格連接元素

6. 函數

Rust代碼使用「蛇形命名法」來作為規范函數和變量名稱的風格。蛇形命名法「只使用小寫的字母進行命名，并以下畫線分隔單詞」。

參數,它們是一種「特殊的變量，并被視作函數簽名的一部分」。當函數存在參數時，你需要在「調用函數時為這些變量提供具體的值」
在Rust中，「函數的返回值等同于函數體的最后一個表達式」。

語法

fn 函數名(參數1: 類型1, 參數2: 類型2) -> 返回類型 {    // 函數體    // 可選的表達式}

最后一行返回值時不需要調用 return。

fn add_numbers(x: i32, y: i32) -> i32 {    let sum = x + y;    sum // 函數中的最后一個表達式會隱式返回}

如果想要一個無返回值的函數，不要定義返回類型。

我們可以在基礎概念_函數部分查看更詳細的解釋

7. 輸入/輸出

輸入

要讀取一個值，使用 io stdin 并給出變量的值，在失敗時需要提供 expect 消息，否則會出錯。

let mut guess = String::new();    io::stdin().read_line(&mut guess).expect("該行讀取失敗");

輸出 / 打印

println!("輸出對應的變量信息 {}", guess); // 這里的 guess 是變量名。

你也可以在末尾有變量

let y = 10;println!("y + 2 = {}", y + 2);

8. Shadowing

在Rust中，一個「新的聲明變量可以覆蓋掉舊的同名變量」，我們把這一個現象描述為：「第一個變量被第二個變量遮蔽Shadow了」。這意味著隨后使用這個名稱時，它指向的將會是第二個變量。

fn main() {    let x = 5; // 定義值為 5 的變量 x    println!("原始值 x: {}", x); // 打印 "原始值 x: 5"        let x = 10; // Shadowing：定義一個新的值為 10 的變量 x    println!("Shadowed x: {}", x); // 打印 "Shadowed x: 10"}

圖片

9. 控制塊

圖片

If else

if condition1 {    // 如果 condition1 為真，則執行的代碼} else if condition2 {    // 如果 condition2 為真，則執行的代碼} else {    // 如果 condition1 和 condition2 都為假，則執行的代碼}

10. 循環

Rust提供了3種循環

loop
while
for

loop

loop {    println!("永無止境的執行");}

While 循環

let mut count = 0;while count < 5 {    println!("Count: {}", count);    count += 1;}

For 循環

for i in 0..5 {    println!("{}", i);}

foreach

當然也少不了對數值的遍歷操作。

(1..=5).for_each(|num| {    println!("Number: {}", num);});// Number: 1// Number: 2// Number: 3// Number: 4// Number: 5

..:它表示一個擴展運算符，表示從第一個數字到最后一個數字生成。

我們也可以在循環中使用 continue 和 break。

11. 所有權

圖片

這個概念是需要特別注意和反復觀看的部分。

MOVE（或）重新分配變量

當變量值被重新分配時，值會給新的所有者，并且舊的所有者被丟棄。

這種行為在字符串中經?？吹剑皇瞧渌愋?，如下所示：

let s1 = String::from("hello");let s2 = s1;println!("{}, world!", s1);

這將導致錯誤，因為 s1 在 s2=s1 之后不再有效。

如何解決上面的問題呢，我們可以使用 Clone：

let s1 = String::from("hello");let s2 = s1.clone();println!("s1 = {}, s2 = {}", s1, s2);

某些類型隱式實現了 Clone。

let x = 5; // x 擁有整數 5let y = x; // 將 x 的值復制到 y，不傳遞所有權

例如，整數隱式實現了 Clone，因此這段代碼不會報錯。

圖片

所有權和函數

fn main() {    let s = String::from("hello");  // s 進入作用域    takes_ownership(s);             // s 的值移動進入函數...                                    // ... 所以這里不再有效    let x = 5;                      // x 進入作用域    makes_copy(x);                  // x 會移入函數，                                    // 但 i32 是 Copy，所以在之后繼續使用 x 是可以的} // 在這里，x 超出作用域，然后是 s。但因為 s 的值被移動了，所以沒有什么特別的發生。fn takes_ownership(some_string: String) { // some_string 進入作用域    println!("{}", some_string);} // 在這里，some_string 超出作用域，調用 drop。內存被釋放。fn makes_copy(some_integer: i32) { // some_integer 進入作用域    println!("{}", some_integer);} // 在這里，some_integer 超出作用域。沒有什么特別的發生。

如果我們像在變量被移動后，繼續使用，那么我們就使用 takes_ownership(s.clone()); （或者）在 takes_ownership 函數中返回值，像這樣：

fn main() {    let s2 = String::from("hello");     // s2 進入作用域    let s3 = takes_and_gives_back(s2);  // s2 移入并被返回}fn takes_and_gives_back(a_string: String) -> String {     a_string  // 返回并移出到調用函數}

借用 — 所有權

傳遞變量的引用，所有權不會被傳遞。

我們稱「創建引用的操作為借用」。就像現實生活中，如果一個人擁有一樣東西，你可以從他們那里借來。借了之后，你必須歸還。你不擁有它。

fn main() {    let s1 = String::from("hello");    let len = calculate_length(&s1);    println!("The length of '{}' is {}.", s1, len);}fn calculate_length(s: &String) -> usize {    s.len()}

針對此處更詳細的內容，可以翻看我們之前的所有權

12. 結構體

struct，或者 structure，是一個「自定義數據類型」，允許我們命名和包裝多個相關的值，從而形成一個有意義的組合。

圖片

struct User {    active: bool,    username: String,    email: String,    sign_in_count: u64,}fn main() {    let mut user1 = User {        active: true,        username: String::from("front789"),        email: String::from("front789@example.com"),        sign_in_count: 1,    };    user1.email = String::from("anotheremail@example.com");    let user2 = User {        email: String::from("another@example.com"),        ..user1    };}

在 user2 中，你會看到 ..，它是擴展運算符，將 user1 中剩余的值傳遞給 user2（除了已經定義的 email）。

結構體的方法

使用 impl 結構體名，并在其中定義函數。

#[derive(Debug)]struct Rectangle {    width: u32,    height: u32,}impl Rectangle {    fn area(&self) -> u32 {        self.width * self.height    }}fn main() {    let rect1 = Rectangle {        width: 30,        height: 50,    };    println!(        "長方形的面積為 {}",        rect1.area()    );}

圖片

針對此處更詳細的內容，可以翻看我們之前的結構體

13. 枚舉

枚舉，也被稱作 enums。枚舉允許你通過「列舉可能的成員variants來定義一個類型」

enum IpAddrKind {    V4,    V6,}let four = IpAddrKind::V4;let six = IpAddrKind::V6;

枚舉的成員位于其標識符的「命名空間中」，并「使用兩個冒號分開」。

match

這是類似于 switch 的東西，

enum Coin {    Penny,    Nickel,    Dime,    Quarter,}fn value_in_cents(coin: Coin) -> u8 {    match coin {        Coin::Penny => 1,        Coin::Nickel => 5,        Coin::Dime => 10,        Coin::Quarter => 25,    }    let number = 5;    match number {        1 => println!("One"),        2 => println!("Two"),        3 | 4 | 5 => println!("Three, Four, or Five"),        _ => println!("Other"), // 默認情況    }}

每個分支相關聯的代碼是一個表達式，而表達式的結果值將作為整個 match 表達式的返回值。

Option 枚舉和其相對于空值的優勢

圖片

if Let

這是一種使用 if 的花式方式，我們在其中定義一個表達式。

fn main() {    let optional_number: Option<i32> = Some(5);    // 使用 if let 匹配 Some 變體并提取內部值    if let Some(num) = optional_number {        println!("Value: {}", num);    } else {        println!("No value");    }}

14. 并發性

并發編程和并行編程

圖片

代碼實現

為了創建一個新線程，需要調用 thread::spawn 函數并「傳遞一個閉包」，并在其中包含希望在新線程運行的代碼。

可以通過將 thread::spawn 的「返回值儲存在變量中來修復新建線程部分沒有執行或者完全沒有執行的問題」。thread::spawn 的返回值類型是 JoinHandle。JoinHandle 是一個「擁有所有權的值」，當「對其調用 join 方法時，它會等待其線程結束」。

use std::thread;fn main() {    // 數據    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];    // 將數據分成兩部分    let mid = numbers.len() / 2;    let (left, right) = numbers.split_at(mid);    // 生成兩個線程來計算每一半的總和    let handle1 = thread::spawn(move || sum(left));    let handle2 = thread::spawn(move || sum(right));    // 等待線程完成并獲取它們的結果    let result1 = handle1.join().unwrap();    let result2 = handle2.join().unwrap();    // 計算最終總和    let total_sum = result1 + result2;    println!("Total sum: {}", total_sum);}fn sum(numbers: &[i32]) -> i32 {    let mut sum = 0;    for &num in numbers {        sum += num;    }    sum}

thread::spawn 要求閉包具有 'static 生命周期，這意味著它不會從周圍范圍借用任何東西，并且可以在整個程序的持續時間內存在。

因此，我們使用move 閉包，其經常與 thread::spawn 一起使用，因為它允許我們「在一個線程中使用另一個線程的數據」。

本文鏈接：http://m.www897cc.com/showinfo-26-85705-0.html一網打盡 Rust 語法

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。郵件：2376512515@qq.com

上一篇：聊聊業務高可用的保障：異地多活架構

下一篇：這個被忽略的細節，是編寫優秀 Python 代碼的必經之路

標簽：

熱門焦點

十個可以手動編寫的 JavaScript 數組 API

JavaScript 中有很多API，使用得當，會很方便，省力不少。你知道它的原理嗎? 今天這篇文章，我們將對它們進行一次小總結。現在開始吧。1.forEach()forEach()用于遍歷數組接收一參
Java NIO內存映射文件：提高文件讀寫效率的優秀實踐！

Java的NIO庫提供了內存映射文件的支持，它可以將文件映射到內存中，從而可以更快地讀取和寫入文件數據。本文將對Java內存映射文件進行詳細的介紹和演示。內存映射文件概述內存
企業采用CRM系統的11個好處

客戶關系管理（CRM）軟件可以為企業提供很多的好處，從客戶保留到提高生產力?！　RM軟件用于企業收集客戶互動，以改善客戶體驗和滿意度?！　RM軟件市場規模如今超過580
雅柏威士忌多款單品價格大跌，泥煤頂流也不香了？

來源 | 烈酒商業觀察編 | 肖海林今年以來，威士忌市場開始出現了降溫跡象，越來越多不斷暴漲的網紅威士忌也開始悄然回歸市場理性。近日，LVMH集團旗下蘇格蘭威士忌品牌雅柏（Ardbeg
猿輔導與新東方的兩種“歸途”

作者｜卓心月出品｜零態LT（ID：LingTai_LT）如何成為一家偉大企業？答案一定是對“勢”的把握，這其中最關鍵的當屬對企業戰略的制定，且能夠站在未來看現在，即使這其中的
花7萬退貨退款無門：誰在縱容淘寶珠寶商家造假？

來源：極點商業作者：楊銘在淘寶購買珠寶玉石后，因為保證金不夠賠付，店鋪關閉，退貨退款難、維權無門的比比皆是。“提供相關產品鑒定證書，支持全國復檢，可以30天無理由退換貨。&
OPPO、vivo、小米等國內廠商Q2在印度智能手機市場份額依舊高達55%

7月20日消息，據外媒報道，研究機構的報告顯示，在全球智能手機出貨量同比仍在下滑的大背景下，印度這一有潛力的市場也未能幸免，出貨量同比也有下滑，多家廠
DRAM存儲器10月價格下跌，NAND閃存本月價格與上月持平

10月30日，據韓國媒體消息，自今年年初以來一直在上漲的 DRAM 存儲器的交易價格僅在本月就下跌了近 10％，此次是全年首次降價，而NAND 閃存本月價格與上月持平。市
2022爆款：ROG魔霸6 冰川散熱系統持續護航

喜逢開學季，各大商家開始推出自己的新產品，進行打折促銷活動。對于忠實的端游愛好者來說，能夠擁有一款夢寐以求的筆記本電腦是一件十分開心的事。但是現在的