Rust 中的 Result ：错误处理

关山月2025-03-11 12:58

Rust 中的 Result

Rust 是一种系统编程语言，提供了一种独特的错误处理机制。在 Rust 中，错误分为两种类型：可恢复错误和不可恢复错误。对于可恢复错误，Rust 提供了 Result 来处理它们。

Result 的定义

Result 是一个枚举类型，包含两个变体：Ok 和 Err。Ok 表示操作成功，并包含一个成功值；而 Err 表示操作失败，并包含一个错误值。

以下是 Result 的定义：

rust 复制代码 
enum Result<T, E> {
    Ok(T),
    Err(E),
}

这里，T 表示成功值的类型，E 表示错误值的类型。

Result 的用法

Result 类型通常用作函数的返回值。当函数执行成功时，它返回 Ok 变体；当函数执行失败时，它返回 Err 变体。

以下是一个简单的例子：

rust 复制代码 
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide(4.0, 2.0);
    match result {
        Ok(value) => println!("Result: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

在这个例子中，divide 函数接受两个参数：被除数和除数。如果除数是 0，则返回 Err ；否则，返回 Ok 。

如何用 Result 处理错误

调用 Result 类型的函数时，需要处理潜在的错误。有几种方法可以做到这一点：

使用 match 语句

以下是一个简单的例子：

rust 复制代码 
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide(4.0, 2.0);
    match result {
        Ok(value) => println!("Result: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

使用 if let 语句

if let 语句是 match 的简化版本。它只能匹配一种情况，不需要处理其他情况。

以下是一个简单的例子：

rust 复制代码 
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide(4.0, 2.0);
    if let Ok(value) = result {
        println!("Result: {}", value);
    }
}

使用 ? 操作符

? 操作符是 Rust 中的一种特殊语法，允许从函数内部方便地传播错误。

以下是一个简单的例子：

rust 复制代码 
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(numerator / denominator)
    }
}

fn calculate(numerator: f64, denominator: f64) -> Result<f64, String> {
    let result = divide(numerator, denominator)?;
    Ok(result * 2.0)
}

fn main() {
    let result = calculate(4.0, 2.0);
    match result {
        Ok(value) => println!("Result: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Result 的常用方法

is_ok 和 is_err 方法

is_ok 和 is_err 方法分别检查 Result 是否是 Ok 或 Err 。

以下是一个简单的例子：

rust 复制代码 
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide(4.0, 2.0);
    if result.is_ok() {
        println!("Result: {}", result.unwrap());
    } else {
        println!("Error: {}", result.unwrap_err());
    }
}

unwrap 和 unwrap_err 方法

unwrap 和 unwrap_err 方法分别从 Result 中获取成功值或错误值。如果 Result 不是预期的变体，则会发生恐慌。

以下是一个简单的例子：

rust 复制代码 
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide(4.0, 2.0);
    let value = result.unwrap();
    println!("Result: {}", value);
}

expect 和 expect_err 方法

expect 和 expect_err 方法与 unwrap 和 unwrap_err 类似，但允许指定自定义错误消息。

以下是一个简单的例子：

rust 复制代码 
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide(4.0, 2.0);
    let value = result.expect("Failed to divide");
    println!("Result: {}", value);
}

Result 的特点和优势

Result 类型具有以下特点和优势：

  • 明确的错误处理：Result 类型强制程序员显式处理错误。
  • 类型安全：Result 类型是一个泛型类型，可以包含任何类型的成功或错误。
  • 方便的错误传播：Rust 提供了 ? 操作符，可以轻松地从函数内部传播错误。
  • 易于组合：Result 类型提供了多种组合方法，如 and、or、and_then 和 or_else。

在代码中使用 Result

以下是一个简单的例子：

rust 复制代码 
use std::num::ParseIntError;

type Result<T> = std::result::Result<T, MyError>;

#[derive(Debug)]
enum MyError {
    DivideByZero,
    ParseIntError(ParseIntError),
}

impl From<ParseIntError> for MyError {
    fn from(e: ParseIntError) -> Self {
        MyError::ParseIntError(e)
    }
}

fn divide(numerator: &str, denominator: &str) -> Result<f64> {
    let numerator: f64 = numerator.parse()?;
    let denominator: f64 = denominator.parse()?;

    if denominator == 0.0 {
        Err(MyError::DivideByZero)
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide("4", "2");
    match result {
        Ok(value) => println!("Result: {}", value),
        Err(e) => println!("Error: {:?}", e),
    }
}

在这个例子中：

  • 我们定义了一个自定义错误类型 MyError，它包含两个变体：DivideByZero 和 ParseIntError。
  • 我们定义了一个类型别名 Result，将 MyError 作为错误类型。
  • divide 函数接受两个字符串参数，并尝试将它们解析为 f64。如果解析失败，使用 ? 操作符传播错误。如果除数是 0，则返回 Err ；否则，函数返回 Ok。

使用 Result 处理文件读/写错误

在处理文件操作时，可能会遇到各种错误，例如文件不存在或权限不足。

以下是一个简单的例子：

rust 复制代码 
use std::fs;
use std::io;

fn read_file(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}

fn main() {
    let result = read_file("test.txt");
    match result {
        Ok(content) => println!("File content: {}", content),
        Err(e) => println!("Error: {}", e),
    }
}

在这个例子中：

  • read_file 函数接受一个文件路径作为参数，并使用 fs::read_to_string 读取文件内容。
  • fs::read_to_string 返回一个 Result 类型，成功值包含文件内容，错误值类型为 io::Error。
  • 在 main 中，我们调用 read_file 并使用 match 处理返回值。如果返回值是 Ok，我们打印文件内容；如果是 Err，我们打印错误消息。

使用 Result 处理网络请求错误

以下是一个简单的例子：

rust 复制代码 
use std::io;
use std::net::TcpStream;

fn connect(host: &str) -> Result<TcpStream, io::Error> {
    TcpStream::connect(host)
}

fn main() {
    let result = connect("example.com:80");
    match result {
        Ok(stream) => println!("Connected to {}", stream.peer_addr().unwrap()),
        Err(e) => println!("Error: {}", e),
    }
}

在这个例子中：

  • connect 函数接受一个主机地址作为参数，并使用 TcpStream::connect 建立 TCP 连接。
  • TcpStream::connect 返回一个 Result 类型，成功值类型为 TcpStream，错误值类型为 io::Error。
  • 在 main 中，我们调用 connect 并使用 match 处理返回值。如果返回值是 Ok，我们打印连接信息；如果是 Err，我们打印错误消息。

Result 和错误处理的最佳实践

在使用 Result 处理错误时，以下最佳实践可以帮助编写更好的代码：

  • 定义自定义错误类型：自定义错误类型有助于更有效地组织和管理错误信息。
  • 使用 ? 操作符传播错误：? 操作符使从函数内部传播错误变得容易。
  • 避免过度使用 unwrap 和 expect：这些方法在遇到 Err 时会导致恐慌。相反，应使用 match 或 if let 正确处理错误。
  • 使用组合方法组合多个 Result 值：and、or、and_then 和 or_else 等方法有助于组合多个 Result 值。

原文：dev.to/leapcell/ru...

相关推荐
UestcXiye6 小时前
Rust 学习笔记：函数和控制流
rust
Source.Liu10 小时前
【mdlib】0 全面介绍 mdlib - Rust 实现的 Markdown 工具集
rust·markdown
机构师12 小时前
<rust><iced><GUI>iced中的复合列表部件：combo_box
后端·rust
景天科技苑16 小时前
【Rust】Rust中的枚举与模式匹配，原理解析与应用实战
开发语言·后端·rust·match·enum·枚举与模式匹配·rust枚举与模式匹配
红尘散仙17 小时前
七、WebGPU 基础入门——Texture 纹理
前端·rust·gpu
红尘散仙17 小时前
八、WebGPU 基础入门——加载图像纹理
前端·rust·gpu
w4ngzhen17 小时前
关于Bevy中的原型Archetypes
rust·游戏开发
sayornottt18 小时前
Rust中的动态分发
后端·rust
YiSLWLL1 天前
使用Tauri 2.3.1+Leptos 0.7.8开发桌面小程序汇总
python·rust·sqlite·matplotlib·visual studio code
yu4106211 天前
Rust 语言使用场景分析
开发语言·后端·rust
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07西电B测-计算机网络综合实验(含验收问题)08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09苍穹外卖面试总结10最新 Kubernetes 集群部署 + flannel 网络插件（保姆级教程，最新 K8S 版本）