日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯網營銷解決方案
Rust語言技巧和竅門

Rust是一種全新系統(tǒng)編程語言，Rust語言立足于編譯時安全，由于沒有其他語言GC附帶，Rust也是一門高性能語言，性能堪比C。最近幾年內，Rust被開發(fā)人員廣為采納，是好多年年度最受歡迎語言和開發(fā)者最想學習的語言。Rust是最有前途可以替代C/C++的語言之一。

成都網絡公司-成都網站建設公司成都創(chuàng)新互聯公司10多年經驗成就非凡，專業(yè)從事網站建設、網站設計，成都網頁設計，成都網頁制作，軟文發(fā)稿，1元廣告等。10多年來已成功提供全面的成都網站建設方案，打造行業(yè)特色的成都網站建設案例，建站熱線：13518219792，我們期待您的來電！

[[333734]]

 

當然Rust也有缺點就是學習曲線比較曲折，對初學者不是那么友好。本文蟲蟲給大家分享一下Rust語言的一些針對初學者的編程技巧，希望對大家有所幫助。

Racer,Clippy,rustfmt和fix

這是非常好用的一組工具。

Racer用來幫助你對rust代碼進行補全。

可以使用cargo安裝racer使用：

 
 
 
 
    
  
  
  
  
  1. cargo install racer 
    2.

racer需要先獲取Rust源碼路徑，可以通過rustup獲取源碼：

 
 
 
 
    
  
  
  
  
  1. rustup component add rust-src 
    2.

rustup update可以隨時獲取最新代碼

Clippy可以在代碼中捕獲各種lints，并檢查代碼是否符合rust慣用寫法，地道不地道、高效不高效?。

要安裝Clippy，請運行rustup component add clippy

然后在工作區(qū)中運行Clippy：

 
 
 
 
    
  
  
  
  
  1. cargo clippy --tests -- -W clippy::cargo 
    2.

可以通過執(zhí)行命令行參數或者clippy.toml配置文檔來制定clippy的檢查事項：

 

 

rustfmt是一種根據風格樣式來格式化Rust代碼的工具。

安裝rustfmt，使用：

 
 
 
 
    
  
  
  
  
  1. rustup component add rustfmt 
    2.

然后工作區(qū)中運行rustfmt：

 
 
 
 
    
  
  
  
  
  1. cargo fmt。 
    2.

同樣的可以用rustfmt.toml來配置rustfmt的風格：

 

 

cargo fix工具可以自動修復編譯器中警告項。

同名宏，函數和類型

熟悉Rust的同學可能知道，Rust最強大的功能之一就是宏，比如Hello，Chongchong范例中：

 
 
 
 
    
  
  
  
  
  1. fn main() { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. println!("Hello，Chongchong"); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. } 
    6.

println!()就是一個宏。

在Rust我們可以使用相同的名稱聲明一個宏，一個函數和一個類型，然后可以用一條import語句將他們引入其他文件。

dbg!宏

 

 

DBG宏可用于顯示表達式和值的計算過程，可以用來快捷調試部分代碼表達式。比如：

 
 
 
 
    
  
  
  
  
  1. let a = 2; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. et b = dbg!((a+3) * 2) + 1; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. assert_eq!(b, 11); 
    6.

上面的代碼將打印出：

 
 
 
 
    
  
  
  
  
  1. [dbg.rs:3] (a + 3) * 2 = 10 
    2.

錯誤類型轉換

直接使用rust的錯誤處理可能不夠靈活，使用unwrap()，當出現錯誤時候就會觸發(fā)panic，導致程序掛掉，很多時候這不是我們所期望的。下面是一個例子，

 
 
 
 
    
  
  
  
  
  1. fn main() { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. let path = "/tmp/example"; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. println!("{}", read_file(path)); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. fn read_file(path: &str) -> String { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. std::fs::read_to_string(path).unwrap() 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. } 
    14.

如果/tmp/example，不存在就會觸發(fā)panic錯誤：

 
 
 
 
    
  
  
  
  
  1. thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }', ok.rs:7:5 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace 
    4.

好在我們可以使用?，通過?運算符可以將錯誤返回轉化為了Err(From::from(err))和Ok(ok)分支處理，這樣錯誤可以轉換為自動類型。部分代碼如下，可以自定義錯誤消息CustomError：

 
 
 
 
    
  
  
  
  
  1. fn main() -> std::result::Result<(),CustomError>{ 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. let path = "/tmp/example "; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. let v = read_file(path)?; 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. Ok(()) 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. } 
    10.

模塊化測試

試想，你項目測試結構如下：

 
 
 
 
    
  
  
  
  
  1. tests/ 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. aaa.rs 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. bbb.rs 
    6.

測試時，這些每個都會被編譯為單獨的二進制文件，這會花費大量編譯時間和空間?？梢詫⑦@些測試文件作為模塊添加到一個測試中，這樣就只生成一個二進制文件。新測試結構如下所示：

 
 
 
 
    
  
  
  
  
  1. tests/ 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. all/ 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. mod.rs // mod aaa; mod bbb; 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. aaa.rs 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. bbb.rs 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. mod.rs // mod all; 
    12.

使用該技巧，能夠大大減少編譯時間，節(jié)省時間和空間提高效率。

當然它也有缺點那就是不能對單個文件進行測試，而只能統(tǒng)一編譯該文件。即使只更改了一個測試文件，它也要編譯完整項目文件。

編譯器緩存

Rust編譯器cargo只支持工作區(qū)內部項目間的編譯緩存，不支持工作區(qū)之間的緩存。對于多個工作區(qū)的多個項目使用相同的依賴關系，就要額外花費時間各自編譯。我們可以借助cargo緩存工具sccahe來解決這個問題。

sccache是類似于ccache的cargo的編譯器緩存，編譯該依賴關系一次，然后在所有項目中就可以重復使用。可以大大節(jié)省編譯時間和磁盤空間。sccache除了可以把編譯構建存在本地外，也支持存在云端，比如AWS S3或者GCS等。

可以使用操作系統(tǒng)包管理器或者cargo來安裝sccache：

cargo install sccache。

windows下可以使用

 
 
 
 
    
  
  
  
  
  1. scoop install sccache 
    2.

要使用sccache緩存rust編譯，需要在cargo配置文件(~/.cargo/config)中定義build.rustc-wrapper：

 
 
 
 
    
  
  
  
  
  1. [build] 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. rustc-wrapper = "/path/to/sccache" 
    4.

也可以在編譯時候直接設置RUSTC_WRAPPER環(huán)境變量：

 
 
 
 
    
  
  
  
  
  1. RUSTC_WRAPPER=/path/to/sccache cargo build 
    2.

避免不必要的克隆

在rust中對變量調用.clone()會為其創(chuàng)建數據的副本。創(chuàng)建數據副本需要消耗很多內存資源，因此大多數情況下會影響程序的性能，應避免使用。通常，可以將使用應用引用而非創(chuàng)建clone。例如：

 
 
 
 
    
  
  
  
  
  1. fn main() { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. let x = Foo::new(); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. func(x.clone()); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. func(x.clone()); // 該克隆是非必須的 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. fn main() { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. let x = Foo::new(); 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. func(x.clone()); 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. func(x); // This will work fine because you do not need 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. // to use x after this call 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. } 
    20.

使用：

 
 
 
 
    
  
  
  
  
  1. fn main() { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. let x = Foo::new(); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. func(&x); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. func(&x); 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. } 
    10.

枚舉大小受最大成員限制

枚舉的大小使其能夠容納其最大的變體。因此，建議在枚舉內使用類似大小的變體，以避免內存布局不理想。如果需要，可以考慮將較大的變量Box化?？紤]以下示例：

 
 
 
 
    
  
  
  
  
  1. enum Foo{ 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. A(u64), 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. B([u64; 1000]), 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. enum FooBoxing { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. A(u64), 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. B(Box<[u64;1000]>) 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. } 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. fn main() { 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. let x = Foo::A(0); // 大小8008 字節(jié) 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. let y = FooBoxing::A(0); // 16字節(jié) 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23. println!("Foo size {:?}", std::mem::size_of_val(&x)); 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25. println!("FooBoxing size {:?}", std::mem::size_of_val(&y)); 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. } 
    28.

在上面的示例中，枚舉Foo的變體A的大小比變體B小得多，但用于兩個變體的內存布局將相同，因此，當使用變體A時，其性能將不理想。

標準交換功能

rust swap函數允許直接交換兩個變量，而無需創(chuàng)建一個臨時變量。

 
 
 
 
    
  
  
  
  
  1. use std::mem; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. let mut x = 5; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. let mut y = 42; 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. mem::swap(&mut x, &mut y); 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. assert_eq!(42, x); 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. assert_eq!(5, y); 
    12.

結論

 

Rust語言中有很多使用的技巧可以參考。希望本文拋磚引玉，給大家一些啟發(fā)。大家如果更好的技巧和實用方法請回復本文。

 


網頁題目：Rust語言技巧和竅門
轉載源于：http://m.5511xx.com/article/cojjdgp.html