Rust是一个现代的系统级编程语言，侧重于安全、速度和并发。

安装

1

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

hello world

1
2
3

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

其中，println!是一个宏，功能是将字符串打印到终端。

编译方式如下

1
2

rustc hello.rs
./hello

或者使用

1

cargo run

cargo是一个rust生态管理工具，我们在接下来的各种实例中都采用这种方式来运行我们的程序。

注释

  1. // 我是注释
  2. /*我是注释*/

其中第二种方式更加灵活，我们可以这样

1

println!("{}",5 + /*plus*/ 4);

格式化输出

  • format!: 格式化字符串。
  • print!: 输出到控制台。
  • println!: 与print!一样，但是多添加了换行。
  • eprint!: 格式化字符串，但是错误输出
  • eprintln!: 与eprint!一样，但是多添加了换行。
1
2
3
4

println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");
println!("{} of {:b} people know binary, the other half doesn't", 1, 2); //二进制展开
println!("{number:>width$}", number=1, width=6);  //向右对齐
println!("{number:>0width$}", number=1, width=6); //向右对齐补0

debug

在Rust中，所有的输出都是使用了std::fmt来进行输出，有一些数据是无法用该方式进行打印的，但是需要进行调试，这个时候需要另一种方式进行debug。

1
2

#[derive(Debug)]
struct DebugPrintable(i32);

通过这种方式就能够将自定义类型使用fmt::Debug来调试输出。

1
2
3
4
5
6
7

#[derive(Debug)]
struct Structure(i32);

fn main() {
    println!("{:?} months in a year.", 12);
    println!("Now {:?} will print!", Structure(3));
}

输出为

1
2

12 months in a year.
Now Structure(3) will print!

其中，{:?}可以换成{:#?}，从而实现更加美观的输出。

Display

除了可以使用debug的方法进行调试输出，Rust也提供了重载输出方法进行输出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#[derive(Debug)]
struct Structure(i32);
impl Display for Structure {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}
fn main() {
    println!("{}", Structure(4));
}

通过对每一个自定义类型的重写能够个性化输出。

?操作符

1

write!(f, "{}", value)?;

能够处理一些异常情况,如果有问题就报错，没有问题就继续执行。

总结

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::fmt::{self, Formatter, Display};

struct City {
    name: &'static str,
    // Latitude
    lat: f32,
    // Longitude
    lon: f32,
}

impl Display for City {
    // `f` is a buffer, and this method must write the formatted string into it
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' };
        let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };

        // `write!` is like `format!`, but it will write the formatted string
        // into a buffer (the first argument)
        write!(f, "{}: {:.3}°{} {:.3}°{}",
               self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
    }
}

impl Display for Color {
    // `f` is a buffer, and this method must write the formatted string into it
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        // write!(f, "{}: {:.3}°{} {:.3}°{}",
        //        self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
        write!(f, "RGB ({0}, {1}, {2}) 0x{0:02X}{1:02X}{2:02X}", self.red, self.green, self.blue)
    }
}



#[derive(Debug)]
struct Color {
    red: u8,
    green: u8,
    blue: u8,
}

fn main() {
    for city in [
        City { name: "Dublin", lat: 53.347778, lon: -6.259722 },
        City { name: "Oslo", lat: 59.95, lon: 10.75 },
        City { name: "Vancouver", lat: 49.25, lon: -123.1 },
    ].iter() {
        println!("{}", *city);
    }
    for color in [
        Color { red: 128, green: 255, blue: 90 },
        Color { red: 0, green: 3, blue: 254 },
        Color { red: 0, green: 0, blue: 0 },
    ].iter() {
        // Switch this to use {} once you've added an implementation
        // for fmt::Display.
        println!("{}", *color);
    }
}

参考资料