Rust语法之变量绑定

     事实上每个非‘Hello World’Rust策划那个徐都使用“变量绑定”。看起来如下：

1
2
3
4
1     fn main() {

2         let x = 5;

3     }

4

     
在每个例子前都加上
fn main() {
有点单调乏味，所以以后就省略。如果读者一直跟着学习，请确保编辑
main()
函数，不能省略，否则会出错。

     在很多语言中，这叫做“变量”。但Rust的变量绑定却暗藏玄机。例如，Rust左边的let表达式是一个“模式”，而不仅仅是一个变量名。这意味着可以这么做：

1
2
1     let (x, y) = (1, 2);

2

     这个表达式求值以后，x是1，y是2。模式是非常强大的，独立成一个章节。我先现在还用不到这些特性，往下学习之际，暂且记住这一点。

     Rust是静态类型语言，这意味着，提前指定类型，在编译时进行类型检查。那么第一个例子为什么能编译呢？那是因为Rust有“类型推断”的能力。如果Rust能分析出来某个东西的类型，就不要求开发者实际敲出来。

     不过，如果愿意，也可以加上类型。类型放在冒号（:）后面：

1
2
1     let x: i32 = 5;

2

     
如果我让你大声地对着全班读出来，就是“x是一个32位的绑定，值
为5
”。

     在本例中我们选择将x表现为一个32位无符号整数。Rust有许多不同原生的整型。符号整型以i开头，无符号整型以u开头。可能整型大小为8，16，32，64位。

     在将来我们可能会会将类型注解写在注释中。看起来将会如下例所示：

1
2
3
4
5
1     fn main() {

2         let x = 5; // x: i32

3     }

4

5

1
2
1       注意注解和let语法之间的相似之处。包括这样的注释不是Rust惯用的，但是我们会偶尔使用它们来帮助你理解Rust推断的是什么类型。   

2

     默认情况下，绑定是不可变的。下面的代码将会出现编译错误：

1
2
3
1     let x = 5;

2     x = 10;

3

1
2
1        

2

编译器会报错：

1
2
3
4
1     error: re-assignment of immutable variable `x`

2          x = 10;

3          ^~~~~~~

4

1
2
1        

2

如果想要绑定可以更改，必须使用
mut
：

1
2
3
1     let mut x = 5; // mut x: i32

2     x = 10;

3

     
绑定默认不可变更的不能用一句话说清楚，不过可以从Rust的核心考虑：安全。如果忘记使用
mut
，编译器就会捕捉到，让你知道更改了本不想更改的东西。如果默认绑定可变，编译器就不能告诉你这个问题。如果你确实想要设成可变的，解决办法很简单：加上
mut
。

     尽可能避免使用可变状态还有其他很好的理由，但超出了本指南所述范围。一般而言，通常能够避免使用可变量，因此在Rust中这么做更可取。尽管如此，有时需要使用可变量，因此并不禁止使用。

     再回到变量绑定。Rust变量绑定还有一个区别于其他语言之处：绑定必须用值初始化才能使用。

     让我们试一下。将你的src/main.rs文件改成像下面这样：

1
2
3
4
5
6
7
1     fn main() {

2         let x: i32;

3

4         println!("Hello world!");

5     }

6

7

     你可以在命令行中使用cargo build构建工程。你将会收到一个警告，但是还是会打印出“Hello world!”：

1
2
3
4
5
6
1<pre name="code" class="cpp">        Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world)

2     src/main.rs:2:9: 2:10 warning: unused variable: `x`, #[warn(unused_variable)]

3        on by default

4     src/main.rs:2     let x: i32;

5                                ^

6

          Rust警告我们从未使用的变量绑定，但是因为我们没有使用过，没有危害，没犯错误。然而，如果我们是如使用x，事情将会改变。让我们尝试一下。将你的程序改成下面的样子：

1
2
3
4
5
6
1     fn main() {

2         let x: i32;

3     

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

5     }

6

1
2
1       尝试构建工程。你将会得到一个错误： 

2

1
2
3
4
5
6
7
8
9
10
11
12
1     $ cargo build

2        Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world)

3     src/main.rs:4:39: 4:40 error: use of possibly uninitialized variable: `x`

4     src/main.rs:4     println!("The value of x is: {}", x);

5                                                           ^

6     note: in expansion of format_args!

7     <std macros>:2:23: 2:77 note: expansion site

8     <std macros>:1:1: 3:2 note: in expansion of println!

9     src/main.rs:4:5: 4:42 note: expansion site

10     error: aborting due to previous error

11     Could not compile `hello_world`.

12

1
2
1        

2

Rust不允许使用未经初始化的值。接下来，我们谈谈添加到
println!
的大括号。

     
如果在输出的字符串中包含两个大括号（｛｝），Rust会解释成要求在这个问题插入某种值。
字符串插入
上一个计算机科学术语，意思是“在字符串中间插入”。我们增加了一个逗号，后面紧接着是x，表示想要在大括号的位置插入x的值。如果传递个给函数和宏的参数多于一个，使用逗号来分割它们。

     如果仅使用大括号，Rust会尝试检查值的类型，以有意义的方式显示值。如果想要更详细地指定格式，还有很多选项可供使用。目前，我们仅使用默认设置：输入整型并不复杂。