std1.97.1——result模块细览

梦醒沉醉2026-08-30 12:33

目录

  • [0. 引言](#0. 引言)
  • [1. Result枚举](#1. Result枚举)
    • [1.1 针对Result\<T, E\>的方法](#1.1 针对Result<T, E>的方法)
      • [1.1.1 is_ok](#1.1.1 is_ok)
      • [1.1.2 is_ok_and](#1.1.2 is_ok_and)
      • [1.1.3 is_err](#1.1.3 is_err)
      • [1.1.4 is_err_and](#1.1.4 is_err_and)
      • [1.1.5 ok](#1.1.5 ok)
      • [1.1.6 err](#1.1.6 err)
      • [1.1.7 as_ref](#1.1.7 as_ref)
      • [1.1.8 as_mut](#1.1.8 as_mut)
      • [1.1.9 map](#1.1.9 map)
      • [1.1.10 map_or](#1.1.10 map_or)
      • [1.1.11 map_or_else](#1.1.11 map_or_else)
      • [1.1.12 map_err](#1.1.12 map_err)
      • [1.1.13 inspect](#1.1.13 inspect)
      • [1.1.14 inspect_err](#1.1.14 inspect_err)
      • [1.1.15 as_deref](#1.1.15 as_deref)
      • [1.1.16 as_deref_mut](#1.1.16 as_deref_mut)
      • [1.1.17 iter](#1.1.17 iter)
      • [1.1.18 iter_mut](#1.1.18 iter_mut)
      • [1.1.19 expect](#1.1.19 expect)
      • [1.1.20 unwrap](#1.1.20 unwrap)
      • [1.1.21 unwrap_or_default](#1.1.21 unwrap_or_default)
      • [1.1.22 expect_err](#1.1.22 expect_err)
      • [1.1.23 unwrap_err](#1.1.23 unwrap_err)
      • [1.1.24 and](#1.1.24 and)
      • [1.1.25 and_then](#1.1.25 and_then)
      • [1.1.26 or](#1.1.26 or)
      • [1.1.27 or_else](#1.1.27 or_else)
      • [1.1.28 unwrap_or](#1.1.28 unwrap_or)
      • [1.1.29 unwrap_or_else](#1.1.29 unwrap_or_else)
      • [1.1.30 unwrap_unchecked(unsafe，使用unwrap)](#1.1.30 unwrap_unchecked(unsafe，使用unwrap))
      • [1.1.31 unwrap_err_unchecked(unsafe，使用unwrap_err)](#1.1.31 unwrap_err_unchecked(unsafe，使用unwrap_err))
    • [1.2 针对Result\<&T, E\>的方法](#1.2 针对Result<&T, E>的方法)
      • [1.2.1 copied](#1.2.1 copied)
      • [1.2.2 cloned](#1.2.2 cloned)
    • [1.3 针对Result\<&mut T, E\>的方法](#1.3 针对Result<&mut T, E>的方法)
      • [1.3.1 copied](#1.3.1 copied)
      • [1.3.2 cloned](#1.3.2 cloned)
    • [1.4 针对Result\<Option\<T\>, E\>的方法](#1.4 针对Result<Option<T>, E>的方法)
      • [1.4.1 transpose](#1.4.1 transpose)
    • [1.5 针对Result<Result<T, E>, E>的方法](#1.5 针对Result<Result<T, E>, E>的方法)
      • [1.5.1 flatten](#1.5.1 flatten)

0. 引言

  Result<T, E>和Option<T>有些方法很像，主要是两者只有两个枚举变体，Result两个枚举变体都有值。

1. Result枚举

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

1.1 针对Result<T, E>的方法

1.1.1 is_ok

  方法签名：

rust 复制代码 
pub const fn is_ok(&self) -> bool

  如果Result是Ok变体，返回true，否则返回false。

rust 复制代码 
fn main() {
	let x: Result<i32, &str> = Ok(-3);
	println!("{}", x.is_ok());
	let x: Result<i32, &str> = Err("Some error message");
	println!("{}", x.is_ok());
}

1.1.2 is_ok_and

  方法签名：

rust 复制代码 
pub fn is_ok_and<F>(self, f: F) -> bool
where
	F: FnOnce(T) -> bool,

  参数f接受任何实现了FnOnce(T) -> bool的类型，包括闭包 、函数指针和函数项。方法会消耗自身。如果Result为Ok(v)，将v传给f，返回f(v)，否则返回false。

rust 复制代码 
fn greater_than_one(x: u32) -> bool {
	x > 1
}

fn main() {
	// 闭包
	let x1: Result<u32, &str> = Ok(2);
	println!("{}", x1.is_ok_and(|x| x > 1));
	let x2: Result<u32, &str> = Ok(0);
	println!("{}", x2.is_ok_and(|x| x > 1));
	let x3: Result<u32, &str> = Err("hey");
	println!("{}", x3.is_ok_and(|x| x > 1));
	let x: Result<String, &str> = Ok("ownership".into());
	println!("{}", x.as_ref().is_ok_and(|x| x.len() > 1));
	println!("still alive {:?}", x);
	// 函数项
	println!("{}", x1.is_ok_and(greater_than_one));
	println!("{}", x2.is_ok_and(greater_than_one));
	println!("{}", x3.is_ok_and(greater_than_one));
}

1.1.3 is_err

  方法签名：

rust 复制代码 
pub const fn is_err(&self) -> bool

  如果Result是Err，返回true，否则返回false。

rust 复制代码 
fn main() {
	let x: Result<i32, &str> = Ok(-3);
	println!("{}", x.is_err());
	let x: Result<i32, &str> = Err("Some error message");
	println!("{}", x.is_err());
}

1.1.4 is_err_and

  方法签名：

rust 复制代码 
pub fn is_err_and<F>(self, f: F) -> bool 
where
	F: FnOnce(E) -> bool,

    参数f接受任何实现了FnOnce(E) -> bool的类型，包括闭包 、函数指针和函数项。方法会消耗自身。如果Result是Err(v)，将v传给f，返回f(v)，否则返回false。

rust 复制代码 
use std::io::{Error, ErrorKind};

fn main() {
	let x: Result<i32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
	println!("{}", x.is_err_and(|x| x.kind() == ErrorKind::NotFound));
	let x: Result<i32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));
	println!("{}", x.is_err_and(|x| x.kind() == ErrorKind::NotFound));
	let x: Result<i32, Error> = Ok(123);
	println!("{}", x.is_err_and(|x| x.kind() == ErrorKind::NotFound));
	let x: Result<i32, String> = Err("ownership".into());
	println!("{}", x.as_ref().is_err_and(|x| x.len() > 1));
	println!("still alive {:?}", x);
}

1.1.5 ok

  方法签名：

rust 复制代码 
pub fn ok(self) -> Option<T>

  方法会消耗自身。将Result<T, E>转换为Option<T>，将Ok(T)映射为Some(T)，将Err(E)映射为None。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(2);
	println!("{:?}", x.ok());
	let x: Result<u32, &str> = Err("Nothing here");
	println!("{:?}", x.ok());
}

1.1.6 err

  方法签名：

rust 复制代码 
pub fn err(self) -> Option<E>

  方法会消耗自身。将Result<T, E>转换为Option<E>，将Ok(T)映射为None，将Err(E)映射为Option<E>。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(2);
	println!("{:?}", x.err());
	let x: Result<u32, &str> = Err("Nothing here");
	println!("{:?}", x.err());
}

1.1.7 as_ref

  方法签名：

rust 复制代码 
pub const as_ref(&self) -> Result<&T, &E>

  将&Result<T, E>转换为Result<&T, &E>。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(2);
	println!("{}", x.as_ref() == Ok(&2));
	let x: Result<u32, &str> = Err("Error");
	println!("{}", x.as_ref() == Err(&"Error")); 
}

1.1.8 as_mut

  方法签名：

rust 复制代码 
pub const fn as_mut(&mut self) -> Result<&mut T, &mut E>

  将&mut Result<T, E>转换为Result<&mut T, &mut E>。

rust 复制代码 
fn mutate(r: &mut Result<i32, i32>) {
	match r.as_mut() {
		Ok(v) => *v = 42,
		Err(e) => *e = 0,
	}
}

fn main() {
	let mut x: Result<i32, i32> = Ok(2);
	mutate(&mut x);
	println!("{:?}", x);
	let mut x: Result<i32, i32> = Err(13);
	mutate(&mut x);
	println!("{:?}", x);
}

1.1.9 map

  方法签名：

rust 复制代码 
pub fn map<U, F>(self, op: F) -> Result<U, E>
where
	F: FnOnce(T) -> U,

  参数f接受任何实现了FnOnce(T) -> U的类型，包括闭包 、函数指针和函数项。方法会消耗自身。将Result<T, E>转换为Result<U, E>，将Ok(v)映射为Ok(f(v))，将Err(e)映射为Err(e)。

rust 复制代码 
fn main() {
    let line = "1\n2\n3\n4\n";
    line.lines().for_each(|n| {
        n.parse::<i32>()
            .map(|i| i * 2)
            .inspect(|i| println!("{}", i))
            .unwrap();
    });
}

1.1.10 map_or

  方法签名：

rust 复制代码 
pub fn map_or<U, F>(self, default: U, f: F) -> U
where
	F: FnOnce(T) -> U,

  参数f接受任何实现了FnOnce(T) -> U的类型，包括闭包 、函数指针和函数项。方法会消耗自身。如果Result是Ok(v)，将v传给f，返回f(v)，否则返回default。

  传递给map_or的参数会被立即求值。如果传递的是函数调用的结果，建议使用map_or_else，它是惰性求值的。

rust 复制代码 
fn main() {
	let x: Result<_, &str> = Ok("foo");
	println!("{}", x.map_or(42, |v| v.len()));
	let x: Result<&str, _> = Err("bar");
	println!("{}", x.map_or(42, |v| v.len()));
}

1.1.11 map_or_else

  方法签名：

rust 复制代码 
pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where
	D: FnOnce(E) -> U,
	F: FnOnce(T) -> U,

  参数default接受任何实现了FnOnce(E) -> U的类型，包括闭包、函数指针和函数项。参数f接受任何实现了FnOnce(T) -> U的类型，包括闭包 、函数指针和函数项。方法会消耗自身。如果Result是Ok(v)，将v传给f，返回f(v)；如果是Err(e)，将e传给default，返回default(e)。

rust 复制代码 
fn main() {
	let k = 21;
	let x: Result<_, &str> = Ok("foo");
	println!("{}", x.map_or_else(|_e| k * 2, |v| v.len()));
	let x: Result<&str, _> = Err("test");
	println!("{}", x.map_or_else(|_e| k * 2, |v| v.len()));
}

1.1.12 map_err

  方法签名：

rust 复制代码 
pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where
	O: FnOnce(E) -> F,

  参数op接受任何实现了FnOnce(E) -> F的类型，包括闭包 、函数指针和函数项。方法会消耗自身。将Result<T, E>转换为Result<T, F>，将Ok(v)映射为Ok(v)，将Err(e)映射为Err(op(e))。

rust 复制代码 
fn stringify(x: u32) -> String {
	format!("error code: {x}")
}

fn main() {
	let x: Result<u32, u32> = Ok(2);
	println!("{:?}", x.map_err(stringify));
	let x: Result<u32, u32> = Err(13);
	println!("{:?}", x.map_err(stringify));
}

1.1.13 inspect

  方法签名：

rust 复制代码 
pub fn inspect<F>(self, f: F) -> Result<T, E>
where
	F: FnOnce(&T),

  参数f接受任何实现了FnOnce(&T)的类型，包括闭包 、函数指针和函数项。方法会消耗自身。如果Result是Ok，对其中值的引用调用f。返回自身。

rust 复制代码 
fn main() {
	let _x: u8 = "4"
		.parse::<u8>()
		.inspect(|x| println!("original: {x}"))
		.map(|x| x.pow(3))
		.expect("failed to parse number");
}

1.1.14 inspect_err

  方法签名：

rust 复制代码 
pub fn inspect_err<F>(self, f: F) -。 Result<T, E>
where
	F: FnOnce(&E),

  ;参数f接受任何实现了FnOnce(&E)的类型，包括闭包 、函数指针和函数项。方法会消耗自身。如果Result是Err，对其中值的引用调用f。返回自身。

rust 复制代码 
use std::fs;

fn main() {
	fs::read_to_string("address.txt")
		.inspect_err(|e| eprintln!("failed to read file: {e}"))
		.err()
		.unwrap();
}

1.1.15 as_deref

  方法签名：

rust 复制代码 
pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where
	T: Deref,

  通过Deref对Result的Ok变体进行解引用强制转换，并返回新的Result。

rust 复制代码 
fn main() {
	let x: Result<String, u32> = Ok("hello".into());
	let y: Result<&str, &u32> = Ok("hello");
	println!("{}", x.as_deref() == y);
	let x: Result<String, u32> = Err(42);
	let y: Result<&str, &u32> = Err(&42);
	println!("{}", x.as_deref() == y);
}

1.1.16 as_deref_mut

  方法签名：

rust 复制代码 
pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where
	T: DerefMut,

  通过DerefMut对Result的Ok变体进行可变解引用强制转换，并返回新的Result。

rust 复制代码 
fn main() {
	let mut s: String = "HELLO".into();
	let mut x: Result<String, u32> = Ok("hello".into());
	let y: Result<&mut str, &mut u32> = Ok(&mut s);
	println!("{}", x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }) == y);
	let mut i = 42;
	let mut x: Result<String, u32> = Err(42);
	let y: Result<&mut str, &mut u32> = Err(&mut i);
	println!("{}", x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }) == y);
}

1.1.17 iter

  方法签名：

rust 复制代码 
pub fn iter(&self) -> Iter<'_, T>

  Iter是std::result::Iter结构体。返回可能包含的值的迭代器。如果Result是Ok变体，迭代器产生一个值，否则不产生任何值。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(7);
	println!("{}", x.iter().next() == Some(&7));
	let x: Result<u32, &str> = Err("nothing!");
	println!("{}", x.iter().next() == None);
}

1.1.18 iter_mut

  方法签名：

rust 复制代码 
pub fn iter_mut(&mut self) -> IterMut<'_, T>

  IterMut是std::result::IterMut结构体。返回可能包含的值的可变迭代器。如果Result是Ok变体，迭代器产生一个值，否则不产生任何值。

rust 复制代码 
fn main() {
	let mut x: Result<u32, &str> = Ok(7);
	x.iter_mut().for_each(|v| *v = 40);
	println!("{:?}", x);
	let mut x: Result<u32, &str> = Err("nothing!");
	println!("{}", x.iter_mut().next() == None);
}

1.1.19 expect

  方法签名：

rust 复制代码 
pub fn expect(self, msg: &str) -> T
where
	E: Debug,

  方法会消耗自身。Result<T, E>中的E必须实现Debug trait。如果Result是Ok变体，返回其中的值，否则panic。panic的内容为msg。

rust 复制代码 
struct Config {
    port: String,
}

fn main() {
    let config = Config { port: "8080".into() };
    let port: u16 = config.port.parse().expect("port must be a valid number");
    println!("listening on {port}");
    let config = Config { port: "abc".into() };
    let port: u16 = config.port.parse().expect("port must be a valid number");
    println!("listening on {port}");
}

1.1.20 unwrap

  方法签名：

rust 复制代码 
pub fn unwrap(self) -> T
where
	E: Debug,

  方法会消耗自身。Result<T, E>中的E必须实现Debug trait。如果Result是Ok变体，返回其中的值，否则panic。panic消息由Err的值提供。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(2);
	println!("{}", x.unwrap());
	let x: Result<u32, &str> = Err("emergency failure");
	x.unwrap();
}

1.1.21 unwrap_or_default

  方法签名：

rust 复制代码 
pub fn unwrap_or_default(self) -> T
where
	T: Default,

  方法会消耗自身。Result<T, E>中的T必须实现Default trait。如果Result是Ok变体，返回其中的值，否则返回该类型的默认值。

rust 复制代码 
fn main() {
	let good_year_from_input = "1909";
	let bad_year_from_input = "190blarg";
	let good_year: u32 = good_year_from_input.parse().unwrap_or_default();
	let bad_year: u32 = bad_year_from_input.parse().unwrap_or_default();
	println!("{}", good_year);
	println!("{}", bad_year);
}

1.1.22 expect_err

  方法签名：

rust 复制代码 
pub fn expect_err(self, msg: &str) -> E
where
	T: Debug,

  方法会消耗自身。Result<T, E>中的T必须实现Debug trait。如果Result是Ok变体，panic，panic消息包括传入的消息和Ok中的值，否则返回Err中的值。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Err("Some Error");
	println!("{}", x.expect_err("Testing expect_err"));
	let x: Result<u32, &str> = Ok(10);
	x.expect_err("Testing expect_err");
}

1.1.23 unwrap_err

  方法签名：

rust 复制代码 
pub fn unwrap_err(self) -> E
where
	T: Debug,

  方法会消耗自身。Result<T, E>中的T必须实现Debug trait。如果Result是Ok变体，panic，panic的消息由Ok包含的值提供，否则返回Err中的值。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Err("emergency failure");
	println!("{}", x.unwrap_err());
	let x: Result<u32, &str> = Ok(2);
	x.unwrap_err();
}

1.1.24 and

  方法签名：

rust 复制代码 
pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>
方法 self res 结果
and Err(e) (忽略) Err(e)
and Ok(x) Err(d) Err(d)
and Ok(x) Ok(y) Ok(y)

  方法会消耗自身。如果Result是Ok变体，返回res，否则返回自身的Err。

  传递给and的参数会被立即求值；如果传递的是函数调用的结果，建议使用and_then，它是惰性求值的。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(2);
	let y: Result<&str, &str> = Err("late error");
	println!("{:?}", x.and(y));
	let x: Result<u32, &str> = Err("early error");
	let y: Result<&str, &str> = Ok("foo");
	println!("{:?}", x.and(y));
	let x: Result<u32, &str> = Err("not a 2");
	let y: Result<&str, &str> = Err("late error");
	println!("{:?}", x.and(y));
	let x: Result<u32, &str> = Ok(2);
	let y: Result<&str, &str> = Ok("different result type");
	println!("{:?}", x.and(y));
}

1.1.25 and_then

  方法签名：

rust 复制代码 
pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where
	F: FnOnce(T) -> Result<U, E>,

  参数op接受任何实现了FnOnce(T) -> Result<U, E>的类型，包括闭包、函数指针和函数项。方法会消耗自身。将Result<T, E>转换为Result<U, E>，将Ok(v)映射为op(v)，将Err(e)映射为Err(e)。

rust 复制代码 
fn sq_then_to_string(x: u32) -> Result<u32, &'static str> {
    x.checked_mul(x).ok_or("overflowed")
}

fn main() {
    let x = Ok(2);
    println!("{:?}", x.and_then(sq_then_to_string));
    let x = Ok(1_000_000);
    println!("{:?}", x.and_then(sq_then_to_string));
    let x = Err("not a number");
    println!("{:?}", x.and_then(sq_then_to_string));
}

  常用于链接可能返回Err的可失败操作。

rust 复制代码 
use std::io::ErrorKind;
use std::path::Path;

fn main() {
	let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
	println!("{}", root_modified_time.is_ok());
	let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
	println!("{}", should_fail.is_err());
	println!("{}", should_fail.unwrap_err().kind() == ErrorKind::NotFound);
}

1.1.26 or

  方法签名：

rust 复制代码 
pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>
方法 self res 结果
or Err(e) Err(d) Err(d)
or Err(e) Ok(y) Ok(y)
or Ok(x) (忽略) Ok(x)

  方法会消耗自身。如果Result是Err变体，返回res，否则返回自身的Ok值。

  传递给or的参数会被立即求值。如果传递的是函数调用的结果，建议使用or_else，它是惰性求值的。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(2);
	let y: Result<u32, &str> = Err("late error");
	println!("{:?}", x.or(y));
	let x: Result<u32, &str> = Err("early error");
	let y: Result<u32, &str> = Ok(2);
	println!("{:?}", x.or(y));
	let x: Result<u32, &str> = Err("not a 2");
	let y: Result<u32, &str> = Err("late error");
	println!("{:?}", x.or(y));
	let x: Result<u32, &str> = Ok(2);
	let y: Result<u32, &str> = Ok(100);
	println!("{:?}", x.or(y));
}

1.1.27 or_else

  方法签名：

rust 复制代码 
pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where
	O: FnOnce(E) -> Result<T, F>,

  参数op接受任何实现了FnOnce(E) -> Result<T, F>的类型，包括闭包、函数指针和函数项。方法会消耗自身。如果Result是Err(e)，将e传给op，返回op(e)，否则返回自身的Ok值。

rust 复制代码 
fn sq(x: u32) -> Result<u32, u32> {
	Ok(x * x)
}
fn err(x: u32) -> Result<u32, u32> {
	Err(x)
}

fn main() {
	let x = Ok(2);
	println!("{:?}", x.or_else(sq).or_else(sq));
	println!("{:?}", x.or_else(err).or_else(sq));
	let x = Err(3);
	println!("{:?}", x.or_else(sq).or_else(err));
	println!("{:?}", x.or_else(err).or_else(err));
}

1.1.28 unwrap_or

  方法签名：

rust 复制代码 
pub fn unwrap_or(self, default: T) -> T

  方法会消耗自身。如果Result是Ok变体，返回其中的值，否则返回default。

  传递给unwrap_or的参数会被立即求值。如果传递的是函数调用的结果，建议使用unwrap_or_else，它是惰性求值的。

rust 复制代码 
fn main() {
	let default = 2;
	let x: Result<u32, &str> = Ok(9);
	println!("{}", x.unwrap_or(default));
	let x: Result<u32, &str> = Err("error");
	println!("{}", x.unwrap_or(default));
}

1.1.29 unwrap_or_else

&emsp 方法签名：

rust 复制代码 
pub fn unwrap_or_else<F>(self, op: F) -> T
where
	F: FnOnce(E) -> T,

  参数op接受任何实现了FnOnce(E) -> T的类型，包括闭包、函数指针和函数项。方法会消耗自身。如果Result是Err(e)，将e传给op，返回op(e)，否则返回Ok中的值。

rust 复制代码 
fn count(x: &str) -> usize {
	x.len()
}

fn main() {
	let x = Ok(2);
	println!("{}", x.unwrap_or_else(count));
	let x = Err("foo");
	println!("{}", x.unwrap_or_else(count));
}

1.1.30 unwrap_unchecked(unsafe，使用unwrap)

  方法签名：

rust 复制代码 
pub unsafe fn unwrap_unchecked(self) -> T

  方法会消耗自身。如果Result是Ok变体，返回其中的值，否则会产生未定义行为。换句话说，在Ok变体上调用该函数是安全的。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Ok(2);
	println!("{}", unsafe { x.unwrap_unchecked() });
	let x: Result<u32, &str> = Err("Emergency failure");
	unsafe { x.unwrap_unchecked() };
}

1.1.31 unwrap_err_unchecked(unsafe，使用unwrap_err)

  方法签名：

rust 复制代码 
pub unsafe fn unwrap_err_unchecked(self) -> E

  方法会消耗自身。如果Result是Err变体，返回其中的值，否则会产生未定义行为。换句话说，在Err变体上调用该函数是安全的。

rust 复制代码 
fn main() {
	let x: Result<u32, &str> = Err("emergency failure");
	println!("{}", unsafe { x.unwrap_err_unchecked() });
	let x: Result<u32, &str> = Ok(2);
	unsafe { x.unwrap_err_unchecked() };
}

1.2 针对Result<&T, E>的方法

1.2.1 copied

  方法签名：

rust 复制代码 
pub const fn copied(self) -> Result<T, E>
where
	T: Copy,

  方法会消耗自身。通过复制Ok部分的内容，将Result<&T, E>映射为Result<T, E>。

rust 复制代码 
fn main() {
	let val = 12;
	let x: Result<&i32, i32> = Ok(&val);
	println!("{}", x == Ok(&12));
	let copied = x.copied();
	println!("{:?}", copied);
}

1.2.2 cloned

  方法签名：

rust 复制代码 
pub fn cloned(self) -。 Result<T, E>
where
	T: Clone,

  方法会消耗自身。通过克隆Ok部分的内容，将Result<&T, E>映射为Result<T, E>。

rust 复制代码 
fn main() {
	let s: String = "hello".into();
	let x: Result<&String, i32> = Ok(&s);
	let cloned = x.cloned();
	println!("{:?}", cloned);
}

1.3 针对Result<&mut T, E>的方法

1.3.1 copied

  方法签名：

rust 复制代码 
pub const fn copied(self) -> Result<T, E>
where
	T: Copy,

  方法会消耗自身。通过复制Ok部分的内容，将Result<&mut T, E>映射为Result<T, E>。

rust 复制代码 
fn main() {
	let mut val = 12;
	let x: Result<&mut i32, i32> = Ok(&mut val);
	println!("{}", x == Ok(&mut 12));
	let copied = x.copied();
	println!("{:?}", copied);
}

1.3.2 cloned

  方法签名：

rust 复制代码 
pub fn cloned(self) -> Result<T, E>
where
	T: Clone,

  方法会消耗自身。通过克隆Ok部分的内容，将Result<&mut T, E>映射为Result<T, E>。

rust 复制代码 
fn main() {
	let mut s = "hello".into();
	let x: Result<&mut String, i32> = Ok(&mut s);
	let cloned = x.cloned();
	println!("{:?}", cloned);		
}

1.4 针对Result<Option<T>, E>的方法

1.4.1 transpose

  方法签名：

rust 复制代码 
pub const fn transpose(self) -> Option<Result<T, E>>

  方法会消耗自身。将Result<Option<T>, E>转换为Option<Result<T, E>>，将Ok(None)映射为None，将Ok(Some())映射为Some(Ok())，将Err()映射为Some(Err())。

rust 复制代码 
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

fn main() {
	let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
	let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
	println!("{}", x.transpose() == y);
	let x: Result<Option<i32>, SomeErr> = Err(SomeErr);
	let y: Option<Result<i32, SomeErr>> = Some(Err(SomeErr));
	println!("{}", x.transpose() == y);
	let x: Result<Option<i32>, SomeErr> = Ok(None);
	let y: Option<Result<i32, SomeErr>> = None;
	println!("{}", x.transpose() == y);
}

1.5 针对Result<Result<T, E>, E>的方法

1.5.1 flatten

  方法签名：

rust 复制代码 
pub const fn flatten(self) -> Result<T, E>

  方法会消耗自身。将Result<Result<T, E>, E>转换为Result<T, E>。

rust 复制代码 
fn main() {
	let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
	println!("{:?}", x.flatten());
	let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
	println!("{:?}", x.flatten());
	let x: Result<Result<&'static str, u32>, u32> = Err(6);
	println!("{:?}", x.flatten());
}

  展平操作每次只移除一层嵌套：

rust 复制代码 
fn main() {
	let x: Result<Result<Result<&'static str, u32>, u32>, u32> = 	Ok(Ok(Ok("hello")));
	println!("{:?}", x.flatten());
	println!("{:?}", x.flatten().flatten());
}
相关推荐
Thneonl3 小时前
同一资源、不同 ID:多源拓扑的 Identity Resolution
架构·rust
绍磊leo3 小时前
【保姆级】dora-rs 一键安装脚本：类ros2的fishros 风格交互菜单 + 国内镜像加速，把坑都替你踩完了
rust·dora-rs
Ramble_Naylor16 小时前
只借不占：Rust 的引用与借用
开发语言·rust
k4m7v2pz20 小时前
交叉编译 Rust 到 aarch64 Linux 掌机：glibc 版本与 sysroot 重建的完整踩坑记录
rust·glibc·交叉编译·aarch64·zigbuild·sysroot
k4m7v2pz1 天前
用 Rust 重造 Java 的 CLI 分发体验：从 java -jar 到 wasmtime run
rust·跨平台·webassembly·wasmtime·wasi·java-jar
Source.Liu1 天前
【IT】Rust实现win下系统信息采集工具的开发
rust
MC皮蛋侠客2 天前
Tauri 2.x 系列（八）：与其他语言结合——Sidecar、服务、FFI 与插件的选择
rust·tauri
MC皮蛋侠客2 天前
Tauri 2.x 系列（五）：调用系统 API——官方插件、Rust crate 与原生能力
开发语言·后端·rust
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03ZCode 周末送额度活动开启：3 亿 Token 免费领取042026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？05历年考研数学一、数学二、数学三真题试卷及答案PDF06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新07AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路08Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费09蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接10VSCode+CodeX扩展，无法启动