一网打尽 Rust 语法

前端小魔女 2024-05-31
35 阅读 0 评论 0 点赞
一网打尽 Rust 语法

悲观者永远正确，而乐观者永远前行

大家好，我是柒八九。一个专注于前端开发技术/Rust及AI应用知识分享的Coder

前言

在之前的Rust学习专栏中，由于受制与文章的脉络，我们只能从概念到使用场景进行事无巨细的解释。相当于一篇文章介绍一种概念。

New Image

但是呢，这种处理方式只是在阅读某个文章时有种豁然开朗的感觉，但是无法从更高的视角去整体把握Rust的一些数据特性。（这也是部分粉丝的提出的一些建议）

所以，今天我们抛开历史包袱，只是单纯的从Rust的角度来窥探一下Rust中的数据类型到底有哪些。（放心，我们会在特定的位置，将附带更详细的文章链接）。

这篇文章没啥原理可言，我们可以将其作为我们以后学习和开发Rust的工具手册。

好了，天不早了，干点正事哇。

New Image

我们能所学到的知识点

  1. 构建运行环境
  2. 变量类型
  3. 操作数组
  4. 操作字符串
  5. 操作向量
  6. 函数
  7. 输入/输出
  8. Shadowing
  9. 控制块
  10. 循环
  11. 所有权
  12. 结构体
  13. 枚举
  14. 并发

1. 构建运行环境

我们在Rust环境配置和入门指南中详细介绍了

  • 如何安装Rust环境
  • 构建一个Rust应用
  • 编译和运行的区别
  • 使用Cargo构建Rust应用

下面，我们就之间直入主题了。

通过创建一个名为 main.rs 的文件并将以下代码放入其中来编写我们的第一个 Rust 代码：

rust
复制代码
fn main() {
    println!("Hello, Front789!");
}

然后通过运行 rustc main.rs 和 ./main.exe 来运行这个程序，就像运行 C 程序一样。

Cargo 是 Rust 的构建系统和包管理器

我们也可以使用 cargo 创建项目。

  • cargo new hello_cargo：初始化一个新项目。
  • cargo build：构建一个 cargo 项目。
  • cargo run：运行一个 cargo 项目，这将编译并运行代码。
  • cargo check：检查是否有编译错误，它比cargo build速度更快。
  • cargo build --release：这将使用优化进行编译，用于最终生产构建。

2. 变量类型

在 Rust 中，默认情况下变量是不可变的，这意味着一旦给变量赋值，其值就不会改变。

所以如果想要一个可变的，即可改变的值，使用 mut。

rust
复制代码
let a = 5;
let mut b = 5; // 可变的
  • 整数：有各种大小的有符号和无符号整数（例如，i8、i16、i32、i64、u8、u16、u32、u64） New Image
rust
复制代码
let number: i32 = 42;
  • 浮点数：单精度和双精度浮点数（例如，f32、f64） New Image
rust
复制代码
let pi: f64 = 3.14159;
  • 布尔值：Rust的布尔类型只拥有两个可能的值true和false，它只会占据单个字节的空间大小。使用bool来表示一个布尔类型。
rust
复制代码
let is_rust_cool: bool = true;
  • 字符：在Rust中char类型占4字节，是一个Unicode标量值，这意味着它可以表示比ASCII多的字符内容。使用char 类型表示一个字符类型
rust
复制代码
let heart_emoji: char = ''❤'';
  • 字符串：可变字符串 New Image
rust
复制代码
let mut s = String::from("front789");
  • 字符串切片：不可变且借用的字符串切片
rust
复制代码
let s1: &str = "front789";
  • 数组：数组中每一个元素都必须是相同类型。 Rust中数组拥有固定的长度，一旦声明就再也不能随意更改大小
rust
复制代码
let array: [i32; 3] = [1, 2, 3];
let a = [3; 5]; // 用值 3 初始化大小为 5 的数组
  • 元组 New Image
    • 为了从元组中获得单个的值，可以使用模式匹配来解构元组
    • 还可以通过索引并使用点号(.)来访问元组中的值
rust
复制代码
let tup = (500, 6.4, 1);
let (x, y, z) = tup;
let aa = tup.0; // 引用元组中的第一个项目

  • 向量 New Image

  • 指针和引用

    • 指针是一个变量，它存储了一个值的内存地址
    • Rust 中最常见的指针是引用。引用以 & 符号为标志并借用了它们所指向的值。除了引用数据没有任何其他特殊功能。它们也没有任何额外开销，所以应用得最多。
rust
复制代码
fn main() {
    // 标量类型
    let number: i32 = 42;
    let pi: f64 = 3.14159;
    let is_rust_cool: bool = true;
    let heart_emoji: char = ''❤'';

    // 复合类型
    let array: [i32; 3] = [1, 2, 3];
    let tuple: (i32, f64, char) = (10, 3.14, ''a'');
    let slice: &[i32] = &[1, 2, 3];
    let string: String = String::from("Hello, Front789!");
    let string_slice: &str = "Hello, Front789!";

    // 特殊类型
    let reference_to_number: &i32 = &number;
    let optional_value: Option<i32> = Some(42);
    let result_value: Result<i32, &str> = Ok(42);
}

以上内容就是Rust中所涉及到的各种数据类型，我们可以从以下的链接中找到更为详细的解释

3. 操作数组

不可变数组：

不可变数组在 Rust 中用 [T; N] 语法来声明,其中 T 表示数组元素的类型,而 N 表示数组的长度。

对于不可变数组,我们可以使用下标访问其元素,但不能修改元素的值。

rust
复制代码
let array = [1, 2, 3, 4, 5];
let first_element = array[0]; // 访问第一个元素
arr[0] = 6; // 这行代码会导致编译错误,因为数组是不可变的

// 迭代
// 使用 for 循环
for &num in &array {
    println!("{}", num);
}
// 另一种迭代器
array.iter().for_each(|&num| {
    println!("{}", num);
});

let slice = &array[1..3]; // 从索引 1 到索引 2（包括）切片

可变数组

Vec<T> 是 Rust 中可变长数组的实现,它允许您动态地增加或减少数组的大小。

rust
复制代码
let mut array = [1, 2, 3, 4, 5];
array[0] = 10; // 修改第一个元素

let mut vec = Vec::new(); // 创建一个空 Vec
vec.push(1); // 向 Vec 中添加一个元素
vec.push(2);
vec.push(3);

// 使用 iter() 遍历元素

for item in array.iter() {
    println!("{}", item);
}

// iter_mut() 方法返回一个可变的迭代器,允许修改 Vec 中的元素
for item in array.iter_mut() {
    *item += 1; // 对每个元素加 1
}

// map
let doubled_array: Vec<_> = 
    array.iter()
    .map(|&num| num * 2)
    .collect();

// filter
let even_elements: Vec<_> = 
    array.iter()
    .filter(|&&num| num % 2 == 0)
    .collect();

// len() 方法返回 Vec 中元素的数量
array.len()

// remove() 方法移除指定索引位置的元素,并返回该元素。如果索引越界,它将导致 panic。
let removed_item = array.remove(2) // removed_item 为3

4. 操作字符串

rust
复制代码
let s1 = String::from("Hello, ");
let s2 = String::from("Front789!");
let combined = s1 + &s2; // 注意：s1 在这里被移动，之后不能再使用
println!("{}", combined); // 打印 "Hello, Front789!"

let mut s = String::from("Hello, ");
s.push_str("Front789!");
println!("{}", s); // 打印 "Hello, Front789!"

// 获取字符
let s = String::from("hello");
let first_char = s.chars().nth(0); // 访问第一个字符

// 子字符串
let s = String::from("hello Front789");
let substring = &s[0..5]; // 提取 "hello"

// len()
let s = String::from("hello");
let length = s.len(); // 字符串的长度

// replace
let s = String::from("hello");
let replaced = s.replace("l", "z"); // 替换 "l" 为 "z"

// split
let s = String::from("hello Front789");
let words: Vec<&str> = s.split_whitespace().collect(); // 分割成单词

// 转换 &str 和 String
let s = String::from("hello");
let s_ref: &str = &s; // 将 String 转换为 &str
let s_copy: String = s_ref.into(); // 将 &str 转换为 String

5. 操作向量

rust
复制代码
let mut v1 = vec![1, 2, 3]; // 使用 vec![] 宏
let mut v2: Vec<i32> = Vec::new(); // 使用 Vec::new() 构造函数

let mut v = Vec::new();
v.push(1);
v.push(2);

let first_element = v[0]; // 访问第一个元素

// 迭代
// 使用 for 循环
for num in &v {
    println!("{}", num);
}

// 使用迭代器
v.iter().for_each(|&num| {
    println!("{}", num);
});

// slice
let slice = &v[1..3]; // 从索引 1 到索引 2（包括）提取元素

// remove
let removed_element = v.remove(1); // 移除索引为 1 的元素（返回被移除的元素）

// sort()
v.sort();

// join
let tt= vec!["hello", "Front789"];
let joined_string = tt.join(", "); // 使用逗号和空格连接元素

6. 函数

Rust代码使用蛇形命名法来作为规范函数和变量名称的风格。蛇形命名法只使用小写的字母进行命名，并以下画线分隔单词。

  1. 参数,它们是一种特殊的变量，并被视作函数签名的一部分。当函数存在参数时，你需要在调用函数时为这些变量提供具体的值
  2. 在Rust中，函数的返回值等同于函数体的最后一个表达式。

语法

rust
复制代码
fn 函数名(参数1: 类型1, 参数2: 类型2) -> 返回类型 {
    // 函数体
    // 可选的表达式
}

最后一行返回值时不需要调用 return。

rust
复制代码
fn add_numbers(x: i32, y: i32) -> i32 {
    let sum = x + y;
    sum // 函数中的最后一个表达式会隐式返回
}

如果想要一个无返回值的函数，不要定义返回类型。

我们可以在基础概念_函数部分查看更详细的解释

7. 输入/输出

输入

要读取一个值，使用 io stdin 并给出变量的值，在失败时需要提供 expect 消息，否则会出错。

rust
复制代码
let mut guess = String::new();    
io::stdin().read_line(&mut guess).expect("该行读取失败");

输出 / 打印

rust
复制代码
println!("输出对应的变量信息 {}", guess); // 这里的 guess 是变量名。

你也可以在末尾有变量

rust
复制代码
let y = 10;

println!("y + 2 = {}", y + 2);

8. Shadowing

在Rust中，一个新的声明变量可以覆盖掉旧的同名变量，我们把这一个现象描述为：第一个变量被第二个变量遮蔽Shadow了。这意味着随后使用这个名称时，它指向的将会是第二个变量。

rust
复制代码
fn main() {
    let x = 5; // 定义值为 5 的变量 x
    println!("原始值 x: {}", x); // 打印 "原始值 x: 5"
    
    let x = 10; // Shadowing：定义一个新的值为 10 的变量 x
    println!("Shadowed x: {}", x); // 打印 "Shadowed x: 10"
}

New Image

9. 控制块

New Image

If else

rust
复制代码
if condition1 {
    // 如果 condition1 为真，则执行的代码
} else if condition2 {
    // 如果 condition2 为真，则执行的代码
} else {
    // 如果 condition1 和 condition2 都为假，则执行的代码
}

10. 循环

Rust提供了3种循环

  1. loop
  2. while
  3. for

loop

rust
复制代码
loop {
    println!("永无止境的执行");
}

While 循环

rust
复制代码
let mut count = 0;
while count < 5 {
    println!("Count: {}", count);
    count += 1;
}

For 循环

rust
复制代码
for i in 0..5 {
    println!("{}", i);
}

foreach

当然也少不了对数值的遍历操作。

rust
复制代码
(1..=5).for_each(|num| {
    println!("Number: {}", num);
});
// Number: 1
// Number: 2
// Number: 3
// Number: 4
// Number: 5

..:它表示一个扩展运算符，表示从第一个数字到最后一个数字生成。

我们也可以在循环中使用 continue 和 break。

11. 所有权

New Image

这个概念是需要特别注意和反复观看的部分。

MOVE（或）重新分配变量

当变量值被重新分配时，值会给新的所有者，并且旧的所有者被丢弃。

这种行为在字符串中经常看到，而不是其他类型，如下所示：

rust
复制代码
let s1 = String::from("hello");
let s2 = s1;

println!("{}, world!", s1);

这将导致错误，因为 s1 在 s2=s1 之后不再有效。

如何解决上面的问题呢，我们可以使用 Clone：

rust
复制代码
let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2);

某些类型隐式实现了 Clone。

rust
复制代码
let x = 5; // x 拥有整数 5
let y = x; // 将 x 的值复制到 y，不传递所有权

例如，整数隐式实现了 Clone，因此这段代码不会报错。

New Image

所有权和函数

rust
复制代码
fn main() {
    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移动进入函数...
                                    // ... 所以这里不再有效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 会移入函数，
                                    // 但 i32 是 Copy，所以在之后继续使用 x 是可以的

} // 在这里，x 超出作用域，然后是 s。但因为 s 的值被移动了，所以没有什么特别的发生。

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 在这里，some_string 超出作用域，调用 drop。内存被释放。

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 在这里，some_integer 超出作用域。没有什么特别的发生。

如果我们像在变量被移动后，继续使用，那么我们就使用 takes_ownership(s.clone()); （或者）在 takes_ownership 函数中返回值，像这样：

rust
复制代码
fn main() {
    let s2 = String::from("hello");     // s2 进入作用域
    let s3 = takes_and_gives_back(s2);  // s2 移入并被返回
}

fn takes_and_gives_back(a_string: String) -> String { 
    a_string  // 返回并移出到调用函数
}

借用 — 所有权

传递变量的引用，所有权不会被传递。

我们称创建引用的操作为借用。就像现实生活中，如果一个人拥有一样东西，你可以从他们那里借来。借了之后，你必须归还。你不拥有它。

rust
复制代码
fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of ''{}'' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

针对此处更详细的内容，可以翻看我们之前的所有权

12. 结构体

struct，或者 structure，是一个自定义数据类型，允许我们命名和包装多个相关的值，从而形成一个有意义的组合。

New Image

rust
复制代码
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let mut user1 = User {
        active: true,
        username: String::from("front789"),
        email: String::from("front789@example.com"),
        sign_in_count: 1,
    };

    user1.email = String::from("anotheremail@example.com");

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}

在 user2 中，你会看到 ..，它是扩展运算符，将 user1 中剩余的值传递给 user2（除了已经定义的 email）。

结构体的方法

使用 impl 结构体名，并在其中定义函数。

rust
复制代码
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "长方形的面积为 {}",
        rect1.area()
    );
}

New Image

针对此处更详细的内容，可以翻看我们之前的结构体

13. 枚举

枚举，也被称作 enums。枚举允许你通过列举可能的成员variants来定义一个类型

rust
复制代码
enum IpAddrKind {
    V4,
    V6,
}

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

枚举的成员位于其标识符的命名空间中，并使用两个冒号分开。

match

这是类似于 switch 的东西，

rust
复制代码
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }

    let number = 5;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 | 4 | 5 => println!("Three, Four, or Five"),
        _ => println!("Other"), // 默认情况
    }
}

每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 match 表达式的返回值。

Option 枚举和其相对于空值的优势

New Image

if Let

这是一种使用 if 的花式方式，我们在其中定义一个表达式。

rust
复制代码
fn main() {
    let optional_number: Option<i32> = Some(5);

    // 使用 if let 匹配 Some 变体并提取内部值
    if let Some(num) = optional_number {
        println!("Value: {}", num);
    } else {
        println!("No value");
    }
}

14. 并发性

并发编程和并行编程

New Image

代码实现

为了创建一个新线程，需要调用 thread::spawn 函数并传递一个闭包，并在其中包含希望在新线程运行的代码。

可以通过将 thread::spawn 的返回值储存在变量中来修复新建线程部分没有执行或者完全没有执行的问题。thread::spawn 的返回值类型是 JoinHandle。JoinHandle 是一个拥有所有权的值，当对其调用 join 方法时，它会等待其线程结束。

rust
复制代码
use std::thread;

fn main() {
    // 数据
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // 将数据分成两部分
    let mid = numbers.len() / 2;
    let (left, right) = numbers.split_at(mid);

    // 生成两个线程来计算每一半的总和
    let handle1 = thread::spawn(move || sum(left));
    let handle2 = thread::spawn(move || sum(right));

    // 等待线程完成并获取它们的结果
    let result1 = handle1.join().unwrap();
    let result2 = handle2.join().unwrap();

    // 计算最终总和
    let total_sum = result1 + result2;

    println!("Total sum: {}", total_sum);
}

fn sum(numbers: &[i32]) -> i32 {
    let mut sum = 0;
    for &num in numbers {
        sum += num;
    }
    sum
}

thread::spawn 要求闭包具有 ''static 生命周期，这意味着它不会从周围范围借用任何东西，并且可以在整个程序的持续时间内存在。

因此，我们使用move 闭包，其经常与 thread::spawn 一起使用，因为它允许我们在一个线程中使用另一个线程的数据。

针对此处更详细的内容，可以翻看我们之前的并发

后记

分享是一种态度。

全文完，既然看到这里了，如果觉得不错，随手点个赞和“在看”吧。

New Image

标签： 技术社区

相关文章