起步

Hello, Rust - 图1

包管理（类比 JS 的 NPM）

Hello, Rust - 图2
Cargo config 文件样例：

  1. [source.crates-io]
  2. registry = "https://github.com/rust-lang/crates.io-index"
  3. replace-with = 'ustc'
  4. [source.ustc]
  5. registry = "git://mirrors.ustc.edu.cn/crates.io-index"

语言基础

常量&变量

变量隐藏实际上只是复用了变量名，变量本身是完全重新申明的！ 常量不可以被隐藏！

  1. fn main() {
  2.     // 定义常量
  3.     const PI: f64 = 3.14;
  5.     // 定义可变变量
  6.     let mut num = 5;
  7.     // 输出 PI=3.14,num=5
  8.     println!("PI={},num={}", PI, num);
  10.     num = 10;
  11.     // 输出 num=10
  12.     println!("num={}", num);
  14.     // 定义不可变变量
  15.     let num2 = 5;
  16.     // 会报错：cannot assign twice to immutable variable
  17.     // num2 = 6; // 注释掉才能编译通过
  18.     println!("num2={}", num2);
  20.     // 变量隐藏，通过 let 关键词复用变量名
  21.     let num2 = 10;
  22.     // 输出 num2=10
  23.     println!("num2={}", num2);
  25.     // 隐藏可变变量 num，之后 num 将不可变了
  26.     let num = 20;
  27.     // num = 222; // 需要注释掉才能编译通过，证明是一个全新的不可变变量
  28.     // 输出 num=20
  29.     println!("num={}", num);
  31.     // 常量不可以被隐藏
  32.     // let PI = 11; // 需要注释掉才能编译通过
  33. }

数据类型

Hello, Rust - 图3

  1. fn main() {
  2.     // f64
  3.     let n1 = 4.63;
  4.     let n2: f32 = 4.63;
  5.     let c1: char = '中';
  6.     let b1 = n1 == n2;
  7.     println!("{}, {}", b1, c1);
  9.     // 定义字符串
  10.     let s1: &str = "中文";
  11.     println!("{} -> {}", c1, s1);
  13.     // 不加 r 前缀，转义
  14.     let s2: &str = "A\nB";
  15.     // 加上 r 前缀，原样输出
  16.     let s3: &str = r"A\nB";
  17.     println!("{} -> {}", s2, s3);
  18. }

函数

  1. fn main() {
  2.     fn1();
  3.     fn2(45);
  4.     let res3 = fn3(3);
  5.     println!("res3={}", res3);
  6. }
  8. // 无参数无返回值
  9. fn fn1() {
  10.     println!("call fn1");
  11. }
  13. // 有参数无返回值
  14. fn fn2(num: i32) {
  15.     println!("call fn2, arg num={}", num);
  16. }
  18. // 有参数有返回值
  19. fn fn3(num: i32) -> i64 {
  20.     println!("call fn3");
  21.     return (num * 2).into();
  22. }

控制流（循环&条件判定）

  1. fn main() {
  2.     // Loop 循环
  3.     let mut i = 0;
  4.     loop {
  5.         i = i + 1;
  6.         println!("loop, i={}", i);
  7.         if i > 5 {
  8.             break;
  9.         }
  10.     }
  12.     // While 循环
  13.     while i < 15 {
  14.         i = i + 1;
  15.         println!("while, i={}", i);
  16.     }
  18.     // For 循环
  19.     for j in (i..20) {
  20.         println!("for, j={}", j);
  21.     }
  22.     // For 循环，包含 25
  23.     for j in (i..=25) {
  24.         println!("for, j={}", j);
  25.     }
  27.     // IF 判定
  28.     println!("i={}", i);
  29.     if i == 15 {
  30.         println!("i={}", i);
  31.     }
  33.     // 条件表达式作为结果
  34.     let res = if i == 15 { 5 } else { 6 };
  35.     println!("res={}", res);
  36. }

所有权

Rust 中非常特别设计，通过所用权的引用和借用，实现了无GC下的内存管理。 这个在我看来是 Rust 的设计理念之一，需要重点理解！

  1. fn main() {
  2.     let s1 = "s1";
  3.     let s1_copy = s1;
  4.     println!("s1={}, s1_copy={}", s1, s1_copy);
  6.     let s2 = String::from("s2");
  7.     // 变量复制 -> 指针移动，原始指针会失效
  8.     let s2_copy = s2;
  9.     // 如下语句会失效，需要注释才能运行
  10.     // println!("s2={}", s2); // error: value borrowed here after move
  11.     // 手动指定要进行深拷贝
  12.     let s2_new = s2_copy.clone();
  13.     println!("s2_copy={}, s2_new={}", s2_copy, s2_new);
  15.     // 引用移动
  16.     let s3 = String::from("Hello");
  17.     let s3_len = calculate_string_length(s3);
  18.     // println!("s3={}, s3 len={}", s3, s3_len); // 会报错， s3 已经被释放
  19.     // 借用（用完会把s4的所有权换回来）
  20.     let s4 = String::from("Rust");
  21.     let s4_len = calculate_string_length_pass_address(&s4);
  22.     // 此时可以正常打印出来
  23.     println!("s4={}, s4 len={}", s4, s4_len);
  24. }
  26. fn calculate_string_length(str: String) -> usize {
  27.     str.len()
  28. }
  30. fn calculate_string_length_pass_address(str: &String) -> usize {
  31.     return str.len();
  32. }

所有权（悬垂指针）

  1. // 特性：所有权（悬垂引用：悬垂指针是其指向的内存可能已经被分配给其它持有者）
  3. fn main() {
  4.     // 如下调用会报错，返回的引用指向的内存区域已经被释放了
  5.     // let reference_to_nothing = dangle();
  6.     let safe_str = safe();
  7.     println!("safe_str={}", safe_str);
  8. }
  10. // 需要先注释，避免编译错误
  11. // fn dangle() -> &String {
  12. //     let s = String::from("hello");
  13. //     &s // 返回字符串 s 的引用，s 离开函数就被释放，引用是无效的
  14. // }
  16. fn safe() -> String {
  17.     let s = String::from("hello");
  18.     s
  19. }

Slice 类型

  1. // Slice 类型（无所有权的类型，字符串字面量就是slice）
  3. fn main() {
  4.     let str = String::from("hello rust");
  5.     let part1 = &str[0..5];
  6.     let part2 = &str[6..str.len()];
  7.     println!("str={}, part1={}, part2={}", str, part1, part2);
  9.     // 获取全部 str
  10.     let str_copy = &str[..];
  11.     println!("str={}, str_copy={}", str, str_copy);
  12. }

猜数字游戏

  1. use rand::Rng;
  2. use std::cmp::Ordering;
  3. use std::io;
  5. fn main() {
  6.     let source = rand::thread_rng().gen_range(1..=100);
  7.     println!("猜数字游戏！随机数字[0-100]已就绪");
  9.     // 循环进行猜测~
  10.     loop {
  11.         println!("请输入你的猜测：");
  12.         // 定义一个可变变量
  13.         let mut num = String::new();
  14.         io::stdin().read_line(&mut num).expect("输入错误");
  15.         // 转换输入的字符串为数字
  16.         // trim 是为了移除输入内容中的换行符
  17.         let num: u16 = match num.trim().parse() {
  18.             Ok(num) => num,
  19.             Err(_) => {
  20.                 println!("你的输入是{}，不是数字，请重新输入", num.trim());
  21.                 // 重新输入
  22.                 continue;
  23.             }
  24.         };
  25.         // 比较两个数字
  26.         match num.cmp(&source) {
  27.             Ordering::Equal => {
  28.                 println!("恭喜，猜测正确！");
  29.                 // 退出循环
  30.                 break;
  31.             }
  32.             Ordering::Greater => {
  33.                 println!("你猜得太大了！");
  34.             }
  35.             Ordering::Less => println!("你猜得太小了！"),
  36.         }
  37.     }
  38. }

常见问题

  1. VSCode 中安装 Rust 插件后，无法启动 Language Server

image.png
这是由于这个插件默认的 rustup 地址不对，需要在 Code -> Perferences -> Settings 中去修改“rust-client.rustupPath”的值为具体的 rustup 地址。该地址一般可用如下方式找到：

  1. # 找到 cargo bin 目录
  2. cd ~/.cargo/bin
  3. # 打印当前目录路径
  4. pwd
  5. # 拼接上 rustup 进行配置，可参考下图

image.pngimage.png