Rust 跨平台应用开发第一章：快速上手 Rust——实用示例

1.3 实用示例

在这一节中，我们将通过一系列实用的示例来帮助您更好地理解 Rust 的特性，并展示如何在实际项目中使用这些特性。示例将涵盖文件操作、网络请求、并发编程、命令行工具以及使用 Cargo 管理依赖等多个方面。

1.3.1 文件操作示例

Rust 提供了强大的标准库来进行文件操作。在这个示例中，我们将实现一个简单的文本文件读写程序。

创建和写入文件

我们将使用 std::fs 模块中的 File 和 Write trait 来创建和写入文件。

use std::fs::File;
use std::io::{self, Write};

fn write_to_file(filename: &str, content: &str) -> io::Result<()> {
    let mut file = File::create(filename)?;
    file.write_all(content.as_bytes())?;
    Ok(())
}

fn main() {
    match write_to_file("output.txt", "Hello, Rust!") {
        Ok(_) => println!("File written successfully."),
        Err(e) => println!("Failed to write to file: {}", e),
    }
}

读取文件

接下来，我们将读取文件的内容并打印到控制台。

use std::fs::read_to_string;

fn read_from_file(filename: &str) -> io::Result<String> {
    let content = read_to_string(filename)?;
    Ok(content)
}

fn main() {
    match read_from_file("output.txt") {
        Ok(content) => println!("File content:\n{}", content),
        Err(e) => println!("Failed to read file: {}", e),
    }
}

1.3.2 网络请求示例

Rust 的 reqwest 库使得发起 HTTP 请求变得非常简单。以下示例将演示如何发送 GET 请求并处理响应。

使用 reqwest 库

首先，确保在 Cargo.toml 中添加 reqwest 依赖：

[dependencies]
reqwest = { version = "0.11", features = ["blocking"] }
tokio = { version = "1", features = ["full"] }

发送 GET 请求

下面的代码示例演示了如何发送 GET 请求并处理 JSON 响应。

use reqwest::blocking::get;
use reqwest::Error;
use serde::Deserialize;

#[derive(Deserialize)]
struct ApiResponse {
    userId: u32,
    id: u32,
    title: String,
    completed: bool,
}

fn fetch_data(url: &str) -> Result<ApiResponse, Error> {
    let response = get(url)?.json()?;
    Ok(response)
}

fn main() {
    let url = "https://jsonplaceholder.typicode.com/todos/1";
    match fetch_data(url) {
        Ok(data) => println!("Fetched data: {:?}", data),
        Err(e) => println!("Error fetching data: {}", e),
    }
}

1.3.3 并发编程示例

Rust 提供了内置的支持用于并发编程。在这个示例中，我们将使用 std::thread 模块创建多个线程并处理数据。

创建线程

下面的代码示例演示了如何创建多个线程，并在每个线程中执行计算任务。

use std::thread;

fn main() {
    let mut handles = vec![];

    for i in 0..5 {
        let handle = thread::spawn(move || {
            println!("Thread {} is running", i);
            // 模拟计算
            i * i
        });
        handles.push(handle);
    }

    for handle in handles {
        match handle.join() {
            Ok(result) => println!("Thread result: {}", result),
            Err(e) => println!("Thread error: {:?}", e),
        }
    }
}

使用 Arc 和 Mutex

为了在多个线程间共享数据，我们可以使用 Arc 和 Mutex 组合。以下示例演示了如何安全地共享和修改数据。

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final count: {}", *counter.lock().unwrap());
}

1.3.4 数据库操作示例

Rust 也支持与数据库的交互。在这个示例中，我们将使用 diesel 库进行数据库操作。

设置 diesel

确保在 Cargo.toml 中添加 diesel 依赖：

[dependencies]
diesel = { version = "1.4", features = ["sqlite"] }

创建数据库连接

以下代码示例演示如何建立与 SQLite 数据库的连接。

#[macro_use]
extern crate diesel;

use diesel::prelude::*;
use diesel::sqlite::SqliteConnection;

fn establish_connection() -> SqliteConnection {
    SqliteConnection::establish("my_database.db")
        .expect(&format!("Error connecting to {}", "my_database.db"))
}

执行查询

以下示例演示了如何执行简单的查询，并处理结果。

#[derive(Queryable)]
struct User {
    id: i32,
    name: String,
}

fn get_users(connection: &SqliteConnection) -> Vec<User> {
    use diesel::dsl::insert_into;
    use diesel::table;

    let results = table::users::table.load::<User>(connection).expect("Error loading users");
    results
}

fn main() {
    let connection = establish_connection();
    let users = get_users(&connection);

    for user in users {
        println!("User {}: {}", user.id, user.name);
    }
}

1.3.5 编写一个简单的命令行工具

Rust 是编写命令行工具的理想选择，因其性能和简洁性。以下示例将展示如何编写一个简单的命令行工具，该工具能够接收用户输入并执行基本的文本操作。

创建新项目

首先，我们需要使用 Cargo 创建一个新的项目。打开终端并运行以下命令：

cargo new cli_tool
cd cli_tool

编写命令行工具代码

我们将在 src/main.rs 中编写代码，使其能够接收用户输入并输出处理后的结果。以下是一个简单的命令行工具，它接受用户输入的字符串并返回字符串的长度和反转结果。

use std::io;

fn main() {
    println!("请输入一个字符串：");

    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("读取输入失败");

    let trimmed_input = input.trim();
    let length = trimmed_input.len();
    let reversed: String = trimmed_input.chars().rev().collect();

    println!("您输入的字符串长度为：{}", length);
    println!("反转后的字符串为：{}", reversed);
}

运行命令行工具

在终端中运行以下命令，启动我们的命令行工具：

cargo run

输入一个字符串，您将看到工具返回该字符串的长度和反转结果。

1.3.6 使用 Cargo 管理依赖

Cargo 是 Rust 的构建系统和包管理器，能够轻松管理项目依赖。以下示例将展示如何在项目中添加和使用外部库。

添加依赖

假设我们想使用 regex 库来处理正则表达式。在 Cargo.toml 中，添加如下依赖：

[dependencies]
regex = "1"

使用外部库

在 src/main.rs 中，我们将使用 regex 库进行模式匹配。以下是一个使用正则表达式提取字符串中所有数字的示例。

use regex::Regex;
use std::io;

fn main() {
    println!("请输入一个字符串：");

    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("读取输入失败");

    let re = Regex::new(r"\d+").unwrap();
    let numbers: Vec<&str> = re.find_iter(&input).map(|mat| mat.as_str()).collect();

    println!("输入字符串中的数字有：{:?}", numbers);
}

运行项目

再次使用以下命令运行项目，您将能够输入一个字符串，并看到其中提取出的所有数字。

cargo run

小结

在本节中，我们通过一系列实用示例展示了 Rust 在文件操作、网络请求、并发编程、命令行工具以及数据库操作等方面的应用。这些示例不仅展示了 Rust 的强大功能，还提供了实际开发中的指导和参考。通过这些示例，您可以更好地理解 Rust 的特性，并将其应用于您的项目中。