rust常用API，文件操作

Rust 中主要有两种字符串类型：

• String：可变的、动态大小的字符串类型。
• &str：不可变的、固定大小的字符串切片。

let s1 = String::new(); // 创建一个空的 String
let s2 = String::from("hello"); // 从字面量创建 String
let s3: &str = "world"; // 创建一个字符串切片

let s1 = String::from("hello");
let s2 = String::from(" world");
let s3 = s1 + &s2; // s1 被移动，s2 作为切片引用

let s1 = String::from("hello");
let s2 = String::from("world");
let s3 = format!("{} {}", s1, s2); // 使用 format! 宏进行格式化

let s = String::from("hello world");
let slice = &s[0..5]; // 获取 "hello" 的切片

let s = String::from("hello");
for c in s.chars() {
    println!("{}", c); // 逐字符遍历
}

let arr: [i32; 5] = [1, 2, 3, 4, 5]; // 创建一个包含 5 个 i32 元素的数组
let arr2 = [0; 5]; // 创建一个包含 5 个 0 的数组

在 Rust 中，数组是固定大小的集合，类型为 [T; N]，其中 T 是元素类型，N 是数组长度。数组的大小在编译时确定，因此不能动态改变大小。

fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    let mut vec: Vec<i32> = arr.to_vec(); // 将数组转换为 Vec
    vec.push(4); // 插入元素
    let new_arr: [i32; 4] = vec.try_into().expect("Vec length mismatch"); // 将 Vec 转换回数组
    println!("{:?}", new_arr); // 输出 [1, 2, 3, 4]
}

可以使用 slice 和 concat 方法将数组切片拼接成新的数组。

fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    let new_arr: [i32; 4] = [arr[0], arr[1], arr[2], 4];
    println!("{:?}", new_arr); // 输出 [1, 2, 3, 4]
}

由于元组的大小和类型是固定的，不能直接在元组中插入元素。

fn main() {
    let tuple: (i32, i32, i32) = (1, 2, 3);
    let new_tuple: (i32, i32, i32, i32) = (tuple.0, tuple.1, tuple.2, 4);
    println!("{:?}", new_tuple); // 输出 (1, 2, 3, 4)
}

除了使用 expect 方法，你还可以使用 match 表达式来处理 Result 类型的错误，这样可以更灵活地处理不同的错误情况。

fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    let mut vec: Vec<i32> = arr.to_vec();
    vec.push(4); // 增加一个元素，使 vec 的长度变为 4

    match vec.try_into() {
        Ok(new_arr) => println!("{:?}", new_arr),
        Err(e) => println!("Error: {:?}", e),
    }
}

读取文件

use std::fs;
use std::io::{self, Read};

fn read_file(file_path: &str) -> io::Result<String> {
    let mut file = fs::File::open(file_path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() -> io::Result<()> {
    let file_path = "example.txt";
    let contents = read_file(file_path)?;
    println!("File contents:\n{}", contents);
    Ok(())
}

写入文件

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

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

fn main() -> io::Result<()> {
    let file_path = "example.txt";
    let content = "Hello, Rust!";
    write_file(file_path, content)?;
    println!("File written successfully");
    Ok(())
}

在 Rust 中，Result 是一个枚举类型，用于表示可能成功或失败的操作。Result 有两个变体：

• Ok(T)：表示操作成功，包含成功的结果值 T。
• Err(E)：表示操作失败，包含错误值 E。

在 Rust 中，() 是一个单元类型（unit type），表示没有值。它通常用于表示函数没有返回值，或者表示一个操作成功但没有返回任何有用的结果。

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

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

fn main() -> io::Result<()> {
    let file_path = "example.txt";
    let content = "Hello, Rust!";
    write_file(file_path, content)?;
    println!("File written successfully");
    Ok(())
}

Rust 中的异常处理主要通过 Result 和 Option 类型来实现。Result 用于表示可能失败的操作，Option 用于表示可能不存在的值。

? 操作符用于简化错误处理。当一个表达式返回 Result 或 Option 类型时，? 操作符会自动处理 Err 或 None，并提前返回错误。例如：

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

fn read_file(file_path: &str) -> io::Result<String> {
    let mut file = File::open(file_path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() -> io::Result<()> {
    let file_path = "example.txt";
    let contents = read_file(file_path)?;
    println!("File contents:\n{}", contents);
    Ok(())
}