Rust语言学习笔记(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，不可变引用)**

//来自copilot，测试有效
fn main() {
let original_string = “Hello, world!”;
let modified_string = replace_char_at(original_string, 5, ‘X’);
println!(“{}”, modified_string); // prints “HelloX world!”
}
//就是在函数里手动复制这个字符串，并在需要的地方修改
fn replace_char_at(s: &str, idx: usize, c: char) -> String {
let mut result = String::with_capacity(s.len());
for (i, d) in s.char_indices() {//s.char_indices()返回迭代器(index, char)
result.push(if i == idx { c } else { d });
}
result
}

**数组的slice**

let a = [1, 2, 3, 4, 5];
let slice = &a[1…3];

## 结构体


整个结构体都是可变的。  
 没什么特别的，就是当结构体包含引用时，要指明生命周期。还没学到  
 定义：

struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}

例化：

fn main() {
let mut user1 = User {
active: true,
username: String::from(“someusername123”),
email: String::from(“someone@example.com”),
sign_in_count: 1,
};
user1.email = String::from(“anotheremail@example.com”);
}
//通过函数返回一个结构体的实例，以及初始化简写(字段名和值名一样，可以简写，顺序无关)
fn build_user(email: String, username: String) -> User {
User {
active: true,
username,
email,
sign_in_count: 1,
}
}
//用其他实例的值，新建一个实例
let user2 = User {
active: user1.active,
username: user1.username,
email: String::from(“another@example.com”),
sign_in_count: user1.sign_in_count,
};
//用其他实例的值，新建一个实例,简写语法
let user2 = User {
email: String::from(“another@example.com”),
…user1
};

省略元组结构体、没有字段的类单元结构体  
 方法：

#[derive(Debug)] //为了便于调试，一般都会写上
struct Rectangle {
width: u32,
height: u32,
}
//用impl关键字，定义在Rectangle上下文中，
//方法的第一个参数一定是&self，可用来访问结构体定义的字段
//如果想要在方法中改变调用方法的实例，需要将第一个参数改为 &mut self
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
//使用函数
let rec = Rectangle{width:1,height:2};
let area = rec.area();

关联函数  
 self不作为第一参数  
 经常被用作返回一个结构体新实例的构造函数。

//例如square关联函数，它接受一个维度参数并且同时作为宽和高，这样可以更轻松的创建一个正方形 Rectangle
impl Rectangle {
fn square(size: u32) -> Self {
Self {
width: size,
height: size,
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）

4年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

[外链图片转存中…(img-zto1MvQF-1713697294369)]

[外链图片转存中…(img-8pjzGrPI-1713697294370)]

[外链图片转存中…(img-VOlt7RB1-1713697294371)]

[外链图片转存中…(img-lxbx7EcT-1713697294371)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）