Rust学习入门（2）：Rust通用的编程概念

文章目录

通用的编程概念
- 变量与可变性
- 数据类型
- - 标量类型
  - 复合类型
  - 函数和注释
  - 控制流（if else）
  - 控制流（循环）
参考链接

通用的编程概念

变量与可变性

声明变量使用let关键字，默认情况下，变量是不可变的

声明变量时，在变量前面加上mut，就可以使变量可变

常量：常量在绑定值以后也是不可变的，但与不可变变量有区别

不允许对常量使用 mut，常量永远不能变。
声明常量使用 const 关键字而不是 let，并且必须注明值的类型。
常量可以在任何作用域中声明，包括全局作用域，这在一个值需要被很多部分的代码用到时很有用。
常量只能被设置为常量表达式，而不可以是其他任何只能在运行时计算出的值或函数的调用结果。

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

命名规范：Rust里常量使用全大写字母，每个单词用之间下划线隔开

隐藏（shadowing）

可以使用相同的名字声明新的变量，新的变量就会shadow（隐藏）之前声明的同名变量

let x = 5;
x = 6;//报错let x = 5;
let x = 6;//不报错 隐藏

使用let声明的同名变量，类型可以与之前不同

数据类型

Rust是静态编译语言，在编译时必须知道所有变量的类型

基于使用的值，编译器通常能推断出它的具体类型
如果可能类型较多，就必须添加类型标注，否则编译会报错（eg：parse方法）

标量类型

一个标量类型代表一个单个的值

整数类型

无符号整数类型以u开头，有符号整数类型以i开头
eg：u8，u16…u128；i8，i16…i128；
isize和usize类型：位数由程序运行的计算机架构决定（在64位计算机上运行就是64位）

整数字面值：

除Byte类型外，所有数值字面值都允许使用类型后缀（如57u8）
可以使用Rust默认类型，整数默认类型是i32
可以使用下划线方便阅读

Number literals	Example
Decimal	92_222
Hex	0xff
Octal	0o77
Binary	0b1111_0000
Byte(u8 only)	b’A’

整数溢出
- 调试模式下编译，Rust会检查整数溢出，发生溢出时，程序会在运行时panic
- 发布模式下（–release）编译：Rust不会检查可能导致panic的整数溢出，如果发生溢出，就执行环绕操作，但程序不会panic（如u8范围的256变成0，257变成1）

浮点类型
- f32，32位，单精度
- f64，64位，双精度
- 浮点数默认类型是f64
布尔类型
- true和false
- 一个字节大小
- 符号是bool
字符类型
- char类型
- 字面值使用单引号
- 占用4字节大小
- 是Unicode标量值，可以表示：拼音、中日韩文、零长度空白字符、emoji表情等

复合类型

复合类型可以将多个值组合成一个类型。

Rust 有两个原生的复合类型：元组（tuple）和数组（array）。

Tuple

Tuple可以将多个类型的多个值放在一个类型里

Tuple的长度是固定的：一旦声明就无法改变

创建Tuple

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

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

fn main() {let tup: (i32, f64, u8) = (500, 6.4, 1);
}

获取Tuple的元素值

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

fn main() {let tup = (500, 6.4, 1);let (x, y, z) = tup;println!("The value of y is: {y}");
}

访问Tuple的元素

使用点标记法，后接元素的索引号

fn main() {let x: (i32, f64, u8) = (500, 6.4, 1);let five_hundred = x.0;let six_point_four = x.1;let one = x.2;
}

数组

数组中的每个元素的类型必须相同

Rust中的数组长度是固定的

创建数组

在中括号里，将值用逗号分开

fn main() {let a = [1, 2, 3, 4, 5];
}

数组的用处

当你想要在栈（stack）而不是在堆（heap）上为数据分配空间，或者是想要确保总是有固定数量的元素时，数组非常有用。

数组并不如vector类型灵活。

vector类型是标准库提供的一个长度可以改变的类似数组的集合类型。

当不确定是应该使用数组还是vector的时候，那么很可能应该使用vector。

然而，当你确定元素个数不会改变时，数组会更有用。

数组的类型

表示形式：[类型;长度]

let a: [i32; 5] = [1, 2, 3, 4, 5];

如果数组中每个元素都相同，可以通过在方括号中指定初始值+分号+元素个数的方式来创建一个每个元素都为相同值的数组

let a = [3; 5];     //相当于let a = [3,3,3,3,3];

访问数组的元素

数组是栈(stack)上分配的已知固定大小的单个内存块

可以使用索引来访问数组的元素

fn main() {let a = [1, 2, 3, 4, 5];let first = a[0];let second = a[1];
}

如果访问的索引超出了数组的范围

编译会通过 //简单错误编译也不会通过
运行会报错（runtime时会panic）

let months = ["1","2","3","4","5"];//1
let index = 15;
let month = months[index];//报错//2
let index = [12,13,14,15];
let month = months[index[1]];//不报错

函数和注释

函数

声明函数使用fn关键字
针对函数和变量名，Rust使用snake case命名规范（即所有字母都是小写，单词之间使用下划线分开）

fn main() {println!("Hello, world!");another_function();
}fn another_function() {println!("Another function.");
}

Rust 不关心函数定义所在的位置，只要函数被调用时出现在调用之处可见的作用域内就行。

函数的参数

parameters形参，arguments实参

在函数签名里，必须声明每个参数的类型，省去编译器推断

fn main() {another_function(5);
}fn another_function(x: i32) {println!("The value of x is: {x}");
}

函数体中的语句与表达式

函数体由一系列语句组成，可选的由一个表达式结束

Rust是一个基于表达式的语言

语句是执行一些动作的指令

表达式会计算产生一个值

函数定义也是语句

语句不返回值，所以不可以使用let将一个语句赋给一个变量

fn main() {//这是一个代码块，它的值是4，这个值作为let语句的一部分绑定给ylet y = {let x = 3;x + 1       //注意表达式的结尾没有分号//如果写成x + 1;那么就变成了一个语句，返回一个空（没有返回值）就是错误的};println!("The value of y is: {y}");
}

函数的返回值

要在箭头->后声明返回值的类型，但并不对返回值命名

在 Rust 中，函数的返回值等同于函数体最后一个表达式的值

使用 return 关键字和指定值，可从函数中提前返回；但大部分函数隐式的返回最后的表达式

fn main() {let x = plus_one(5);println!("The value of x is: {x}");
}fn plus_one(x: i32) -> i32 {x + 1      //注意不加分号//加分号就变成了语句
}

注释

//行注释
/* */段注释
文档注释（之后说）

控制流（if else）

if表达式

if的条件必须是bool类型

表达式中与条件相关联的代码块就叫做分支（arm）

if后可以跟else表达式（可选）

如果使用多于一个else if，推荐使用match重构代码

fn main() {let number = 3;if number < 5 {println!("condition was true");} else {println!("condition was false");}
}

如果if后不是bool类型就会报错

fn main() {let number = 3;//报错if number {println!("number was three");}
}

在let语句中使用if

if是一个表达式，所以可以放在let语句中等号的右边

fn main() {let condition = true;//number返回5let number = if condition { 5 } else { 6 };println!("The value of number is: {number}");
}

fn main() {let condition = true;//if else中可能返回结果的分支返回类型必须一致，否则number类型无法确定//这也体现了rust是安全的语言let number = if condition { 5 } else { "six" };println!("The value of number is: {number}");
}

控制流（循环）

loop循环

loop关键字告诉Rust反复的执行一块代码，直到你喊停

fn main() {loop {println!("again!");}
}

喊停：
1.CTRL+C
2.break

while条件循环

每次执行循环体之前都判断一次条件

fn main() {let mut number = 3;while number != 0 {println!("{number}!");number -= 1;}println!("LIFTOFF!!!");
}

for循环遍历集合

可以针对集合中的每个元素来执行一些代码

由于for循环的安全性、简洁性，所以它在Rust里用的最多

//对一个集合的每个元素执行一些代码
//iter（iterator即迭代器，返回遍历内容）
//element表示遍历里的元素（这里是&i32类型，相当于是指针）
fn main() {let a = [10, 20, 30, 40, 50];for element in a.iter {println!("the value is: {element}");}
}

//(1..4)就是range，表示从1到4进行遍历，不包含4
//.rev表示反转
fn main() {for number in (1..4).rev() {println!("{number}!");}println!("LIFTOFF!!!");
}

Range是由标准库所提供，指定一个开始数字和结束数字，range可以生成它们之间的数字（不含结束）

rev方法可以反转Range

参考链接

Rust编程语言入门教程（Rust语言/Rust权威指南配套）【已完结】_哔哩哔哩_bilibili
Rust程序设计语言简体中文