小米平板5 Pro 12.4簡評：多專多能 兼顧影音娛樂的大屏利器
疫情帶來了網課，網課盤活了安卓平板，安卓平板市場雖然中途停滯了幾年，但好的一點就是停滯的這幾年行業又有了新的發展方向，例如超窄邊框、高刷新率、多攝鏡頭組合等，這就讓安卓
在我的交流群里有許多人在討論 rust。所以陸續有人開始嘗試學習 rust，不過大家的一致共識就是：rust 上手很困難。當然，這樣的共識在網上也普遍存在。
這篇文章，就是專門為想要學習 rust 的前端開發而寫，為大家拋開 rust 的迷霧，讓大家感受到，上手 rust，其實沒有那么難。從本質上來說，他跟 JavaScript 是非常相似的。大家可以將這篇文章作為 rust 學習的先導片，我將會提前為大家掃清那些阻礙你學習 rust 的障礙，極大的降低 rust 的上手成本。
JavaScript 并沒有模糊變量與值的概念。然而由于許多人在學習 JavaScript 之初就沒有重視變量與值的區別，在表達或者理解時，也經?；煊?，反正也不會出錯，于是久而久之，就形成了刻板印象，變量與值就傻傻分不清了。
一定要記住，變量就是變量，值就是值。
// a 是變量// 2 是值// a = 2 是給變量賦值let a = 2;在 rust 中，我們就必須要明確變量與值的區別，因為 rust 有一個非常有趣且核心的規定：每一個值，同時只能擁有一個變量。例如，如下代碼中，我首先聲明了一個變量 a，并且給 a 賦值一個字符串。
然后我聲明一個變量 b，并將變量 a 賦值給 b。
let a = "123".to_string();let b = a;println!("xxxx, {}", a);// error: borrow of moved value: `a` value borrowed here after move再然后，當我想要使用變量 a 時，我們發現報錯了。
根據我們剛才的那個規定，b = a 是將其值的所有權，轉移給了 b，所以此時變量 a 失去了值。當我們再次想要通過變量 a 訪問對應的值時，自然就會出錯。
這個規定，在 rust 中，稱之為所有權，是 rust 獨特的核心設計，也是我們學習 rust 必須掌握的核心知識點之一。明確區分變量與值，能夠幫我們快速掌握 rust 的這個核心特性。
只有面試過大量的人，你才知道，好多人其實不知道 JavaScript 的基礎數據類型是不可變的。對可變與不可變概念的不重視，也是導致前端上手 rust 困難的重要因素之一。
在 JavaScript 中，由于其強大的自動垃圾回收機制，我們在代碼上可以隨時修改變量的值，因此下面這段代碼再正常不過了。
let a = 10;a = 20;然而在 rust 中，由于沒有垃圾回收機制，編譯器必須明確知道變量到底是可變的還是不可變的，因此同樣的代碼，在 rust 中會直接報錯
注意：我們這里說的是變量的可變性和不可變性，而不是值的可變性與不可變性。
let a = 10;a = 20;// error: cannot mutate immutable variable `a`與此同時，如果你要聲明一個具有可變性的變量，那么你需要通過語法明確的告訴編譯器，這樣這段代碼就能編譯通過。
// 即使這樣寫，編譯器也會告訴你，你聲明了一個值，// 但是這個值還沒有被 read 過，就被重寫了let mut a = 10;a = 20;復雜的數據類型也保持了一樣的規定。不加 mut 的情況下聲明的變量，都是不可變的。
// 不加 mut 表示不可變，后續修改就會報錯let mut p = Person { name: "TOM".to_string(), age: 32};p.name = "TOM2".to_string();在 rust 的開發中，我們需要明確告訴編譯器變量的可變與不可變，習慣了這一點，rust 的學習就進展了一大步。
// 這樣表示不可變let a = 10;// 添加 mut 表示可變let mut a = 10;在我們前端開發中，有一個存在非常廣泛的共識性知識的錯誤理解：那就是
基礎數據類型存儲在棧內存中
我在《JavaScript 核心進階》中，專門花費了很多篇幅來講解為什么這是一個錯誤的理解。不過，很顯然，對于前端開發而言，這個知識的理解是否正確，并不重要，因為他不影響我們的代碼邏輯和功能實現。因此大家都不夠重視。
然而在 rust 中，對于這個知識的理解就顯得尤其重要，當你帶著這個錯誤理解來到 rust 的學習，你會感受到非常的不適應。
這里的關鍵之一，就在于字符串。
在 JavaScript 中，字符串是一個基礎數據類型。但往往我們只會在棧內存中存儲一些簡單的數據，很顯然，字符串可以變得復雜和龐大，龐大到整個棧內存可能都放不下。因此，字符串，其實并沒有那么簡單。
在 rust 中，字符串還原了他的本色，它是一個復雜數據類型，它存在于堆內存中。而與之對應的基本類型，變成了 char，表示單個字符。因此，我們需要非常嚴肅的對待字符串，把他看成一個復雜類型去學習。
// 聲明一個字符串let hello: String = String::from("hello world!");// 聲明一個字符串片段let name: &str = "TOM";// 將字符串片段轉成字符串類型let name1: String = "TOM".to_string();// 將字符串轉成字符串片段let name2: &str = hello.as_str();// 一個字符let a: char = 'h';純前端開發者對引用這個概念的理解有點大概差不多就是這樣的意思。所以對于按值傳遞、按引用傳遞這樣的概念理解得不是很透徹。當然，由于 JavaScript 太強大了，精準理解這些概念也沒有太大的必要。
但在 rust 中，就必須要求開發者非常明確的搞懂按值訪問/傳遞和按引用訪問/傳遞。
首先，在 JavaScript 中的基本數據類型，總是按值訪問/傳遞。 其原因是因為基本類型在內存中有明確的大小，非常的輕量，因此復制成本非常低，甚至有可能比復制一個引用的成本都還要低。
例如如下代碼：
let a = 1;let b = a;b++;console.log(a); // 仍然為1console.log(b); // 變成了2這段代碼在內存中的表現如下圖所示：
在 rust 中，基本類型也有同樣的表現。只不過我們要明確告訴編譯器，變量 b 是一個可變變量。
let a = 1;let mut b = a;b += 1;println!(" {a:?}"); // 仍然為1println!(" {b:?}"); // 變成了2在 rust 中基本類型雖然也可以有引用的寫法 let b = &a;，但是為了降低理解成本，我們可以在初學時無視他，因為大多數場景也不會這樣使用，就算使用了他的結果也沒啥大的區別。
將基本類型傳入函數中，也是一樣，對于前端開發者來說，他不會發生什么靈異事件讓我們理解不了。
// 簡寫語法：return v + 1fn addone(v: i32) -> i32 { v + 1}let a = 10;let b = addone(a);println!("xxxx, : {}, {}", a, b);// xxxx, : 10, 11我們聲明了一個不可變變量 a，并將其傳入函數 addone 中，此時 a 的值發生一次復制行為，并將復制之后的結果參與到函數的運行中去。因此最終 a 的值不受到函數執行的影響。這里的表現與 JS 一模一樣。
其次，在 JavaScript 中的引用數據類型，總是按引用訪問/傳遞。
例如下面這個例子，我聲明了兩個變量指向同一個值，當我通過任意一個變量引用修改值之后，最終的表現是兩個變量都會發生變化。
const book = { title: 'JavaScript 核心進階', author: '這波能反殺', date: '2020.08.02'}const b2 = book;b2.author = '反殺';console.log(book); // {title: "JavaScript 核心進階", author: "反殺", date: "2020.08.02"}console.log(b2); // {title: "JavaScript 核心進階", author: "反殺", date: "2020.08.02"}這段代碼在內存中的表現為：
但是，類似的代碼，在 rust 中就會出大問題。為什么呢，因為在 rust 中，默認是按照按值訪問/傳遞。查看如下代碼。
我需要一個可變的變量 b2，然后通過修改 b2 的值，來觀察 book 的變化。
struct Book { title: String, author: String, date: String} let book = Book { title: "rust 核心進階".to_string(), author: "這波能反殺".to_string(), date: "2024.03.12".to_string(),};let mut b2 = book;b2.author = "反殺".to_string();println!("bookxxxx: {}", book.title);// error: borrow of moved value: `book` value borrowed here after move是的，在 rust 中執行這段代碼會報錯，因為 rust 默認是按值訪問，所以當我們在代碼中執行 let mut b2 = book; 時，實際上已經將 book 對應的值的所有權，轉移給了 b2。
所有權：每個值只能同時擁有一個變量。
此時，當我們再訪問 book，編譯器就會告訴我們，book 的所有權已經被轉移了。
因此，如果我們要模仿出來 JavaScript 那種一樣的代碼，我們就需要借助引用來完成。
首先我們要約定好，book 的值是可變的。因此要使用 mut 來標識變量。
let mut book = Book { title: "rust 核心進階".to_string(), author: "這波能反殺".to_string(), date: "2024.03.12".to_string(),};其次，對于 b2 來說，所有權不能被 b2 剝奪，因此我們需要使用引用。
// 賦值一份引用，表示借用：而不是所有權轉移let b2 = &book;但是，b2 也需要被修改，因此 b2 得是一個可變引用。
let b2 = &mut book;完整代碼如下：
struct Book { title: String, author: String, date: String} let mut book = Book { title: "rust 核心進階".to_string(), author: "這波能反殺".to_string(), date: "2024.03.12".to_string(),};let b2 = &mut book;b2.author = "反殺".to_string();println!("bookxxxx: {}", book.author);在函數傳參時也是這樣的邏輯。因為 rust 是默認的按值傳遞，因此當我們將一個復合類型傳入函數時，實際上是把值傳進入，這樣就會發生所有權的轉移。
例如我聲明一個簡單的函數，然后只是在函數內部訪問傳入的值。
fn foo(bk: Book) { println!("bookxxxx: {}", bk.author);}然后執行該函數，當我們將 book 傳入函數之后，再訪問 book，就會發現報錯，明確的告訴我們 book 已經失去值的所有權了。
let book = Book { title: "rust 核心進階".to_string(), author: "這波能反殺".to_string(), date: "2024.03.12".to_string(),};foo(book);// 報錯println!("bookxxxx: {}", book.author);為了確保 book 不會失去所有權，我們可以改造成按引用傳遞的方式。類型約束中，加上 &。
fn foo(bk: &Book) { println!("bookxxxx: {}", bk.author);}然后傳入引用類型。
foo(&book);這樣，就跟 JavaScript 中的執行表現完全一致了。當然，我們如果要進一步在函數內部修改值，則傳入可變引用即可。
fn foo(bk: &mut Book) { println!("bookxxxx: {}", bk.author);}foo(&mut book);ok，理解了這點小差異，基于 JavaScript 掌握 rust，可以說是信手拈來，毫無壓力。
實踐中，這種傳入可變引用的場景其實是比較少的，按照函數式的指導思想來說的話，我們也應該盡量避免這樣使用。
按值傳遞時，內存往往更可控。因此，當我們總是在使用按值傳遞時，其實不會涉及到太過于復雜的生命周期的概念，編譯器就能很輕松識別出來內存應該在什么時候回收。
但是，當我們使用引用時，情況就變得復雜起來。例如我們聲明一個結構體。
struct Book2 { title: &str, author: &str, date: &str}該結構體三個字段都約定用引用類型來初始化。那么這個時候就有可能會發生一種情況：當我使用引用類型初始化該結構體時，有可能某一個字段的引用所對應的值，被提前銷毀掉了，那該結構體該如何自處呢？例如這個例子。
// 聲明一個標準字符串類型let title = String::from("rust 核心進階");let book = Book2 { title: title.as_str(), ...}// 按值傳遞，title 失去值的所有權read(title);fn read(book: String) { println!("xxxxx, {}", book);}此時尷尬的事情就發生了，title 的值沒了，所以呢，book.title 就訪問不到值了。這種情況，被稱為懸垂指針。
為了避免這種奇怪的事情發生，因此我們在使用引用時，就必須要明確的告訴編譯器，我們到底會不會搞這種騷操作，讓懸垂指針的情況出現。
約定的方式很簡單，我們可以明確告訴編譯器，結構體實例本身，與初始化的幾個值，一定會擁有共同的生命周期。不會出現某個值的引用私自額外處理掉的情況。因此，我們會傳入一個生命周期泛型，來完成我們這個約定。
struct Book2<'a> { title: &'a str, author: &'a str, date: &'a str}如果暫時不懂泛型，可以等懂了泛型再來回顧，這里的 'a 是隨便寫的一個字母，表達一個與泛型變量類似的概念，也可以是 'b，大家保持一致即可。
這里表達的是，Book2 的實例，與每一個初始化的引用，一定有相同的生命周期，大家會一起共進退。
約定了一致的生命周期之后，如果某個字段引用想要私自轉移所有權，對不起，這種情況編譯器就不會允許發生。
// 報錯：cannot move out of `title` because....read(title);在函數中也是一樣，當我們要返回引用數據類型時，很多時候就需要標明生命周期，告訴編譯器我們的約定。
例如這個案例，函數執行最終會返回入參中的一個，那么入參的生命周期與返回引用的生命周期就應該保持一致。因此我們使用泛型生命周期的語法約定一下即可。
fn longest<'b>(x: &'b str, y: &'b str) -> &'b str { if x.len() > y.len() { x } else { y }}如果不一致呢？我們就可以約定兩個泛型生命周期變量。
fn longest2<'a, 'b>(x: &'a str, y: &'a str) -> &'b str { let he = "hello"; let wo = "world"; if x.len() > y.len() { he } else { wo }}在一些編譯器能夠推斷出來的場景，就可以不需要約定生命周期。例如：
fn foo(x: &str) -> &str { x}除此之外，當你想要標識一個引用具有全局生命周期時，我們使用 'static。
let s: &'static str = "I have a static lifetime.";rust 中的生命周期其實就這么簡單。我們也有一種方式可以避免使用生命周期：那就是少使用引用。這個就很重要。
當然，有的時候我們還需要結合生命周期與泛型共同使用。看上去代碼就很難懂。不過不要慌。把生命周期當成一個泛型變量就好了。
fn longest_with_an_announcement<'a, T>( x: &'a str, y: &'a str, ann: T) -> &'a str where T: std::fmt::Display{ println!("xxxx T: {}", ann); if x.len() > y.len() { x } else { y }}where 表示對 T 的類型進行進一步解釋說明，明確限定 T 的使用范圍。
// 表示將會在 {} 中使用變量where T: std::fmt::Display還有一些 rust 的特性我并沒有列出來，因為他們中的許多知識理解起來就沒有太多的困擾性了，例如 trait、impl、數組、元組、enum、HashMap、mod、其他基礎語法等。
當然，要成為 rust 高手，我們必須對棧內存和堆內存有非常準確的掌握，而不是僅僅只局限于知道一個概念。rust 要求我們對內存與數據類型有更精準的掌握。
除此之外，rust 與 JavaScript 一樣，也是一門函數式編程語言。
rust 也用 let 與 const 聲明變量與常量。這該死的親切感。
rust 中也閉包。而且 rust 的閉包是顯示出來的，理解起來更容易。當然，由于概念上引入了所有權、可變、不可變，所以導致了許多朋友在學習 rust 閉包時也充滿了困惑，但是我們上面已經拿捏了這些概念，他們造成的難度都是紙老虎。
rust 的異步編程，有一個最常用的模式：單線程模型，與我們常說的事件循環體系是一模一樣的。遺憾的是，許多前端對事件循環掌握得并不好，依然處于一個大概知道有這么個東西的階段。
rust 也支持泛型，而泛型是 TS 的核心特性之一。rust 也有完善的類型推導機制，所以學習思路和 TS 都是一樣的，關鍵的問題是，TS 的泛型和類型推導，反而更加靈活與復雜。
本文鏈接：http://m.www897cc.com/showinfo-26-90187-0.htmlRust 上手很難？搞懂這些知識，前端開發能快速成為 Rust 高手
聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。郵件：2376512515@qq.com
上一篇： 我們一起聊聊.NET快速實現網頁數據抓取
Copyright ? 2016-2023 天津谷騏科技有限公司 版權所有 sitemap.xml
違法及侵權請聯系：2376512515@qq.com 津ICP備18001702號
津公網安備 12010102000574號