+ [分支 —— match](#__match_155)
+ [循环 —— loop](#__loop_157)
+ [循环 —— while](#__while_201)
+ [循环 —— for](#__for_203)
变量与常量
可变变量与不可变变量
可变变量let mut a = 1;
跟其他语言中的变量一样，可以随便赋值(相同数据类型)
不可变变量let a = 1; 在程序运行过程中不可随便赋值。
特殊的语言机制：隐藏
1.在新作用域内，用let隐藏之前的变量值，退出作用域后，值自动恢复为以前的
fn main() {
let x = 5;
let x = x + 1;
//大括号内是个新的作用域
{
let x = x \* 2; //必须借助let 否则会报错
println!("The value of x in the inner scope is: {x}");
}
//x = 999; 错误，仍然是个不可变变量
println!("The value of x is: {x}"); //x恢复为6
}
输出：
The value of x in the inner scope is: 12
The value of x is: 6
2.隐藏复用变量名，可以改变值的类型；但可变变量不行
//可行
let spaces = " ";
let spaces = spaces.len();
//报错
let mut spaces = " ";
spaces = spaces.len();
个人思考：使用let mut时，就像C一样使用变量；使用let 在加上隐藏机制，就可以像Python一样使用变量
不可变变量出现原因:如果一部分代码假设一个值永远也不会改变，而另一部分代码改变了这个值，第一部分代码就有可能以不可预料的方式运行。
常量
类似 C/C++中#define 宏定义的用法。
全局变量 在声明它的作用域中，在整个程序生命周期都有效。
声明 const PI:f32 = 3.1415
数据类型
标量类型
整型、浮点型、布尔型、字符型 参考
数值运算
除法：/ 除不尽则向0取整；
取余：%
特殊的：
整型的 isize 和 usize 类型依赖运行程序的计算机架构：64 位架构上它们是 64 位的，32 位架构上它们是 32 位的。
布尔型只有true/false，像Python，不像C， C语言标准（C89）没有为布尔值单独设置一个类型，所以在判断真假时，使用整数 0 表示假，所有非0表示真。
字符型：单引号''声明char字面量，双引号 ""声明字符串字面量。有字面量应该就有指针、引用什么的，后面会说到
复合类型
元组
1、元组内，多个值的类型可以不同
2、长度固定，声明后不能变
//声明
let tup = (500, 6.4, 1);
let tup: (i32, f64, u8) = (500, 6.4, 1);
//解构
let (x, y, z) = tup; //x=500,y=6.4,z=1
//访问
let five_hundred = x.0;
数组
1、数组内，多个值类型必须相同，这点与元组不同
2、长度固定，声明后不能变，这点与元组相同
//声明
let a = [1, 2, 3, 4, 5];
let a: [i32; 5] = [1, 2, 3, 4, 5];
let a = [3; 5];
//访问
let first = a[0];
函数
语句与表达式（Rust特有）
语句（Statements）是执行一些操作但不返回值的指令。
函数定义 fn main() { let y = 6; }
变量定义 let y = 6; 不返回值，所以不能x = y = 6，
表达式（Expressions）计算并产生一个值。大部分 Rust 代码是由表达式组成的.
1.数学运算，比如 5 + 6，这是一个表达式并计算出值 11
2.表达式可以是语句的一部分，语句 let y = 6; 中的 6 是一个表达式
3.宏调用是一个表达式。
4.函数调用是一个表达式。(可以把一个函数直接赋值给变量)
5.用大括号创建的一个新的块作用域也是一个表达式(可以把一个大括号直接赋值给变量)
6.if语句也是表达式，具体见下面介绍if的板块
fn main() {
let y = {
let x = 3;
x + 1 //最后是个表达式，不能有分号，否则就变成了语句，导致报错
}; //这里也暗示了，在使用函数返回值的时候，可以直接使用表达式
println!("The value of y is: {y}");
}
参数与返回值
参数没什么很特别的，就是声明时要指明类型，像C。
在 Rust 中，函数的返回值等同于函数体最后一个表达式的值。使用 return加粗样式 关键字和指定值，可从函数中提前返回；但大部分函数隐式的返回最后的表达式。
fn main() {
let x = 5;
let y = 1;
let x = plus\_y(x,y);
println!("The value of x is: {x}");
}
// 看一下参数怎么定义，
// 注意需指明返回值类型，用->符号
fn plus\_y(x: i32, y: i32) -> i32 {
x + y //没有; 是一个表达式，隐式返回
}
控制流
分支 —— if
if是一个表达式，可以用来给变量赋值，注意，if和else分支赋值的类型要一致。
Rust编译时就确切的知道变量类型。
fn main() {
let condition = true;
let number = if condition { 5 } else { 6 };
println!("The value of number is: {number}");
}
基本使用语法，没什么特殊的。像其他语言一样，只会执行第一个条件为 true 的代码块，并且一旦它找到一个以后，甚至都不会检查剩下的条件了。
fn main() {
let number = 6;
if number % 4 == 0 {
println!("number is divisible by 4");
} else if number % 3 == 0 {
println!("number is divisible by 3");
} else {
println!("number is not divisible by 4 or 3");
}
}
分支 —— match
强大的 Rust 分支结构 match 还没学到
循环 —— loop
第一次遇见这个(除了汇编)，还没想明白这么设计的原因
1、基本语义
一直执行，除非遇到break，或者控制台手动Ctrl+C
2、循环返回值
break后面可以跟返回值
这个挺特殊的，有返回值传参，可以发挥一些作用，但我还没想清楚
官方举例说：比如检查线程是否完成了任务。然而你可能会需要将操作的结果传递给其它的代码。
3、循环标签与多重循环
一般来说，最内层循环不用定义标签，(我测试了一下，写上标签也是可以的，但是没啥用)。因为标签的作用是，在最内层循环里，break加上标签来指明跳出外层循环，否则默认是跳出当前循环。
注意标签的定义，'counting_up: loop{}，最前面一个'，且没有闭合，最后有:
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}");
}
//输出是
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2
循环 —— while
一点特殊的都没有，像Python一样用就行
循环 —— for
像Python一样，可以用直接用for遍历集合元素，
要循环指定次数，像下面一样用，也和Python一样属于[a,b),取不到b。
这里的..，可以看作一个符号，不能在中间加个数用来指定步长，语法不允许。
要制定步长可以采用 for i in (0..3).rev().step_by(1)，.rev()是反转，.step_by()是指定步长，步长不能为负值。
fn main() {
for number in (1..4).rev() {//反转range
println!("{number}!");
}
println!("LIFTOFF!!!");
//指定步长
for i in (0..3).step\_by(1){
print!("{}", i);
}
}
所有权(最与众不同的特性)
首先明确3条规则
Rust 中的每一个值都有一个 所有者（owner）。
值在任一时刻有且只有一个所有者。
当所有者（变量）离开作用域，这个值将被丢弃。(个人理解：一个作用域包括用{}括起来的；函数等）
{ // s 在这里无效，它尚未声明
let s = "hello"; // 从此处起，s 是有效的
// 使用 s
} // 此作用域已结束，s 不再有效
变量与内存的交互方式
堆上分配的数据：移动
对于String类型这种在堆上分配的数据，离开作用域后，Rust会自动调用drop()函数释放堆内存。(类似C++自动调用析构函数)
在采用正常的等号赋值时，如下：
let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1);//报错
实际上是将s2指向hello的实际内存位置，没有另外分配内存，此时s1和s2都指向同一位置，而为了保证不出现二次释放的错误，Rust机制使得s1无效，等价于将s1移动到s2。
如果一定要重新分配堆内存的话，需要用到.clone()方法。
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);
栈上分配的数据：克隆
对于在栈上分配的数据(就是整型、浮点型、字符型、布尔型这种内存大小确定的)，因为给变量分配一个内存的开销很小，只是再执行压栈操作，所以不采用像上文String类型那种移动的方式，而是相当于直接克隆的。
在函数中使用：
根据作用域的知识，我们可以知道，存在堆上的数据，如果直接作为参数传入函数，在函数调用时发生作用域切换，在函数返回时，会被drop掉。
而这个参数很有可能在函数返回后还会被用到，我们不希望它被drop。以及我们在函数中创建的一些变量，我们也希望能回到主函数后继续使用。有一个方法，通过return将值传回去，使得可以继续使用，但这样未免太麻烦。因此我们要介绍引用机制。
引用
引用（reference）像一个指针，因为它是一个地址，我们可以由此访问储存于该地址的属于其他变量的数据。 与指针不同，引用确保指向某个特定类型的有效值。指针指向一个实际内存地址，引用只是一个内存单元的别名。(对概念的解释可能不太完整，目前知道怎么用就行了，暂不深究)
对于Rust里的引用，它指向变量，但不拥有所有权，释放引用对变量不产生影响。
创建引用：&s1语法让我们创建一个指向值s1的引用
fn calculate\_length(s: &String) -> usize { // s 是 String 的引用
s.len()
} // 这里，s 离开了作用域。但因为它并不拥有引用值的所有权，
// 所以什么也不会发生
变量 s 有效的作用域与函数参数的作用域一样，不过当 s 停止使用时并不丢弃引用指向的数据，因为 s 并没有所有权。当函数使用引用而不是实际值作为参数，无需返回值来交还所有权，因为就不曾拥有所有权。
可变引用
定义变量和传引用时，都加上mut修饰。
fn main(){
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push\_str(", world");
}
出现了新的限制，
1.不能同时拥有，两个可变引用，以免出现数据竞争，例如用一个引用修改了原变量，但数据没有及时同步到内存中。(参考体系结构缓存一致性问题)
这里同时的意思是：可以使用大括号来创建一个新的作用域，以允许拥有多个可变引用。因为大括号内的引用在退出大括号时会被销毁。
2.不能出现可变引用和不可变引用同时存在，同样是因为缓存一致性问题
3.可以同时有多个不可变引用，不涉及到修改，有几个都没问题
在任意给定时间，要么 只能有一个可变引用，要么只能有多个不可变引用。
引用必须总是有效的。
悬垂指针——如何返回一个在函数内创建的变量？
悬垂指针是其指向的内存可能已经被分配给其它持有者。在编译时会报错。
fn dangle() -> &String { // dangle 返回一个字符串的引用
let s = String::from("hello"); // s 是一个新字符串
&s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
// 危险！返回的引用s 指向的内存被释放了！
//正确使用，直接返回 String
fn no\_dangle() -> String {
let s = String::from("hello");
s
}
slice—切片
slice 是一种引用，所以它没有所有权。
String slice
1.基本使用：返回一个引用，可以是部分的引用，也可以是全部的引用
let s = String::from("hello world");
//部分引用
let hello = &s[0..5];
let world = &s[6..11];
let len = s.len();
//全部引用
let slice = &s[0..len];
let slice = &s[..];
2.从一个例子体会slice是不可变引用&str
返回一个slice 解决index与内容不匹配导致内存问题，本质上因为slice是一个&str，不可变引用，由于引用间的限制，使得内存不会出错。
fn main() {
let mut s = String::from("hello world");
let word = first\_word(&s);
s.clear(); // 错误！
println!("the first word is: {}", word);
}
错误原因：clear 需要清空 String，它尝试获取一个可变引用。
在调用 clear 之后的 println! 使用了 word 中的引用，所以这个不可变的引用在此时必须仍然有效。Rust 不允许 clear 中的可变引用和 word 中的不可变引用同时存在，因此编译失败。
3.写函数签名时，参数用&str，因为String可以轻松转换为&str
当传参要传一个String时，可以用slice传一个&str，这样函数参数就兼容String类型和字符串字面量
fn main() {
let my_string = String::from("hello world");
// `first\_word` 适用于 `String`（的 slice），部分或全部
let word = first\_word(&my_string[0..6]);
let word = first\_word(&my_string[..]);
// `first\_word` 也适用于 `String` 的引用，
// 这等价于整个 `String` 的 slice
let word = first\_word(&my_string);
let my_string_literal = "hello world";
// `first\_word` 适用于字符串字面值，部分或全部
let word = first\_word(&my_string_literal[0..6]);
let word = first\_word(&my_string_literal[..]);
// 因为字符串字面值已经字符串 slice 了，这也是适用的，无需 slice 语法！
let word = first\_word(my_string_literal);
}
4.要想在函数里修改string,不能用&str
传入&mut String可变引用，类似上文可变引用部分
fn main(){
let mut my_string = String::from("Hello, world!");
my_string = myreplace(&mut my_string);
println!("{my\_string}");
}
//这里之所以有返回值，是因为replace()方法会重新分配一段内存
//如果用push\_str()方法，可以去掉返回值
fn myreplace(s:&mut String) -> String{
s.replace(",",":")
}
字符串字面量本质上是slice
基本数据类型里提到的字符串字面量，就是一个slice，类型&str,它是一个指向二进制程序特定位置的 slice。这也就是为什么字符串字面值是不可变的；因为&str 是一个不可变引用。
怎么在函数里修改字符串字面量(&str，不可变引用)
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
4年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**
[外链图片转存中…(img-56e6i5Gk-1713697329483)]
[外链图片转存中…(img-XvkmhECr-1713697329484)]
[外链图片转存中…(img-Y0wpgCAZ-1713697329484)]
[外链图片转存中…(img-p3jtYaIT-1713697329486)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
1171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
