引言

欢迎👏来到Rust Ocean。

读者定位

定位读者为懂得基本编程概念。为了简短忽略了基本概念,如果你觉得理解困难的话,考虑找更基础的书来看。

Rust是什么

Rust 是一门注重安全(safety)、速度(speed)和并发(concurrency)的现代系统编程语言。Rust 通过内存安全来实现上述目标,但不用垃圾回收机制(Garbage collection, GC)。
Rust解决了空指针问题,错误处理更可靠,大大增加了可靠性和对代码的信心❤️。
如果你看了我以上的简单介绍还不明真相的话,还在犹豫是否学习Rust的话,可以浏览下《爱上Rust》。在阅读前可以看看intorust的英文短视频介绍。

极简风格

本书采用极简风格,不求大全,目标是学完后有基本的了解。希望是轻松的方式,两三天就学完。
参考了《通过例子学Rust》《RustPrimer》两本书,更多内容请移步前往。

To English Readers

I wrote this in Chinese, so if some links are in Chinese, you can use Google Translate to help it.

第1章:基础知识

当你开始阅读的时候,说明你已经有一些兴趣了。
Rust入门非常简单,不需要任何配置。
可以去playground在线运行代码。本地安装就省略了,请参考引言中的参考书。
下面是hello world:
// 这是注释内容,将会被编译器忽略掉

fn main() {
    println!("Hello Rust World!");
}

println! 是一个 (macros),可以将文本输出到控制台(console)。
使用 Rust 的编译器 rustc 可以将源程序生成可执行文件:
$ rustc hello.rs
rustc 编译后将得到可执行文件 hello
$ ./hello
Hello Rust World!
有一个runner可以一步运行。
另外自带的cargo可以提供项目管理,在小项目里有介绍。

第2章:结构体、Trait

先看看结构体:
// 单元结构体
struct Nil;

// 元组结构体
struct Pair(i32, f32);

// 带有两个字段的结构体
struct Point {
    x: f32,
    y: f32,
}

// 结构体可以作为另一个结构体的字段
#[allow(dead_code)]
struct Rectangle {
    p1: Point,
    p2: Point,
}

fn main() {
    // 实例化结构体 `Point`
    let point: Point = Point { x: 0.3, y: 0.4 };

    // 访问 point 的字段
    println!("point coordinates: ({}, {})", point.x, point.y);

    // 实例化一个单元结构体
    let _nil = Nil;

    // 实例化一个元组结构体
    let pair = Pair(1, 0.1);

    // 访问元组结构体的字段
    println!("pair contains {:?} and {:?}", pair.0, pair.1);

    // 解构一个元组结构体
    let Pair(integer, decimal) = pair;

    println!("pair contains {:?} and {:?}", integer, decimal);
}
Trait
trait HasArea {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl HasArea for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * (self.radius * self.radius)
    }
}

fn main() {
    let c = Circle {
        radius: 1.0f64,
    };
    println!("circle c has an area of {}", c.area());
}


这个程序会输出:
circle c has an area of 3.141592653589793
{}, {:?}分别对应两个Trait:Display和Debug。

第3章:HashMap、数组

先看看HashMap的简单用法。
use std::collections::HashMap;

fn main(){
    let mut come_from = HashMap::new();
    // 插入
    come_from.insert("WaySLOG", "HeBei");
    come_from.insert("Marisa", "U.S.");
    come_from.insert("Mike", "HuoGuo");
    
    // 查找key
    if !come_from.contains_key("elton") {
        println!("Oh, 我们查到了{}个人,但是可怜的Elton猫还是无家可归", come_from.len());
    }
    
    // 根据key删除元素
    come_from.remove("Mike");
    println!("\nMike猫!\n");
    
    // 利用get的返回判断元素是否存在
    let who = ["MoGu", "Marisa"];
    for person in &who {
        match come_from.get(person) {
            Some(location) => println!("{} 来自: {}", person, location),
            None => println!("{} 也无家可归啊.", person),
        }
    }
    
    // 遍历输出
    println!("\n那么,所有人呢?");
    for (name, location) in &come_from {
        println!("{}来自: {}", name, location);
    }
}
再看看数组:
fn main() {
    let mut array: [i32; 3] = [0; 3];

    array[1] = 1;
    array[2] = 2;

    assert_eq!([1, 2], &array[1..]);

    // This loop prints: 0 1 2
    for x in &array {
        println!("{} ", x);
    }
}
动态数组Vec
fn main() {
    //创建空Vec
    let v: Vec<i32> = Vec::new();
    println!("{:?}", v);
    
    //使用宏创建空Vec
    let v = vec![1, 2, 3, 4, 5];
    println!("{:?}", v);
    //创建十个零
    let v = vec![0; 10];
    //创建可变的Vec,并压入元素3
    println!("{:?}", v);
    let mut v = vec![1, 2];
    v.push(3);
    println!("{:?}", v);
    //创建拥有两个元素的Vec,并弹出一个元素
    let mut v = vec![1, 2];
    let two = v.pop();
    println!("{:?}", two);
    //创建包含三个元素的可变Vec,并索引一个值和修改一个值
    let mut v = vec![1, 2, 3];
    v[1] = v[1] + 5;
    println!("{:?}", v);
    
}

特别章:🔥所有权、借用和生命周期

所有权系统的这几个概念是Rust与众不同的地方。是安全基础,号称编译就不会崩溃。
所有权系统可以用借书来类比,先看所有权:
fn main() {
    let a: String = String::from("xyz");
    let _b = a;
    println!("{}", a);
}
这个代码在传统的语言是没问题的,这里编译会报错,因为发生了所有权转移。
再看借用:
fn main() {
    let a: String = String::from("xyz");
    let _b = &a;
    println!("{}", a);
}
改了一个字就是借用了,可以编译了。
再看生命周期:
fn _foo<'a>(x: &'a str) -> &'a str {
    x
}
这个就是有些奇怪的生命周期写法。有些简单的情况可以省略生命周期,更简洁。简单说,生命周期就是指定变量的存在时间吧,当编译器无法确定的时候,会要求程序员写生命周期。

小结

通过三个简单例子,介绍了三个概念,当然实际情况要复杂一些,不过基本思路差不多。
Rust正是通过所有权、借用以及生命周期,没有手动管理内存的安全性风险,也没有GC造成的程序暂停问题。需要付出的是一些时间去逐渐熟悉它们。

第4章:代码组织

模块的基本用法
mod ccc {
    pub fn print_ccc() {
        println!("{}", 25);
    }
}

fn main() {
    use ccc::print_ccc;

    print_ccc();
    // 或者
    ccc::print_ccc();
}

包crate是更大的单位。
真正我们在开发时,会大量用到外部库。外部库是通过
extern crate xxx;
这样来引入的。
注:要使上述引用生效,还必须在 Cargo.toml 的 dependecies 段,加上 xxx="version num" 这种依赖说明。
引入后,就相当于引入了一个符号 xxx,后面可以直接以这个 xxx 为根引用这个 crate 中的 item:
extern crate xxx;

use xxx::yyy::zzz;
引入的时候,可以通过 as 关键字重命名。
extern crate xxx as foo;

use foo::yyy::zzz;

第5章:Rust花絮

没想好写什么,暂时空白。

特别章:❌错误处理

Rust解决了空指针的问题,而且不用异常。
Rust的❌错误处理很有特色,我们看看例子:
1 简单一些的Option
fn get(x: i32) -> Option<i32> {
    match x>0 {
        true => Some(1),
        false => None
    }
}
fn main() {
    let x : i32;
    x = get(1).unwrap();
    println!("x has the value {}", x);
}
Option是一个Enum类型,有两个值Some和None,例子中用match分别处理。unwrap适合于演示代码,直接对None引发panic。
2 更复杂错误处理的情况用Result,看例子:
use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");

    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

fn main() {
    let result : Result<String, io::Error>;
    result = read_username_from_file();
    println!("{:?}", result);
}
Result也是Enum类型,两个值分别是Ok和Err,可以方便地传递错误信息。
3 简化错误传递的问号操作
use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

//You can link the call
//File::open("hello.txt")?.read_to_string(&mut s)?;

fn main() {
  println!("{:?}", read_username_from_file());
}

?操作是用来简化错误的传递。
你可以尝试去掉末尾的❓,你会发现编译器准确地发现了错误,这大大提升了你对代码的信心,不需要花额外的功夫去写单元测试。

小结:

通过几个简单例子,大致学完了错误处理。
概括起来说,大致有两个方式:
Option,包括Some和None。适合于简单情况。
enum Option<T> {
    Some(T),
    None,
}
Result,包括Ok和Err。用于传递错误信息。
enum Result<T, E> {
    Ok(T),
    Err(E),
}
简化错误传递的?操作,可以选用。演示代码中常见到unwrap,会panic。还有一种expect("info"),也是panic,不过会带上info。
好消息是消除了空指针问题,不利的是似乎有些复杂,需要时间来消化。
就这样,下一个话题。

第6章:并发

extern crate rayon;

use rayon::prelude::*;

fn main() {
    let mut colors = [-20.0f32, 0.0, 20.0, 40.0,
        80.0, 100.0, 150.0, 180.0, 200.0, 250.0, 300.0];
    println!("original:    {:?}", &colors);

    colors.par_iter_mut().for_each(|color| {
        let c : f32 = if *color < 0.0 {
                0.0
            } else if *color > 255.0 {
                255.0
            } else {
                *color
            };
        *color = c / 255.0;
    });
    println!("transformed: {:?}", &colors);
}
这个例子是通过库实现的并发,看上去比较简单。
关于并发我还缺少经验,所以就点到为止。留待以后再探讨。

第7章:宏

这里简单介绍下。
macro_rules! create_function {
    ($func_name:ident) => (
        fn $func_name() {
            println!("function {:?} is called", stringify!($func_name))
        }
    )
}

fn main() {
    create_function!(foo);
    foo();
}

第8章:测试

Rust 的测试特性按精细度划分,分为 3 个层次:
  1. 函数级;
  2. 模块级;
  3. 工程级;
另外,Rust 还支持对文档进行测试。
这里介绍简单的函数级测试。
#[test]
fn it_works() {
    assert!(2>1); // do test work
}
非常简单,Rust 中,只需要在一个函数的上面,加上 #[test] 就标明这是一个测试用的函数。
有了这个属性之后,在使用 cargo build 编译时,就会忽略这些函数。使用 cargo test 可以运行这些函数。
Rust 提供了两个宏来执行测试断言:
assert!(expr)               测试表达式是否为 true 或 false
assert_eq!(expr, expr)      测试两个表达式的结果是否相等

——实践小项目:Json处理

这个项目参考RustPrimer书,《Json处理》。介绍了caogo的用法。
通过小项目可以验证一下我们对Rust的理解是否正确。

结论

终于学习完了,看看你花了多少时间,入门了么?
希望学习愉快,等待下一个语言,下次再见!