变量绑定是指将一些值绑定到一个名字上，这样可以在之后使用他们。Rust 中使用 let 声明一个绑定：
fn main() {
let x = 123;
}可变
绑定默认是不可变的（immutable）。下面的代码将不能编译：
let x = 123;
x = 456;编译器会给出如下错误：
Compiling hello_world v0.1.0 (yourpath/hello_world)
error[E0384]: re-assignment of immutable variable `x`
--> main.rs:3:5
|
2 | let x = 123;
| - first assignment to `x`
3 | x = 456;
| ^^^^^^^ re-assignment of immutable variable如果想使得绑定是可变的，使用 mut:
let mut x = 123;
x = 456;如果你声明了一个可变绑定而又没有改变它，虽然可以编译通过，但编译器还是会给出一些建议和警告：
let mut x = 123;
Compiling hello_world v0.1.0 (yourpath/hello_world)
warning: unused variable: `x`, #[warn(unused_variables)] on by default
--> main.rs:2:9
|
2 | let mut x = 123;
| ^^^^^
warning: variable does not need to be mutable, #[warn(unused_mut)] on by default
--> main.rs:2:9
|
2 | let mut x = 123;
| ^^^^^
Finished debug [unoptimized + debuginfo] target(s) in 0.63 secs这正是 Rust 出于安全的目的。
初始化绑定
Rust 变量绑定有另一个不同于其他语言的方面：绑定要求在可以使用它之前必须初始化。
例如以下代码：
fn main() {
let x: i32;
println!("Hello world!");
}Rust 会警告我们从未使用过这个变量绑定，但是因为我们从未用过它，无害不罚。
Compiling hello_world v0.1.0 (yourpath/hello_world)
warning: unused variable: `x`, #[warn(unused_variables)] on by default
--> main.rs:2:9
|
2 | let x: i32;
| ^
Finished debug [unoptimized + debuginfo] target(s) in 0.29 secs然而，如果确实想使用 x， 事情就不一样了。修改代码：
fn main() {
let x: i32;
println!("The value of x is: {}", x);
}这是无法通过编译的：
Compiling hello_world v0.1.0 (yourpath/hello_world)
error[E0381]: use of possibly uninitialized variable: `x`
--> main.rs:3:39
|
3 | println!("The value of x is: {}", x);
| ^ use of possibly uninitialized `x`
<std macros>:2:27: 2:58 note: in this expansion of format_args!
<std macros>:3:1: 3:54 note: in this expansion of print! (defined in <std macros>)
main.rs:3:5: 3:42 note: in this expansion of println! (defined in <std macros>)
error: aborting due to previous error
error: Could not compile `hello_world`.Rust 不允许我们使用一个未经初始化的绑定。
Mode
在许多语言中，这叫做变量。不过 Rust 的变量绑定有一些不同的巧妙之处。例如 let语句的左侧是一个“模式”，而不仅仅是一个变量。我们也可以这样写：
let (x, y) = (1, 2);在这个语句被计算后，x 将会是1，'y' 将会是2。也许有人会忍不住说：这不类似于 golang 中的多变量绑定嘛。
var x, y = 1, 2事实上不是这样的。(1, 2)这种形式是一个元组,是一个固定大小的有序列表。上面的例子还可以写成以下形式：
let n = (1, "hello");
let (x, y) = n;第一个let将一个元组(1, "hello")绑定到n上，第二个let将元组解构，将元组中的字段绑定到x和y上。
更多模式和元组（Tuple）的特性，将在后续的章节详细介绍。
类型注解
Rust 是一个静态类型语言，意味着我们需要先确定我们需要的类型。事实上，Rust 有一个叫做类型推断的功能，如果它能确认这是什么类型，就不需要明确指定类型。当然也可以显示的标注类型, 类型写在一个冒号':'后面：
let x: i32 = 123;对于数值类型，也可以这样：
let x = 123i32; // let x: i32 = 123
let y = 123_i32; // let y: i32 = 123
let z = 100_000i32; // let z: i32 = 100000
