一、Rust 注释的方式

第一种注释方式： //后跟注释内容

第二种注释方式：/*里面为的内容都是注释内容*/

用于文档的注释：

在 Rust 中使用 // 可以使其之后到第一个换行符的内容变成注释。

在这种规则下，三个反斜杠 /// 依然是合法的注释开始。所以 Rust 可以用 /// 作为说明文档注释的开头：

这时候把鼠标放在sum函数上面就会出现优美的函数提示：

注：Cargo 具有 cargo doc 功能，开发者可以通过这个命令将工程中的说明注释转换成 HTML 格式的说明文档：可以在该项目下的target目录下找到doc文件，进入后可看到html文件。

二、Rust 函数

我们在C/C++里都知道一个函数包含：返回值类型、函数名、参数列表和函数体，那么在Rust里面又有什么不一样的地方呢？

1、函数的四大格式

1.1、无参无返

语法：

fn 函数名() {}

其中 Rust 函数名称的命名风格是小写字母以下划线分割，例如：

fn another_function() {
    println!("Hello, runoob!");
}

1.2、无参有返

语法：

fn 函数名() -> 返回值类型 {}

例如：

fn five() -> i32 {
        5
}
//此时输入five()，结果就是5

在此例子中已经显示了 Rust 函数声明返回值类型的方式：在参数声明之后用 -> 来声明函数返回值的类型，而且不用加 return也可以

1.3、有参无返

语法：

fn 函数名(x:类型,y:类型) {}

例如：

fn another_function(x: i32, y: i32) {
    println!("x 的值为 : {}", x);
    println!("y 的值为 : {}", y);

Rust 中定义函数如果需要具备参数必须声明参数名称和类型

1.4、有参有返

语法：

fn 函数名(x:类型,y:类型) ->返回值类型 {}

例如：

fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

在函数体中，随时都可以以 return 关键字结束函数运行并返回一个类型合适的值。

但是 Rust 不支持自动返回值类型判断！ 如果没有明确声明函数返回值的类型，函数将被认为是"纯过程"，不允许产生返回值。

2、函数体的语句和表达式

Rust 函数体由一系列可以以表达式（Expression）结尾的语句（Statement）组成。到目前为止，我们仅见到了没有以表达式结尾的函数，但已经将表达式用作语句的一部分。

语句是执行某些操作且没有返回值的步骤。例如：

let a = 6;

表达式有计算步骤且有返回值。以下是表达式（假设出现的标识符已经被定义）：

a = 7

b + 2

c*(a + b)

Rust 中可以在一个用 {} 包括的块里编写一个较为复杂的表达式：

fn main() {
    let x = 5;
    let y = {
        let x = 3;
        x + 1
    };
    println!("x 的值为 : {}", x);
    println!("y 的值为 : {}", y);
}
//运行结果：x为5，y为4。

很显然，这段程序中包含了一个表达式块，而且在块中可以使用函数语句。

最后一个步骤是表达式，此表达式的结果值是整个表达式块所代表的值。这种表达式块叫做函数体表达式。

注意： x+1 后不能加分号，否则将变为一条语句。

三、Rust 条件语句

先来看代码：

fn main() {
    let num = 3;
    if num < 5{
        println!("条件成立");
    }else{
        println!("条件不成立");
    }
}

由上面代码可看出Rust 里的if语句和C/C++非常相似，唯一的区别就是条件可以不加小括号，同时Rust中也支持else if语句。

但是 Rust 中的 if 不存在单语句不用加 {} 的规则，即不允许使用一个语句代替一个块。

Rust 中的条件表达式必须是 bool 类型，例如下面的程序是错误的：

fn main() {
    let number = 3;
    if number {   // 报错，expected `bool`, found integerrustc(E0308)
        println!("Yes");
    }
}

虽然 C/C++ 语言中的条件表达式用整数表示，非 0 即真，但这个规则在很多注重代码安全性的语言中是被禁止的。

在 Rust 中我们可以使用 if-else 结构实现类似于三元条件运算表达式 (A ? B : C) 的效果：

fn main() {
    let a = 3;
    let number = if a > 0 { 1 } else { -1 };
    println!("number 为 {}", number);
}

注意：两个函数体表达式的类型必须一样！且必须有一个 else 及其后的表达式块。

四、Rust 循环语句

Rust 除了灵活的条件语句以外，循环结构的设计也十分成熟。

1、有关while循环

Rust 里也有while循环语句，与条件语句类似，循环的条件也可以不加小括号。

Rust 里没有do while循环，这是因为do在Rust 语言里规定为保留字，后续版本或许会用到。

在 C 语言中 for 循环使用三元语句控制循环，但是 Rust 中没有这种用法，需要用 while 循环来代替：

let mut i = 0;
while i < 10 {
    // 循环体
    i += 1;
}

2、for 的迭代循环

for 循环是最常用的循环结构，常用来遍历一个线性数据据结构（比如数组）。for 循环遍历数组：

fn main() {
    let arr = [1, 2, 3, 4, 5];
    for i in a.iter() {
        println!("值为 : {}", i);
    }
}

这个程序中的 for 循环完成了对数组 a 的遍历。a.iter() 代表 a 的迭代器（iterator），后面文章详细说明

当然，for 循环其实是可以通过下标来访问数组的：

fn main() {
let arr = [10, 20, 30, 40, 50];
    for i in 0..5 {
        println!("a[{}] = {}", i, a[i]);
    }
}

3、loop 循环

我们在开发过程中会遇到这样一个情况：某个循环无法在开头和结尾判断是否继续进行循环，必须在循环体中间某处控制循环的进行。如果遇到这种情况，我们经常会在一个 while (true) 循环体里实现中途退出循环的操作。

Rust 语言有原生的无限循环结构 —— loop：

fn main() {
    let s = ['W', 'L', 'Q', 'Y'];
    let mut i = 0;
    loop {
        let ch = s[i];
        if ch == 'Q' {
            break;
        }
        println!("\'{}\'", ch);
        i += 1;
    }
}

loop 的巧妙用法：

fn main() {
    let s = ['W', 'L', 'Q', 'Y'];
    let mut i = 0;
    let pos = loop {
        let ch = s[i];
        if ch == 'Q' {
            break i;
        }
        i += 1;
    };
    println!(" \'Q\' 的索引为 {}", pos);
}

loop 循环可以通过 break 关键字类似于 return 一样使整个循环退出并给予外部一个返回值。这是一个十分巧妙的设计，因为 loop 这样的循环常被用来当作查找工具使用，如果找到了某个东西当然要将这个结果交出去。