你不知道的 Rust

前言

本文檔不是一篇 Rust 入門教程，而是從前端開發者的視角對 Rust 進行較感性的雜談：諸如學習曲線、開發體驗、語法差異、性能差異、優勢領域等細節會被討論到。通過這種橫向的對比，有助於我們進一步瞭解：

我們是否需要去學習 Rust，學習它大概需要的時間成本
Rust 開發體驗有哪些痛點，又有那些爽點
Rust 在不同場景的具體優勢在哪裏
我們前端開發者可以基於 Rust 做哪些有意思的東西

學習曲線

這裏選取幾個較有代表性的語言作爲比較對象，分別對入門和精通兩個場景進行一個簡單對比：

入門

標準：以完成一個簡單 demo 作爲入門標準
結論：Rust >> C++ > C > TypeScript > JavaScript
細節：
我們知道 Rust 以編譯器嚴格著稱，在你成功跑起一個諸如《猜數遊戲》[1] 的 demo 之前，你需要經歷編譯器在編碼階段和編譯階段的雙重吊打（嚴格的語法、Rust 特有的 ownership[2] 規則、生命週期等）；另外還需要消化一些較新穎的語法如 match 匹配模式 [3]、Option/Result[4]，這會是漫長且痛苦的一段時間。
即便是難如 C++ 也會在入門階段允許你較快地編寫出一個可運行的 demo，而基於 Rust 的設計理念 [5]，這個難度從你開始寫的第一行代碼就需要揹負。但即便如此，開發者在多次編譯器報錯中會開始逐漸適應 Rust 的規則和細節，當邁過這個坎後，編碼的速度會有明顯的提升，恭喜此時已越過 Rust 第一個也是最陡峭的山坡。

精通

標準：以熟練掌握語言的高階功能和最佳實踐作爲精通標準
結論：C++ ≈ Rust >> TypeScript > C > JavaScript
細節：
- 如傳聞所言：“沒有人可以精通 C++，包括 Bjarne Stroustrup 本人”，雖然有誇大成分，但當中的複雜內容：宏、多範式編程、函數重載、手動管理內存、線程默認不安全、指針的高效使用等確實足以讓程序員花費數年甚至數十年去完全掌握這門語言
- 相較於 C++，精通 Rust 的難度個人感覺絲毫不減，一些共同的難點包括：宏、多範式編程、函數重載，指針的高效使用；雖然 Rust 的 ownership 規則優秀地實現了減少了線程安全以及手動管理內存的心智負擔，但新引入的生命週期 lifetime[6]、trait 語法 [7]、切片 [8] 等概念也是 Rust 勸退的首席代表

開發細節（Pros & Cons）

下面將通過對比一些在 TypeScript/JavaScript 中常用到的語法、數據結構和設計模式在 Rust 實現的異同，來感受它們具體的開發細節差異：

Cons

字符串操作

ts/js 的字符串拼接非常便捷，而 Rust 雖然方法比較多但相對還是比較繁瑣的：

const a = "Hello";
const b = "world";
// 1. ``
console.log(`${a},${b}`); // good
// 2. +
console.log(a + ',' + b);
// 3. join
[a, b].join(',');

let mut _a = "Hello".to_string();
let _b = "world".to_string();
// 1. push_str
_a.push_str()
_a.push_str(&_b);
println!("{}", _a);
// 2. +
println!("{}", _a + ",".to_string() + &_b);
// 3. !format
println!("{}", format!("{},{}", _a, _b)); // not bad
// 4. !concat
println!("{}", concat!("a", "b"));

https://stackoverflow.com/questions/30154541/how-do-i-concatenate-strings

重複代碼

通過一定的抽象，我們在 ts/js 基本上可以做到不重複地寫如下代碼，但目前在 Rust 原生層面還是未能很好地支持：

enum 的值問題

一般使用中我們會把 enum 的每個 item 綁定一個值，比如說 enum 是請求返回的一個字段，那麼值的對應的是服務端具體對應字段的數字

enum AllotStatus {
  unknown = 0,
  /** 待分配 */
  wait_allot = 1,
  /** 待挑選 */
  wait_pitch = 2,
  /** 全部 */
  all_status = 3,
}

由於 Rust 的 enum 是沒有 “值” 的概念的，因此如果你想把 enum 的每個 item 映射到一個具體的值需要這樣實現：

pub enum AllotStatus {
  Unknown,
  WaitAllot,
  WaitPitch,
  AllStatus,
}

impl Code for AllotStatus {
  fn fmt(&self) -> Result {
    match self {
      &AllotStatus::Unknown => 0,
      &AllotStatus::WaitAllot => 1,
      &AllotStatus::WaitPitch => 2,
      &AllotStatus::AllStatus => 2,
    }
  }
}

我們可以看到 Rust 寫法中出現了 6 次AllotStatus這個單詞，

stackoverflow[9] 上也有一個類似的討論以供參考

可選函數變量及默認值

我們在 JavaScript/TypeScript 可以輕鬆將某幾個函數參數設置爲可選的，並且爲它們提供一個默認值，而這在 Rust 是暫時還不支持的：

function merge(a: string, b?: string, options = 'test') {}

fn add(a: String, b: Option<String>, c: Option<String>) {
    // 需要在函數開頭顯示賦值一次
    let b = b.unwrap_or("");
    let c = c.unwrap_or("test");
}

閉包

基於 Rust 對於閉包較嚴格的要求，以下這段基於 JavaScript/TypeScirpt 的遞歸遍歷收集文件路徑的代碼在 Rust 實現起來並沒有那麼輕鬆：

const names = [];
function travel(folderPath = '') {
    const subNames = fs.readdirSync(dirPath);
    for (const subName of subNames) {
        const subPath = path.resolve(dirPath, subName);
        const status = fs.lstatSync(subPath);
        const isDir = status.isDirectory();
        if (isDir) {
            travelFolder(subPath);
        } else {
            names.push(subPath);
        }
    }
}

// 上述代碼在Rust實現大概樣子是這樣的：
let names: Vec<String>;
let travel = |path: u32| {
    let paths = read_dir(path).unwrap();
    for path in paths {
        let path = path.unwrap().path();
        if meta.is_dir() {
          travel(path);
        } else {
          names.push(String::from(path));
        }
    }
};
// 這裏編譯器會報錯`cannot find function `travel` in this scope not found in this scope`
// 原因是travel這個函數在閉包中並沒有被申明

// 因此一種妥協的寫法是：
// see https://stackoverflow.com/questions/30559073/cannot-borrow-captured-outer-variable-in-an-fn-closure-as-mutable about why using `Arc` and `Mutex`
  let mut res = Arc::new(Mutex::new(Vec::<String>::new()));
  struct Iter<'s> {
    f: &'s dyn Fn(&Iter, &str) -> (),
  }
  let iter = Iter {
    f: &|iter, path| {
      let paths = read_dir(path).unwrap();
      for path in paths {
        let path = path.unwrap().path();
        let meta = metadata(path.clone()).unwrap();
        let path = path.to_str().unwrap();
        if meta.is_dir() {
          (iter.f)(iter, path);
        } else {
          res.lock().unwrap().push(String::from(path));
        }
      }
    },
  };
  (iter.f)(&iter, folder_path);

更多相關的說明可以查看這裏 [10] 和這裏 [11]

Pros

match 匹配模式

Rust 的招牌 match 匹配模式在進行匹配模式判斷的時候比 JavaScript/TypeScirpt 的 switch 句式要優越不少，下面是具體的例子，根據字符串s的內容做匹配：

let res = match s {
  "i32" => IdlFieldType::Number,
  "i64" | "string" => IdlFieldType::String, // 或語句
  // 匹配項還可以是一個函數式，比如這裏的正則匹配，非常靈活
  s if Regex::new(r"refers?").unwrap().is_match(s) => {}
 }

switch(s) {
    case 'i32': {
        break;
    }
    case 'i64':
    case 'string': {
        break;
    }
    default: {
        if (/refers?/.test(s)) {}
        break;
    }
}

傳播錯誤捷徑——？

Rust 通過在函數結尾添加?(question mark) 的語法糖來節省多次編寫對 result 的錯誤判斷處理

// long way without using question mark operator ?
fn find_char_index_in_first_word() {
    let res1 = func1()?;
    let res2 = func2()?;
}

function find_char_index_in_first_word() {
    const res1 = func1();
    if (!res1) {
        return xxx;
    }
    const res2 = func2();
    if (!res2) {
        return xxx;
    }
}

多線程

基於 rust 的多線程thread方案，在一些適合併發場景（比如把上述場景擴展到讀取 10 個互相獨立的 node_modules 文件夾），則可以進一步加速程序，相較於 js 使用 web worker（相對割裂的方案）可能會是一個更合適的方案

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

// 主線程
var worker = new Worker('/jsteststatic/static/worker.js') //必須是網絡路徑，不能是本地路徑
worker.postMessage('Hello World')
worker.postMessage({method: 'echo', args: ['Work']})
worker.onmessage = function (event) {
  console.log('Received message ' + event.data)
  // worker.terminate()  // 結束web worker 釋放資源
} 

// 子線程
var self = this
self.addEventListener('message', function (e) {
  self.postMessage('You said: ' + e.data)
}, false)

單測

JavaScript/TypeScript

在前端一般我們需要藉助 Jest 等測試框架來運行單測文件，有如下特點：

需要安裝 Jest 框架
單測文件一般單獨寫在一個單測文件，與原文件有一定的割裂感
運行單測以命令行形式運行

Rust

Rust 單測相較來說有一下優點：

Rust 內置單測功能無需安裝第三方包
單測代碼一般和被測代碼寫在同一個文件
編輯器內置了單個單測運行按鈕，方便了對單測的及時驗證

性能

以下數據非嚴格實驗條件下的精準數據，僅作爲性能數量級的一個感官對比參考

對比場景

遍歷一個 node_modules 文件夾下的所有文件夾的路徑（大概 28000 個文件）

對比方案

NodeJS 版本

    const stack = [];
    while (stack.length) {
      const cur = stack.pop();
      const subNames = fs.readdirSync(cur);
      for (const subName of subNames) {
        const subPath = path.resolve(cur, subName);
        const status = fs.lstatSync(subPath);
        const isDir = status.isDirectory();
        if (isDir) {
            stack.push(subPath);
        }
        // ...
      }
    }

Rust 版本

    let mut stack: Vec<ReadDir> = vec![root];
    while !stack.is_empty() {
        let cur = stack.pop().unwrap();
        for r in cur {
            let path = r.unwrap().path();
            if path.is_dir() {
                let p = read_dir(path).unwrap();
                stack.push(p);
            }
            // ...
        }
    }

fLnk8Z

在一些適合多線程的場景，Rust 凸顯的優勢會更加明顯（比如把上述場景擴展到讀取 10 個互相獨立的 node_modules 文件夾），在上面的 “多線程” 已有介紹

應用場景

工具方向

編譯打包相關：
前端代碼編譯 & 打包
https://swc.rs/
SWC
代碼轉義：
Fast and 100% API compatible postcss replacer
https://github.com/justjavac/postcss-rs
thrift idl -> ts types
Ridl:
postcss:

webassembly

Deno
deno 目前全面採用 rust 編寫核心部分
https://deno.land/
ZapLib
通過將速度很慢的 JavaScript 函數重寫爲 Rust 並將它們編譯爲 Wasm
https://zaplib.com/
Photon
藉助 rust+wasm 的圖像處理庫
https://github.com/silvia-odwyer/photon

客戶端

Tauri
跨端桌面客戶端
https://github.com/tauri-apps/tauri
dioxus
跨全端
類 tsx 寫法
https://github.com/DioxusLabs/dioxus
命令行
目前很火的 mac 端命令行工具，基於 Rust 開發
https://www.warp.dev/
Wrap

其他

Linux 內核 / 嵌入式開發
https://github.com/Rust-for-Linux

學習資料

Rust 的入門教程個人比較建議直接跟隨官方入門書 [12] 以及輔助參考《Rust 語言聖經》[13]
另外可以多參考上面提到的一些小型的 Rust 工具庫 [14] 的源碼，代碼量較小容易入門

參考資料

[1] 《猜數遊戲》: https://www.bilibili.com/video/BV1hp4y1k7SV?p=8

[2] ownership: https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html

[3] match 匹配模式: https://doc.rust-lang.org/book/ch06-00-enums.html

[4] Option/Result: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html?highlight=result#recoverable-errors-with-result

[5] 設計理念: https://rustacean-principles.netlify.app/how_rust_empowers.html

[6] 生命週期 lifetime: https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#validating-references-with-lifetimes

[7] trait 語法: https://doc.rust-lang.org/book/ch10-02-traits.html#traits-defining-shared-behavior

[8] 切片: https://course.rs/difficulties/slice.html

[9] stackoverflow: https://stackoverflow.com/questions/36928569/how-can-i-create-enums-with-constant-values-in-rust

[10] 這裏: https://stackoverflow.com/questions/16946888/is-it-possible-to-make-a-recursive-closure-in-rust

[11] 這裏: http://smallcultfollowing.com/babysteps/blog/2013/04/30/the-case-of-the-recurring-closure/

[12] 官方入門書: https://doc.rust-lang.org/book/title-page.html

[13] 《Rust 語言聖經》: https://rusty.rs/

[14] 工具庫: https://github.com/justjavac/postcss-rs

❤️ 謝謝支持

以上便是本次分享的全部內容，希望對你有所幫助 ^_^

歡迎關注公衆號 ELab 團隊 收貨大廠一手好文章~

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/VkK_nFB8FWFvywRKJueyyQ

前言