Rust语言关键字

• let
• mut
• fn
• const
• if
• else

变量和常量

变量和常量的区别

不允许改变值的变量，可能会使你想起另一个大部分编程语言都有的概念：常量（constants）。类似于不可变变量，常量是绑定到一个名称的不允许改变的值，不过常量与变量还是有一些区别。
首先，不允许对常量使用 mut。常量不光默认不能变，它总是不能变。
声明常量使用 const 关键字而不是 let，并且 必须 注明值的类型。在下一部分，“数据类型” 中会介绍类型和类型注解，现在无需关心这些细节，记住总是标注类型即可。
常量可以在任何作用域中声明，包括全局作用域，这在一个值需要被很多部分的代码用到时很有用。
最后一个区别是，常量只能被设置为常量表达式，而不能是函数调用的结果，或任何其他只能在运行时计算出的值。

隐藏

我们可以定义一个与之前变量同名的新变量，而新变量会 隐藏 之前的变量。Rustacean 们称之为第一个变量被第二个 隐藏 了，这意味着使用这个变量时会看到第二个值。可以用相同变量名称来隐藏一个变量，以及重复使用 let 关键字来多次隐藏
隐藏与将变量标记为 mut 是有区别的。当不小心尝试对变量重新赋值时，如果没有使用 let 关键字，就会导致编译时错误。通过使用 let，我们可以用这个值进行一些计算，不过计算完之后变量仍然是不变的。
mut 与隐藏的另一个区别是，当再次使用 let 时，实际上创建了一个新变量，我们可以改变值的类型，但复用这个名字。

数据类型

标量（scalar）类型代表一个单独的值。Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。

整型

Rust 中的整型字面值

整型溢出

比方说有一个 u8 ，它可以存放从零到 255 的值。那么当你将其修改为 256 时会发生什么呢？这被称为 “整型溢出”（“integer overflow” ），关于这一行为 Rust 有一些有趣的规则。当在 debug 模式编译时，Rust 检查这类问题并使程序 panic，这个术语被 Rust 用来表明程序因错误而退出。第九章 “panic! 与不可恢复的错误” 部分会详细介绍 panic。

在 release 构建中，Rust 不检测溢出，相反会进行一种被称为二进制补码包装（two’s complement wrapping）的操作。简而言之，256 变成 0，257 变成 1，依此类推。依赖整型溢出被认为是一种错误，即便可能出现这种行为。如果你确实需要这种行为，标准库中有一个类型显式提供此功能，Wrapping。

浮点型

Rust 也有两个原生的 浮点数（floating-point numbers）类型，它们是带小数点的数字。Rust 的浮点数类型是 f32 和 f64，分别占 32 位和 64 位。默认类型是 f64，因为在现代 CPU 中，它与 f32 速度几乎一样，不过精度更高。

数值运算

#![allow(unused)]
fn main() {
    // 加法
    let sum = 5 + 10;

    // 减法
    let difference = 95.5 - 4.3;

    // 乘法
    let product = 4 * 30;

    // 除法
    let quotient = 56.7 / 32.2;

    // 取余
    let remainder = 43 % 5;
}

布尔型

true / false

字符类型

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
}

复合类型（Compound types）可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple）和数组（array）。

元组类型

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

#![allow(unused)]
// tup 变量绑定到整个元组上，因为元组是一个单独的复合元素。
// 为了从元组中获取单个值，可以使用模式匹配（pattern matching）来解构（destructure）元组值
fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}
// 程序首先创建了一个元组并绑定到 tup 变量上。接着使用了 let 和一个模式将 tup 分成了三个不同的变量，x、y 和 z。
// 这叫做 解构（destructuring），因为它将一个元组拆成了三个部分。最后，程序打印出了 y 的值，也就是 6.4。

#![allow(unused)]
// 除了使用模式匹配解构外，也可以使用点号（.）后跟值的索引来直接访问它们。
fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

数组类型

另一个包含多个值的方式是 数组（array）。与元组不同，数组中的每个元素的类型必须相同。Rust 中的数组与一些其他语言中的数组不同，因为 Rust 中的数组是固定长度的：一旦声明，它们的长度不能增长或缩小。

当你想要在栈（stack）而不是在堆（heap）上为数据分配空间（第四章将讨论栈与堆的更多内容），或者是想要确保总是有固定数量的元素时，数组非常有用。但是数组并不如 vector 类型灵活。vector 类型是标准库提供的一个 允许 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，你可能应该使用 vector。

#![allow(unused)]
fn main() {
    let a = [1, 2, 3, 4, 5];
    let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    let a = [3; 5]; // 变量名为 a 的数组将包含 5 个元素，这些元素的值最初都将被设置为 3。
    // 这种写法与 let a = [3, 3, 3, 3, 3]; 效果相同，但更简洁。
    // 数组是一整块分配在栈上的内存。可以使用索引来访问数组的元素
    let first = a[0];
    let second = a[1];
}

函数

函数遍布于 Rust 代码中。你已经见过语言中最重要的函数之一：main 函数，它是很多程序的入口点。你也见过 fn 关键字，它用来声明新函数。

Rust 代码中的函数和变量名使用 snake case 规范风格。在 snake case 中，所有字母都是小写并使用下划线分隔单词。

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

    another_function();
}

fn another_function() {
    println!("Another function.");
}

函数参数

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

在函数签名中，必须 声明每个参数的类型。这是 Rust 设计中一个经过慎重考虑的决定：要求在函数定义中提供类型注解，意味着编译器不需要你在代码的其他地方注明类型来指出你的意图。

fn main() {
    another_function(5, 6);
}
// 当一个函数有多个参数时，使用逗号分隔
fn another_function(x: i32, y: i32) {
    println!("The value of x is: {}", x);
    println!("The value of y is: {}", y);
}

fn main() {
    let x = 5;

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

    println!("The value of y is: {}, x is {}", y, x);
}

具有返回值的函数

fn five() -> i32 {
    5
}

fn six() -> i32 {
    return 6;
}

fn main() {
    let x = five();

    println!("The value of x is: {}", x);
    let x = six();

    println!("The value of x is: {}", x);
}

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

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    println!("The value of x is: {}", x);
    let y = x + 2;
    println!("The value of y is: {}", y);
    x + 1
}

注释

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

    // 行内注释是这样吧
    println!("The value of x is: {}", x); // 或者这样
}
/**
 * 文档注释是这样吧
 */
fn plus_one(x: i32) -> i32 {
    println!("The value of x is: {}", x);
    let y = x + 2;
    println!("The value of y is: {}", y);
    x + 1
}

控制流

if 表达式

/**
 * 所有的 if 表达式都以 if 关键字开头，其后跟一个条件。
 * 在这个例子中，条件检查变量 number 的值是否小于 5。
 * 在条件为真时希望执行的代码块位于紧跟条件之后的大括号中。
 * if 表达式中与条件关联的代码块有时被叫做 arms，
 * 就像 “比较猜测的数字和秘密数字” 部分中讨论到的 match 表达式中的分支一样。
 * 
 * 也可以包含一个可选的 else 表达式来提供一个在条件为假时应当执行的代码块，这里我们就这么做了。
 * 如果不提供 else 表达式并且条件为假时，程序会直接忽略 if 代码块并继续执行下面的代码。
 */
fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

代码中的条件 必须 是 bool 值。如果条件不是 bool 值，我们将得到一个错误。

在 let 语句中使用 if

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

    println!("The value of number is: {}", number);
}

代码块的值是其最后一个表达式的值，而数字本身就是一个表达式。在这个例子中，整个 if 表达式的值取决于哪个代码块被执行。这意味着 if 的每个分支的可能的返回值都必须是相同类型

if 代码块中的表达式返回一个整数，而 else 代码块中的表达式返回一个字符串。这不可行，因为变量必须只有一个类型。Rust 需要在编译时就确切的知道 number 变量的类型，这样它就可以在编译时验证在每处使用的 number 变量的类型是有效的。Rust 并不能够在 number 的类型只能在运行时确定的情况下工作；这样会使编译器变得更复杂而且只能为代码提供更少的保障，因为它不得不记录所有变量的多种可能的类型。

错误示例:

fn main() {
    let condition = true;

    let number = if condition {
        5
    } else {
       "six"
    };

    println!("The value of number is: {}", number);
}

使用循环重复执行

多次执行同一段代码是很常用的，Rust 为此提供了多种 循环（loops）。一个循环执行循环体中的代码直到结尾并紧接着回到开头继续执行。为了实验一下循环，让我们新建一个叫做 loops 的项目。

Rust 有三种循环：loop、while 和 for。我们每一个都试试。

使用loop重复执行代码

loop 关键字告诉 Rust 一遍又一遍地执行一段代码直到你明确要求停止。

fn main() {
    loop {
        println!("again!");
    }
}

使用 break 关键字来告诉程序何时停止循环。

loop 的一个用例是重试可能会失败的操作，比如检查线程是否完成了任务。然而你可能会需要将操作的结果传递给其它的代码。如果将返回值加入你用来停止循环的 break 表达式，它会被停止的循环返回：

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

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

    println!("The result is {}", result);
}

while 条件循环

在程序中计算循环的条件也很常见。当条件为真，执行循环。当条件不再为真，调用 break 停止循环。这个循环类型可以通过组合 loop、if、else 和 break 来实现；如果你喜欢的话，现在就可以在程序中试试。

然而，这个模式太常用了，Rust 为此内置了一个语言结构，它被称为 while 循环。

fn main() {
    let mut number = 3;

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

        number = number - 1;
    }

    println!("LIFTOFF!!!");
}

使用 for 遍历集合

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

    for element in a.iter() {
        println!("the value is: {}", element);
    }
}

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

• 综合例子

fn main() {
    loop {
        println!("请输入工具编号:");
        println!("1: 华氏温度转为摄氏度");
        println!("2: 摄氏度转为华氏温度");
        println!("3: 生成 n 阶斐波那契数列");
        println!("4: 打印圣诞颂歌“The Twelve Days of Christmas” 的歌词");
        println!("0: 退出");
        let tn = loop {
            let mut tn = String::new();
            std::io::stdin().read_line(&mut tn).expect("Failed to read line");
            let tn: usize = match tn.trim().parse() {
                Ok(num) => num,
                Err(_) => {
                    println!("输入错误,请重新输入工具编号:");
                    continue;
                },
            };
            if tn == 0 || tn == 1 || tn == 2 || tn == 3 || tn == 4 {
                break tn;
            }
            println!("输入错误,请重新输入工具编号:");
        };
        println!("你输入了: {}",  tn);
        println!();
        if tn == 0 {
            println!("你选择退出, 下次再见咯 ^_^");
            return;
        }
        let tn = tn - 1;
        let tools_arr = ["华氏温度转为摄氏度", "摄氏度转为华氏温度", "生成 n 阶斐波那契数列", "打印圣诞颂歌“The Twelve Days of Christmas” 的歌词"];
        println!("你选择的工具为: {}", tools_arr[tn]);
        println!();
        if tn == 0 {
            translate_to_c();
        } else if tn == 1 {
            translate_to_h();
        } else if tn == 2 {
            nb();
        } else if tn == 3 {
            pc();
        }
        println!("\n\n");
    }
}
/** 
 * 相互转换摄氏与华氏温度。
 * 1 摄氏度=33.8 华氏度
 * 1 华氏度=-17.2222222 摄氏度
 * */
fn translate_to_c() {
    println!("请输入华氏温度:");
    let h;
    let tn = loop {
        let mut tn = String::new();
        std::io::stdin().read_line(&mut tn).expect("Failed to read line");
        let tn: f32 = match tn.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("输入错误,请重新输入华氏温度:");
                continue;
            },
        };
        h = tn;
        break 5.0 * (tn - 32.0 ) / 9.0;
    };
    println!("{}℉ = {}℃", h, tn);
}
/** 
 * 相互转换摄氏与华氏温度。
 * 1 摄氏度=33.8 华氏度
 * 1 华氏度=-17.2222222 摄氏度
 * */
fn translate_to_h() {
    println!("请输入摄氏温度:");
    let c;
    let tn = loop {
        let mut tn = String::new();
        std::io::stdin().read_line(&mut tn).expect("Failed to read line");
        let tn: f32 = match tn.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("输入错误,请重新输入摄氏温度:");
                continue;
            },
        };
        c = tn;
        break 9.0 * tn / 5.0 + 32.0;
    };
    println!("{}℃ = {}℉", c, tn);
}
/** 打印 n 阶斐波那契数列。*/
fn nb() {
    println!("请输入阶数 n:");
    let n = loop {
        let mut tn = String::new();
        std::io::stdin().read_line(&mut tn).expect("Failed to read line");
        let tn: usize = match tn.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("输入错误,请重新输入阶数 n:");
                continue;
            },
        };
        break tn;
    };
    println!("即将打印{}阶斐波那契数列:", n);
    for elem in 0..n+1 {
        print!("{} ", fbnq(elem));
    }
    println!();
}
/** 生成 n 阶斐波那契数列 */
fn fbnq(n: usize) -> usize {
    if n == 0 || n == 1 {
        return n;
    }
    fbnq(n - 1) + fbnq(n-2)
}
/** 打印圣诞颂歌 “The Twelve Days of Christmas” 的歌词，并利用歌曲中的重复部分（编写循环）。*/
fn pc() {
    // 略
}