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...

相关推荐
JordanHaidee25 分钟前
【Rust GUI开发入门】编写一个本地音乐播放器（12. 国际化应用-多语言支持）
rust
红烧code14 小时前
【Rust GUI开发入门】编写一个本地音乐播放器（4. 绘制按钮组件）
rust·gui·svg·slint
朝阳58116 小时前
使用过程宏实现自动化新增功能
后端·rust
JordanHaidee17 小时前
【Rust GUI开发入门】编写一个本地音乐播放器（8. 从文件中提取歌曲元信息）
rust
清心91520 小时前
Windows系统Rust安装与配置，解决安装慢问题
rust
清心91520 小时前
Windows系统Rust安装，自定义安装目录
rust
恒云客1 天前
Rust开发环境配置
开发语言·后端·rust
红烧code2 天前
【Rust GUI开发入门】编写一个本地音乐播放器（1. 主要技术选型&架构设计）
rust·gui·slint·rodio·lofty
JordanHaidee2 天前
【Rust GUI开发入门】编写一个本地音乐播放器（3. UI与后台线程通信）
rust
Source.Liu2 天前
【mdBook】1 安装
笔记·rust·markdown
热门推荐
01OpenSpeedy简介02在国行 macOS 下用 DeepSeek 补齐 Xcode 26 的 AI 能力：问题、原因与 mitmproxy 解决方案（含可用脚本与安装教程）03UV安装并设置国内源04GitHub 镜像站点05UV 工具安装与国内镜像源配置指南06KGG转MP3工具|非KGM文件|解密音频07阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换08Spec-Kit 使用指南09Linux下V2Ray安装配置指南10VsCode远程Copilot无法使用Claude Agent问题