Rust学习Day2: 变量与可变性、数据类型和函数和控制流
变量与可变性
定义永恒不变的值
定义： let
rust
let x = 5不可被赋值:
rust
let x = 5;
x = 6;
// 运行会报错定义可变的变量
定义: let mut
rust
let mut y = 10;可以被赋值修改:
rust
let mut y = 10;
y = 11;
// 输出
println!("y: {y}"); // 输出 11常量
语法: const xxx
定义说明: 可以在任何作用域中(包括全局)，一般定义是用全英文大写加下划线来定义，还需要类型
作用域示例:
rust
// 全局
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
fn main(){
println!("Three hours in seconds is: {}", THREE_HOURS_IN_SECONDS);
}
rust
// 局部
fn main(){
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
println!("Three hours in seconds is: {}", THREE_HOURS_IN_SECONDS);
}上面两种写法，都可以正常输出
遮蔽
示例：
rust
fn main(){
// 遮蔽
let j = 10;
let j = j + 5; // 遮蔽了之前的 j
{
let j = j * 2; // 遮蔽了外层的 j
println!("The value of j in the inner scope is: {}", j); // 输出 30
}
println!("The value of j in the outer scope is: {}", j); // 输出 15
}遮蔽可以改变类型:
rust
fn main(){
let spaces = " "; // 字符串类型
let spaces = spaces.len(); // 转为数字类型了
println!("spaces: {}", spaces) // 输出数字 3
}定义是mut不可改变类型:
rust
fn main(){
let mut spaces = " "; // 字符串
spaces = spaces.len();
// 运行会报错
}数据类型
基础使用：
rust
let guess: u32 = "42".parse().expect("Not a number!"); // 里面的u32 就是数据类型 数字标量类型
整形
rust中的整形：
| 长度 | 有符号 | 无符号 |
|---|---|---|
| 8-bit | i8 | u8 |
| 16-bit | i16 | u16 |
| 32-bit | i32 | u32 |
| 64-bit | i64 | u64 |
| 128-bit | i128 | u128 |
| 架构相关 | isize | usize |
有符号与无符号说明：
- 有符号：通俗理解就是 数字前面有正负号
- 无符号：就是前面没有正负号
长度说明：
例：如 长度为8-bit，则有符号对应的范围为 -(2的n-1次方) 到2的n-1次方-1内的数字，无符号则只有0后面的
架构相关说明： isize 和usize类型依赖运行程序的计算机架构。64位则是64位，32则是32；
其他说明： rust的默认整形类型是i32。isize或usize主要作为某些集合的索引。
浮点型：
说明： 分为f32和f64,所有浮点型都是有符号的
示例:
rust
fn main(){
// 浮点型
let fx = 2.10; // 默认是 f64
let fy: f32 = 3.10; // 显式指定为 f32
println!("The value of fx is: {}", fx);
println!("The value of fy is: {}", fy);
}其他说明： 默认浮点类型是f64; f32是单精度浮点数，f64是双精度;
数值运算：
rust的所有类型支持基本的加、减、乘、除和取余：
rust
// 示例
fn main(){
let sum = 5 + 10; // 加法
let difference = 95.5 - 4.3; // 减法
let product = 4 * 30; // 乘法
let quotient = 56.7 / 32.2; // 除法
let truncated = -5 / 3; // 整数除法，结果向零截断
let remainder = 43 % 5; // 取模
println!("The 加法 is: {}", sum); // 15
println!("The difference is: {}", difference); // 91.2
println!("The product is: {}", product); // 120
println!("The quotient is: {}", quotient); // ≈1.7608...
println!("The truncated division is: {}", truncated); // -1
println!("The remainder is: {}", remainder); // 3
}布尔类型：
布尔类型有两个选项：true和false
rust
fn main(){
// 布尔类型
let t = true;
let f: bool = false; // 显式指定类型
println!("The value of t is: {}", t); // true
println!("The value of f is: {}", f); // false
}字符串类型：
rust
fn main(){
let c = 'z'; // 字符类型，使用单引号
let z = 'ℤ'; // Unicode 字符
let heart_eyed_cat = '😻'; // Emoji 也是字符
println!("The value of c is: {}", c);
println!("The value of z is: {}", z);
println!("The value of heart_eyed_cat is: {}", heart_eyed_cat);
}其他说明：
char: 最原始的字母类型，可以用单引号声明，可以直接生命emoji
字符串: 可以用双引号生命
复合类型
定义： 复合类型可以将多个值最合成一个类型。RUST有两个原生的复合类型：元组(tuple)和数组(array)
元组类型
定义： 元组是一个将多个不同类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小
示例：组合成的tup可以理解为一个元组类型
rust
fn main(){
let tup: (i32, f64, u8) = (500, 6.4, 1);
}示例：获取值需要解构
rust
fn main(){
let tup: (i32, f64, u8) = (500, 6.4, 1); // 定义一个元组
let (x, y, z) = tup; // 解构元组
println!("The value of x is: {}", x); // 500
println!("The value of y is: {}", y); // 6.4
println!("The value of z is: {}", z); // 1
}示例：元组类型也可以直接通过.索引来获取
rust
fn main(){
let tup: (i32, f64, u8) = (500, 6.4, 1); // 定义一个元组
println!("The first value of tup is: {}", tup.0); // 500
println!("The second value of tup is: {}", tup.1); // 6.4
println!("The third value of tup is: {}", tup.2); // 1
}数组类型
定义： 与元组不同，数组中的每个元素的类型必须相同且数字长度是固定的；
示例: 基本使用
rust
fn mian(){
let a = [1,2,3,4,5];
}示例：其他常见的定义方式
rust
fn main(){
let a:[i32; 5] = [1, 2, 3, 4, 5]; // 显式指定类型和长度
let c = [3; 5]; // 指定初始化值为3，个数为5
}数组的访问：
示例：有效的访问
rust
fn main(){
let a = [1,2,3,4,5];
// 数组访问
let first = a[0]; // 访问数组的第一个元素
let second = a[1]; // 访问数组的第二个元素
println!("The first element of a is: {}", first); // 1
println!("The second element of a is: {}", second); // 2
// 无效的访问，不可超过索引
let dd = a[5]; // 则会报错
}函数：
说明： 每个rust必须要有 main 函数，作为入口点。 fn关键词用来声明新函数
示例：基本使用
rust
fn main(){
println!("hello");
// 调用函数
another_function(); // 输出 world
}
// 定义函数
fn another_function(){
println!("world");
}参数：
示例：定义多个参数的函数，参数1为数字，参数2为字符
rust
fn main(){
// 调用
print_labeled_measurement(5, 's'); // 输出 The measurement is: 5s
}
// 定义带参数的函数
fn print_labeled_measurement(value: i32, unit_label: char) { // 第一参数为整形，字符类型
println!("The measurement is: {}{}", value, unit_label);
}语句和表达式：
定义：
- 语句：是执行一些操作但不返回值的指令。
- 表达式：计算并产生一个值。
示例：
rust
fn main(){
// 语句：
let t = 6;
// 表达式：
let y = {
let x = 3;
x + 1 // 这里没有分号，所以这是一个表达式，返回值是 4
}; // 大括号，可以表示一个表达式，直接获取 x+1的值
println!("The value of y is: {}", y); // 4
}具有返回值的函数
示例：
rust
// 定义基本的具有返回值的函数
fn five() -> i32 { // 定义一个函数，返回类型为 i32
5 // 这里没有分号，所以这是一个表达式，返回值是
}
fn main() {
let x = five();
println!("The value of x is: {x}"); // x=5
}示例：带表达式的函数
rust
fn main(){
// 带表达式的函数
let six = plus_one(5);
println!("The value of six is: {}", six); // 6
}
// 带表达式的函数
fn plus_one(x: i32) -> i32 {
x + 1 // 这里没有分号，所以这是一个表达式，返回值是 x + 1 有表达式会报错
}控制流
if 表达式：
示例：基本语法
rust
fn main(){
// if 表达式
let number = 6;
if number < 5 {
println!("Condition was true.");
} else {
println!("Condition was false.");
}
// 输出 condition was false 因为6 < 5
}示例：多重表达式 else if
rust
fn main(){
let number = 6;
// if 多重表达式
if number % 4 == 0 {
println!("number is divisible by 4");
} else if number % 3 == 0 {
println!("number is divisible by 3");
} else if number % 2 == 0 {
println!("number is divisible by 2");
} else {
println!("number is not divisible by 4, 3, or 2");
}
}示例：if作为表达式
rust
fn main(){
// if 作为表达式
let condition = true;
let number = if condition { 5 } else { 6 }; // if 是一个表达式，所以它的结果可以赋值给一个变量
println!("The value of number is: {}", number); // 输出： 5
}示例： 作为表达式时，两个选项的类型需要一致，按如下会报错
rust
fn main() {
let condition = true;
let number = if condition { 5 } else { "six" };
println!("The value of number is: {number}");
}循环控制：
rust有三种循环：
loopwhilefor
使用loop重复执行代码
示例：基本使用(这是个死循环，可以ctrl+c 强制停止)
rust
fn main(){
loop {
println!("agin!")
}
}示例：从循环中返回值
rust
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2; // 从循环中返回值
}
};
println!("The result is: {}", result); // 20示例：循环标签：在多个循环直接消除歧义
rust
fn main(){
let mut count = 0;
'counting_up: loop { // 定义一个循环标签
println!("count = {}", count);
let mut remaining = 10;
loop {
println!("remaining = {}", remaining);
if remaining == 9 {
break; // 只退出内层循环
}
if count == 2 {
break 'counting_up; // 退出外层循环
}
remaining -= 1;
}
count += 1;
}
println!("End count = {}", count);
}while循环
示例：
rust
fn main(){
let mut number = 3;
while number != 0 { // 当 number 不等于 0 时继续循环
println!("{}!", number);
number -= 1;
}
println!("LIFTOFF!!!");
}for循环
示例：配合while输出
rust
fn main(){
// for 循环
let a = [10, 20, 30, 40, 50];
let mut index = 0;
while index < 5 {
println!("the value is: {}", a[index]);
index += 1;
}
}示例：输出所有
rust
fn main(){
// for 循环
let a = [10, 20, 30, 40, 50];
for e in a {
println!("value: {e}");
}
}示例：反转 rev
rust
fn main() {
for number in (1..4).rev() {
println!("{number}!");
}
println!("LIFTOFF!!!");
}本人正在参考官方文档学习这门语言，如果有描述错误的，欢迎各位RUST大神指出；
