Rust权威指南之通用编程概念
一. 变量与可变性
1.1. 变量与常量
在Rust中的变量默认是不可变的。但是如果使用mut关键字可以让变量可变。下面先看一个不可变的例子：
fn main() {
let x = 5;
println!("The value of x is: {}", x);
x = 10; // ERROR
println!("The value of x is: {}", x);
}
此时是无法通过编译的，执行cargo run会报错：
error[E0384]: cannot assign twice to immutable variable `x`
--> src/main.rs:4:5
|
2 | let x = 5;
| -
| |
| first assignment to `x`
| help: consider making this binding mutable: `mut x`
3 | println!("The value of x is: {}", x);
4 | x = 10;
| ^^^^^^ cannot assign twice to immutable variable // 不能给不可变变量赋值两次
For more information about this error, try `rustc --explain E0384`.
error: could not compile `rust-example` due to previous error
Rust的编译器给了非常详细的错误提示：不能给不可变变量赋值两次。Rust的编译器能够保证那些声明为不可变的值一定不会发生改变。
接着看一下mut的使用：
fn main() {
let mut x = 5;
println!("The value of x is: {}", x);
x = 10;
println!("The value of x is: {}", x);
}
此时在执行cargo run就不会报错了！
Finished dev [unoptimized + debuginfo] target(s) in 0.04s
Running `target/debug/rust-example`
The value of x is: 5
The value of x is: 10
正是因为mut出现了变量绑定的过程中，所有我们可以合法的将x的值从5改到10。
在变量的可变和不可变可能会让你联想到另一个常见的编程概念：常量。例子：
const MIN_VALUE: i32 = 0; // Rust中预订俗成的使用下划线分隔全大写字母来命名一个常量
fn main() {
const MAX_VALUE: i32 = 10;
}
常量默认是不可变的；在申明的时候必须显示标明数据类型；常量可以被声明在任何的作用域中，甚至是全局作用域。
1.2. 隐藏
在上一篇文章中，有将String变量转为i32的操作，是用同名变量覆盖旧的变量。
let mut guess = String::new();
io::stdin().read_line(&mut guess).expect("读取失败");
let guess: i32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue
};
在Rust中，我们把这一现象描述为：第一个变量被第二个变量隐藏了。这意味着我们随后使用这个名称时，它指向的将会是第二个变量。这里我们也可以重复使用let关键字并配以相同的名称来不断的隐藏变量
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("The value if x is: {}", x);
}
执行编译运行：cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `target/debug/rust-example`
The value if x is: 12
这里需要注意隐藏机制和mut的区别：
- 声明变量为mut，不使用let会编译错误。通过let我们可以对这个值执行一系列的变换操作，并允许这个变量在操作完成后保持自己的不变性。
- 由于重复使用let关键字会创建出新的变量，所以我们可以复用变量名称的同时改变他的类型。
let x = "hello world";
let x = x.len();
println!("The value if x is: {}", x); // 11
如果使用mut会报错：
let mut x = "hello world";
// let x = x.len(); // OK
x = x.len(); // ERROR
二. 数据类型
Rust中每一个值都有其特定的数据类型，Rust会根据数据类型来决定应该如何处理它们。Rust是一门静态语言，这意味着它在编译程序的过程中需要知道所有变量的具体类型。在大部分情况下，编译器都可以根据我们如何绑定、使用变量的值来自动推导出变量的类型。但是有些时候还是需要我们显示的标注类型：
let guess1: u32 = "42".parse().expect("Not a number"); // OK
let guess2 = "42".parse().expect("Not a number"); // ERROR
此时guess2是错误如下:
error[E0282]: type annotations needed
--> src/main.rs:3:9
|
3 | let guess2 = "42".parse().expect("Not a number");
| ^^^^^^
|
help: consider giving `guess2` an explicit type
|
3 | let guess2: _ = "42".parse().expect("Not a number");
| +++
For more information about this error, try `rustc --explain E0282`.
error: could not compile `rust-example` due to previous error
这段信息表明当前的编译器无法自动推导出变量的类型，为了避免混淆，它需要我们手动添加类型标注。
2.1. 标量类型
标量类型是单个值类型的统称。Rust中内置了4种基础的标量类型：整数、浮点数、布尔值和字符。
2.1.1. 整数类型
整数是指那些没有小数部分的数字。每个长度不同的值都存在有符号和无符号两种变体。
| 长度 | 有符号 | 无符号 |
|---|---|---|
| 8bit | i8 | u8 |
| 16bit | i16 | u16 |
| 32bit | i32 | u32 |
| 64bit | i64 | u64 |
| arch | isize | usize |
有符号和无符号代表了一个整数类型是否拥有描述负数的能力。上面的isize/usize两个特殊的整数类型，它们的长度取决于程序运行的目标平台，在64位架构的它们是64位的，而在32位架构上的，它们就是32位的。
下面看一下整数字面量。注意：除了Byte，其余所有字面量都可以使用类型后缀，例如：57u8，代表一个使用了u8类型的整数57，同时也可以使用下划线作为分隔符以方便读数。
| 整数字面量 | 示例 |
|---|---|
| Decimal | 98_222 |
| Hex | 0xff |
| Octal | 0o77 |
| Binary | 0b1111_000 |
| Byte(u8 only) | b'A' |
这里需要注意一点就是整数溢出的问题，Rust在Debug模式下整数溢出会panic，但是在release模式下如果发生整数溢出发生时执行二进制补码环绕。简单来说，任何超出类型的最大值的数值会被环绕为类型最小值，例如u8的256会变成0，257会变成1。此时程序虽然不会panic，但是计算结果就会让人很奇怪了。
2.1.2. 浮点数类型
除了整数，Rust还提供了两种基础的浮点数类型，浮点数就是带小数的数字。这种类型是f32(单精度浮点数)/f64(双精度浮点数).它们分别占用了32位/64位空间。由于在现代CPU中f64与f32的运行效率相差无几，却拥有更高的精度，所有在Rust中，默认会将浮点数字面量的类型推到为f64。
let b = 5.6; // f64
所有的数值类型，Rust都支持常见的数学运算：加、减、乘、除、取余。
2.1.3. 布尔类型
Rust的布尔和其他编程语言一样，布尔类型只支持两个可能的值：true/false，它占据耽搁字节的空间大小。
let b = false;
布尔类型最主要的用途是在if表达式内作为条件使用。
2.1.4. 字符类型
在Rust中，char类型被用于描述语言中最基础的单个字符。char类型使用单引号指定，而不同于字符串使用双引号指定。
let a = 'a';
let b = '*';
Rust的char占用4个字节。是一个Unicode标量值，这也意味着它可以比ASCII多得多的字符内容。
2.2. 复合类型
复合类型可以将多个不同类型的值组合为一个类型。Rust提供了两种内置的基础复合类型：元组和数组。
2.2.1. 复合类型
元组是一种相当常见的复合类型，他可以将其他不同类型的多个值组合进一个复合类型中。元组还拥有一个固定的长度：你无法在声明结束后增加或减少其中的元素数量。
let tup: (i32, bool, f32) = (500, true, 6.5);
元组支持使用模式匹配来解构元组：
let tup: (i32, bool, f32) = (500, true, 6.5);
let (x, y, z) = tup; // 解构
println!("x: {}, y: {}, z: {}", x, y, z); // x: 500, y: true, z: 6.5
除了解构，我们还可以通过索引访问并使用点号（.）来访问元组的值。元组的索引从0开始。
let tup: (i32, bool, f32) = (500, true, 6.5);
println!("x: {}, y: {}, z: {}", tup.0, tup.1, tup.2); // x: 500, y: true, z: 6.5
2.2.2. 数组类型
数组可以存储多个值的集合。于元组不一样，数组中每一个元素类型都必须相同。Rust中的数组拥有固定的长度，一旦声明就再也不能随意改变大小。
let a = [1, 2, 3, 4, 5];
let a: [i32, 5] = [1, 2, 3, 4, 5] // i32后面的5表示当前数组包含5个元素
let a = [3; 5] // 这种写法等价于 a = [3, 3, 3, 3, 3]
和这种固定大小的数组不同Rust标准库还提供了一种更加灵活的动态数组（vector）类型。动态数组是一种类似于数组的集合类型，但是它允许用户自己调整数组的大小。
数组由一整块分配在栈上的内存组成，你可以通过索引来访问一个数组中所有元素：
let a = [1, 2, 3, 4, 5];
let first = a[0];
let last = a[4];
println!("first: {}, last: {}", first, last);
如果访问数组位置越界，虽然并不会报错，但是运行时会panic。
let last = a[5];
此时运行会报错：
error: this operation will panic at runtime
--> src/main.rs:4:16
|
4 | let last = a[5];
| ^^^^ index out of bounds: the length is 5 but the index is 5
|
= note: `#[deny(unconditional_panic)]` on by default
error: could not compile `rust-example` due to previous error
三. 函数
函数在Rust中有广泛应用。你应该已经见过Rust最重要的main函数了。Rust代码使用蛇形命名法（只用小写的字母命名，并以下划线分隔单词）来作为规范函数和变量名称的风格。
fn main() {
println!("hello world");
another_function();
}
fn another_function() {
println!("Another function");
}
编译执行：
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `target/debug/rust-example`
hello world
Another function
3.1. 函数参数
在函数声明中定义参数，它们是一个特殊的变量，并被称作为函数签名的一部分。当函数存在参数时，你需要在调用函数时为这些变量提供具体的值。
fn main() {
println!("hello world");
another_function(3);
}
fn another_function(x: i32) {
for i in 0..x {
println!("Another function => {}", i);
}
}
编译执行：
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `target/debug/rust-example`
hello world
Another function => 0
Another function => 1
Another function => 2
3.2. 函数体中语句与表达式
函数体由若干个语句组成，并可以以一个表达式作为结尾。Rust是一门基于表达式的语言，所以它将语句和表达式区别为两个概念。
- 语句：是指那些执行操作但不返回的指令。
- 表达式：是指绘进行计算并产生一个值作为结果的指令。
看下面的例子：
let x = (let y = 6); // ERROR
由于let y = 6没有任何返回值，所以变量x就没有可以绑定的东西。在看另一个例子：
let y = { // @1
let x = 3;
x + 1 // @2
};
这里@1是一个代码块。并且最后y=4。这里的@2是没有分号的，所以@2这段加上分号，代码变成了语句而不会返回任何值。
3.3. 函数的返回值
函数可以向调用它的代码返回值。例子：
fn main() {
println!("hello world");
let result = another_function(3);
println!("result = {}", result); // reuslt = 13
}
fn another_function(x: i32) -> i32 {
x + 10 // 这里需要注意下 x + 10; 为什么不对的原因
}
编译执行：
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `target/debug/rust-example`
hello world
result = 13
四. 注释
代码注释和平常其他语句注释一样，例子：
fn main() {
// 注释 println!("hello world");
let result = another_function(3);
println!("result = {}", result); // 注释 result = 13
}
五. 控制流
5.1. if表达式
先看一下最常用的使用方式， 条件表达式必须产生一个bool类型的值。
fn main() {
let number = 3;
if number < 5 { // 这里是没有()的
println!("condition was true");
} else {
println!("condition was false");
}
}
接着看一下else if多重条件判断，这种情况match更好用。
fn main() {
let number = 3;
if number % 4 == 0 {
println!("number is divisible by 4");
} else if number % 3 == 0 {
println!("number is divisible by 3");
} else if number % 2 == 0 {
println!("number is divisible by 2");
} else {
println!("number is not divisible by 4, 3 or 2");
}
}
在Rust中let可以和if搭配使用，例子：
fn main() {
let condition = true;
let number = if condition { 5 } else { 6 }; // 看着很方便的样子
println!("number = {}", number);
}
5.2. 循环语句
Rust提供了3种循环：loop、while和for，下面挨个看一下使用方式
5.2.1. loop循环
loop关键字就是一直执行某一块代码，直到显示的声明退出为止。例子：
fn main() {
let mut total = 0;
let result = loop {
total += 1;
if total == 10 {
break total * 2
}
};
println!("result = {}", result);
}
5.2.2. while循环
while循环是一种常见的循环，每次循环都会判断一次条件，条件true继续执行代码片段，条件为false或碰到break就退出当前循环。
fn main() {
let mut total = 0;
while total < 10 {
total += 1;
};
println!("result = {}", total); // result = 10
}
5.2.3. for循环
for循环和其他语言一样，下面看一个简答的遍历数组：
fn main() {
let a = [10, 20, 30, 40, 50];
// 方法一：
for item in a {
println!("{}", item)
}
// 方法二：
for item in a.iter() {
println!("{}", item)
}
// 方法三：
for index in 0..a.len() {
println!("{}", a[index])
}
}
下一章见！
转载自:https://juejin.cn/post/7164333973051539469