连续 4 年成为“开发者最喜欢的语言”，这门编程语言你了解过吗？

fn main() {   println!("hello rust");}

随着 Facebook 的 Libra 项目出炉，Rust 一下子火了，这是 Rust 有史以来最大的项目，但随着全球数字货币的兴起，Rust 的旅程可能才刚刚开始。

虽然你可能还不太了解 Rust，但在开发者眼中，Rust 真香！连续 4 年，在 Stack Overflow 开发者「最受喜爱编程语言」评选中，Rust 都是第一名。

2015 年 5 月 15 日，Rust 正式发布了 1.0 版本。4 年来，它凭借着「安全」和「高并发」两个特性，受到了越来越多开发者的喜爱。Rust 正以势如破竹之势占领区块链新兴项目市场，很多著名的老项目也在考虑转向使用 Rust 重写。

Rust 的语言特性（安全、高性能、并发编程）与区块链的特性（分布式、加密、安全敏感）天生契合，很多著名的区块链项目已经选择使用 Rust 作为其开发语言，包括：Parity、Polkadot、Substrate、Grin、Ethereum 经典、Holochain、Cardano-Rust、Exonum、Lighthouse、Nimiq、Nervos、Conflux-Rust、Codechain、Witnet 等，更不用说即将到来的 Libra。

相信，选择使用 Rust 作为第一开发语言的区块链项目也会越来越多，我们会迎来一波的 Rust 语言学习高潮，而区块链开发者的薪资有多高，相信大家都清楚。

实验楼上线了一门【免费】的 Rust 教程 —— 《通过例子学 Rust》。课程改编自经典教材《Rust By Example》，并根据教材内容配置了线上实验环境，和挑战测试。每一个知识点都有配套的实例和小练习，让大家轻松地掌握这门语言。

想要学习的朋友可以点击 《通过例子学 Rust》哦。

接下来，大家就跟着我熟悉一下 Rust 的一些基础语法吧，用 Rust 写出你的第一个小程序。

本文建议收藏，这样随时都可以拿出来巩固一下基础 Rust 知识。

---

以下是 《通过例子学 Rust》第一节内容：

简介

Rust 是一门注重安全（safety）、速度（speed）和并发（concurrency）的现代系统编程语言。Rust 通过内存安全来实现以上目标，但不用垃圾回收机制（garbage collection, GC)。

本课程为《通过例子学 Rust》的在线实验版本，通过在线实验一系列程序例子，一步步完成 Rust 编程语言的入门。欢迎在课程仓库中参与修订和完善，仓库地址见 通过例子学 Rust - 在线实验版。所有文档内容版权跟随中文及英文原文档的版权（版权为 MIT 协议 或 Apache 协议）。

知识点

本节实验的主要内容包括以下知识点：

• 课程介绍
• 如何编写第一个程序
• Hello World 程序详解
• 注释
• 格式化输出

Hello World

我们的第一个程序将打印传说中的 "Hello World" 消息，下面是完整的程序代码和编译运行过程。

这是传统的 Hello World 程序的源码。首先，在实验楼 WebIDE 中 /home/project 目录下新建 hello.rs 文件，编写以下代码（以 // 开头的注释内容可以不必输入）：

// 这是注释内容，将会被编译器忽略掉
// 可以单击那边的按钮 "Run" 来测试这段代码 ->
// 若想用键盘操作，可以使用快捷键 "Ctrl + Enter" 来运行

// 这段代码支持编辑，你可以自由地修改代码！
// 通过单击 "Reset" 按钮可以使代码恢复到初始状态 ->

// 这是主函数
fn main() {
    // 调用编译生成的可执行文件时，这里的语句将被运行。

    // 将文本打印到控制台
    println!("Hello World!");
}

println! 是一个 宏（macros），可以将文本输出到控制台（console）。

在实验楼 WebIDE 终端中执行以下命令，使用 Rust 的编译器 rustc 从源程序生成可执行文件：

$ cd /home/project
$ rustc hello.rs

使用 rustc 编译后将得到可执行文件 hello，使用以下命令来运行生成的文件 hello：

$ ./hello

执行后的结果如下所示：

动手试一试

请尝试下在你的 hello.rs 程序中增加一行代码，再一次使用宏 println!，得到下面结果：

Hello World!
I'm a Rustacean!

注释

注释对任何程序都不可缺少，同样 Rust 支持几种不同的注释方式。

• 普通注释，其内容将被编译器忽略掉：

• // 单行注释，注释内容直到行尾。

• /* 块注释， 注释内容一直到结束分隔符。*/

• 文档注释，其内容将被解析成 HTML 帮助文档:

• /// 为接下来的项生成帮助文档。
• //! 为注释所属于的项（译注：如 crate、模块或函数）生成帮助文档。

fn main() {
    // 这是行注释的例子
    // 注意有两个斜线在本行的开头
    // 在这里面的所有内容都不会被编译器读取

    // println!("Hello, world!");

    // 请运行一下，你看到结果了吗？现在请将上述语句的两条斜线删掉，并重新运行。

    /*
     * 这是另外一种注释——块注释。一般而言，行注释是推荐的注释格式，
     * 不过块注释在临时注释大块代码特别有用。/* 块注释可以 /* 嵌套, */ */
     * 所以只需很少按键就可注释掉这些 main() 函数中的行。/*/*/* 自己试试！*/*/*/
     */

     /*
      注意，上面的例子中纵向都有 `*`，这只是一种风格，实际上这并不是必须的。
      */

     // 观察块注释是如何简单地对表达式进行修改的，行注释则不能这样。
     // 删除注释分隔符将会改变结果。
     let x = 5 + /* 90 + */ 5;
     println!("Is `x` 10 or 100? x = {}", x);
}

格式化输出

打印操作由 std::fmt 里面所定义的一系列 宏 来处理，包括：

• format!：将格式化文本写到 字符串（String）。译注：字符串 是返回值不是参数。
• print!：与 format! 类似，但将文本输出到控制台（io::stdout）。
• println!: 与 print! 类似，但输出结果追加一个换行符。
• eprint!：与 format! 类似，但将文本输出到标准错误（io::stderr）。
• eprintln!：与 eprint! 类似，但输出结果追加一个换行符。

这些宏都以相同的做法解析（parse）文本。另外有个优点是格式化的正确性会在编译时检查。

新建 format.rs 文件，编写代码如下。

fn main() {
    // 通常情况下，`{}` 会被任意变量内容所替换。
    // 变量内容会转化成字符串。
    println!("{} days", 31);

    // 不加后缀的话，31 就自动成为 i32 类型。
    // 你可以添加后缀来改变 31 的类型。

    // 用变量替换字符串有多种写法。
    // 比如可以使用位置参数。
    println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");

    // 可以使用命名参数。
    println!("{subject} {verb} {object}",
             object="the lazy dog",
             subject="the quick brown fox",
             verb="jumps over");

    // 可以在 `:` 后面指定特殊的格式。
    println!("{} of {:b} people know binary, the other half don't", 1, 2);

    // 你可以按指定宽度来右对齐文本。
    // 下面语句输出 "     1"，5 个空格后面连着 1。
    println!("{number:>width$}", number=1, width=6);

    // 你可以在数字左边补 0。下面语句输出 "000001"。
    println!("{number:>0width$}", number=1, width=6);

    // println! 会检查使用到的参数数量是否正确。
    println!("My name is {0}, {1} {0}", "Bond");
    // 改正 ^ 补上漏掉的参数："James"

    // 创建一个包含单个 `i32` 的结构体（structure）。命名为 `Structure`。
    #[allow(dead_code)]
    struct Structure(i32);

    // 但是像结构体这样的自定义类型需要更复杂的方式来处理。
    // 下面语句无法运行。
    println!("This struct `{}` won't print...", Structure(3));
    // 改正 ^ 注释掉此行。
}

std::fmt 包含多种 traits（trait 有「特征，特性」等意思）来控制文字显示，其中重要的两种 trait 的基本形式如下：

• fmt::Debug：使用 {:?} 标记。格式化文本以供调试使用。
• fmt::Display：使用 {} 标记。以更优雅和友好的风格来格式化文本。

上例使用了 fmt::Display，因为标准库提供了那些类型的实现。若要打印自定义类型的文本，需要更多的步骤。

动手试一试

• 改正上面代码中的两个错误（见代码注释中的「改正」），使它可以没有错误地运行。
• 再用一个 println! 宏，通过控制显示的小数位数来打印：Pi is roughly 3.142 （Pi 约等于 3.142）。为了达到练习目的，使用 let pi = 3.141592 作为 Pi 的近似 值。

提示：设置小数位的显示格式可以参考文档 std::fmt。

调试（Debug）

所有的类型，若想用 std::fmt 的格式化 trait 打印出来，都要求实现这个 trait。自动的实现只为一些类型提供，比如 std 库中的类型。所有其他类型都必须手动实现。

fmt::Debug 这个 trait 使这项工作变得相当简单。所有类型都能推导（derive，即自动创建）fmt::Debug 的实现。但是 fmt::Display 需要手动实现。

// 这个结构体不能使用 `fmt::Display` 或 `fmt::Debug` 来进行打印。
struct UnPrintable(i32);

// `derive` 属性会自动创建所需的实现，使这个 `struct` 能使用 `fmt::Debug` 打印。
#[derive(Debug)]
struct DebugPrintable(i32);

所有 std 库类型都天生可以使用 {:?} 来打印。新建 format1.rs 文件，编写代码如下：

// 推导 `Structure` 的 `fmt::Debug` 实现。
// `Structure` 是一个包含单个 `i32` 的结构体。
#[derive(Debug)]
struct Structure(i32);

// 将 `Structure` 放到结构体 `Deep` 中。然后使 `Deep` 也能够打印。
#[derive(Debug)]
struct Deep(Structure);

fn main() {
    // 使用 `{:?}` 打印和使用 `{}` 类似。
    println!("{:?} months in a year.", 12);
    println!("{1:?} {0:?} is the {actor:?} name.",
             "Slater",
             "Christian",
             actor="actor's");

    // `Structure` 也可以打印！
    println!("Now {:?} will print!", Structure(3));

    // 使用 `derive` 的一个问题是不能控制输出的形式。
    // 假如我只想展示一个 `7` 怎么办？
    println!("Now {:?} will print!", Deep(Structure(7)));
}

在实验楼 WebIDE 终端中编译并运行程序。

$ rustc format1.rs
$ ./format1

执行结果如下所示：

所以 fmt::Debug 确实使这些内容可以打印，但是牺牲了一些美感。Rust 也通过 {:#?} 提供了「美化打印」的功能：

#[derive(Debug)]
struct Person<'a> {
    name: &'a str,
    age: u8
}

fn main() {
    let name = "Peter";
    let age = 27;
    let peter = Person { name, age };

    // 美化打印
    println!("{:#?}", peter);
}

将上面代码添加到 format1.rs 中后，编译并运行的结果如下所示：

你可以通过手动实现 fmt::Display 来控制显示效果。

显示（Display）

fmt::Debug 通常看起来不太简洁，因此自定义输出的外观经常是更可取的。这需要通过手动实现 fmt::Display 来做到。fmt::Display 采用 {} 标记。实现方式看起来像这样：

// （使用 `use`）导入 `fmt` 模块使 `fmt::Display` 可用
use std::fmt;

// 定义一个结构体，咱们会为它实现 `fmt::Display`。以下是个简单的元组结构体
// `Structure`，包含一个 `i32` 元素。
struct Structure(i32);

// 为了使用 `{}` 标记，必须手动为类型实现 `fmt::Display` trait。
impl fmt::Display for Structure {
    // 这个 trait 要求 `fmt` 使用与下面的函数完全一致的函数签名
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // 仅将 self 的第一个元素写入到给定的输出流 `f`。返回 `fmt:Result`，此
        // 结果表明操作成功或失败。注意 `write!` 的用法和 `println!` 很相似。
        write!(f, "{}", self.0)
    }
}

fmt::Display 的效果可能比 fmt::Debug 简洁，但对于 std 库来说，这就有一个问题。模棱两可的类型该如何显示呢？举个例子，假设标准库对所有的 Vec 都实现了同一种输出样式，那么它应该是哪种样式？下面两种中的一种吗？

• Vec ：/:/etc:/home/username:/bin（使用 : 分割）
• Vec ：1,2,3（使用 , 分割）

我们没有这样做，因为没有一种合适的样式适用于所有类型，标准库也并不擅自规定一种样式。对于 Vec 或其他任意泛型容器（generic container），fmt::Display 都没有实现。因此在这些泛型的情况下要用 fmt::Debug。

这并不是一个问题，因为对于任何非泛型的容器类型， fmt::Display 都能够实现。新建 display.rs 文件，编写代码如下：

use std::fmt; // （使用 `use`）导入 `fmt` 模块使 `fmt::Display` 可用

// 带有两个数字的结构体。推导出 `Debug`，以便与 `Display` 的输出进行比较。
#[derive(Debug)]
struct MinMax(i64, i64);

// 实现 `MinMax` 的 `Display`。
impl fmt::Display for MinMax {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // 使用 `self.number` 来表示各个数据。
        write!(f, "({}, {})", self.0, self.1)
    }
}

// 为了比较，定义一个含有具名字段的结构体。
#[derive(Debug)]
struct Point2D {
    x: f64,
    y: f64,
}

// 类似地对 `Point2D` 实现 `Display`
impl fmt::Display for Point2D {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // 自定义格式，使得仅显示 `x` 和 `y` 的值。
        write!(f, "x: {}, y: {}", self.x, self.y)
    }
}

fn main() {
    let minmax = MinMax(0, 14);

    println!("Compare structures:");
    println!("Display: {}", minmax);
    println!("Debug: {:?}", minmax);

    let big_range =   MinMax(-300, 300);
    let small_range = MinMax(-3, 3);

    println!("The big range is {big} and the small is {small}",
             small = small_range,
             big = big_range);

    let point = Point2D { x: 3.3, y: 7.2 };

    println!("Compare points:");
    println!("Display: {}", point);
    println!("Debug: {:?}", point);

    // 报错。`Debug` 和 `Display` 都被实现了，但 `{:b}` 需要 `fmt::Binary`
    // 得到实现。这语句不能运行。
    // println!("What does Point2D look like in binary: {:b}?", point);
}

程序运行的结果如下所示：

fmt::Display 被实现了，而 fmt::Binary 没有，因此 fmt::Binary 不能使用。 std::fmt 有很多这样的 trait，它们都要求有各自的实现。这些内容将在 后面的 std::fmt 章节中详细介绍。

动手试一试

检验上面例子的输出，然后在示例程序中，仿照 Point2D 结构体增加一个复数结构体。使用一样的方式打印，输出结果要求是这个样子：

Display: 3.3 + 7.2i
Debug: Complex { real: 3.3, imag: 7.2 }

测试实例：List

对一个结构体实现 fmt::Display，其中的元素需要一个接一个地处理到，这可能会很麻烦。问题在于每个 write! 都要生成一个 fmt::Result。正确的实现需要处理所有的 Result。Rust 专门为解决这个问题提供了 ? 操作符。

在 write! 上使用 ? 会像是这样：

// 对 `write!` 进行尝试（try），观察是否出错。若发生错误，返回相应的错误。
// 否则（没有出错）继续执行后面的语句。
write!(f, "{}", value)?;

另外，你也可以使用 try! 宏，它和 ? 是一样的。这种写法比较罗嗦，故不再推荐， 但在老一些的 Rust 代码中仍会看到。使用 try! 看起来像这样：

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

有了 ?，对一个 Vec 实现 fmt::Display 就很简单了。新建 vector.rs 文件，编写代码如下：

use std::fmt; // 导入 `fmt` 模块。

// 定义一个包含单个 `Vec` 的结构体 `List`。
struct List(Vec<i32>);

impl fmt::Display for List {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // 使用元组的下标获取值，并创建一个 `vec` 的引用。
        let vec = &self.0;

        write!(f, "[")?;

        // 使用 `v` 对 `vec` 进行迭代，并用 `count` 记录迭代次数。
        for (count, v) in vec.iter().enumerate() {
            // 对每个元素（第一个元素除外）加上逗号。
            // 使用 `?` 或 `try!` 来返回错误。
            if count != 0 { write!(f, ", ")?; }
            write!(f, "{}", v)?;
        }

        // 加上配对中括号，并返回一个 fmt::Result 值。
        write!(f, "]")
    }
}

fn main() {
    let v = List(vec![1, 2, 3]);
    println!("{}", v);
}

程序运行的结果如下：

动手试一试：

更改程序使 vector 里面每个元素的下标也能够打印出来。新的结果如下：

[0: 1, 1: 2, 2: 3]

格式化

我们已经看到，格式化的方式是通过格式字符串来指定的：

• format!("{}", foo) -> "3735928559"
• format!("0x{:X}", foo) -> "0xDEADBEEF"
• format!("0o{:o}", foo) -> "0o33653337357"

根据使用的参数类型是 X、o 还是未指定，同样的变量（foo）能够格式化成不同的形式。

这个格式化的功能是通过 trait 实现的，每种参数类型都对应一种 trait。最常见的格式化 trait 就是 Display，它可以处理参数类型为未指定的情况，比如 {}。

新建 format2.rs 文件，编写代码如下：

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

struct City {
    name: &'static str,
    // 纬度
    lat: f32,
    // 经度
    lon: f32,
}

impl Display for City {
    // `f` 是一个缓冲区（buffer），此方法必须将格式化后的字符串写入其中
    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!` 和 `format!` 类似，但它会将格式化后的字符串写入
        // 一个缓冲区（即第一个参数f）中。
        write!(f, "{}: {:.3}°{} {:.3}°{}",
               self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
    }
}

#[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() {
        // 在添加了针对 fmt::Display 的实现后，请改用 {} 检验效果。
        println!("{:?}", *color)
    }
}

程序运行的结果如下：

在 fmt::fmt 文档中可以查看格式化 traits 一览表和它们的参数类型。

动手试一试

为上面的 Color 结构体实现 fmt::Display，应得到如下的输出结果：

RGB (128, 255, 90) 0x80FF5A
RGB (0, 3, 254) 0x0003FE
RGB (0, 0, 0) 0x000000

如果感到疑惑，可看下面两条提示：

• 你可能需要多次列出每个颜色，
• 你可以使用 :02 补零使位数为 2 位。

实验总结

本节实验中我们学习了以下的内容：

• 课程介绍
• 如何编写第一个程序
• Hello World 程序详解
• 注释
• 格式化输出

---

还想继续学习的小伙伴，点击 《通过例子学 Rust》, 免费学！