Rust 基础语法

变量，基本类型，函数，注释和控制流，这些几乎是每种编程语言都具有的编程概念。

这些基础概念将存在于每个 Rust 程序中，及早学习它们将使你以最快的速度学习 Rust 的使用。

变量

首先必须说明，Rust 是强类型语言，但具有自动判断变量类型的能力。这很容易让人与弱类型语言产生混淆。

如果要声明变量，需要使用 let 关键字。例如：

let a = 123;

只学习过 JavaScript 的开发者对这句话很敏感，只学习过 C 语言的开发者对这句话很不理解。

在这句声明语句之后，以下三行代码都是被禁止的：

a = "abc";
a = 4.56; 
a = 456;

第一行的错误在于当声明 a 是 123 以后，a 就被确定为整型数字，不能把字符串类型的值赋给它。

第二行的错误在于自动转换数字精度有损失，Rust 语言不允许精度有损失的自动数据类型转换。

第三行的错误在于 a 不是个可变变量。

前两种错误很容易理解，但第三个是什么意思？难道 a 不是个变量吗？

这就牵扯到了 Rust 语言为了高并发安全而做的设计：在语言层面尽量少的让变量的值可以改变。所以 a 的值不可变。但这不意味着 a 不是"变量"（英文中的 variable），官方文档称 a 这种变量为"不可变变量"。

如果我们编写的程序的一部分在假设值永远不会改变的情况下运行，而我们代码的另一部分在改变该值，那么代码的第一部分可能就不会按照设计的意图去运转。由于这种原因造成的错误很难在事后找到。这是 Rust 语言设计这种机制的原因。

当然，使变量变得"可变"（mutable）只需一个 mut 关键字。

let mut a = 123;
a = 456;

这个程序是正确的。

常量与不可变变量的区别

既然不可变变量是不可变的，那不就是常量吗？为什么叫变量？

变量和常量还是有区别的。在 Rust 中，以下程序是合法的：

let a = 123;   // 可以编译，但可能有警告，因为该变量没有被使用
let a = 456;

但是如果 a 是常量就不合法：

const a: i32 = 123;
let a = 456;

变量的值可以"重新绑定"，但在"重新绑定"以前不能私自被改变，这样可以确保在每一次"绑定"之后的区域里编译器可以充分的推理程序逻辑。 虽然 Rust 有自动判断类型的功能，但有些情况下声明类型更加方便：

let a: u64 = 123;

这里声明了 a 为无符号 64 位整型变量，如果没有声明类型，a 将自动被判断为有符号 32 位整型变量，这对于 a 的取值范围有很大的影响。

重影（Shadowing）

重影的概念与其他面向对象语言里的"重写"（Override）或"重载"（Overload）是不一样的。重影就是刚才讲述的所谓"重新绑定"，之所以加引号就是为了在没有介绍这个概念的时候代替一下概念。

重影就是指变量的名称可以被重新使用的机制：

实例

fn main() {  
    let x = 5;  
    let x = x + 1;  
    let x = x * 2;  
    println!("The value of x is: {}", x);  
}  

这段程序的运行结果：

The value of x is: 12

重影与可变变量的赋值不是一个概念，重影是指用同一个名字重新代表另一个变量实体，其类型、可变属性和值都可以变化。但可变变量赋值仅能发生值的变化。

let mut s = "123";
s = s.len();

这段程序会出错：不能给字符串变量赋整型值。

总结

1. rust 作为强类型语言，但是也有自动判断类型的能力，所以它的使用有点类似于c++的size_t 或者 auto 。我们使用的关键字是 let。 可以简单记录为 let 走天下。创建变量？ let。更新变量 ？ let。

2. 由此引出第二点，不再是传统的一次创建，任意更改。

   1. 在 rust中，由于为高并发而做的努力，它不再允许随意更改。
   2. 你可以想象在以往高并发中死锁和数据污染导致的令人头大的后果和补救措施，以及我们为此做出的巨大妥协和投入了大量的成本。
   3. 现在，我们将他限制住了。

3. 每次修改变量时，有两种方式：

   1. 使用let关键字每次修改，重新声明。(既是重影)
      1. 这样使用时，编译会告警。
   2. 添加mut 关键字 (mutable)

      let mut zry = 123;
      zry = 432;
      //但是类型修改时还是不行，这是原则问题>_<
      zry = 'zry';
      zry = 123.1;
      

4. 后置的类型强声明

   1. 在rust 中，类型的声明是可以显式限制的，毕竟是强类型嘛。
   2. 在显式声明时， 语法为 变量后 ：类型如：

      let z: i32 = 123;
      let r: u64 = 234;
      

   3. 其意义在于当我们想以更大的空间容纳数据但我又不想使用新的空间时，或者想要预留更大的空间时方便

5. 重影

   1. 在学习Rust 的过程中，你会发现一些很酷的内容，我们在重定义变量这个操作时，不会直白的说，我在这里重定义了，而是说 重影。这个蛮中二的词雀氏让我有种高大冷峻的范。
   2. 那么实际重影做的是什么呢？我们之前说了Rust 并发安全，所以限制随意修改变量值。但我们有两种方式实现修改。第一种就是重影。
   3. 代码实现：

      let z = 1;
      let z = z+1;
      let z = z*2;
      let z = z*z;
      printin!("z is {}",z)；
      

   

6. mut 改变的只能是同类型值