pub enum Option<T> {
None,
Some(T),
}
Expand description
Option
类型。有关更多信息,请参见 模块级文档。
Variants§
Implementations§
source§impl<T> Option<T>
impl<T> Option<T>
1.70.0 · sourcepub fn is_some_and(self, f: impl FnOnce(T) -> bool) -> bool
pub fn is_some_and(self, f: impl FnOnce(T) -> bool) -> bool
const: 1.48.0 · sourcepub const fn as_ref(&self) -> Option<&T>
pub const fn as_ref(&self) -> Option<&T>
从 &Option<T>
转换为 Option<&T>
。
Examples
在不移动 String
的情况下将 Option<String>
的长度计算为 Option<usize>
。
map
方法按值使用 self
参数,从而消耗了原始文件,因此该技术使用 as_ref
首先将 Option
引用给原始文件中的值。
let text: Option<String> = Some("Hello, world!".to_string());
// 首先,使用 `as_ref` 将 `Option<String>` 转换为 `Option<&String>`,然后在 `map` 上消费它,在栈上留下 `text`。
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");
Runsourcepub fn as_slice(&self) -> &[T]
🔬This is a nightly-only experimental API. (option_as_slice
#108545)
pub fn as_slice(&self) -> &[T]
option_as_slice
#108545)返回包含值的一部分 (如果有)。如果这是 None
,则返回一个空切片。
这对于在 Option
或切片上使用单一类型的迭代器很有用。
Note: 如果您有 Option<&T>
并希望获得 T
的一部分,您可以通过 opt.map_or(&[], std::slice::from_ref)
解包。
Examples
#![feature(option_as_slice)]
assert_eq!(
[Some(1234).as_slice(), None.as_slice()],
[&[1234][..], &[][..]],
);
Run这个函数的倒数是 (折扣借用) [_]::first
:
#![feature(option_as_slice)]
for i in [Some(1234_u16), None] {
assert_eq!(i.as_ref(), i.as_slice().first());
}
Runsourcepub fn as_mut_slice(&mut self) -> &mut [T]
🔬This is a nightly-only experimental API. (option_as_slice
#108545)
pub fn as_mut_slice(&mut self) -> &mut [T]
option_as_slice
#108545)返回包含值的可变切片 (如果有)。如果这是 None
,则返回一个空切片。
这对于在 Option
或切片上使用单一类型的迭代器很有用。
Note: 如果您有一个 Option<&mut T>
而不是 &mut Option<T>
,这个方法需要,您可以通过 opt.map_or(&mut [], std::slice::from_mut)
获得一个可变切片。
Examples
#![feature(option_as_slice)]
assert_eq!(
[Some(1234).as_mut_slice(), None.as_mut_slice()],
[&mut [1234][..], &mut [][..]],
);
Run结果是指向我们原始 Option
的零项或一项的可变切片:
#![feature(option_as_slice)]
let mut x = Some(1234);
x.as_mut_slice()[0] += 1;
assert_eq!(x, Some(1235));
Run此方法的逆 (折扣借用) 是 [_]::first_mut
:
#![feature(option_as_slice)]
assert_eq!(Some(123).as_mut_slice().first_mut(), Some(&mut 123))
Runconst: unstable · sourcepub fn expect(self, msg: &str) -> T
pub fn expect(self, msg: &str) -> T
返回包含 self
值的包含的 Some
值。
Panics
如果值为 None
并带有由 msg
提供的自定义 panic 消息,就会出现 panics。
Examples
let x = Some("value");
assert_eq!(x.expect("fruits are healthy"), "value");
Run推荐的消息样式
我们建议使用 expect
消息来描述您期望 Option
应该是 Some
的原因。
提示: 如果您无法记住如何表达预期错误消息,请记住将注意力集中在 “should” 上,就像在 “env 变量应该由 blah 设置” 或 “ 给定的二进制文件应该可由当前用户使用和执行“ 中一样。
有关期望消息样式的更多详细信息以及我们建议背后的原因,请参见 std::error
模块文档中有关 “常见的消息样式” 的部分。
const: unstable · sourcepub fn unwrap(self) -> T
pub fn unwrap(self) -> T
返回包含 self
值的包含的 Some
值。
由于此函数可能为 panic,因此通常不建议使用该函数。
相反,更喜欢使用模式匹配并显式处理 None
大小写,或者调用 unwrap_or
,unwrap_or_else
或 unwrap_or_default
。
Panics
如果 self 的值等于 None
,就会出现 panics。
Examples
let x = Some("air");
assert_eq!(x.unwrap(), "air");
Runsourcepub fn unwrap_or(self, default: T) -> T
pub fn unwrap_or(self, default: T) -> T
返回包含的 Some
值或提供的默认值。
急切地评估传递给 unwrap_or
的参数; 如果要传递函数调用的结果,建议使用 unwrap_or_else
,它是惰性求值的。
Examples
assert_eq!(Some("car").unwrap_or("bike"), "car");
assert_eq!(None.unwrap_or("bike"), "bike");
Runsourcepub fn unwrap_or_else<F>(self, f: F) -> Twhere
F: FnOnce() -> T,
pub fn unwrap_or_else<F>(self, f: F) -> Twhere F: FnOnce() -> T,
sourcepub fn unwrap_or_default(self) -> Twhere
T: Default,
pub fn unwrap_or_default(self) -> Twhere T: Default,
1.58.0 (const: unstable) · sourcepub unsafe fn unwrap_unchecked(self) -> T
pub unsafe fn unwrap_unchecked(self) -> T
sourcepub fn map<U, F>(self, f: F) -> Option<U>where
F: FnOnce(T) -> U,
pub fn map<U, F>(self, f: F) -> Option<U>where F: FnOnce(T) -> U,
Maps 通过将函数应用于包含的值 (如果是 Some
) 或返回 None
(如果是 None
),将 Option<T>
转换为 Option<U>
。
Examples
将 Option<String>
的长度计算为 Option<usize>
,使用原始数据:
let maybe_some_string = Some(String::from("Hello, World!"));
// `Option::map` 按值获取 self,消耗 `maybe_some_string`
let maybe_some_len = maybe_some_string.map(|s| s.len());
assert_eq!(maybe_some_len, Some(13));
let x: Option<&str> = None;
assert_eq!(x.map(|s| s.len()), None);
Runsourcepub fn inspect<F>(self, f: F) -> Selfwhere
F: FnOnce(&T),
🔬This is a nightly-only experimental API. (result_option_inspect
#91345)
pub fn inspect<F>(self, f: F) -> Selfwhere F: FnOnce(&T),
result_option_inspect
#91345)sourcepub fn map_or<U, F>(self, default: U, f: F) -> Uwhere
F: FnOnce(T) -> U,
pub fn map_or<U, F>(self, default: U, f: F) -> Uwhere F: FnOnce(T) -> U,
返回提供的默认结果 (如果没有),或将函数应用于包含的值 (如果有)。
传递给 map_or
的参数会被急切地评估; 如果要传递函数调用的结果,建议使用 map_or_else
,它是延迟计算的。
Examples
let x = Some("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);
let x: Option<&str> = None;
assert_eq!(x.map_or(42, |v| v.len()), 42);
Runsourcepub fn map_or_else<U, D, F>(self, default: D, f: F) -> Uwhere
D: FnOnce() -> U,
F: FnOnce(T) -> U,
pub fn map_or_else<U, D, F>(self, default: D, f: F) -> Uwhere D: FnOnce() -> U, F: FnOnce(T) -> U,
sourcepub fn ok_or<E>(self, err: E) -> Result<T, E>
pub fn ok_or<E>(self, err: E) -> Result<T, E>
将 Option<T>
转换为 Result<T, E>
,将 Some(v)
映射到 Ok(v)
,将 None
映射到 Err(err)
。
急切地评估传递给 ok_or
的参数; 如果要传递函数调用的结果,建议使用 ok_or_else
,它是延迟计算的。
Examples
let x = Some("foo");
assert_eq!(x.ok_or(0), Ok("foo"));
let x: Option<&str> = None;
assert_eq!(x.ok_or(0), Err(0));
Runsourcepub fn ok_or_else<E, F>(self, err: F) -> Result<T, E>where
F: FnOnce() -> E,
pub fn ok_or_else<E, F>(self, err: F) -> Result<T, E>where F: FnOnce() -> E,
将 Option<T>
转换为 Result<T, E>
,将 Some(v)
映射到 Ok(v)
,将 None
映射到 Err(err())
。
Examples
let x = Some("foo");
assert_eq!(x.ok_or_else(|| 0), Ok("foo"));
let x: Option<&str> = None;
assert_eq!(x.ok_or_else(|| 0), Err(0));
Run1.40.0 · sourcepub fn as_deref_mut(&mut self) -> Option<&mut T::Target>where
T: DerefMut,
pub fn as_deref_mut(&mut self) -> Option<&mut T::Target>where T: DerefMut,
从 Option<T>
(或 &mut Option<T>
) 转换为 Option<&mut T::Target>
。
在这里保留原始的 Option
,创建一个包含对内部类型的 Deref::Target
类型的可变引用的新的 Option
。
Examples
let mut x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref_mut().map(|x| {
x.make_ascii_uppercase();
x
}), Some("HEY".to_owned().as_mut_str()));
Runsourcepub fn and<U>(self, optb: Option<U>) -> Option<U>
pub fn and<U>(self, optb: Option<U>) -> Option<U>
如果选项为 None
,则返回 None
; 否则,返回 optb
。
传递给 and
的参数被热切地评估; 如果要传递函数调用的结果,建议使用 and_then
,它是惰性求值的。
Examples
let x = Some(2);
let y: Option<&str> = None;
assert_eq!(x.and(y), None);
let x: Option<u32> = None;
let y = Some("foo");
assert_eq!(x.and(y), None);
let x = Some(2);
let y = Some("foo");
assert_eq!(x.and(y), Some("foo"));
let x: Option<u32> = None;
let y: Option<&str> = None;
assert_eq!(x.and(y), None);
Runsourcepub fn and_then<U, F>(self, f: F) -> Option<U>where
F: FnOnce(T) -> Option<U>,
pub fn and_then<U, F>(self, f: F) -> Option<U>where F: FnOnce(T) -> Option<U>,
如果选项为 None
,则返回 None
; 否则,使用包装的值调用 f
,并返回结果。
一些语言调用此操作平面图。
Examples
fn sq_then_to_string(x: u32) -> Option<String> {
x.checked_mul(x).map(|sq| sq.to_string())
}
assert_eq!(Some(2).and_then(sq_then_to_string), Some(4.to_string()));
assert_eq!(Some(1_000_000).and_then(sq_then_to_string), None); // overflowed!
assert_eq!(None.and_then(sq_then_to_string), None);
Run通常用于链接可能返回 None
的错误操作。
let arr_2d = [["A0", "A1"], ["B0", "B1"]];
let item_0_1 = arr_2d.get(0).and_then(|row| row.get(1));
assert_eq!(item_0_1, Some(&"A1"));
let item_2_0 = arr_2d.get(2).and_then(|row| row.get(0));
assert_eq!(item_2_0, None);
Run1.27.0 · sourcepub fn filter<P>(self, predicate: P) -> Selfwhere
P: FnOnce(&T) -> bool,
pub fn filter<P>(self, predicate: P) -> Selfwhere P: FnOnce(&T) -> bool,
如果选项为 None
,则返回 None
; 否则,使用包装的值调用 predicate
并返回:
该函数的工作方式类似于 Iterator::filter()
。
您可以想象 Option<T>
是一个或零个元素上的迭代器。
filter()
让您决定保留哪些元素。
Examples
fn is_even(n: &i32) -> bool {
n % 2 == 0
}
assert_eq!(None.filter(is_even), None);
assert_eq!(Some(3).filter(is_even), None);
assert_eq!(Some(4).filter(is_even), Some(4));
Runsourcepub fn or(self, optb: Option<T>) -> Option<T>
pub fn or(self, optb: Option<T>) -> Option<T>
如果包含值,则返回选项,否则返回 optb
。
传递给 or
的参数会被急切地评估; 如果要传递函数调用的结果,建议使用 or_else
,它是延迟计算的。
Examples
let x = Some(2);
let y = None;
assert_eq!(x.or(y), Some(2));
let x = None;
let y = Some(100);
assert_eq!(x.or(y), Some(100));
let x = Some(2);
let y = Some(100);
assert_eq!(x.or(y), Some(2));
let x: Option<u32> = None;
let y = None;
assert_eq!(x.or(y), None);
Runsourcepub fn or_else<F>(self, f: F) -> Option<T>where
F: FnOnce() -> Option<T>,
pub fn or_else<F>(self, f: F) -> Option<T>where F: FnOnce() -> Option<T>,
如果选项包含值,则返回该选项,否则调用 f
并返回结果。
Examples
fn nobody() -> Option<&'static str> { None }
fn vikings() -> Option<&'static str> { Some("vikings") }
assert_eq!(Some("barbarians").or_else(vikings), Some("barbarians"));
assert_eq!(None.or_else(vikings), Some("vikings"));
assert_eq!(None.or_else(nobody), None);
Run1.37.0 · sourcepub fn xor(self, optb: Option<T>) -> Option<T>
pub fn xor(self, optb: Option<T>) -> Option<T>
如果 self
,optb
之一恰好是 Some
,则返回 Some
,否则返回 None
。
Examples
let x = Some(2);
let y: Option<u32> = None;
assert_eq!(x.xor(y), Some(2));
let x: Option<u32> = None;
let y = Some(2);
assert_eq!(x.xor(y), Some(2));
let x = Some(2);
let y = Some(2);
assert_eq!(x.xor(y), None);
let x: Option<u32> = None;
let y: Option<u32> = None;
assert_eq!(x.xor(y), None);
Run1.53.0 · sourcepub fn insert(&mut self, value: T) -> &mut T
pub fn insert(&mut self, value: T) -> &mut T
将 value
插入到选项,然后返回对它的可变引用。
如果该选项已包含值,则将丢弃旧值。
另请参见 Option::get_or_insert
,如果选项已包含 Some
,则不会更新值。
Example
let mut opt = None;
let val = opt.insert(1);
assert_eq!(*val, 1);
assert_eq!(opt.unwrap(), 1);
let val = opt.insert(2);
assert_eq!(*val, 2);
*val = 3;
assert_eq!(opt.unwrap(), 3);
Run1.20.0 · sourcepub fn get_or_insert(&mut self, value: T) -> &mut T
pub fn get_or_insert(&mut self, value: T) -> &mut T
如果为 None
,则将 value
插入到选项中,然后返回所包含的值的变量引用。
另请参见 Option::insert
,即使选项已包含 Some
,它也会更新值。
Examples
let mut x = None;
{
let y: &mut u32 = x.get_or_insert(5);
assert_eq!(y, &5);
*y = 7;
}
assert_eq!(x, Some(7));
Runsourcepub fn get_or_insert_default(&mut self) -> &mut Twhere
T: Default,
🔬This is a nightly-only experimental API. (option_get_or_insert_default
#82901)
pub fn get_or_insert_default(&mut self) -> &mut Twhere T: Default,
option_get_or_insert_default
#82901)1.20.0 · sourcepub fn get_or_insert_with<F>(&mut self, f: F) -> &mut Twhere
F: FnOnce() -> T,
pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut Twhere F: FnOnce() -> T,
sourcepub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>where
F: FnOnce(T, U) -> R,
🔬This is a nightly-only experimental API. (option_zip
#70086)
pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>where F: FnOnce(T, U) -> R,
option_zip
#70086)使用函数 f
压缩 self
和另一个 Option
。
如果 self
是 Some(s)
,而 other
是 Some(o)
,则此方法返回 Some(f(s, o))
。
否则,返回 None
。
Examples
#![feature(option_zip)]
#[derive(Debug, PartialEq)]
struct Point {
x: f64,
y: f64,
}
impl Point {
fn new(x: f64, y: f64) -> Self {
Self { x, y }
}
}
let x = Some(17.5);
let y = Some(42.7);
assert_eq!(x.zip_with(y, Point::new), Some(Point { x: 17.5, y: 42.7 }));
assert_eq!(x.zip_with(None, Point::new), None);
Runsource§impl<T> Option<&T>
impl<T> Option<&T>
source§impl<T> Option<&mut T>
impl<T> Option<&mut T>
source§impl<T, E> Option<Result<T, E>>
impl<T, E> Option<Result<T, E>>
1.33.0 (const: unstable) · sourcepub fn transpose(self) -> Result<Option<T>, E>
pub fn transpose(self) -> Result<Option<T>, E>
将 Result
的 Option
转换为 Option
的 Result
。
None
将映射到 Ok(None)
。
Some(Ok(_))
和 Some(Err(_))
将映射到 Ok(Some(_))
和 Err(_)
。
Examples
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;
let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x, y.transpose());
Runsource§impl<T> Option<Option<T>>
impl<T> Option<Option<T>>
1.40.0 (const: unstable) · sourcepub fn flatten(self) -> Option<T>
pub fn flatten(self) -> Option<T>
从 Option<Option<T>>
转换为 Option<T>
。
Examples
基本用法:
let x: Option<Option<u32>> = Some(Some(6));
assert_eq!(Some(6), x.flatten());
let x: Option<Option<u32>> = Some(None);
assert_eq!(None, x.flatten());
let x: Option<Option<u32>> = None;
assert_eq!(None, x.flatten());
Run展平一次只能删除一层嵌套:
let x: Option<Option<Option<u32>>> = Some(Some(Some(6)));
assert_eq!(Some(Some(6)), x.flatten());
assert_eq!(Some(6), x.flatten().flatten());
RunTrait Implementations§
1.30.0 · source§impl<'a, T> From<&'a Option<T>> for Option<&'a T>
impl<'a, T> From<&'a Option<T>> for Option<&'a T>
source§fn from(o: &'a Option<T>) -> Option<&'a T>
fn from(o: &'a Option<T>) -> Option<&'a T>
从 &Option<T>
转换为 Option<&T>
。
Examples
将 Option<String>
转换为 Option<usize>
,保留原始值。
map
方法按值取 self
参数,消耗原始值,因此该技术使用 from
首先将 Option
用于对原始值内部值的引用。
let s: Option<String> = Some(String::from("Hello, Rustaceans!"));
let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len());
println!("Can still print s: {s:?}");
assert_eq!(o, Some(18));
Run1.30.0 · source§impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>
impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>
source§impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V>
impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V>
source§fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V>
fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V>
接受 Iterator
中的每个元素:如果为 None
,则不再获取其他元素,并返回 None
。
如果没有出现 None
,则返回一个 V
类型的容器,其中包含每个 Option
的值。
Examples
这是一个使 vector 中的每个整数递增的示例。
当计算将导致溢出时,我们使用 add
的检查变体返回 None
。
let items = vec![0_u16, 1, 2];
let res: Option<Vec<u16>> = items
.iter()
.map(|x| x.checked_add(1))
.collect();
assert_eq!(res, Some(vec![1, 2, 3]));
Run如您所见,这将返回预期的有效项。
这是另一个示例,尝试从另一个整数列表中减去一个,这次检查下溢:
let items = vec![2_u16, 1, 0];
let res: Option<Vec<u16>> = items
.iter()
.map(|x| x.checked_sub(1))
.collect();
assert_eq!(res, None);
Run由于最后一个元素为零,因此会下溢。因此,结果值为 None
。
这是前一个示例的变体,显示在第一个 None
之后不再从 iter
提取其他元素。
let items = vec![3_u16, 2, 1, 10];
let mut shared = 0;
let res: Option<Vec<u16>> = items
.iter()
.map(|x| { shared += x; x.checked_sub(2) })
.collect();
assert_eq!(res, None);
assert_eq!(shared, 6);
Run由于第三个元素引起下溢,因此不再使用其他元素,因此 shared
的最终值为 6 (= 3 + 2 + 1
),而不是 16。
source§impl<T> FromResidual<<Option<T> as Try>::Residual> for Option<T>
impl<T> FromResidual<<Option<T> as Try>::Residual> for Option<T>
source§fn from_residual(residual: Option<Infallible>) -> Self
fn from_residual(residual: Option<Infallible>) -> Self
try_trait_v2
#84277)Residual
类型构造类型。 Read more1.4.0 · source§impl<'a, T> IntoIterator for &'a Option<T>
impl<'a, T> IntoIterator for &'a Option<T>
1.4.0 · source§impl<'a, T> IntoIterator for &'a mut Option<T>
impl<'a, T> IntoIterator for &'a mut Option<T>
source§impl<T: PartialOrd> PartialOrd<Option<T>> for Option<T>
impl<T: PartialOrd> PartialOrd<Option<T>> for Option<T>
1.37.0 · source§impl<T, U> Product<Option<U>> for Option<T>where
T: Product<U>,
impl<T, U> Product<Option<U>> for Option<T>where T: Product<U>,
source§fn product<I>(iter: I) -> Option<T>where
I: Iterator<Item = Option<U>>,
fn product<I>(iter: I) -> Option<T>where I: Iterator<Item = Option<U>>,
接受 Iterator
中的每个元素:如果它是 None
,则不再获取其他元素,并返回 None
。
如果没有发生 None
,则返回所有元素的乘积。
Examples
这会将字符串 vector 中的每个数字相乘,如果无法解析字符串,则操作返回 None
:
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));
let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, None);
Runsource§impl<T> Residual<T> for Option<Infallible>
impl<T> Residual<T> for Option<Infallible>
1.37.0 · source§impl<T, U> Sum<Option<U>> for Option<T>where
T: Sum<U>,
impl<T, U> Sum<Option<U>> for Option<T>where T: Sum<U>,
source§fn sum<I>(iter: I) -> Option<T>where
I: Iterator<Item = Option<U>>,
fn sum<I>(iter: I) -> Option<T>where I: Iterator<Item = Option<U>>,
接受 Iterator
中的每个元素:如果它是 None
,则不再获取其他元素,并返回 None
。
如果没有发生 None
,则返回所有元素的总和。
Examples
这总结了字符 ‘a’ 在字符串 vector 中的位置,如果单词没有字符 ‘a’,则该操作返回 None
:
let words = vec!["have", "a", "great", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, Some(5));
let words = vec!["have", "a", "good", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, None);
Runsource§impl<T> Try for Option<T>
impl<T> Try for Option<T>
§type Residual = Option<Infallible>
type Residual = Option<Infallible>
try_trait_v2
#84277)source§fn from_output(output: Self::Output) -> Self
fn from_output(output: Self::Output) -> Self
try_trait_v2
#84277)Output
类型构造类型。 Read moresource§fn branch(self) -> ControlFlow<Self::Residual, Self::Output>
fn branch(self) -> ControlFlow<Self::Residual, Self::Output>
try_trait_v2
#84277)?
来决定操作符是应该生成一个值 (因为它返回了 ControlFlow::Continue
),还是将一个值传播回调用者 (因为它返回了 ControlFlow::Break
)。 Read more