这部分我们学习 rust 语言的 变量、数据类型、函数、注释、流程控制 这五个方面的内容。前文介绍了前两个内容，本文介绍后三个内容。

函数

函数在 rust 代码普遍存在，我们也已经见过了它的主函数 main 函数了，它是进入程序的入口。我们也见过了 fn 关键字了，它是用来声明函数的。


特别说明一下：rust 语言的函数和变量都是以小写字母和下划线命名的，如果以其它方式命名，你会收到一个警告。

函数说明

函数是以 fn 关键字打头，然后是函数名字和小括号，最后的大括号是用来告诉编译器函数体的开始和结束。我们也可以通过函数名字和小括号来调用我们定义的函数，定义的函数可以在主函数前面，也可以在主函数后面。rust 不关心定义的位置，只要你在某个地方定义了它。我们来看个简单的例子吧：

fn main() {
    println!("Hello, world!");

    another_function();
}

fn another_function() {
    println!("另一个函数");
}

运行结果：

cargo run                                          
   Compiling hello_cargo v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.57s
     Running `target/debug/hello_cargo`
Hello, world!
另一个函数

函数参数

函数也可以附带一些参数，函数和参数共同构成函数声明。当我们调用函数的时候，也需要把函数需要的参数传给它。我们直接看个例子吧：

fn main() {
    another_function(5, 6);
}

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

运行的结果是：

cargo run
   Compiling hello_cargo v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.23s
     Running `target/debug/hello_cargo`
The value of x is: 5
The value of y is: 6

例子传了两个参数，5 传给了 x，6 传给了 y。

函数体可以包含语句和表达式

函数体是由一系列语句的集合，并以表达式结束组合而成的。我们还没有使用过表达式结尾的函数，但是我们即将看到表达式作为函数体语句的一部分。因为 rust 是一种基于表达式的语言，这对于理解 rust 语言是很重要的，其他语言没有这样的设计，接下来我们来看一下这是一种什么样的设计。

我们在之前章节也使用过语句和表达式。语句是一些操作的集合而不返回值，表达式是用来返回结果的。在其他语言中，我们可以把代码写成 x = y = 6，使得 x 和 y 都为 6，但是在 rust 语言中不允许这样。

表达式返回值是 rust 语言特有的风格：

• 一些简单的数学算式，比如 5 + 6 就是一个返回 11 的表达式。
• 表达式也是语句的一部分，比如 6 是语句 let y = 6 中的返回值为 6 的表达式。
• 函数调用也是一种表达式。
• 宏指令调用也是一种表达式。
• 使用 {} 创建的新作用域也是一种表达式。

直接上代码来看一下这一条说明吧：

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!("y 的值是: {}", y);
}

在这里，很容易看到的一个表达式是：

    {
        let x = 3;
        x + 1
    };

因为这块在 {} 创建的新作用域中，它返回的值是 4，而 4 这个值赋给 let 语句的变量 y 中。特别说明：x + 1 结尾不带分号，因为表达式不能带有分号，如果添加了分号，则会自动转成语句，就不会返回 4 这个值了，这一点要牢记。

函数返回值

函数可以给调用它的代码返回函数计算结果。我们不需要给返回值命名，但是需要在符号 -> 后面声明返回值的类型。在 rust 中，函数返回值就是函数体结尾的表达式。当然我们也可以使用 return 关键字来返回值，但是大部分函数都是以最后的表达式作为返回值的。我们直接看例子吧：

fn main() {
    let x = plus_one(5);

    println!("x 的值是: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

这里的 let x = plus_one(5) 就相当于 let x = 6。我们定义了函数 plus_one，它的返回值类型是 i32，返回的值是 x + 1，这里不能加分号。

注释

所有的程序员都力求他们写的程序可以很容易地被其他人理解，所以会在程序中写一些说明。这些笔记、说明会被编译器忽略，但是对于阅读源码的人是相当有用的。


在 rust 中，注释是以两个斜线开头，直到行结束为止。

流程控制

在大部分程序语言中，是否运行这部分代码取决于条件语句是否为真，是否持续运行这部分代码取决于条件是否持续为真。这部分我们来学习 rust 的判断和循环两种控制流程。

判断

判断语句根据条件来判断执行哪个分支的代码。

if

所有的判断表达式都是使用 if 打头，然后紧跟条件表达式。我们直接来看例：

fn main() {
    let number = 3;

    if number < 5 {
        println!("条件为真");
    } else {
        println!("条件为假");
    }
}

如果变量 number 比 5 小，就打印 条件为真，否则就打印 条件为假。在 if 这里也可以考虑一下 match 关键字。再说一下 else 表达式，主要是提供一个条件为假时的代码，如果不提供 else 表达式，程序会直接跳过 if 表达式。

tips：if 后面的表达式必须是 bool 类型的，这点和 ruby、javascript语言是不同的。

else if

我们也可以使用 if、else if、else 结合起来写多条件判断的代码，直接看个例子：

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("能被 4 整除");
    } else if number % 3 == 0 {
        println!("能被 3 整除");
    } else if number % 2 == 0 {
        println!("能被 2 整除");
    } else {
        println!("不能被 2, 3, 4 整除");
    }
}

如果使用了太多的 else if 表达式会使代码显得很乱，可以考虑 match 关键字来代替，后文再介绍这个内容。

使用 let 接收 if 的值

因为 if 是个表达式，可以使用 let 语句来接收 if 表达式返回的值。内容比较简单，直接看代码：

fn main() {
    let condition = true;
    let number = if condition {
        5
    } else {
        6
    };

    println!("结果是: {}", number);
}

运行的结果是：

cargo run
   Compiling hello_cargo v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.23s
     Running `target/debug/hello_cargo`
结果是: 5

if 和 else 返回值的类型必须是相同的。

循环

关于循环，rust 提供了几种循环的方法： loop、while、for，我们依次看一下：

loop

loop 关键字是告诉 rust 重复执行后面的代码块，直到代码明确告诉 rust 停止，比如：

fn main() {
    loop {
        println!("重复打印");
    }
}

这里会重复打印 重复打印 这 4 个字，直到我们使用 ctrl-c 结束程序。还可以在循环代码块中使用 break 关键字跳出循环。

使用 let 接收 loop 的值

loop 表达式也可以和 if 表达式一样返回一个值，赋给 let 语句。返回的表达式可以跟在 break 关键字的后面。看个例子：

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("结果是 {}", result);
}

代码的结果是 20，相对比较简单，不说了。

while

如果执行循环前需要进行条件判断，则使用 while 关键字。当条件为真时，执行循环体，循环体中也可以使用 break 关键字来停止。这块直接看个例子：

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);

        number -= 1;
    }

    println!("结束");
}

因为这块内容和其他语言差不多，这里就不讲解了。

for

如果想要遍历数组，则使用 for 关键字。当然也可以使用 while 关键字，先看 while 关键字的例子：

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("值是: {}", a[index]);

        index += 1;
    }
}

会根据索引依次打印数组中的 5 个值，再看 for 关键字的例子：

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("值是: {}", element);
    }
}

这是使用的是迭代器 iter()，当然也可以使用 Range 关键字，如下：

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("结束");
}

rev() 方法是把 1，2，3，4 倒序变量 4，3，2，1。

欢迎阅读单鹏飞的学习笔记