你不知道的 Rust

前言

本文檔不是一篇 Rust 入門教程,而是從前端開發者的視角對 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 原生層面還是未能很好地支持:

  1. 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] 上也有一個類似的討論以供參考

  1. 可選函數變量及默認值

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

function merge(a: string, b?: string, options = 'test') {}
fn add(aString, bOption<String>, cOption<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 namesVec<String>;
let travel = |pathu32| {
    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 等測試框架來運行單測文件,有如下特點:

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);
        }
        // ...
      }
    }

  1. Rust 版本

    let mut stackVec<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 文件夾),在上面的 “多線程” 已有介紹

應用場景

工具方向

webassembly

客戶端

其他

學習資料

參考資料

[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