Rust语言技巧和窍门

Rust是一种全新系统编程语言，Rust语言立足于编译时安全，由于没有其他语言GC附带，Rust也是一门高性能语言，性能堪比C。最近几年内，Rust被开发人员广为采纳，是好多年年度最受欢迎语言和开发者最想学习的语言。Rust是最有前途可以替代C/C++的语言之一。

成都网络公司-成都网站建设公司成都创新互联公司10多年经验成就非凡，专业从事网站建设、网站设计，成都网页设计，成都网页制作，软文发稿，1元广告等。10多年来已成功提供全面的成都网站建设方案，打造行业特色的成都网站建设案例，建站热线：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

然后在工作区中运行Clippy：

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

可以通过执行命令行参数或者clippy.toml配置文档来制定clippy的检查事项：

 

 

rustfmt是一种根据风格样式来格式化Rust代码的工具。

安装rustfmt，使用：

 
 
 
 
    
  
  
  
  
  1. rustup component add rustfmt 
    2.

然后工作区中运行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()，当出现错误时候就会触发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，不存在就会触发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.

使用该技巧，能够大大减少编译时间，节省时间和空间提高效率。

当然它也有缺点那就是不能对单个文件进行测试，而只能统一编译该文件。即使只更改了一个测试文件，它也要编译完整项目文件。

编译器缓存

Rust编译器cargo只支持工作区内部项目间的编译缓存，不支持工作区之间的缓存。对于多个工作区的多个项目使用相同的依赖关系，就要额外花费时间各自编译。我们可以借助cargo缓存工具sccahe来解决这个问题。

sccache是类似于ccache的cargo的编译器缓存，编译该依赖关系一次，然后在所有项目中就可以重复使用。可以大大节省编译时间和磁盘空间。sccache除了可以把编译构建存在本地外，也支持存在云端，比如AWS S3或者GCS等。

可以使用操作系统包管理器或者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环境变量：

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

避免不必要的克隆

在rust中对变量调用.clone()会为其创建数据的副本。创建数据副本需要消耗很多内存资源，因此大多数情况下会影响程序的性能，应避免使用。通常，可以将使用应用引用而非创建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 字节 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. let y = FooBoxing::A(0); // 16字节 
    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函数允许直接交换两个变量，而无需创建一个临时变量。

 
 
 
 
    
  
  
  
  
  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语言中有很多使用的技巧可以参考。希望本文抛砖引玉，给大家一些启发。大家如果更好的技巧和实用方法请回复本文。

 

标题名称：Rust语言技巧和窍门
网站路径：http://www.shufengxianlan.com/qtweb/news39/4839.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站收录知识

行业网站建设

品牌网站建设公司　　 　泸县网站建设　　 　和县翔豪网站　　 　四川绵阳机房　　 　成都钢筋机械设备　　 　普格博源建站　　 　四川服务器托管　　 　成都服务器托管　　 　木包装箱　　 　微信服务号订阅号开发　　 　绵阳主机托管　　 　成都app软件开发　　 　品牌网站建设　　 　兴久牧业　　 　新型地坪材料　　 　南充服务器托管　　 　整合营销　　 　重庆水土机房托管　　 　特丽尔硅藻泥　　 　四川正泰动物