这部分我们学习 rust 语言的 变量、数据类型、函数、注释、流程控制 这五个方面的内容。本文我们介绍前两个内容，下一篇文章介绍后三个内容。
变量
默认情况下，rust 语言中声明的变量是不可变的，比如如下代码：
fn main() {
let x = 5;
println!("x 的值是: {}", x);
x = 6;
println!("x 的值是: {}", x);
}我们先来跑一下这段代码：
cargo run
Compiling hello_cargo v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/hello_cargo)
error[E0384]: cannot assign twice to immutable variable `x`
--> src/main.rs:4:5
|
2 | let x = 5;
| -
| |
| first assignment to `x`
| help: make this binding mutable: `mut x`
3 | println!("x 的值是: {}", x);
4 | x = 6;
| ^^^^^ cannot assign twice to immutable variable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0384`.
通过运行结果，我们发现这段代码有问题的，然后我们从报错信息中抓取关键信息：cannot assign twice to immutable variable，它的意思是 不可变变量不能进行二次赋值。但是有些时候，我们也需要修改变量的值，应该怎么办呢，在变量名的前面，let 关键字的后面添加一个关键字 mut 就行了，我们来试试：
fn main() {
let mut x = 5;
println!("x 的值是: {}", x);
x = 6;
println!("x 的值是: {}", x);
}运行一下代码：
cargo run
Compiling hello_cargo v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 3.53s
Running `target/debug/hello_cargo`
x 的值是: 5
x 的值是: 6这种不可变变量的设计有着很多安全方面的考虑，这里不再赘述。谈到这里，很容易联想到编程语言的另一个概念——常量，那二者有什么区别呢？
1.常量不能使用 mut 关键字修饰，常量在任何情况下都是不可变的(变量是在默认情况下不可变)。
2.常量使用 const 关键字来声明，而变量使用 let 关键字来声明。
3.常量需要在常量名后面紧跟冒号和类型，例如 const MAX_POINTS: u32 = 100_000;，而变量可以省略冒号和类型的修饰。
4.常量的作用域是任何作用域，包括全局作用域。
5.常量只能使用常量表达式赋值，而不能使用函数结果或者其它运行时产生的值。
注：这是说明一下，常量通常使用大写字母和下划线 _ 来命名。
我们再来说一个变量的特性——覆盖。在上一篇写猜数字游戏的文章中，我们做数字类型转换的时候，新类型的名字使用了旧类型的名字，这种情况就是覆盖。先来个实例：
fn main() {
let x = 5;
println!("x 的值是: {}", x);
let x = 6;
println!("x 的值是: {}", x);
}我们来看运行结果：
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.36s
Running `target/debug/hello_cargo`
x 的值是: 5
x 的值是: 6通过结果可以发现，第二个使用 let 关键字修饰的不可变变量 x 把第一个 x 覆盖了，也就是说把 x 的值从 5 改成了 6。那这和 mut 有什么区别呢？
1.覆盖的第二个变量需要使用 let 关键字修饰，如果没有 let 关键字，则会报错。
2.覆盖的第二个变量不仅可以改变值，还可以修改变量的类型；而 mut 不可以改变类型。
这里举两个例子来说明第二个区别：
fn main() {
let space = "abc";
println!("space 代表的是：{}", space);
let space = space.len();
println!("space 代表的是：{}", space);
}先来运行第一个例子：
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.22s
Running `target/debug/hello_cargo`
space 代表的是：abc
space 代表的是：3然后看第二个例子：
fn main() {
let mut space = "abc";
println!("space 代表的是：{}", space);
space = space.len();
println!("space 代表的是：{}", space);
}跑一下第二个例子：
cargo run
Compiling hello_cargo v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/hello_cargo)
error[E0308]: mismatched types
--> src/main.rs:4:13
|
4 | space = space.len();
| ^^^^^^^^^^^ expected &str, found usize
|
= note: expected type `&str`
found type `usize`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.
error: could not compile `hello_cargo`.
To learn more, run the command again with --verbose.
可以轻易看到二者的区别，好了，接下来我们看 rust 的基本类型。
数据类型
rust 的数据类型就是在编译期间告诉 rust 的编译器如何处理这些数据。在这里，我们会了解到两种数据类型：基本数据类型和组合数据类型。
基本数据类型
基本数据类型也就是简单值，rust 主要包含了 4 种基本数据类型，分别是整型、浮点型、布尔型和字符型。你可能在其他语言中见过这些类型，现在，我们来看一下它们在 rust 语言中是怎么样的。
整型
整型是不包含小数的数字类型。整型包含了两种类型：i 打头的有符号整型和 u 打头的无符号整型。我们使用一个表格来描述 rust 的整型：
|占用空间 |有符号整型 |无符号整型|
|:--:|:--:|:--:|
|8-bit |i8 |u8
|16-bit |i16 |u16
|32-bit |i32 |u32
|64-bit |i64 |u64
|128-bit |i128 |u128
|格式 |i+长度 |u+长度
整型在使用过程中默认类型是 i32。
浮点型
浮点型包含了两种类型：单精度浮点型 f32，双精度浮点型 f64。浮点型在使用过程中默认类型是 f64。
数据操作
rust 支持的基本数据操作有：加 +，减 -，乘 *，除 /，取模 %。
布尔型
布尔型通常有两个值：true和false。它占用 1 个字节，使用 bool 关键字来声明。
字符型
rust 的字符类型占用 4 个字节，它的值是使用单引号 ' 引起来的。
组合数据类型
组合数据类型是把多个值组合成一个类型。在 rust 中，组合数据类型有两种：元组和数组。
元组
元组是把多个基本类型组合成一个组合类型。它有一个确定的长度，一旦确定就不能再次加减元素了。我们先来看一个元组的实例：
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
println!("第0个值：{}, 第1个值：{}, 第2个值：{}", tup.0, tup.1, tup.2);
let (x, y, z) = tup;
println!("x的值：{}, y的值：{}, z的值：{}", x, y, z);
}它运行的结果是：
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`
第0个值：500, 第1个值：6.4, 第2个值：1
x的值：500, y的值：6.4, z的值：1
元组的取值有两种方式，一种是把元组解构成多个变量，另一种就是使用 . 的方式，顺序是从 0 开始。
数组
数组和元组不一样的地方是：数组只能使用相同的数据类型。数组和元组相同的地方是：长度一旦确定就不能加减元素了。如果想改变数组的长度，可以使用 vector 类型，后续文章会介绍 vector 类型的情况。而且数组还有一个特性，它会把数据分配到栈内存，而不是堆内存。下面举几个常用的数组的例子：
fn main() {
// 定义一个简单的数组
let a = [1, 2, 3, 4, 5];
// 定义一年 12 个月，而且不需要增减月份，那么可以直接定义包含 12 个月份的数组
let months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
// 定义包含 5 个元素的 i32 类型的数组
let a: [i32; 5] = [1, 2, 3, 4, 5];
// 数组的值是 5 个 3
let a = [3; 5];
// 取值
println!("a[3]的值是：{}", a[3]);
println!("a[9]的值是：{}", a[9]); // 编译时这里会报错：error: index out of bounds: the len is 5 but the index is 9
}数组的取值方式是以中括号 [0] 的方式，顺序是从 0 开始。如果取值越界，rust 会在编译期告诉你，这就是 rust 安全原则的第一个例子。
这一节未完，待续~~~
欢迎阅读单鹏飞的学习笔记
