├── .gitignore ├── .vscode └── launch.json ├── 03_hello_rust └── hello.rs ├── 04_data_type └── main.rs ├── 05_int └── main.rs ├── 06_float └── main.rs ├── README.md ├── array_15 ├── Cargo.toml └── src │ └── main.rs ├── async_await40 ├── Cargo.toml └── src │ └── main.rs ├── boolandchar07 ├── Cargo.toml └── src │ └── main.rs ├── borrow_17 ├── Cargo.toml └── src │ └── main.rs ├── closure_26 ├── Cargo.toml └── src │ └── main.rs ├── collections_21 ├── Cargo.toml └── src │ └── main.rs ├── condition_11 ├── Cargo.toml └── src │ └── main.rs ├── const_09 ├── Cargo.toml └── src │ └── main.rs ├── enum_20 ├── Cargo.toml └── src │ └── main.rs ├── error_28 ├── Cargo.toml └── src │ └── main.rs ├── file_24 ├── Cargo.toml ├── data2.txt └── src │ └── main.rs ├── function_13 ├── Cargo.toml └── src │ └── main.rs ├── generis_22 ├── Cargo.toml └── src │ └── main.rs ├── io_23 ├── Cargo.toml └── src │ └── main.rs ├── iterator_25 ├── Cargo.toml └── src │ └── main.rs ├── let_35 ├── Cargo.toml └── src │ └── main.rs ├── loop_12 ├── Cargo.toml └── src │ └── main.rs ├── match_34 ├── Cargo.toml └── src │ └── main.rs ├── module_30 ├── Cargo.toml ├── mylib │ ├── Cargo.toml │ └── src │ │ └── lib.rs └── src │ └── main.rs ├── ownership_move_16 ├── Cargo.toml └── src │ └── main.rs ├── slice_18 ├── Cargo.toml └── src │ └── main.rs ├── smart_pointer_29 ├── Cargo.toml └── src │ └── main.rs ├── string_10 ├── Cargo.toml └── src │ └── main.rs ├── struct_19 ├── Cargo.toml └── src │ └── main.rs ├── thread_27 ├── Cargo.toml └── src │ └── main.rs ├── tuple_14 ├── Cargo.toml └── src │ └── main.rs ├── type_convert_33 ├── Cargo.toml └── src │ └── main.rs ├── type_system_32 ├── Cargo.toml └── src │ └── main.rs ├── use_closuer39 ├── Cargo.toml └── src │ └── main.rs ├── variable_define_08 ├── Cargo.toml └── src │ └── main.rs └── variable_define_31 ├── Cargo.toml └── src └── main.rs /.gitignore: -------------------------------------------------------------------------------- 1 | # Generated by Cargo 2 | # will have compiled files and executables 3 | /target/ 4 | 5 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries 6 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html 7 | Cargo.lock 8 | 9 | # These are backup files generated by rustfmt 10 | **/*.rs.bk 11 | 03_hello_rust/hello 12 | rust_basic_edu.code-workspace 13 | 06_float/main 14 | 05_int/main 15 | 04_data_type/main 16 | /bool07/target/ 17 | /.idea/ 18 | /boolandchar07/target/ 19 | /const_09/target/ 20 | /variable_define_08/target/ 21 | /string_10/target/ 22 | /condition_11/target/ 23 | /loop_12/target/ 24 | /function_13/target/ 25 | /tuple_14/target/ 26 | /array_15/target/ 27 | /ownership_move_16/target/ 28 | /borrow_17/target/ 29 | /slice_18/target/ 30 | /struct_19/target/ 31 | /enum_20/target/ 32 | /collections_21/target/ 33 | /generis_22/target/ 34 | /io_23/target/ 35 | /file_24/target/ 36 | /closure_26/target/ 37 | /iterator_25/target/ 38 | /thread_27/target/ 39 | /error_28/target/ 40 | /module_30/target/ 41 | /smart_pointer_29/target/ 42 | /module_30/mylib/target/ 43 | /variable_define_31/target/ 44 | /type_system_32/target/ 45 | /type_convert_33/target/ 46 | /match_34/target/ 47 | /let_35/target/ 48 | /use_closuer39/target/ 49 | /async_await40/target/ 50 | -------------------------------------------------------------------------------- /.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | // 使用 IntelliSense 了解相关属性。 3 | // 悬停以查看现有属性的描述。 4 | // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 5 | "version": "0.2.0", 6 | "configurations": [ 7 | { 8 | "type": "lldb", 9 | "request": "launch", 10 | "name": "Custom launch", 11 | "program": "${workspaceRoot}/demo08/target/debug/demo08", 12 | "cwd": "${workspaceRoot}", 13 | }, 14 | ] 15 | } -------------------------------------------------------------------------------- /03_hello_rust/hello.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello Rust!") 3 | } -------------------------------------------------------------------------------- /04_data_type/main.rs: -------------------------------------------------------------------------------- 1 | fn main () { 2 | // let 变量名=值 let是关键字来声明和定义一个变量 3 | 4 | let food = "清蒸螃蟹"; 5 | let price= 366; 6 | let checked= true; 7 | 8 | println!("food is {}", food); 9 | println!("price is {}", price); 10 | println!("checked is {}", checked); 11 | } -------------------------------------------------------------------------------- /05_int/main.rs: -------------------------------------------------------------------------------- 1 | fn main () { 2 | 3 | //有符号类型signed可以存储正数或负数, 无符号类型 usigned只能存储正数。 4 | //按存储控件来说，划分1字节，2字节，4字节，8字节，16字节， 1字节=8位 5 | let price =100; 6 | let price2:u32=200; 7 | let price3:i32=-300; 8 | let price4:isize=400; 9 | let price5:usize=500; 10 | 11 | println!("price is {}",price); 12 | println!("price2 is {} and price3 is {}",price2,price3); 13 | println!("price4 is {} and price5 is {}",price4,price5); 14 | 15 | // let price6:i32=66.66; 16 | let price7:i8=192; 17 | } -------------------------------------------------------------------------------- /06_float/main.rs: -------------------------------------------------------------------------------- 1 | fn main () { 2 | // let price8:f64=99; 3 | let price9=18.00; 4 | let price10:f32=8.88; 5 | let price11:f64=168.125; 6 | 7 | println!("price9 {}",price9); 8 | println!("price10 {}",price10); 9 | println!("price11 {}",price11); 10 | 11 | let price12=1_000_000; 12 | println!("price12 {}",price12); 13 | 14 | let price13 = 1_000_000.666_123; 15 | println!("price13 {}",price13); 16 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Rust基础教程 2 | 3 | [文字版地址](http://www.go-edu.cn/categories/Rust%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B/) 4 | 5 | #【2022】最新最全Rust编程语言入门教程,视频版如下: 6 | 7 | [为什么要使用Rust语言](https://www.bilibili.com/video/BV16B4y1q7Sq) 8 | 9 | [Rust环境搭建](https://www.bilibili.com/video/BV16B4y1q7Sq?p=2) 10 | 11 | [hello_rust](https://www.bilibili.com/video/BV16B4y1q7Sq?p=3) 12 | 13 | [数据类型](https://www.bilibili.com/video/BV16B4y1q7Sq?p=4) 14 | 15 | [整型](https://www.bilibili.com/video/BV16B4y1q7Sq?p=5) 16 | 17 | [浮点型](https://www.bilibili.com/video/BV16B4y1q7Sq?p=6) 18 | 19 | [布尔和字符](https://www.bilibili.com/video/BV16B4y1q7Sq?p=7) 20 | 21 | [定义变量](https://www.bilibili.com/video/BV16B4y1q7Sq?p=8) 22 | 23 | [常量](https://www.bilibili.com/video/BV16B4y1q7Sq?p=9) 24 | 25 | [字符串](https://www.bilibili.com/video/BV16B4y1q7Sq?p=10) 26 | 27 | [运算符](https://www.bilibili.com/video/BV16B4y1q7Sq?p=11) 28 | 29 | [条件判断](https://www.bilibili.com/video/BV16B4y1q7Sq?p=12) 30 | 31 | [循环](https://www.bilibili.com/video/BV16B4y1q7Sq?p=13) 32 | 33 | [函数](https://www.bilibili.com/video/BV16B4y1q7Sq?p=14) 34 | 35 | [元组](https://www.bilibili.com/video/BV16B4y1q7Sq?p=15) 36 | 37 | [数组](https://www.bilibili.com/video/BV16B4y1q7Sq?p=16) 38 | 39 | [所有权和移动](https://www.bilibili.com/video/BV16B4y1q7Sq?p=17) 40 | 41 | [借用](https://www.bilibili.com/video/BV16B4y1q7Sq?p=18) 42 | 43 | [切片](https://www.bilibili.com/video/BV16B4y1q7Sq?p=19) 44 | 45 | [结构体](https://www.bilibili.com/video/BV16B4y1q7Sq?p=20) 46 | 47 | [枚举](https://www.bilibili.com/video/BV16B4y1q7Sq?p=21) 48 | 49 | [集合](https://www.bilibili.com/video/BV16B4y1q7Sq?p=22) 50 | 51 | [泛型](https://www.bilibili.com/video/BV16B4y1q7Sq?p=23) 52 | 53 | [io](https://www.bilibili.com/video/BV16B4y1q7Sq?p=24) 54 | 55 | [文件操作](https://www.bilibili.com/video/BV16B4y1q7Sq?p=25) 56 | 57 | [迭代器](https://www.bilibili.com/video/BV16B4y1q7Sq?p=26) 58 | 59 | [闭包](https://www.bilibili.com/video/BV16B4y1q7Sq?p=27) 60 | 61 | [多线程](https://www.bilibili.com/video/BV16B4y1q7Sq?p=28) 62 | 63 | [错误处理](https://www.bilibili.com/video/BV16B4y1q7Sq?p=29) 64 | 65 | [智能指针](https://www.bilibili.com/video/BV16B4y1q7Sq?p=30) 66 | 67 | [包管理](https://www.bilibili.com/video/BV16B4y1q7Sq?p=31) 68 | 69 | [模块](https://www.bilibili.com/video/BV16B4y1q7Sq?p=32) 70 | 71 | [变量绑定](https://www.bilibili.com/video/BV16B4y1q7Sq?p=33) 72 | 73 | [类型系统](https://www.bilibili.com/video/BV16B4y1q7Sq?p=34) 74 | 75 | [类型转换](https://www.bilibili.com/video/BV16B4y1q7Sq?p=35) 76 | 77 | [match匹配](https://www.bilibili.com/video/BV16B4y1q7Sq?p=36) 78 | 79 | [if let和while let](https://www.bilibili.com/video/BV16B4y1q7Sq?p=37) 80 | 81 | 82 | -------------------------------------------------------------------------------- /array_15/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "array_15" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /array_15/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | //let 变量名称:[数据类型;数组长度]=[值1,值2,值3,...]; 3 | let arr1:[&str;3]=["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 4 | //let 变量名称=[值1,值2,值3,...]; 5 | let mut arr2=["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 6 | //let 变量名称:[数据类型;数组长度]=[默认值;数组长度]; 7 | let arr3:[&str;3]=["";3]; 8 | 9 | println!("{}",arr1.len()); 10 | 11 | for item in arr1{ 12 | println!("充电科目:{}\n",item); 13 | } 14 | 15 | for item in arr1.iter(){ 16 | println!("已参加的充电科目:{}\n",item); 17 | } 18 | 19 | // arr2[0]=""; 20 | println!("{:?}",arr2); 21 | show_arr(arr2); 22 | println!("{:?}",arr2); 23 | 24 | let mut arr3=["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 25 | println!("{:?}",arr3); 26 | modify_arr(&mut arr3); 27 | println!("{:?}",arr3); 28 | } 29 | 30 | fn modify_arr(arr: &mut[&str;3]){ 31 | let l = arr.len(); 32 | for i in 0..l{ 33 | arr[i]=""; 34 | } 35 | } 36 | 37 | fn show_arr(mut arr:[&str;3]){ 38 | let l = arr.len(); 39 | for i in 0..l{ 40 | if i==0{ 41 | arr[0]=""; 42 | } 43 | println!("充电科目:{}",arr[i]) 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /async_await40/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "async_await40" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | async-std = { version = "1.12.0", features = ["attributes"] } 10 | -------------------------------------------------------------------------------- /async_await40/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::future::Future; 2 | use std::time::Duration; 3 | use async_std::task::{block_on, sleep, spawn}; 4 | 5 | #[async_std::main] 6 | async fn main() { 7 | // do3(); 8 | // do4(); 9 | 10 | // let do3_span=spawn(do3); 11 | // let do4_span=spawn(do4); 12 | // 13 | // do3_span.join().unwrap(); 14 | // do4_span.join().unwrap(); 15 | 16 | // let do3_async = spawn(do3()); 17 | // do4().await; 18 | // do3_async.await; 19 | 20 | let result = block_on(go_study()); 21 | println!("{}",result); 22 | } 23 | 24 | async fn lesson() ->String{ 25 | String::from("从0到Go语言微服务架构师") 26 | } 27 | 28 | fn study1() -> impl Future{ 29 | async { 30 | let x= lesson().await; 31 | x+" 学习目标" 32 | } 33 | } 34 | 35 | fn go_study() -> impl Future{ 36 | let r = |x:String| async move { 37 | let y:String=study1().await; 38 | y+&*x 39 | }; 40 | r(String::from(":全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。")) 41 | } 42 | 43 | // 44 | // fn do3(){ 45 | // for i in 1..=5{ 46 | // println!("do3 {}",i); 47 | // sleep(Duration::from_millis(500)); 48 | // } 49 | // } 50 | // 51 | // fn do4(){ 52 | // for i in 1..=5{ 53 | // println!("do4 {}",i); 54 | // sleep(Duration::from_millis(1000)); 55 | // } 56 | // } 57 | 58 | 59 | async fn do3(){ 60 | for i in 1..=5{ 61 | println!("do3 {}",i); 62 | sleep(Duration::from_millis(500)).await; 63 | } 64 | } 65 | 66 | async fn do4(){ 67 | for i in 1..=5{ 68 | println!("do4 {}",i); 69 | sleep(Duration::from_millis(1000)).await; 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /boolandchar07/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "boolandchar07" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /boolandchar07/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | //使用bool关键字声明一个布尔值，取值，true,false 3 | let checked:bool = true; 4 | println!("checked {}",checked); 5 | //字符： 是字符串的基本组成，也就是单个字符或字，UTF-8作为底层编码，包含数字，字母，Unicode和其他特殊字符。 6 | let c='R'; 7 | println!("c {}",c); 8 | } 9 | -------------------------------------------------------------------------------- /borrow_17/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "borrow_17" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /borrow_17/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | //借用 &变量名 3 | let studyList=vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 4 | let studyList2 = studyList; 5 | show(&studyList2); 6 | println!("{:?}",studyList2); 7 | 8 | let mut studyList3=vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 9 | println!("{:?}",studyList3); 10 | show2(&mut studyList3); 11 | println!("{:?}",studyList3); 12 | //借用borrow 从一个函数中的变量传递给另外一个函数作为参数暂时使用。函数离开后将所有权返回给当初传递给他的变量。 13 | //可变借用， 定义时候和使用的时候 都要用 &mut 14 | } 15 | 16 | fn show(v:&Vec<&str>){ 17 | println!("{:?}",v); 18 | } 19 | 20 | fn show2(v:&mut Vec<&str>){ 21 | v[0]="第一个充电项目已完成"; 22 | println!("{:?}",v) 23 | } 24 | -------------------------------------------------------------------------------- /closure_26/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "closure_26" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /closure_26/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | || 代替 ()将输入参数括起来 4 | 函数体界定符是{},对于单个表达式是可选的，其他情况必须加上。 5 | 有能力捕获外部环境的变量。 6 | 7 | |参数列表|{ 8 | 业务逻辑 9 | } 10 | 11 | ||{ 12 | 业务逻辑 13 | } 14 | 闭包可以赋值一个变量。 15 | */ 16 | 17 | let double = |x| {x*2}; 18 | let add =|a,b|{a+b}; 19 | let x = add(2,4); 20 | println!("{}",x); 21 | 22 | let y = double(5); 23 | println!("{}",y); 24 | 25 | let v= 3 ; 26 | let add2=|x|{v+x}; 27 | println!("{}",add2(4)); 28 | 29 | /* 30 | 捕获 31 | 闭包，可以在没有标注的情况下运行。可移动(move)，可借用(borrow)，闭包可以通过 32 | 引用 &T 33 | 可变引用 &mut T 34 | 值 T 35 | 36 | 总结闭包 37 | 38 | 闭包是在一个函数内创建立即调用的另外一个函数。 39 | 闭包是一个匿名函数 40 | 闭包虽然没有函数名，但可以把整个闭包赋值一个变量，通过该变量来完成闭包的调用 41 | 闭包不用声明返回值，但可以有返回值。并且使用最后一条语句的执行结果作为返回值，闭包的返回值也可以给变量。 42 | 闭包也称之为内联函数。可以让闭包访问外层函数里的变量。 43 | */ 44 | } 45 | -------------------------------------------------------------------------------- /collections_21/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "collections_21" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /collections_21/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::{HashMap, HashSet}; 2 | 3 | fn main() { 4 | /* 5 | 向量vector 6 | 特点 7 | 1 相同类型的元素集合。 8 | 2 长度可变，运行时增加减少都可以。 9 | 3 使用索引查找。 10 | 4 添加元素到队尾。 11 | 5 向量内存在堆上，长度可动态变化。 12 | 13 | 创建向量 14 | Vec::new(); 15 | vec![val1,val2,...] 16 | */ 17 | 18 | let mut v = Vec::new(); 19 | v.push("Go语言极简一本通"); 20 | v.push("Go语言微服务架构核心22讲"); 21 | v.push("从0到Go语言微服务架构师"); 22 | println!("{:?}",v); 23 | println!("len:{}",v.len()); 24 | 25 | let mut v2=vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 26 | println!("{:?}",v2); 27 | 28 | let x = v2.remove(0); 29 | println!("{}",x); 30 | println!("{:?}",v2); 31 | 32 | if v.contains(&"从0到Go语言微服务架构师"){ 33 | println!("找到了"); 34 | } 35 | let y = v[0]; 36 | println!("{}",y); 37 | 38 | for item in v{ 39 | println!("充电项目:{}",item); 40 | } 41 | 42 | /* 43 | HashMap 键值对的集合，键不能重复的，值可以重复。 显示导入std::collections 44 | 45 | let mut 变量名称=HashMap::new(); 46 | */ 47 | 48 | let mut proccess = HashMap::new(); 49 | 50 | proccess.insert("Go语言极简一本通",1); 51 | proccess.insert("Go语言微服务架构核心22讲",2); 52 | proccess.insert("从0到Go语言微服务架构师",3); 53 | 54 | println!("{:?}",proccess); 55 | println!("len {}",proccess.len()); 56 | 57 | match proccess.get(&"从0到Go语言微服务架构师"){ 58 | Some(v)=>{ 59 | println!("HashMap v:{}",v) 60 | } 61 | None=>{ 62 | println!("找不到"); 63 | } 64 | } 65 | 66 | for (k,v) in proccess.iter(){ 67 | println!("k:{} v:{}",k,v); 68 | } 69 | 70 | if proccess.contains_key(&"Go语言极简一本通"){ 71 | println!("找到了"); 72 | } 73 | 74 | let x = proccess.remove(&"Go语言极简一本通"); 75 | println!("{:?}",x); 76 | println!("{:?}",proccess); 77 | 78 | /* 79 | HashSet 相同数据类型的集合，没有重复的值。如果存在相同的值，插入会失败。 80 | let mut 变量名称=HashSet::new(); 81 | */ 82 | 83 | let mut studySet = HashSet::new(); 84 | studySet.insert("Go语言极简一本通"); 85 | studySet.insert("Go语言微服务架构核心22讲"); 86 | studySet.insert("从0到Go语言微服务架构师"); 87 | 88 | println!("{:?}",studySet); 89 | 90 | studySet.insert("从0到Go语言微服务架构师"); 91 | println!("{:?}",studySet); 92 | println!("len: {}",studySet.len()); 93 | 94 | for item in studySet.iter(){ 95 | println!("hashSet-充电项目:{}",item); 96 | } 97 | 98 | match studySet.get("从0到Go语言微服务架构师"){ 99 | None=>{ 100 | println!("找不到") 101 | } 102 | Some(data)=>{ 103 | println!("studySet中找到:{}",data); 104 | } 105 | } 106 | 107 | if studySet.contains("Go语言微服务架构核心22讲"){ 108 | println!("包含 Go语言微服务架构核心22讲"); 109 | } 110 | 111 | studySet.remove("Go语言极简一本通"); 112 | println!("{:?}",studySet); 113 | 114 | studySet.remove("golang"); 115 | println!("{:?}",studySet); 116 | 117 | } 118 | -------------------------------------------------------------------------------- /condition_11/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "condition_11" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /condition_11/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | if 条件表达式{ 4 | //条件表达式 为 真，就执行这个代码。 5 | } 6 | */ 7 | let total:f32 = 666.00; 8 | if total>500.00{ 9 | println!("打8折,{}",total*0.8); 10 | } 11 | /* 12 | if 条件表达式{ 13 | //条件表达式 为 真，就执行这个代码。 14 | }else{ 15 | //条件表达式 为 假，就执行else中的这个代码。 16 | } 17 | */ 18 | let total:f32 = 166.00; 19 | if total>500.00{ 20 | println!("打8折,{}",total*0.8); 21 | }else{ 22 | println!("无优惠折扣{}",total); 23 | } 24 | /* 25 | if...else if ... else 26 | if 条件表达式1{ 27 | 条件表达式1 为真，执行此业务逻辑 28 | } 29 | else if 条件表达式2{ 30 | 条件表达式2 为真，执行此业务逻辑 31 | } 32 | else{ 33 | 条件表达式1和条件表达式2读为假，执行此业务逻辑 34 | } 35 | */ 36 | 37 | let total:f32=366.00; 38 | if total>200.00&&total<500.00{ 39 | println!("打9折,{}",total*0.9); 40 | }else if total>500.00{ 41 | println!("打8折,{}",total*0.8); 42 | }else{ 43 | println!("无优惠折扣{}",total); 44 | } 45 | 46 | let code="10010"; 47 | let choose = match code{ 48 | "10010"=>"联通", 49 | "10086"=>"移动", 50 | _=>"Unknown" 51 | }; 52 | println!("选择{}",choose); 53 | 54 | let code="80010"; 55 | let choose = match code{ 56 | "10010"=>"联通", 57 | "10086"=>"移动", 58 | _=>"Unknown" 59 | }; 60 | println!("选择{}",choose); 61 | } 62 | -------------------------------------------------------------------------------- /const_09/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "const_09" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /const_09/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | const 常量名称:数据类型=值; 4 | 常量名称通常是大写字母。 5 | 常量可以在任何地方定义，常量只是一个符号，编译时替换为具体的值。 6 | 7 | static 具有'static声明周期的，可以是可变的变量（static mut关键字） 8 | */ 9 | 10 | const PI:f64=3.1415926; 11 | println!("{}",PI); 12 | 13 | 14 | //变量的隐藏 15 | let name="《Go语言极简一本通》"; 16 | let name = "《从0到Go语言微服务架构师》"; 17 | println!("{}",name); 18 | 19 | //隐藏变量并且改变数据类型 20 | let price = 199; 21 | let price="299"; 22 | println!("{}",price); 23 | 24 | //常量不能被隐藏，也不能被重复定义 25 | // const DISCOUNT:f64 = 0.8; 26 | const DISCOUNT:f64 = 0.6; 27 | 28 | 29 | static BOOK:&'static str = "《Go语言极简一本通》"; 30 | println!("{}",BOOK); 31 | 32 | } 33 | -------------------------------------------------------------------------------- /enum_20/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "enum_20" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /enum_20/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | enum 枚举名称{ 4 | variant1, 5 | variant2, 6 | ... 7 | } 8 | 9 | 使用枚举 10 | 枚举名称::variant 11 | 12 | Option经常用于函数的返回值，可以有返回值Some(T)，也可以没有返回值None。 13 | enum Option{ 14 | Some(T), //用于返回一个值 15 | None //用于返回null,用None来代替 16 | } 17 | 18 | match 判断枚举变量的值。 19 | 20 | 带数据类型的枚举 21 | enum 枚举名称{ 22 | variant1(数据类型1), 23 | variant2(数据类型2), 24 | ... 25 | } 26 | */ 27 | 28 | let level3=RoadMap::从0到Go语言微服务架构师; 29 | println!("level3--{:?}",level3); 30 | 31 | let p=6; 32 | let result=get_discount(p); 33 | println!("{:?}",result); 34 | 35 | print_road_map(RoadMap::Go语言极简一本通); 36 | print_road_map(RoadMap::Go语言微服务架构核心22讲); 37 | print_road_map(RoadMap::从0到Go语言微服务架构师); 38 | 39 | let level3 = StudyRoadMap::Name(String::from("从0到Go语言微服务架构师")); 40 | match level3{ 41 | StudyRoadMap::Name(val)=>{ 42 | println!("{:?}",val); 43 | } 44 | } 45 | } 46 | 47 | enum StudyRoadMap{ 48 | Name(String), 49 | } 50 | 51 | fn print_road_map(r:RoadMap){ 52 | match r { 53 | RoadMap::Go语言极简一本通=>{ 54 | println!("Go语言极简一本通") 55 | }, 56 | RoadMap::Go语言微服务架构核心22讲=>{ 57 | println!("Go语言微服务架构核心22讲") 58 | } 59 | RoadMap::从0到Go语言微服务架构师=>{ 60 | println!("从0到Go语言微服务架构师") 61 | } 62 | } 63 | } 64 | 65 | fn get_discount(price:i32)->Option{ 66 | if price>100{ 67 | Some(true) 68 | }else{ 69 | None 70 | } 71 | } 72 | 73 | #[derive(Debug)] 74 | enum RoadMap{ 75 | Go语言极简一本通, 76 | Go语言微服务架构核心22讲, 77 | 从0到Go语言微服务架构师, 78 | } 79 | //这是Go语言学习的3个阶段 80 | -------------------------------------------------------------------------------- /error_28/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "error_28" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /error_28/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::fs::File; 2 | 3 | fn main() { 4 | // panic!("出错了"); 5 | // println!("Hello Rust"); 6 | 7 | //panic 程序立即退出，退出的时候调用者抛出退出原因。 8 | 9 | let v = vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 10 | // v[5]; 11 | 12 | // let f = File::open("abc.jpg"); 13 | // println!("{:?}",f); 14 | 15 | //unwrap expect 16 | let result = is_even(6).unwrap(); 17 | println!("结果{}",result); 18 | 19 | let result = is_even(11).unwrap(); 20 | println!("结果{}",result); 21 | 22 | //unwrap是Result的方法，实例上调用此方法时，如果是Ok,就返回Ok中的对象， 23 | // 如果是Err枚举，在运行时会panic 24 | 25 | //expect区别是 expect方法接收msg:&str作为参数，可以自定义报错信息。 26 | } 27 | 28 | fn is_even(no :i32)->Result{ 29 | return if no%2==0{ 30 | Ok(true) 31 | }else{ 32 | Err("输入值，不是偶数".to_string()) 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /file_24/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "file_24" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /file_24/data2.txt: -------------------------------------------------------------------------------- 1 | 2 | www.go-edu.cnRust 3 | Rust -------------------------------------------------------------------------------- /file_24/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::fs; 2 | use std::fs::OpenOptions; 3 | use std::io::{Read, Write}; 4 | 5 | fn main() { 6 | // let file=std::fs::File::open("data.txt"); 7 | // println!("文件打开\n{:?}",file); 8 | // 9 | // let file = std::fs::File::create("data2.txt").expect("创建失败"); 10 | // println!("文件创建成功{:?}",file); 11 | 12 | // fs::remove_file("data.txt").expect("无法删除文件"); 13 | // println!("文件已删除"); 14 | 15 | // let mut file=OpenOptions::new().append(true).open("data2.txt").expect("失败"); 16 | // file.write("\nwww.go-edu.cn".as_bytes()).expect("写入失败"); 17 | // println!("\n数据追加成功"); 18 | 19 | // file.write_all("Rust".as_bytes()).expect("失败"); 20 | // file.write_all("\nRust".as_bytes()).expect("失败"); 21 | // println!("\n数据写入成功"); 22 | //write_all并不会在写入后自动写入换行\n 23 | 24 | let mut file = std::fs::File::open("data2.txt").unwrap(); 25 | let mut contents = String::new(); 26 | file.read_to_string(&mut contents).unwrap(); 27 | println!("{}",contents) 28 | } 29 | -------------------------------------------------------------------------------- /function_13/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "function_13" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /function_13/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | fn function缩写 4 | fn 函数名称([参数:参数类型]) -> 返回值{ 5 | //执行逻辑代码 6 | } 7 | 8 | 无明确返回值时候，就会返回一个单元类型 () 9 | */ 10 | 11 | hello(); 12 | println!("{}",get_name()); 13 | println!("{}",get_name2()); 14 | 15 | let mut price=99; 16 | double_price(price); 17 | println!("外部price是{}",price); 18 | 19 | let mut price=88; 20 | double_price2(&mut price); 21 | println!("外部price是{}",price); 22 | 23 | let name = String::from("从0到Go语言微服务架构师"); 24 | show_name(name); 25 | println!("调用show_name函数后{}",name); 26 | } 27 | 28 | fn hello(){ 29 | println!("Hello,rust!"); 30 | } 31 | 32 | fn get_name()->String{ 33 | return String::from("Go语言微服务架构核心22讲"); 34 | } 35 | 36 | //没有return关键字，函数会默认使用最后一条语句的执行结果作为返回值，并且数据类型要保持一致。 37 | fn get_name2()->String{ 38 | String::from("从0到Go语言微服务架构师") 39 | } 40 | 41 | //值传递，函数内部和外部各自保存了相同的值，互不影响，因此内外结果不一致。 42 | fn double_price(mut price:i32){ 43 | price=price*2; 44 | println!("内部的price是{}",price); 45 | } 46 | //引用传递，把当前变量的内存地址传递给函数。传递的变量和函数参数共同指向了同一个内存位置。引用传递在参数类型的前面加上&符号。 47 | //* 解引用符，用于获取访问变量price指向的内存地址上存储的变量的值。 48 | fn double_price2(price:&mut i32){ 49 | *price = *price *2; 50 | println!("内部的price是{}",price); 51 | } 52 | 53 | fn show_name(name:String){ 54 | println!("充电科目:{}",name); 55 | } 56 | -------------------------------------------------------------------------------- /generis_22/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "generis_22" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /generis_22/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::fmt::{Display, Formatter}; 2 | 3 | fn main() { 4 | let mut v:Vec=vec![1,2,3]; 5 | // v.push("4"); 6 | 7 | /* 8 | 泛型结构体 9 | struct 结构体名称{ 10 | 字段:T, 11 | } 12 | */ 13 | 14 | let t:Data=Data{value:100}; 15 | println!("值:{}",t.value); 16 | 17 | let t:Data=Data{value:66.00}; 18 | println!("值:{}",t.value); 19 | 20 | /* 21 | 特质Trait,对标其他语言的接口，都是行为的抽象。使用trait关键字用来定义。可以是具体方法，也可以是抽象的方法。 22 | trait some_trait{ 23 | 抽象方法 24 | fn method1(&self); 25 | 26 | 具体实现的普通方法 27 | fn method2(&self){ 28 | 方法的具体代码 29 | } 30 | } 31 | 32 | impl for 为每个结构体实现某个特质。 33 | */ 34 | let book=Book{ 35 | id:1, 36 | name:String::from("Go语言极简一本通"), 37 | author:String::from("欢喜"), 38 | }; 39 | book.Show(); 40 | 41 | /* 42 | 泛型函数，主要是参数类型是泛型，不要求所有参数都必须是泛型参数，可以是摸一个参数是泛型的。 43 | fn 函数名称(参数1:T,...){ 44 | 函数实现代码 45 | } 46 | */ 47 | show2(book); 48 | } 49 | 50 | struct Book{ 51 | name:String, 52 | id:u32, 53 | author:String, 54 | } 55 | 56 | fn show2(t:T){ 57 | println!("{}",t); 58 | } 59 | 60 | impl Display for Book{ 61 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { 62 | println!("ID:{},Name:{},Author:{}",self.id,self.name,self.author); 63 | let r=Result::Ok(()); 64 | return r; 65 | } 66 | } 67 | 68 | trait ShowBook{ 69 | fn Show(&self); 70 | } 71 | 72 | impl ShowBook for Book{ 73 | fn Show(&self) { 74 | println!("ID:{},Name:{},Author:{}",self.id,self.name,self.author); 75 | } 76 | } 77 | 78 | 79 | struct Data{ 80 | value:T, 81 | } 82 | -------------------------------------------------------------------------------- /io_23/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "io_23" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /io_23/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::io::Write; 2 | 3 | fn main() { 4 | 5 | /* 6 | std::io::stdin() 返回标准输入流stdin的句柄。 7 | read_line() stdin的句柄的一个方法，从标准输入流中读取一行数据。返回一个Result枚举。会自动删除行尾的换行符\n. 8 | unwrap() 是一个帮助的方法，简化恢复错误的处理。返回Result中的存储实际值。 9 | */ 10 | // let mut in_word=String::new(); 11 | // let result = std::io::stdin().read_line(&mut in_word).unwrap(); 12 | // println!("您输入的是:{}",in_word); 13 | // println!("读取的字节数为:{}",result); 14 | 15 | 16 | let result1 = std::io::stdout().write("面向加薪学习".as_bytes()).unwrap(); 17 | println!("写入的字节数为:{}\n",result1); 18 | let result2=std::io::stdout().write("www.go-edu.cn".as_bytes()).unwrap(); 19 | println!("写入字节数为:{}\n",result2); 20 | /* 21 | std::io::stdout()返回标准输出流的句柄。 22 | write()是标准输出流stdout的句柄上的一个方法，用于向标准输出流中写入字节流内容。也放回一个Result枚举。 23 | 不会输出结束时自动追加换行符\n. 24 | */ 25 | 26 | let input_args=std::env::args(); 27 | for arg in input_args{ 28 | println!("命令行参数:{}",arg); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /iterator_25/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "iterator_25" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /iterator_25/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let v = vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 3 | let mut it = v.iter(); 4 | println!("{:?}",it.next()); 5 | println!("{:?}",it.next()); 6 | println!("{:?}",it.next()); 7 | println!("{:?}",it.next()); 8 | 9 | let iter=v.iter(); 10 | for item in iter{ 11 | println!("{}\n",item); 12 | } 13 | /* 14 | iter() 返回一个只读可冲入迭代器，迭代器元素的类型为&T, 15 | into_iter() 返回一个只读不可重入迭代器，迭代器元素的类型为T, 16 | iter_mut() 返回一个可修改重入迭代器，迭代器元素的类型为&mut T 17 | */ 18 | } 19 | -------------------------------------------------------------------------------- /let_35/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "let_35" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /let_35/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s = Some("从0到Go语言微服务架构师"); 3 | let s1:Option=None; 4 | let s2:Option=None; 5 | 6 | //如果let将s解构成Some(i),则执行语句块{} 7 | if let Some(i) = s{ 8 | println!("已上车{:?}",i); 9 | } 10 | 11 | //如果解构失败，就执行else 12 | if let Some(i)=s1{ 13 | println!("Matched {:?}",i) 14 | }else{ 15 | println!("不匹配") 16 | } 17 | 18 | let flag=false; 19 | if let Some(i)=s2{ 20 | println!("Matched{:?}",i); 21 | }else if flag{ 22 | println!("不匹配s2") 23 | }else{ 24 | println!("默认分支") 25 | } 26 | 27 | let mut num=Some(0); 28 | 29 | while let Some(i)=num{ 30 | if i>9{ 31 | println!("{},quit!",i); 32 | num=None; 33 | }else{ 34 | println!("i is {:?} Try again",i); 35 | num=Some(i+1); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /loop_12/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "loop_12" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /loop_12/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | 3 | /* 4 | for 临时变量 in 左区间..右区间{ 5 | //执行业务逻辑 6 | } 7 | 左闭右开区间 8 | */ 9 | for num in 1..5{ 10 | println!("num is {}",num); 11 | } 12 | 13 | for num in 1..=5{ 14 | println!("num is {}",num); 15 | } 16 | let studyList = vec![ 17 | "《Go语言极简一本通》", 18 | "Go语言微服务架构核心22讲", 19 | "从0到Go语言微服务架构师", 20 | ]; 21 | //iter()每次迭代是借用集合中的一个元素。元素本身不会改变，循环之后还可以使用。 22 | for name in studyList.iter(){ 23 | match name { 24 | &"从0到Go语言微服务架构师"=>println!("恭喜你进阶到第三阶段-{}",name), 25 | _=>println!("上车:{}",name), 26 | } 27 | } 28 | let studyList2 = vec![ 29 | "《Go语言极简一本通》", 30 | "Go语言微服务架构核心22讲", 31 | "从0到Go语言微服务架构师", 32 | ]; 33 | //into_iter 会消耗集合，每次迭代，集合中的数据本身被提供，一旦集合被消耗完了。之后无法再使用，因为它已经在循环中被move了 34 | for name in studyList2.into_iter(){ 35 | match name { 36 | "从0到Go语言微服务架构师"=>println!("恭喜你进阶到第三阶段-{}",name), 37 | _=>println!("上车:{}",name), 38 | } 39 | } 40 | 41 | let mut studyList3 = vec![ 42 | "《Go语言极简一本通》", 43 | "Go语言微服务架构核心22讲", 44 | "从0到Go语言微服务架构师", 45 | ]; 46 | for name in studyList3.iter_mut(){ 47 | *name = match name { 48 | &mut "从0到Go语言微服务架构师"=>{"恭喜你进阶到第三阶段--从0到Go语言微服务架构师"}, 49 | _=>*name, 50 | } 51 | } 52 | println!("studyList3:{:?}",studyList3); 53 | /* 54 | while (条件表达式) { 55 | 执行业务代码 56 | } 57 | */ 58 | let mut num = 1; 59 | while num<20{ 60 | println!("num is {}",num); 61 | num=num*2; 62 | } 63 | 64 | let mut num=1; 65 | loop{ 66 | if num>20{ 67 | break; 68 | } 69 | println!("num is {}",num); 70 | num=num*3; 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /match_34/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "match_34" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /match_34/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | 解构 &、ref、ref mut 4 | 解引用 * 5 | */ 6 | 7 | let num= &100; 8 | 9 | match num { 10 | &val=> println!("&val 是 {:?}",val), 11 | } 12 | 13 | match *num{ 14 | val => println!("val 是 {:?}",val), 15 | } 16 | //ref他改变了赋值的行为，可以对具体值创建引用。 17 | let ref num3 = 66; 18 | 19 | //定义2个非引用变量，通过ref和ref mut仍然可以得到其引用。 20 | let num4 = 5; 21 | let mut mut_num4=7; 22 | 23 | match num4 { 24 | ref r => println!("num4 是 {:?}",*r), 25 | } 26 | 27 | match mut_num4{ 28 | ref mut m =>{ 29 | *m+=10; 30 | println!("mut_num4 是 {:?}",m); 31 | } 32 | } 33 | 34 | let s =Study{ 35 | name:String::from("从0到Go语言微服务架构师"), 36 | target:String::from("全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。"), 37 | spend:3, 38 | }; 39 | 40 | let Study{ 41 | name:name, 42 | target:target, 43 | spend:spend 44 | }=s; 45 | 46 | println!("name={},target={},spend={}",name,target,spend); 47 | 48 | let s2 =Study{ 49 | name:String::from("从0到Go语言微服务架构师"), 50 | target:String::from("全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。"), 51 | spend:5, 52 | }; 53 | let Study{name,..}=s2; 54 | println!("name = {}",name); 55 | } 56 | struct Study{ 57 | name:String, 58 | target:String, 59 | spend:u32, 60 | } 61 | -------------------------------------------------------------------------------- /module_30/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "module_30" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | mylib={path="../module_30/mylib"} 10 | -------------------------------------------------------------------------------- /module_30/mylib/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "mylib" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /module_30/mylib/src/lib.rs: -------------------------------------------------------------------------------- 1 | #[cfg(test)] 2 | mod tests { 3 | #[test] 4 | fn it_works() { 5 | let result = 2 + 2; 6 | assert_eq!(result, 4); 7 | } 8 | } 9 | 10 | pub mod add_salary{ 11 | pub fn study(name:String){ 12 | println!("面向加薪学习 {}",name); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /module_30/src/main.rs: -------------------------------------------------------------------------------- 1 | use mylib::add_salary::study; 2 | 3 | fn main() { 4 | /* 5 | 私有模块 6 | mod module_name{ 7 | fn function_name(){ 8 | 9 | } 10 | } 11 | 12 | pub关键字 13 | 14 | pub mod public_module{ 15 | pub fn function_name(){ 16 | //公开方法 17 | } 18 | 19 | fn function_name2(){ 20 | //私有方法 21 | } 22 | } 23 | 24 | 使用模块 25 | use 公开模块::函数名称； 26 | 27 | pub mod mod1{ 28 | pub mod mod2{ 29 | pub mod mod3{ 30 | pub fn function_name(参数){ 31 | 代码逻辑 32 | } 33 | } 34 | } 35 | } 36 | 37 | use mod1::mod2::mod3::function_name; 38 | */ 39 | 40 | study("从0到Go语言微服务架构师".to_string()); 41 | } 42 | -------------------------------------------------------------------------------- /ownership_move_16/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "ownership_move_16" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /ownership_move_16/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let name="从0到Go语言微服务架构师"; 3 | 4 | //move 5 | // let a=b 6 | // foo(a) 7 | /* 8 | 栈 后进先出。类型大小是固定的。如i32. 9 | 堆 编译时大小未知或不确定大小。用户自己管理，增加内存溢出风险。 10 | */ 11 | 12 | let a=88; 13 | let b=a; 14 | println!("a {}, and b {}", a ,b); 15 | 16 | // let v1=vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 17 | // let v2= v1; 18 | // println!("{:?}",v1); 19 | // 20 | // let studyList=vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 21 | // let studyList2 = studyList; 22 | // show(studyList2); 23 | // println!("studyList2 {:?}",studyList2); 24 | 25 | let studyList3=vec!["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 26 | let studyList4=studyList3; 27 | let result = show2(studyList4); 28 | println!("result:{:?}",result); 29 | println!("result:{:?}",studyList4); 30 | 31 | //赋值并不是唯一涉及移动所有权的操作，值在作为参数传递或从函数返回时也会被移动。 32 | 33 | } 34 | 35 | fn show2(v:Vec<&str>) -> Vec<&str>{ 36 | println!("v {:?}",v); 37 | return v; 38 | } 39 | 40 | fn show(v:Vec<&str>){ 41 | println!("v {:?}",v) 42 | } 43 | -------------------------------------------------------------------------------- /slice_18/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "slice_18" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /slice_18/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | let 切片变量=&变量[起始位置..结束位置] 左闭右开的一个区间 4 | */ 5 | 6 | let mut v = Vec::new(); 7 | v.push("Go语言极简一本通"); 8 | v.push("Go语言微服务架构核心22讲"); 9 | v.push("从0到Go语言微服务架构师"); 10 | println!("len:{}",v.len()); 11 | let s1=&v[..2]; 12 | //[..]获取全部元素 13 | //[起始位置..] 获取 起始位置 到 整个容器的全部元素 14 | //[..结束位置] 获取 从0到结束位置的元素 15 | println!("s1:{:?}",s1); 16 | show_slice(s1); 17 | println!("s1:{:?}",s1); 18 | 19 | let mut v2 = Vec::new(); 20 | v2.push("Go语言极简一本通"); 21 | v2.push("Go语言微服务架构核心22讲"); 22 | v2.push("从0到Go语言微服务架构师"); 23 | println!("modify_slice 之前 v2:{:?}",v2); 24 | modify_slice(&mut v2[1..3]); 25 | println!("modify_slice 之后 v2:{:?}",v2); 26 | } 27 | 28 | fn show_slice(s:&[&str]){ 29 | println!("show_slice函数内:{:?}",s); 30 | } 31 | 32 | fn modify_slice(s:&mut [&str]){ 33 | s[0]="这个阶段学习完毕"; 34 | println!("modify_slice:{:?}",s); 35 | } 36 | -------------------------------------------------------------------------------- /smart_pointer_29/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "smart_pointer_29" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /smart_pointer_29/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::ops::Deref; 2 | 3 | fn main() { 4 | /* 5 | 如果一个结构体，实现了deref和drop的Trait，那他们就不是普通结构体了。 6 | Rust提供了堆上存储数据的能力并把这个能力封装到了Box中。 7 | 把栈上的数据搬到堆上的能力，就叫做装箱。 8 | Box可以把数据存储到堆上，而不是栈上，box 装箱，栈还是包含指向堆上数据的指针。 9 | 10 | 星号 * 解引用符。 11 | */ 12 | let a = 6; 13 | let b = Box::new(a); 14 | println!("b={}",b); 15 | 16 | let price1 = 158; 17 | let price2 = Box::new(price1); 18 | println!("{}",158==price1); 19 | println!("{}",158==*price2); 20 | 21 | let x = 666; 22 | let y =CustomBox::new(x); 23 | 24 | println!("666==x is {}",666==x); 25 | println!("666==*y is {}",666==*y); 26 | println!("x==*y is {}",x==*y); 27 | } 28 | 29 | struct CustomBox{ 30 | value:T 31 | } 32 | 33 | impl CustomBox{ 34 | fn new(v:T)->CustomBox{ 35 | CustomBox{value:v} 36 | } 37 | } 38 | impl Deref for CustomBox{ 39 | type Target = T; 40 | 41 | fn deref(&self) -> &T { 42 | &self.value 43 | } 44 | } 45 | 46 | impl Drop for CustomBox{ 47 | fn drop(&mut self) { 48 | println!("drop CustomBox 对象!") 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /string_10/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "string_10" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /string_10/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | //&str 是在模块 std:str,字符串切片。 3 | let lesson="Go语言微服务架构核心22讲"; 4 | 5 | /* 6 | 字符串对象 在堆上分配，可以在运行时提供字符串值以及响应的操作方法。 7 | String::new()创建一个新的空字符串，他是静态的 8 | String::from() 从具体的字符串字面量创建字符串对象。 9 | */ 10 | let s1= String::new(); 11 | println!("s1:{},s1-len:{}",s1,s1.len()); 12 | 13 | let s2 = String::from("面向加薪学习"); 14 | println!("s2:{},s2-len:{}",s2,s2.len()); 15 | 16 | let mut s3 = String::new(); 17 | s3.push_str("Go语言极简一本通"); 18 | println!("{}",s3); 19 | 20 | s3.push('O'); 21 | s3.push('K'); 22 | println!("{}",s3); 23 | 24 | let s4 = String::from("面向加薪学习"); 25 | let result =s4.replace("面向加薪学习","www.go-edu.cn"); 26 | println!("{}",result); 27 | 28 | let s5=String::from("面向加薪学习 www.go-edu.cn"); 29 | println!("length is {}",s5.len()); 30 | 31 | let s6="从0到Go语言微服务架构师".to_string(); 32 | println!("{}",s6); 33 | 34 | let s7 = String::from("Go语言微服务架构核心22讲"); 35 | show_name(s7.as_str()); 36 | 37 | //去掉头尾空白符 ， 制表符\t 空格 回车\r 换行\n 回车换行\r\n 38 | let s8=" \tGo语言极简一本通\tGo语言微服务架构核心22讲 \r\n从0到Go语言微服务架构师\r\n "; 39 | println!("length is {}",s8.len()); 40 | println!("length is {}",s8.trim().len()); 41 | println!("{}",s8); 42 | 43 | let s9 = "Go语言极简一本通、Go语言微服务架构核心22讲、从0到Go语言微服务架构师"; 44 | for item in s9.split('、'){ 45 | println!("充电科目：{}",item); 46 | } 47 | 48 | let s10 = "从0到Go语言微服务架构师"; 49 | for c in s10.chars(){ 50 | println!("字符:{}",c); 51 | } 52 | 53 | let s11 ="Go语言极简一本通".to_string(); 54 | let s12 = " 欢喜".to_string(); 55 | 56 | let result2= s11+&s12; 57 | println!("{}",result2); 58 | } 59 | 60 | fn show_name(name:&str){ 61 | println!("充电科目:{}",name); 62 | } 63 | -------------------------------------------------------------------------------- /struct_19/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "struct_19" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /struct_19/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | 元组结构体 4 | struct Pair(String,i32); 5 | 6 | C语言风格结构体 7 | struct 结构体名称{ 8 | ... 9 | } 10 | 11 | 单元结构体,不带字段，在泛型中很有用。 12 | type Unit 13 | 14 | 15 | struct 结构体名称{ 16 | 字段1:数据类型 17 | 字段2:数据类型 18 | ... 19 | } 20 | 21 | 22 | let 实例名称 = 结构体名称{ 23 | 字段1:数据1 24 | 字段2:数据2 25 | ... 26 | } 27 | */ 28 | 29 | let s = Study{ 30 | name:String::from("从0到Go语言微服务架构师"), 31 | target:String::from("全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。"), 32 | spend: 3, 33 | }; 34 | println!("{:?}",s); 35 | 36 | println!("{}",s.name); 37 | 38 | let s3 = get_instance( 39 | String::from("Go语言极简一本通"), 40 | String::from("学习Go语言语法，并且完成一个单体服务"),5); 41 | println!("{:?}",s3); 42 | 43 | // show(s3); 44 | 45 | /* 46 | impl 结构体{ 47 | fn 方法名(&self,参数列表) 返回值{ 48 | //方法体 49 | } 50 | } 51 | 52 | 函数 可以直接调用，同一个程序不能出现2个相同的函数签名的函数，因为函数不归属任何owner. 53 | 方法 归属某一个owner,不同的owner可以有相同的方法签名。 54 | 55 | impl 是 implement的缩写。 "实现"的意思。 56 | 57 | self "自己"的意思， &self表示当前结构体的实例。也是结构体普通方法固定的第一个参数，其他参数可选。 58 | 59 | 结构体静态方法 60 | fn 方法名(参数:数据类型,...) -> 返回类型{ 61 | //方法体 62 | } 63 | 调用方式 结构体名称::方法名(参数列表) 64 | 65 | */ 66 | 67 | println!("spend {}",s3.get_spend()); 68 | let s4 = Study::get_instance_another( 69 | String::from("Go语言极简一本通"), 70 | String::from("学习Go语言语法，并且完成一个单体服务"),5); 71 | println!("s4 {:?}",s4); 72 | 73 | /* 74 | 单元结构体 75 | 是一个类型，有且只有一个值() 76 | */ 77 | 78 | //元组结构体 79 | let pair=(String::from("从0到Go语言微服务架构师"),1); 80 | 81 | println!("pair 包含{:?} and {:?}",pair.0,pair.1); 82 | 83 | //解构元组结构体 84 | let (study,spend) = pair; 85 | println!("pair 包含{:?} and {:?}",study,spend); 86 | } 87 | 88 | fn show(s:Study){ 89 | println!("name is {} target is {} spend is {}",s.name,s.target,s.spend); 90 | } 91 | 92 | fn get_instance(name:String,target :String,spend:i32) -> Study{ 93 | return Study{ 94 | name, 95 | target, 96 | spend, 97 | } 98 | } 99 | 100 | #[derive(Debug)] 101 | struct Study { 102 | name:String, 103 | target:String, 104 | spend:i32 105 | } 106 | 107 | impl Study{ 108 | fn get_spend(&self)->i32{ 109 | return self.spend; 110 | } 111 | 112 | fn get_instance_another(name:String,target:String,spend:i32)->Study{ 113 | return Study{ 114 | name, 115 | target, 116 | spend 117 | }; 118 | } 119 | } 120 | -------------------------------------------------------------------------------- /thread_27/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "thread_27" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /thread_27/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::thread; 2 | use std::time::Duration; 3 | 4 | fn main() { 5 | /* 6 | 创建线程 std::thread::spawn(); 7 | */ 8 | 9 | // thread::spawn(||{ 10 | // for i in 1..10{ 11 | // println!("子线程{}",i); 12 | // thread::sleep(Duration::from_millis(1)); 13 | // } 14 | // }); 15 | // 16 | // for i in 1..5{ 17 | // println!("主线程{}",i); 18 | // thread::sleep(Duration::from_millis(1)); 19 | // } 20 | // thread::sleep()会让线程睡眠一段时间，某个线程睡眠的时候，有让出cpu,可以让不同的线程交替执行，要看操作系统如何调度线程。 21 | 22 | // Join方法 23 | 24 | let handler = thread::spawn(||{ 25 | for i in 1..10{ 26 | println!("子线程{}",i); 27 | thread::sleep(Duration::from_millis(1)); 28 | } 29 | }); 30 | 31 | for i in 1..5{ 32 | println!("主线程{}",i); 33 | thread::sleep(Duration::from_millis(1)); 34 | } 35 | handler.join().unwrap(); 36 | } 37 | -------------------------------------------------------------------------------- /tuple_14/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "tuple_14" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tuple_14/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | let tuple变量名称:(数据类型1，数据类型2,...) = (数据1,数据2,...) 4 | let tuple变量名称 = (数据1,数据2,...) 5 | */ 6 | let t = ("Go语言极简一本通","掌握Go语言语法，并且可以完成单体服务应用。"); 7 | println!("{:?}",t); 8 | //元组变量.索引数字 9 | println!("{}",t.0); 10 | println!("{}",t.1); 11 | show_tuple(t); 12 | println!("{:?}",t); 13 | 14 | let(book,target) = t; 15 | println!("{}",book); 16 | println!("{}",target); 17 | 18 | let arr1:[&str;3]=["Go语言极简一本通","Go语言微服务架构核心22讲","从0到Go语言微服务架构师"]; 19 | for item in arr1{ 20 | print!("充电科目 :{}\n",item); 21 | } 22 | 23 | } 24 | fn show_tuple(t:(&str,&str)){ 25 | println!("{:?}",t); 26 | } 27 | -------------------------------------------------------------------------------- /type_convert_33/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "type_convert_33" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /type_convert_33/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let s1 = "从0到Go语言微服务架构师"; 3 | let s2=String::from(s1); 4 | 5 | let my_number = MyNumber::from(1); 6 | println!("{:?}",my_number); 7 | 8 | let spend=3; 9 | let my_spend:MyNumber = spend.into(); 10 | println!("{:?}",my_spend); 11 | 12 | let cost:i32 = "5".parse().unwrap(); 13 | println!("{}",cost); 14 | } 15 | #[derive(Debug)] 16 | struct MyNumber{ 17 | num:i32, 18 | } 19 | 20 | impl From for MyNumber{ 21 | fn from(item: i32) -> Self { 22 | MyNumber{ num:item} 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /type_system_32/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "type_system_32" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /type_system_32/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let spend = 1; 3 | /* 4 | mismatched types [E0308] expected `f64`, found `i32` 5 | */ 6 | // let cost:f64=spend; 7 | 8 | let cost = spend as f64; 9 | println!("转换 {}->{}",spend,cost); 10 | 11 | let x = 1u8; 12 | let y = 2u32; 13 | let z=3f32; 14 | 15 | let i=1; 16 | let f = 1.0; 17 | 18 | let study = String::from("从0到Go语言微服务架构师"); 19 | 20 | let mut vec=Vec::new(); 21 | vec.push(study); 22 | println!("{:?}",vec); 23 | 24 | //别名，要用驼峰命名法CamelCase,别名不是新类型，不能提供额外的类型安全。 25 | 26 | let myU64:MyU64=5 as ThirdU64; 27 | let otherU64:OtherU64 = 2 as ThirdU64; 28 | println!("{} MyU64 + {} OtherU64 = {}",myU64,otherU64,myU64+otherU64); 29 | } 30 | 31 | type MyU64 = u64; 32 | type OtherU64 = u64; 33 | type ThirdU64=u64; 34 | -------------------------------------------------------------------------------- /use_closuer39/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "use_closuer39" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /use_closuer39/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let add = |x, y| x + y; 3 | let result = add(3, 4); 4 | println!("{}", result); 5 | 6 | receives_closure(add); 7 | 8 | let y = 2; 9 | receives_closure2(|x| x+y); 10 | 11 | let y =3; 12 | receives_closure2(|x| x+y); 13 | 14 | let closure = returns_closure(); 15 | println!("返回闭包=>{}",closure(1)); 16 | 17 | let result = do1(add,5); 18 | println!("result(1)=>{}",result(1)); 19 | 20 | let result = do2(add,5); 21 | println!("result(2)=>{}",result(2)); 22 | } 23 | 24 | fn do2(f:F,x:X)->impl Fn(Y)->Z 25 | where 26 | F:Fn(X,Y)->Z, 27 | X:Copy{ 28 | move |y| f(x,y) 29 | } 30 | 31 | fn do1(f:F,x:i32)->impl Fn(i32)->i32 32 | where 33 | F:Fn(i32,i32)->i32 34 | { 35 | move |y| f(x,y) 36 | } 37 | 38 | fn returns_closure() -> impl Fn(i32)->i32{ 39 | |x| x+6 40 | } 41 | 42 | fn receives_closure(closure: F) 43 | where 44 | F: Fn(i32, i32) -> i32 45 | { 46 | let result = closure(3, 5); 47 | println!("闭包作为参数执行结果=>{}", result) 48 | } 49 | 50 | 51 | fn receives_closure2(closure: F) 52 | where 53 | F: Fn(i32) -> i32 { 54 | let result = closure(1); 55 | println!("closure(1)=>{}",result); 56 | } 57 | -------------------------------------------------------------------------------- /variable_define_08/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "variable_define_08" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /variable_define_08/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | 定义变量的格式 4 | let 变量名=值; 不指定变量类型 5 | let 变量名:数据类型=值; 指定变量类型 6 | 7 | 变量就是给某一个内存地址起名字。 8 | 9 | 变量的命名规范 10 | 1 可以是字母，数字，下划线。 11 | 2 必须以字母或下划线开头。不能以数字开头。 12 | 3 变量名区分大小写。 13 | 14 | 可变变量 15 | mut关键字，mutable缩写。 16 | let mut 变量名=值; 17 | let mut 变量名:数据类型=值; 18 | */ 19 | 20 | let Study = ""; 21 | println!("{}",Study); 22 | 23 | let mut price=188; 24 | price=288; 25 | println!("{}",price); 26 | } 27 | -------------------------------------------------------------------------------- /variable_define_31/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "variable_define_31" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /variable_define_31/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | /* 3 | 变量是有作用域的，也就是在一个代码块中生存。代码块 {}，也允许变量遮蔽。 4 | */ 5 | 6 | //main函数中 7 | let spend = 1; 8 | { 9 | //只存在本代码块中 10 | let target = "面向加薪学习"; 11 | println!("内部 {}",target); 12 | //遮蔽了外面的spend 13 | let spend=2.0; 14 | println!("内部 {}",spend); 15 | } 16 | //target在此作用域是不存在的 17 | // println!("外部 {}",target); 18 | println!("外部 {}",spend); 19 | //遮蔽了spend 20 | let spend=String::from("学习时间1小时"); 21 | println!("外部 {}",spend); 22 | 23 | let spend2; 24 | { 25 | let x=2; 26 | spend2= x*x; 27 | } 28 | println!("spend2:{}",spend2); 29 | 30 | let spend3; 31 | // println!("spend3:{}",spend3);//报错，使用了未初始化的绑定。 32 | spend3=1; 33 | println!("another binding spend3:{}",spend3); 34 | 35 | //冻结 资源存在使用的引用时，在当前作用域中这一资源是不可被修改的。 36 | let mut spend4 = Box::new(1); 37 | let spend5 = &spend4; 38 | spend4 = Box::new(100); 39 | println!("{}",spend4); 40 | println!("{}",spend5); 41 | } 42 | --------------------------------------------------------------------------------