一、Rust语言的基础语法

1、理解变量与常量

声明变量使用let关键字

默认情况下，声明的变量是不可变的（immutable）

下面是错误示范：

let x = 6;

x = 8;

声明变量时加上mut关键字可使变量可变

正确示范：

let mut x = 6;

x = 8;

常量用const关键字定义

声明时必须标注类型

在程序运行期间，常量在其声明的作用域内一直有效

命名规范：使用大写字母，单词之间用下划线隔开

例如： const MIN_COUNTS:u32=10_000

数值大的时候可以适当添加下划线来增加可读性

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

2、常量与不可变变量的区别

不可变变量和常量有很多区别：

常量永远都是不可变的，不可以使用mut

常量可以在任何作用域内进行声明，包括全局作用域

常量只可以绑定到常量表达式，无法绑定到函数的调用结果或只能在运行时才能计算出的值

变量的值可以"重新绑定"并能更改数据类型，但在"重新绑定"以前不能私自被改变

3、重影（Shadowing）

重影的概念与其他面向对象语言里的"重写"（Override）或"重载"（Overload）是不一样的。重影就是刚才讲述的所谓"重新绑定"

使用相同的名字来声明新的变量名，新的变量就会shadow(隐藏)之前声明的同名变量

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

使用示例：

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

二、基本数据类型

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

1、整数型（Integer）

整数型简称整型，按照比特位长度和有无符号分为一下种类：

位长度 有符号 无符号

8-bit i8 u8

16-bit i16 u16

32-bit i32 u32

64-bit i64 u64

128-bit i128 u128

arch isize usize

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

整型的表述方法有以下几种：

进制 举例

十进制 37_123

十六进制 0xee

八进制 0o76

二进制 0b1111_0000

字节(只能表示u8型) b’A’

有的整数中间存在一个下划线，这种设计可以让人们在输入一个很大的数字时更容易判断数字的值大概是多少。

2、浮点数型（Floating-Point）

Rust 有两种基础的浮点类型，也就是含有小数部分的类型：

f32，32位，单精度

f64，64位，双精度

Rust 的浮点类型使用了IEE-754标准来描述

f64 是默认类型，在现代CPU上f64与f32运行速度差不多，且f64精度更高

3、数学运算

用一段程序反应数学运算，例如：

fn main() {
    let sum = 5 + 10; // 加
    let difference = 95.5 - 4.3; // 减
    let product = 4 * 30; // 乘
    let quotient = 56.7 / 32.2; // 除
    let remainder = 43 % 5; // 求余
}

注意：Rust 不支持 ++ 和 --，因为这两个运算符出现在变量的前后会影响代码可读性，减弱了开发者对变量改变的意识能力。

4、布尔类型

Rust 布尔类型有两个值：ture 和 false

占用一个字节

用 bool表示

例：let t =true;

或：let f :bool = false;

5、字符类型

Rust 中字符类型char用来描述语言中最基础的单个字符

字符类型的字面值使用单引号，占用4个字节大小

是Unicode标量值，这意味着它可以支持中文，日文和韩文字符等非英文字符甚至表情符号

Unicode 值的范围从 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF （包括两端）

一般推荐使用字符串储存 UTF-8 文字（非英文字符尽可能地出现在字符串中）

三、复合数据类型

复合类型可以将多个值放在一个类型里

Rust 提供了两种基础的复合类型：元组（Tuple）和 数组

1、元组

可以将多个类型的多个值放在一个类型里且长度固定

创建Tuple

在小括号里将值用逗号分开

Tuple 中的每个位置都对应一个类型，且各元素的类型不必相同

获取Tuple中的元素值

使用模式匹配来解构一个Tuple 来获取元素值

访问Tuple 中的元素值

在Tuple 变量使用点标记法，后接元素的索引下标

使用示例：

fn main() {
    let tle:(i32,f64,u16) = (500,8.8,666);  // 定义元组
    let (x,y,z) = tle;       // 解构元组获取值
    println!("{},{},{}",x,y,z);             // 通过解构打印元组值
    println!("{},{},{}",tle.0,tle.1,tle.2); // 通过点标记法访问元素
}

2、数组

可以将多个值放在一个类型里，数组里元素类型一致且长度固定，由于在C或者Java里我们对数组比较熟悉，直接来看使用示例：

let a = [1, 2, 3, 4, 5];
// a 是一个长度为 5 的整型数组
let b = ["January", "February", "March"];
// b 是一个长度为 3 的字符串数组
let c: [i32; 5] = [1, 2, 3, 4, 5];
// c 是一个长度为 5 的 i32 数组
let d = [3; 5];
// 等同于 let d = [3, 3, 3, 3, 3];
let first = a[0];
let second = a[1];
// 数组访问
a[0] = 123; // 错误：数组 a 不可变
let mut a = [1, 2, 3];
a[0] = 4; // 正确