//访问
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)