变量

可变与不可变变量

Rust中使用let来声明变量，但是let声明的是不可变变量，如果想要可变，则需要加上mut关键字

fn main(){let x = 10;x = x + 1; //报错，因为x是不可变类型let mut y = 11;y = y + 1; //可行
}

变量与常量

常量与不可变变量一样都是不能被修改的，但是他与不可变变量有很多区别。

1. 常量用const声明，且必须标注其类型
2. 常量不能加mut修饰
3. 常量可以在任何作用域内声明（包括全局）
4. 常量只可以绑定在常量表达式中，无法绑定在函数的调用结果或者只能在运行时才能计算出的值。
5. 在场许运行期间，长廊在其作用域内一直有效。

常量命名规范：全大写字母+下划线分割（不符合规范rust编译器会警告）

const MAX_POINT = 10000;
fn main(){
}

变量的Shadowing

Rust允许用户在一个作用域内重复的声明一个同名变量，并且可以是不同的类型的，而后声明的变量会覆盖前面声明的变量，这叫做变量的shadowing

fn main(){let x = 100;let x = "Test"; // 此时在对x进行操作，x的值就是"Test"let number = "123123";let number = number.trim().parse(); //转化为数字//上述shadowing就使得通用一个number的变量名，但是却做到了类型转换。
}

标量类型

Rust是一个强类型的静态语言，这意味着在编译时编译器就需要明确的知道每个变量的类型，而不是像Py一样，“变量的类型是动态可变的”。

而上述的代码没有指定类型，只使用了let，是因为Rust的编译器可以自行推断出变量的类型（根据返回值，上下文，调用情况）。而有时情况过于复杂时便无法推断，便需要使用者自行标注出类型。

整数

整数类型如下：

可以看到分类无符号和有符号类型，并且每个类型都标清楚了占多少字节，最后一个isize类型表示的是CPU位数长度的整数类型（一个机器字长），与电脑硬件有关。

如下面代码所示，在变量后面加冒号在家类型就可以强制显示的的表明变量的类型。

fn main(){let x: i8 = 18;let y: u32 = 100;
}

整数字面值如上：
Rust允许在数字之间加下划线用于增加可读性。其中十六进制以0x开头，八进制以0o开头，二进制以0b开头。
而字节类型需要在字符串前加一个b。

Rust允许在数值后面加上类型来标注这个数字的类型

fn main(){let x = 1002u32let y = 10010010i32let z = 0b100100let a = 0xffa0let b = b'B'
}

Rust的int默认值是32，浮点数默认值是64Bytes。如果整数类型发生了溢出，那么程序就会panic，如果在发布模式下编译则不会检查溢出。Rust的溢出会进行环绕操作，即对可取的最大值取余。

布尔类型则是有两个值，一个是true，一个是false占两个字节

fn main(){let x: bool = true;
}

字符类型用来描述语言中最基础的单个字符，占四个字节，使用的值是Unicode表值。

fn main(){let x: char = '你';let u: char = '🙂';
}

复合类型

Rust提供了两种复合类型，一个是Tuple，一种是数组。
Tuple的创建遵循以下规则：

fn main(){let x: (i32, char, f32) = (2003, 'a', 0.3);println!("{} {} {}", x.0, x.1, x.2);
}

对于元组可以使用点+索引的形式来得到元素，元组是定长的，你可以认为它类似于C的struct的简化版。

元组还可以进行拆包，其过程如下：

fn main(){let x: (i32, char, f32) = (2003, 'a', 0.3);let (a, b, c ) = x;
}

另一个数据类型，数组则是定长，且使用[]来进行定义和创建

fn main(){let x: [i32; 5] = [1, 2, 3, 4, 5]; // 创建一个i32类型，长度为5的数组let y = [5; 4];// 创建4个i32类型值为5，长度为4的数组let z = ["xxx", "yyy"]; //创建两个str类型的数组
}

上述需要注意的是let y = [5; 4];这种写法相当于是创建一个重复为5，长度为4的数组

函数

rust的函数的格式为：

fn 函数名(参数: 类型) -> 返回值{函数体;
}

fn main(){let x = test();
}fn test(){println!("Test");
}

上述的test的返回值是()。

fn main(){let _x = test(32);
}fn test(number: i32) -> (){println!("Test number is {}", number);
}

Rust的函数体由Statement和Expression来构成，其中Statement指的是像let x = 10;这类的语句，而Expression则是x + 3, x == 5这样具有返回值的表达式。

Rust默认最后一个表达式即为返回值（或者函数题的值），如果没有则默认值为()

fn main(){let x = test(10);println!("Test number is {}", x);
}fn test(number: i32) -> i32{5 + number //注意，5 + number后面没有分号，否则将会被视为一个语句
}

这个函数体还可以作为变量的值来传递

fn main(){let x = {let mut _y = 11;_y * 3};println!("{}", x)
}

上述x的的值是33，如果函数体最后一个语句没有返回值，则会得到()

控制流

与Rust控制流相关的有loop，while，for in的循环语句和if else，match的判断语句。其中match涉及到枚举不在这里记录，放在枚举那里。

if else

if和else就类似于C语言，当只有一个单独的语句时可以不用最外层的括号

fn main(){let x = 10;if x > 5 {println!("大于5");}else if x == 5 {println!("小于5");}else {println!("小于5");}
}

三元运算符，有点类似于python与C的结合体，例子如下

if 条件 {结果1} else {结果2}

fn main(){let x = if 5 > 3 {5} else {3};println!("x is {}", x);let y = if x != 5 {x * 2}else{x - 3};println!("y is {}", y);
}
/*Compiling hello_world v0.1.0 (E:\RustProject\Hello_World)Finished dev [unoptimized + debuginfo] target(s) in 0.69sRunning `target\debug\hello_world.exe`
x is 5
y is 2
*/

loop & while

loop的用法就是相当于while true，也就是loop内的语句会被不停地循环，直到遇到break为止。
用法如下：

fn main(){let mut x = 0;loop{x += 1;if x > 10{break;}}println!("x is {}", x);
}

而对于while循环则是和C和Py一样，break和continue语句也是同样的道理。

while 条件{}

fn main(){let mut x = 0;while x <= 10 {x += 1;}println!("x is {}", x);
}

for in

for in则是类似于py的for in集合的模式，in后面需要跟一个可以迭代的类型例如数组。
需要注意的是此时tmp是&i32类型，也就是说它的类型是确定的，没法for in一个多种类型的Tuple。

fn main(){let x = [3, 4, 5, 6];for tmp in x.iter(){ //iter方法得到x的迭代器println!("{}", tmp);}
}
/*Compiling hello_world v0.1.0 (E:\RustProject\Hello_World)Finished dev [unoptimized + debuginfo] target(s) in 1.07sRunning `target\debug\hello_world.exe`
3
4
5
6
*/

对于计数之类的需求，Rust提供了Range的方法，可以使用a…b来构造一个a+1,a+2…, b-2, b-1的序列来进行遍历，如下：

fn main(){for x in 3..10{println!("{}", x);}
}
/*Compiling hello_world v0.1.0 (E:\RustProject\Hello_World)Finished dev [unoptimized + debuginfo] target(s) in 1.03sRunning `target\debug\hello_world.exe`
3
4
5
6
7
8
9
*/

struct

struct的定义

Rust的struct定义如下：

struct 名称{
变量1: 类型,
变量2: 类型…
}

struct Rectangle{width: u32,length: u32
}

而struct的初始化则是使用名字+变量名:值的形式初始化，注意，struct不允许有字段为空值，也就是说需要全部值都初始化

    let re = Rectangle{width: 10,length: 19};

而这些值的访问就类似于C的struct，直接用点+对应的字段即可。

struct也可以设置为mut，而对于struct来说，一旦设置为mut，则里面每个值都必须要是mut，也就是说都是可变的。

    let mut re = Rectangle{width: 10,length: 19};re.width = 100;

当有变量名与struct内部定义的变量名同名时，可以省去冒号进行初始化

struct Rectangle{width: u32,length: u32
}fn main(){let width = 9;let mut re = Rectangle{width, // 省去了冒号，因为width同名length: 19};
}

当想要对struct进行更新时，有一种简单的简写操作，如下：

    let width = 9;let mut re = Rectangle{width, length: 19};let re2 = Rectangle{width: 100,..re //re表示，剩下的字段的值与re的剩余字段的值相同};

Tuple Struct

struct的方法与函数

对于一个struct，它拥有对应的方法和函数，而对于方法则是应用于struct的上下文中的，可以获取和修改具体的struct的值。而函数则不能，他只是与某种struct关联到了一起而已。
使用impel关键字来为struct绑定方法和函数。

第一个参数带有self关键字就是方法，而不带有则是函数

struct Rectancle{width: u32,length: u32,
}impl Rectancle {//为Rectangle绑定函数和方法fn area(&self) -> u32{//绑定一个方法&self表示Rectangle结构体本身self.width * self.length //返回面积}
}fn main(){let y = Rectancle{width: 10,length: 15};println!("Area is {}", y.area());
}

下面是绑定一个函数例子

struct Rectancle{width: u32,length: u32,
}impl Rectancle {fn area(&self) -> u32{self.width * self.length}fn make_square(size: u32) -> Rectancle { //构造一个正方形Rectancle { width: (size), length: (size) }}
}fn main(){let sq = Rectancle:: make_square(10);//通过使用::的方式来调用函数println!("Area is {}", sq.area());
}

需要注意，每个struct允许拥有多个impel的模块。