一.变量类型

Rust语言中的基础数据类型有以下几种：

1.整数型

整数型简称整型，按照比特位的长度和有无符号位可以分为以下几种

isize和usize两种整数类型是用来衡量数据大小的，它们的位长度取决于所运行的目标平台，如果是32位架构的处理器将使用32位位长度整型。

整型变量默认使用i32.

2.浮点数型

Rust和其他语言一样支持32位浮点数（f32）和64位浮点数（f64）

64位浮点数的精度更高，因为它有64个比特位可以表示数据

因为现代计算机处理器对两种浮点数计算的速度几乎相同，默认情况下计算机会使用六十四位浮点数。

fu main()
{
  let x=2.0;//f64
  let y:f32=3.0;//f32
}

3.其他类型

其他类型

此外，布尔型用bool表示；字符型用char表示。

复合类型

元组是用一对小括号()包括的一组数据，可以包含不同种类的数据。

        let tup:(i32,f64,u8,bool,char)=(500,6.4,1,true,'a');
        // tup.0 即500
        // tup.1 即6.4
        // tup.2 即1
        //以此类推即可

我们可以这样来使用元组

    let (x, y, z) = tup;
    println!("{} {} {}",x,y,z);

数组

在Rust中，我们依旧是用[]来表示数组，不过我们不需要规定其长度。

    let a=[1,2,3,4,5];//a是一个长度为5的整型数组
    let b=["asd","saddf"];//b是一个长度为2的字符串数组
    //数组的访问
    let c=a[0];
    let d=b[6];

总结：由于Rust语言如此表示类型，因此它是一种强类型语言。 

二.变量

必须声明的一点是，Rust是一门具有自动判断变量类型能力的强类型语言，它并不是一个弱类型语言。

2.1不可变变量

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

let a=123;

 在声明了a变量之后，以下三行代码是被禁止的。

    let a=3;
    a='a';//不可行，字符不可赋值给整型
    a=4.56;//不可行，有精度缺失
    a=456;//不可行，a是个不可变变量。

前两个错误是很容易理解的，但是第三个错误很难理解，为什么a是一个不可变的变量？

这就牵扯到了Rust语言为了高并发安全而做的设计：

在语言层面尽量少的让变量可以改变，所以a的值不可变。

但这并不意味着a不是“变量”，官方文档中将其称为不可变变量。

那么，为什么Rust语言设置这种机制呢？

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

2.2可变变量

那么，如何让变量可变呢？

这里，我们可以使用mut关键字。

    let mut a = 122; //被mut修饰的变量变得可变
    a = 456;
    println!("我是a,我的值是{}", a);

  

三.常量与不可变变量的区别

大家学习到了这里一定很奇怪常量和不可变变量的区别。

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

变量和常量还是有区别的。在Rust中，他们的区别在于以下：

        let a = 123;   // 可以编译，但可能有警告，因为第一次定义的a变量没有被使用。
        let a = 456;   //这是一个新的a变量

但是，如果是常量的话，就无法通过编译。

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

 心细的人可能发现了一个问题，为什么我们可以取同名变量呢？

这是因为Rust允许在同一个作用域内对同名变量进行重定义，具体地说，这一个特性被称为变量屏蔽。变量屏蔽允许你用同一个作用域内使用相同的变量名来声明新的变量，而之前的变量会无效。

fn main() {
    let a = 123;   // 声明变量a并赋值为123
    println!("第一次a的值：{}", a);  // 使用变量a

    let a = 456;   // 再次声明变量a并赋值为456，遮蔽了之前的变量a
    println!("第二次a的值：{}", a);  // 使用新的变量a
}

四.重影

重影就是刚才讲述的所谓"变量屏蔽"，现在我们详细的解释一下这个东西。

重影和可变变量的赋值是两个概念

重影是指用同一个名字重新表示另一个变量实体，其类型、可变属性和值都可以变化。

而赋值只能改变值。

fn main() {
    //重影的概念-->重影即刚刚说的变量屏蔽。
    let x = 5;
    let x = x + 1; //结合性左->右;先使用上一行代码中定义的x，之后将计算后的值赋值给新的x
    let x = x * 2; //同理，先x*2;之后再赋值给最新的x
    println!("The value of x is:{}", x);
    //需要注意的是，重影和可变变量的赋值不是一个概念
    //重影是同一个名字重新代表另一个变量实体，其类型、可变属性、值都可以发生变化。
    //赋值只能改变值
}

打印结果如下： 

下面我们来看一下地址：

  fn main（）
  {
    //重影：变量的名称一样，但地址不一样。
    //重影的变量是多个不同的变量实体。
    let a=1;
    println!("第一个 'a' 的地址: {:p}", &a);
    let a=2;
    println!("第二个 'a' 的地址: {:p}", &a);
  }

 

五.常量

最后我们再来介绍一下常量

Rust 是一种静态类型的语言，这意味着变量的类型在编译时必须明确。虽然编译器在很多情况下能够推断出变量的类型，但对于常量来说，类型必须显式地指定，因为常量的值在编译时必须是已知的，而编译器无法像对待普通变量那样推断出其类型。

如果不指定类型，而且编译器无法推断出类型信息的话，编译器将会报错，指出缺少类型信息。

const a = 123; // 错误：缺少类型注解

 下面我们看一段可以推断出类型信息的代码

const A: i32 = 10; // 显式指定类型为 i32
const B = 20;      // 没有显式指定类型，但编译器可以推断为 i32
fn main() {
    let x = A + B; // 这里 x 的类型会被推断为 i32，因为 A 和 B 都是 i32
    println!("x = {}", x);
}

 但是，如果这段代码是这样子的，则无法通过编译

const B = 3; // error:没有类型注解，而且没有用到。无法推断类型

fn main() {
    // 这里没有用到常量 B
}

 关于常量的最后一个点是关于重影的。

     //常量不会被屏蔽，第二次再定义a不会屏蔽第一次定义的a
    const a:i32=123;
    let a=3;//error
    const a:i32=456;//error