這篇文章給所有想要學(xué)習(xí)rust語言的同學(xué)進(jìn)行一個(gè)學(xué)習(xí)參考，rust語言是一款正在崛起的語言，希望每個(gè)出于熱愛或者工作學(xué)習(xí)Rust的朋友都能有收獲

rust的故事

2006 年，Graydon Hoare 這一年 29 歲，是 Mozilla 瀏覽器公司的程序員。有一天他下班回到溫哥華的公寓，結(jié)果發(fā)現(xiàn)電梯又壞了——原因是系統(tǒng)崩潰了，而且不是第一次了。

他住在 21 樓，只能硬著頭皮爬樓梯。一邊爬，一邊越想越氣：“我們搞計(jì)算機(jī)的，居然連個(gè)不會(huì)崩潰的電梯程序都做不出來，簡直離譜。”

他很清楚，這類故障常常是內(nèi)存管理出問題。像電梯這種嵌入式設(shè)備里，軟件大多是用 C 或 C++ 寫的。這類語言運(yùn)行快、占空間小，但也容易出錯(cuò)，尤其是容易引入“內(nèi)存漏洞”——只要處理不當(dāng)，程序就會(huì)直接崩潰。

微軟曾經(jīng)統(tǒng)計(jì)過，它自家代碼中高達(dá) 70% 的漏洞，都和 C/C++ 寫的內(nèi)存管理有關(guān)。

大多數(shù)人可能就是罵幾句了事，但 Hoare 決定做點(diǎn)什么。他回到家，打開筆記本，開始設(shè)計(jì)一門新語言。他想要一種既能寫出小而快的程序，又能在根本上避免內(nèi)存 bug 的語言。

他給這門語言起名叫 Rust，靈感來自一種非常頑強(qiáng)的真菌——在他眼里，這個(gè)名字意味著“為生存而過度設(shè)計(jì)”

這正是 Rust 的設(shè)計(jì)哲學(xué)：
程序可以慢慢變舊，但不能悄悄變壞。

rust的發(fā)展歷程

Rust 的發(fā)展歷程并不光鮮，甚至可以說一度接近夭折。它最早起源于 2006 年，是 Mozilla 工程師 Graydon Hoare 在個(gè)人時(shí)間里發(fā)起的一個(gè)實(shí)驗(yàn)性項(xiàng)目，初衷很簡單：擺脫 C/C++ 中長期困擾系統(tǒng)開發(fā)者的內(nèi)存安全與并發(fā)問題。那時(shí)的 Rust 只是一個(gè)個(gè)人嘗試，沒有明確的目標(biāo)，也談不上生態(tài)和穩(wěn)定性。

2009 年 Mozilla 接手 Rust 后，這門語言并沒有立刻走向成熟，反而經(jīng)歷了長期的方向搖擺與設(shè)計(jì)反復(fù)。早期的 Rust 版本頻繁推翻語法和特性，幾乎每個(gè)版本都像一門新語言，學(xué)習(xí)成本極高，社區(qū)難以積累經(jīng)驗(yàn)，Mozilla 內(nèi)部也開始質(zhì)疑是否有必要繼續(xù)投入資源維護(hù)這樣一個(gè)復(fù)雜而激進(jìn)的項(xiàng)目。2012 到 2014 年間，Rust 迎來了第一次真正的生存危機(jī)，如果繼續(xù)沿著原有路線發(fā)展，它很可能會(huì)就此消失。

真正的轉(zhuǎn)折點(diǎn)發(fā)生在 Rust 團(tuán)隊(duì)對(duì)自身設(shè)計(jì)的深刻反思之中。他們選擇主動(dòng)“剎車”，凍結(jié)特性，明確以所有權(quán)與借用系統(tǒng)為核心，放棄短期的靈活性與炫技，轉(zhuǎn)而追求長期的穩(wěn)定性與可維護(hù)性。這一決定雖然讓 Rust 在使用上顯得嚴(yán)格而難學(xué)，卻為它奠定了堅(jiān)實(shí)的語言基礎(chǔ)。2015 年 Rust 1.0 正式發(fā)布，語法和語義趨于穩(wěn)定，Rust 才真正意義上“活了下來”。

然而，Rust 并沒有在 1.0 發(fā)布后立刻爆發(fā)。相當(dāng)長一段時(shí)間里，它依然被認(rèn)為學(xué)習(xí)曲線陡峭、編譯緩慢、生態(tài)尚不成熟，更多是工程師欣賞卻不敢在核心業(yè)務(wù)中使用的語言。直到云計(jì)算、大規(guī)模并發(fā)系統(tǒng)和安全問題成為現(xiàn)實(shí)壓力，內(nèi)存安全從“錦上添花”變成“剛性需求”，Rust 才迎來了屬于自己的時(shí)代。

隨著 AWS、Microsoft、Google 等大型公司在關(guān)鍵系統(tǒng)中采用 Rust，Linux 內(nèi)核也開始引入 Rust 支持，這門曾經(jīng)瀕臨失敗的語言逐漸進(jìn)入主流視野?；仡?Rust 的發(fā)展歷史，它并不是贏在起點(diǎn)，而是在一次次否定與重構(gòu)中，選擇了最難卻最穩(wěn)的一條路，這也正是 Rust 今天能夠站在系統(tǒng)級(jí)編程舞臺(tái)中央的原因。

好的，該說的基本都說了，下面就開始我們的rust內(nèi)容教學(xué)。

rust環(huán)境安裝

可以去官方下載安裝工具來安裝rust：rust安裝工具

這里我們選擇x64（一般的筆記本都是這個(gè)）。下載完成之后打開exe文件

我這里已經(jīng)安裝過了，沒有過程。第一次安裝的話會(huì)自動(dòng)安裝完成，等待即可。

安裝完成之后打開cmd控制臺(tái)，輸入下面的命令查看rust編譯器版本

成功輸出版本信息，說明安裝成功

rust特性和使用場(chǎng)景

Rust 并不是“語法炫技型語言”，它的每一個(gè)設(shè)計(jì)，幾乎都圍繞兩個(gè)關(guān)鍵詞：

安全（Safety） 與 性能（Performance）

內(nèi)存安全：內(nèi)存安全是Rust最重要，也是最具代表性的特性，在傳統(tǒng)系統(tǒng)級(jí)語言（c/c++）當(dāng)中，常見的內(nèi)存安全問題包括，空指針訪問，野指針，內(nèi)存泄漏，越界訪問等等。rust在編譯期間就通過“所有權(quán)系統(tǒng)”徹底避免這些問題”。

在保證安全的同時(shí)，Rust 并沒有犧牲性能。Rust 的抽象大多是零成本抽象（Zero-cost Abstraction），例如模式匹配、迭代器、泛型和 trait，在編譯后通常會(huì)被優(yōu)化為與手寫 C 代碼相當(dāng)?shù)臋C(jī)器指令，不引入額外的運(yùn)行時(shí)開銷。這使得 Rust 在性能上可以直接對(duì)標(biāo) C / C++，卻大幅降低了出錯(cuò)概率。

Rust 對(duì)并發(fā)安全的關(guān)注同樣體現(xiàn)在語言層面。傳統(tǒng)語言中常見的數(shù)據(jù)競爭、競態(tài)條件，往往依賴文檔約定或運(yùn)行時(shí)檢查，而 Rust 通過類型系統(tǒng)和所有權(quán)規(guī)則，將“是否線程安全”變成了編譯期問題。Send、Sync 等 trait 明確約束了數(shù)據(jù)能否跨線程傳遞，使得“無數(shù)據(jù)競爭的并發(fā)”成為語言級(jí)別的保證，而非最佳實(shí)踐。

使用場(chǎng)景

正是由于這些特性，Rust 非常適合用于對(duì)安全性和性能要求極高的場(chǎng)景，例如系統(tǒng)軟件、網(wǎng)絡(luò)服務(wù)、云基礎(chǔ)設(shè)施、區(qū)塊鏈、數(shù)據(jù)庫、瀏覽器內(nèi)核以及操作系統(tǒng)組件等。近年來，Rust 也逐漸進(jìn)入 Web 后端、微服務(wù)和高并發(fā)服務(wù)領(lǐng)域，在保持接近底層性能的同時(shí)，顯著提升了系統(tǒng)的穩(wěn)定性和可維護(hù)性。

rust的ide選擇

vscode

VsCode:堪稱編程界萬金油編譯器，含金量無需多言，安裝對(duì)應(yīng)的插件什么代碼都能跑

網(wǎng)站鏈接：vscode下載地址

RustRover

RustRover：jetbrains家出品，必屬精品，專業(yè)rust語言ide，含金量不多說了，可以自己找一下破解方法

網(wǎng)站鏈接：RustRover下載

下面我的代碼編寫都是以RustRover為例子

rust的重要概念

所有權(quán)系統(tǒng)

每一塊內(nèi)存，都有且只有一個(gè)“主人”。

let s = String::from("hello");
let t = s;        // 所有權(quán)轉(zhuǎn)移（move）

借用（Borrowing）

不擁有，但可以臨時(shí)使用。

fn print_len(s: &String) {
    println!("{}", s.len());
}

Move / Copy 語義

所有權(quán)可以被顯式或隱式轉(zhuǎn)移。

let a = 10;
let b = a;  // Copy

let s1 = String::from("hi");
let s2 = s1; // Move

crate（包）

Rust 的最小編譯單元，可以理解為 “一次被編譯和鏈接的完整代碼包”。

簡要來說：

• 一個(gè) crate 要么是 庫（lib crate），要么是 可執(zhí)行程序（binary crate）

• 編譯時(shí)，Rust 以 crate 為單位 進(jìn)行編譯和依賴管理

• 一個(gè)項(xiàng)目可以包含 多個(gè) crate

• 對(duì)外暴露的代碼由 crate 的 public API 決定

Proc-macro Crate（過程宏）

編譯期運(yùn)行的 Rust 程序，用來“生成 Rust 代碼。它不是在運(yùn)行時(shí)干活，而是在“編譯 Rust 代碼時(shí)”幫你寫代碼

• 本質(zhì)上是一個(gè) 獨(dú)立的 crate

• 在 編譯期執(zhí)行

• 輸入是 Rust 代碼，輸出也是 Rust 代碼

• 用來減少樣板代碼、實(shí)現(xiàn)語法級(jí)擴(kuò)展

常見的過程宏形式包括三種：

• 派生宏（derive）：如 #[derive(Debug)]

• 屬性宏（attribute）：如 #[route("/hello")]

• 函數(shù)式宏（function-like）：如 sql!(...)

Cargo

Cargo 是 Rust 的官方構(gòu)建工具和包管理器，可以把它理解為 Rust 世界里的“項(xiàng)目管家 + 構(gòu)建系統(tǒng) + 依賴管理器”，幾乎所有現(xiàn)代 Rust 項(xiàng)目都離不開它。

Cargo 的核心配置文件是 Cargo.toml，它描述了一個(gè) Rust 項(xiàng)目的“身份信息”和“依賴關(guān)系”，包括項(xiàng)目名、版本、使用的 Rust 版本、依賴的第三方庫（crate）以及構(gòu)建配置。Cargo 會(huì)根據(jù)這個(gè)文件自動(dòng)下載依賴、解析版本、處理編譯順序。

rust變量類型

Rust 是強(qiáng)類型 + 靜態(tài)類型語言，變量的類型在編譯期就必須確定。

整數(shù)類型（Integer）

let a: i32 = -10;
let b: u64 = 100;
let idx: usize = 5;

浮點(diǎn)類型（Floating-point）

let pi: f64 = 3.14159;

布爾類型（Boolean）

let ok: bool = true;

字符類型（char）

• Unicode 字符

• 占 4 字節(jié)

let c: char = '中';
let emoji: char = '??';

元組（Tuple）

• 不同類型的組合

• 定長

let tup: (i32, f64, char) = (1, 2.0, 'a');

let (x, y, z) = tup;

數(shù)組（Array）

• 相同類型

• 定長

• 存在棧上

let arr: [i32; 3] = [1, 2, 3];

切片（Slice）

• 對(duì)數(shù)組或集合的引用

• 動(dòng)態(tài)長度

let slice: &[i32] = &arr[0..2];

rust基礎(chǔ)語法

第一行代碼Hello world

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

變量聲明（let / mut）

let x = 10;        // 不可變（默認(rèn)）
let mut y = 20;   // 可變
y += 1;

if 條件判斷（沒有三元運(yùn)算符）

let n = 10;

if n > 0 {
    println!("positive");
} else if n == 0 {
    println!("zero");
} else {
    println!("negative");
}

for 循環(huán)

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

包含右邊界

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

while 循環(huán)

let mut i = 0;

while i < 5 {
    println!("{}", i);
    i += 1;
}

loop 無限循環(huán)

let mut i = 0;

loop {
    if i == 5 {
        break;
    }
    i += 1;
}

loop需要返回值時(shí)

let result = loop {
    if i > 10 {
        break i * 2;
    }
    i += 1;
};

match 判斷

Rust沒有switch的設(shè)計(jì)，使用match代替

let n = 2;

match n {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    _ => println!("other"),
}

if let（簡化match）

let x = Some(5);

if let Some(v) = x {
    println!("{}", v);
}

break / continue

for i in 0..10 {
    if i == 3 {
        continue;
    }
    if i == 7 {
        break;
    }
    println!("{}", i);
}

函數(shù)定義

rust的函數(shù)定義上和go挺像的，fn 函數(shù)名稱（入?yún)ⅲ侯愋停?>返回類型。細(xì)節(jié)是最后一行返回內(nèi)容時(shí)不需要分號(hào)。

fn add(a: i32, b: i32) -> i32 {
    a + b   // 最后一行是返回值（無分號(hào)）
}

注釋

rust的注釋和其他語言沒什么區(qū)別，不多介紹了

// 單行注釋

/*
   多行注釋
*/

/// 文檔注釋（用于生成文檔）

rust高級(jí)語法

下面則是深入一個(gè)rust的重要設(shè)計(jì)和概念，以下內(nèi)容難度相對(duì)比較高和抽象，希望大家都不要放棄。

生命周期

生命周期是 Rust 用來描述**引用“活多久”**的機(jī)制，它并不影響運(yùn)行時(shí)行為，而是完全服務(wù)于編譯期檢查。通過生命周期，Rust 可以在不使用垃圾回收的前提下，確保引用永遠(yuǎn)不會(huì)懸垂。生命周期的本質(zhì)不是“讓你寫更多標(biāo)注”，而是把“對(duì)象之間的依賴關(guān)系”顯式地交給編譯器驗(yàn)證。

代碼示例：

// 'a 表示 x、y 和返回值共享同一個(gè)生命周期
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    // 返回的引用一定來自 x 或 y
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let a = String::from("hello");
    let b = String::from("rust");

    // &a、&b 的生命周期都覆蓋了 longest 的返回值
    println!("{}", longest(&a, &b));
}

閉包和迭代器

Rust 對(duì)函數(shù)式編程的支持體現(xiàn)在閉包和迭代器上。閉包可以捕獲環(huán)境，并根據(jù)捕獲方式自動(dòng)推導(dǎo) Fn、FnMut、FnOnce，而迭代器則通過惰性求值和組合操作，提供了極高的表達(dá)力。這些抽象在編譯期會(huì)被完全優(yōu)化，不引入額外運(yùn)行時(shí)成本，是 Rust “零成本抽象”理念的典型體現(xiàn)。

示例如下

// 'a 表示 x、y 和返回值共享同一個(gè)生命周期
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    // 返回的引用一定來自 x 或 y
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let a = String::from("hello");
    let b = String::from("rust");

    // &a、&b 的生命周期都覆蓋了 longest 的返回值
    println!("{}", longest(&a, &b));
}

循環(huán)引用和自引用

在引入引用計(jì)數(shù)（如 Rc / Arc）后，循環(huán)引用成為一個(gè)必須正視的問題。Rust 并不會(huì)自動(dòng)替你處理這些情況，而是通過 Weak 指針等機(jī)制，讓開發(fā)者顯式打破引用環(huán)。同時(shí)，自引用結(jié)構(gòu)在 Rust 中也是一個(gè)典型的高級(jí)難點(diǎn)，需要借助 Pin 等機(jī)制來保證內(nèi)存地址的穩(wěn)定性。

代碼示例：

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    next: RefCell<Option<Rc<Node>>>,   // 強(qiáng)引用：擁有所有權(quán)
    prev: RefCell<Option<Weak<Node>>>, // 弱引用：不增加計(jì)數(shù)
}

fn main() {
    let a = Rc::new(Node {
        next: RefCell::new(None),
        prev: RefCell::new(None),
    });

    let b = Rc::new(Node {
        next: RefCell::new(None),
        // Weak 用于防止 a <-> b 循環(huán)引用
        prev: RefCell::new(Some(Rc::downgrade(&a))),
    });

    // a 強(qiáng)引用 b，但 b 不強(qiáng)引用 a
    *a.next.borrow_mut() = Some(b);
}

多線程并發(fā)模型

Rust 的并發(fā)模型建立在“編譯期無數(shù)據(jù)競爭”之上。通過 Send、Sync 以及所有權(quán)規(guī)則，Rust 能在編譯階段阻止絕大多數(shù)并發(fā)錯(cuò)誤。Mutex、RwLock、Channel 等并發(fā)工具在 Rust 中并不神秘，但它們的安全使用是由類型系統(tǒng)強(qiáng)制保障的，而不是依賴約定

代碼示例：

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Arc：線程安全的引用計(jì)數(shù)
    // Mutex：保證同一時(shí)間只有一個(gè)線程修改數(shù)據(jù)
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..5 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            // lock() 返回互斥鎖，作用域結(jié)束自動(dòng)釋放
            *c.lock().unwrap() += 1;
        }));
    }

    for h in handles {
        h.join().unwrap();
    }

    println!("{}", *counter.lock().unwrap());
}

Macro 宏編程

Rust 的宏是編譯期代碼生成工具，分為聲明宏和過程宏。宏并不是語法糖，而是一種元編程能力，可以用來減少重復(fù)代碼、擴(kuò)展語言表達(dá)能力，甚至構(gòu)建領(lǐng)域?qū)Ｓ谜Z言（DSL）。許多 Rust 生態(tài)中的“魔法”，本質(zhì)都來自宏。

代碼示例：

// 聲明宏：在編譯期展開代碼
macro_rules! say_hello {
    ($name:expr) => {
        println!("Hello, {}", $name);
    };
}

fn main() {
    // 這里不是函數(shù)調(diào)用，而是宏展開
    say_hello!("Rust");
}

async / await 異步編程

Rust 的異步模型是基于 Future 的零成本抽象，async/await 只是語法層面的簡化。不同于依賴運(yùn)行時(shí)調(diào)度的語言，Rust 將異步狀態(tài)機(jī)編譯成顯式結(jié)構(gòu)，由執(zhí)行器驅(qū)動(dòng)運(yùn)行。這使得 Rust 在高并發(fā)場(chǎng)景下既高效又可控。

代碼如下：

// async fn 會(huì)被編譯成一個(gè)實(shí)現(xiàn)了 Future 的狀態(tài)機(jī)
async fn hello() -> i32 {
    42
}

#[tokio::main] // 啟動(dòng)異步執(zhí)行器
async fn main() {
    // await 驅(qū)動(dòng) Future 運(yùn)行，直到完成
    let v = hello().await;
    println!("{}", v);
}

錯(cuò)誤處理

Rust 采用 Result 和 Option 作為核心錯(cuò)誤處理機(jī)制，避免了異常帶來的隱式控制流。通過 ? 運(yùn)算符，錯(cuò)誤可以在保持代碼簡潔的同時(shí)被顯式傳播。錯(cuò)誤在 Rust 中是一等公民，而不是運(yùn)行時(shí)的“意外情況”。

fn parse_num(s: &str) -> Result<i32, std::num::ParseIntError> {
    // ?：成功則解包，失敗則立刻返回 Err
    let n = s.parse::<i32>()?;
    Ok(n * 2)
}

fn main() {
    match parse_num("10") {
        Ok(v) => println!("{}", v),
        Err(e) => println!("error: {}", e),
    }
}

rust生態(tài)框架

后端框架

Actix-web

Actix-web 是一個(gè)高性能、偏底層控制的 Rust 后端 Web 框架，以性能著稱，內(nèi)部基于 Actor 模型，在高并發(fā)場(chǎng)景下非常強(qiáng)

use actix_web::{get, App, HttpServer, Responder};

#[get("/hello")]
async fn hello() -> impl Responder {
    "Hello Actix-web"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(hello)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Axum

Axum 是一個(gè)基于 Tokio + Tower 的現(xiàn)代 Rust Web 框架，強(qiáng)調(diào)類型安全、組合式設(shè)計(jì)，API 非常“Rust 風(fēng)格”。

use axum::{routing::get, Router};

async fn hello() -> &'static str {
    "Hello Axum"
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/hello", get(hello));

    axum::Server::bind(&"127.0.0.1:8080".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

數(shù)據(jù)庫框架

Diesel

github地址：https://github.com/diesel-rs/diesel

Diesel 是 Rust 中最成熟的 ORM 框架，主打 編譯期 SQL 校驗(yàn) 和 強(qiáng)類型映射，非常安全，但使用成本較高。

代碼示例：

use diesel::prelude::*;

#[derive(Queryable)]
struct User {
    id: i32,
    name: String,
}

let results = users
    .limit(10)
    .load::<User>(&mut conn)?;

SeaORM

github地址：SeaQL/sea-orm: ?? A powerful relational ORM for Rust

SeaORM 是新一代異步 ORM，在“類型安全”和“開發(fā)效率”之間做了平衡。

適合場(chǎng)景：

• CRUD 密集型業(yè)務(wù)

• 快速開發(fā)

代碼示例：

let users = User::find()
    .limit(10)
    .all(&db)
    .await?;

緩存

Redis

Redis 是 Rust 中最常用的分布式緩存方案，官方社區(qū)最成熟的客戶端是 redis（也叫 redis-rs）

use redis::AsyncCommands;

let client = redis::Client::open("redis://127.0.0.1/")?;
let mut conn = client.get_async_connection().await?;

conn.set("key", "value").await?;
let val: String = conn.get("key").await?;

本地緩存（moka）

Moka 是 Rust 非常流行的高性能本地緩存庫，支持并發(fā)、TTL、LRU。

use moka::sync::Cache;

let cache = Cache::new(10_000);

cache.insert("key", "value");
let v = cache.get(&"key");

消息隊(duì)列

Kafka

rdkafka 是 Rust 中最主流的 Kafka 客戶端，基于 C 庫 librdkafka，性能和穩(wěn)定性非常強(qiáng)。

use rdkafka::producer::{FutureProducer, FutureRecord};

let producer: FutureProducer = config.create()?;

producer.send(
    FutureRecord::to("topic")
        .payload("hello kafka")
        .key("key"),
    Duration::from_secs(0),
).await?;

NATS

NATS 是輕量級(jí)、高性能消息系統(tǒng)，在 Rust 微服務(wù)中非常常見。

let client = async_nats::connect("localhost").await?;
client.publish("subject", "hello").await?;

API網(wǎng)關(guān)

Tower

Tower 是 Rust 服務(wù)生態(tài)的中間件標(biāo)準(zhǔn)，提供限流、超時(shí)、重試、熔斷等能力，是很多網(wǎng)關(guān)方案的基礎(chǔ)。

use tower::{ServiceBuilder};
use tower_http::trace::TraceLayer;

let service = ServiceBuilder::new()
    .layer(TraceLayer::new_for_http())
    .service(my_service);

Hyper

Hyper 是 Rust 最底層、最高性能的 HTTP 庫，Axum、Tower 等都構(gòu)建在它之上。

use hyper::{Body, Request, Response};

async fn handler(_: Request<Body>) -> Response<Body> {
    Response::new(Body::from("Hello Gateway"))
}

日志

Rust 的日志體系是 分層設(shè)計(jì)，靈活但需要理解一次。

tracing

tracing 是 Rust 新一代結(jié)構(gòu)化日志與鏈路追蹤框架，特別適合微服務(wù)。

use tracing::info;

info!(user_id = 42, "request received");

tracing + tower_http

在 Web / 網(wǎng)關(guān)項(xiàng)目中，常見組合是

• 自動(dòng)記錄請(qǐng)求日志

• 支持鏈路追蹤

• 易于接入 OpenTelemetry

use tower_http::trace::TraceLayer;

let app = Router::new()
    .layer(TraceLayer::new_for_http());

一些學(xué)習(xí)rust語言的網(wǎng)站：

Rust 圣經(jīng)（目前最好的rust教學(xué)）

菜鳥教程 rust

rust程序設(shè)計(jì)課程語言

總結(jié)

Rust 并不是一門“輕松上手”的語言，它對(duì)學(xué)習(xí)者的要求明顯高于許多現(xiàn)代編程語言。初學(xué) Rust 時(shí)，你需要花大量精力去理解所有權(quán)、借用、生命周期以及類型系統(tǒng)，這些概念并非語法技巧，而是 Rust 對(duì)程序正確性和安全性的根本約束。很多在其他語言中可以“先跑起來再說”的寫法，在 Rust 中必須一開始就想清楚，這會(huì)讓人感到挫敗，也常常產(chǎn)生“寫代碼像在和編譯器較勁”的感覺。

但正是這種看似嚴(yán)苛的學(xué)習(xí)過程，構(gòu)成了 Rust 最核心的價(jià)值。Rust 把大量原本在運(yùn)行時(shí)、線上環(huán)境中才會(huì)暴露的問題，提前到了編譯期解決。學(xué)習(xí) Rust，實(shí)際上是在被迫建立一種更嚴(yán)謹(jǐn)?shù)墓こ趟季S：清楚數(shù)據(jù)的生命周期、明確所有權(quán)邊界、對(duì)并發(fā)和資源管理保持敬畏。這些能力一旦形成，不僅會(huì)讓你寫出更可靠的 Rust 代碼，也會(huì)反過來提升你在其他語言中的代碼質(zhì)量。

因此，學(xué)習(xí) Rust 更像是一種“長期投資”。前期進(jìn)度可能緩慢，甚至?xí)岩赏度胧欠裰档?，但隨著理解逐漸加深，你會(huì)發(fā)現(xiàn)代碼變得更可控、系統(tǒng)更穩(wěn)定、問題更早暴露。Rust 不承諾讓你寫得更快，但它承諾讓你在復(fù)雜系統(tǒng)中犯更少的錯(cuò)。對(duì)于愿意投入時(shí)間、耐心和思考深度的開發(fā)者來說，這份努力最終會(huì)轉(zhuǎn)化為扎實(shí)而持久的工程能力。

以上就是所有rust教學(xué)的內(nèi)容，希望這篇文章能幫到每一個(gè)正在學(xué)習(xí)rust的朋友。如果這篇文章對(duì)你們有幫助，可以點(diǎn)贊，收藏加關(guān)注一下。你們的支持是我更新的最大動(dòng)力

到此這篇關(guān)于新手輕松入門rus學(xué)習(xí)t語言（基礎(chǔ)、高級(jí)語法和生態(tài)框架）的文章就介紹到這了,更多相關(guān)rust語言學(xué)習(xí)內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！