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>
.
§ 例子
Option<usize>
计算 Option<String>
as 的长度,而不移动 .该方法按值获取 self
参数,使用原始值,因此此技术用于 as_ref
首先对 Option
原始值的引用。
let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");
Run1.33.0 (const: unstable) · sourcepub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>
pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>
1.75.0 · sourcepub fn as_slice(&self) -> &[T]
pub fn as_slice(&self) -> &[T]
返回包含值的切片(如果有)。如果是 None
,则返回空切片。这对于在 Option
or 切片上使用单一类型的迭代器非常有用。
注意:如果您有 Option<&T>
并希望获得一片 T
,您可以通过 opt.map_or(&[], std::slice::from_ref)
.
§ 例子
assert_eq!(
[Some(1234).as_slice(), None.as_slice()],
[&[1234][..], &[][..]],
);
Run
这个函数的反数是(贴现借款):
for i in [Some(1234_u16), None] {
assert_eq!(i.as_ref(), i.as_slice().first());
}
Run1.75.0 · sourcepub fn as_mut_slice(&mut self) -> &mut [T]
pub fn as_mut_slice(&mut self) -> &mut [T]
返回包含值的可变切片(如果有)。如果是 None
,则返回空切片。这对于在 Option
or 切片上使用单一类型的迭代器非常有用。
注意:如果该方法采用的 而不是 Option<&mut T>
&mut Option<T>
,则可以通过 opt.map_or(&mut [], std::slice::from_mut)
获取可变切片。
§ 例子
assert_eq!(
[Some(1234).as_mut_slice(), None.as_mut_slice()],
[&mut [1234][..], &mut [][..]],
);
Run
结果是零个或一个项目的可变切片,指向我们的原始 Option
项目:
let mut x = Some(1234);
x.as_mut_slice()[0] += 1;
assert_eq!(x, Some(1235));
Run
这种方法(贴现借款)的反面是:
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
值。
§ 恐慌
如果值为 ,则为 ,并带有 提供的 msg
自定义紧急消息。
§ 例子
let x = Some("value");
assert_eq!(x.expect("fruits are healthy"), "value");
Run§
推荐的邮件样式
我们建议使用 expect
messages 来描述您期望 Option
应该是 Some
的原因。
提示:如果您在记不住如何表达 expect 错误消息时遇到困难,请记住将重点放在“应该”这个词上,例如“env 变量应该由废话设置”或“给定的二进制文件应该可用且可由当前用户执行”。
有关期望消息样式的更多详细信息以及我们建议背后的原因,请参阅模块文档中的部分。
sourcepub 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,
通过将函数应用于包含的值 (if Some
) 或返回 None
(if None
) 来 Option<T>
映射 to Option<U>
。
§ 例子
将 an Option<String>
的长度计算为 Option<usize>
,消耗原始:
let maybe_some_string = Some(String::from("Hello, World!"));
// `Option::map` takes self *by value*, consuming `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 map_or_else<U, D, F>(self, default: D, f: F) -> U
pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
计算默认函数结果(如果没有),或将其他函数应用于包含的值(如果有)。
§ 基本示例
let k = 21;
let x = Some("foo");
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3);
let x: Option<&str> = None;
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);
Run§
处理基于结果的回退
在处理可选值时,一个有点常见的情况是,如果选项不存在,则想要调用一个容易出错的回退。此示例将命令行参数(如果存在)或文件内容分析为整数。但是,与访问命令行参数不同,读取文件是容易出错的,因此必须用 Ok
.
let v: u64 = std::env::args()
.nth(1)
.map_or_else(|| std::fs::read_to_string("/etc/someconfig.conf"), Ok)?
.parse()?;
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,
1.40.0 · sourcepub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>where
T: DerefMut,
pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>where
T: DerefMut,
sourcepub fn and<U>(self, optb: Option<U>) -> Option<U>
pub fn and<U>(self, optb: Option<U>) -> Option<U>
如果选项为 ,则返回 ,否则返回 optb
。
传递给 and
的论点被热切地评估;如果要传递函数调用的结果,建议使用 ,这是延迟计算的。
§ 例子
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>
pub fn and_then<U, F>(self, f: F) -> Option<U>
如果选项为 ,则返回 ,否则使用包装值调用 f
并返回结果。
某些语言将此操作称为 flatmap。
§ 例子
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
通常用于链接可能返回的易出错操作。
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) -> Option<T>
pub fn filter<P>(self, predicate: P) -> Option<T>
sourcepub fn or(self, optb: Option<T>) -> Option<T>
pub fn or(self, optb: Option<T>) -> Option<T>
如果选项包含值,则返回该选项,否则返回 optb
。
传递给 or
的论点被热切地评估;如果要传递函数调用的结果,建议使用 ,这是延迟计算的。
§ 例子
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);
Run1.37.0 · sourcepub fn xor(self, optb: Option<T>) -> Option<T>
pub fn xor(self, optb: Option<T>) -> Option<T>
如果 正好是 之一 self
, optb
则返回 ,否则返回 。
§ 例子
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.20.0 · sourcepub fn get_or_insert(&mut self, value: T) -> &mut T
pub fn get_or_insert(&mut self, value: T) -> &mut T
sourcepub 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 take_if<P>(&mut self, predicate: P) -> Option<T>
🔬This is a nightly-only experimental API. (option_take_if
#98934)
pub fn take_if<P>(&mut self, predicate: P) -> Option<T>
option_take_if
#98934)
从选项中取出值,但前提是谓词 true
的计算结果基于对值的可变引用。
换言之,如果谓词返回 true
,则替换 self
为 None
。此方法的操作类似于,但有条件。
§ 例子
#![feature(option_take_if)]
let mut x = Some(42);
let prev = x.take_if(|v| if *v == 42 {
*v += 1;
false
} else {
false
});
assert_eq!(x, Some(43));
assert_eq!(prev, None);
let prev = x.take_if(|v| *v == 43);
assert_eq!(x, None);
assert_eq!(prev, Some(43));
Runsourcepub 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)
拉链 self
和另一个 Option
具有功能 f
。
如果 self
is Some(s)
和 other
is Some(o)
,则此方法返回 Some(f(s, o))
。否则, None
将返回。
§ 例子
#![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>>
source§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>
.
§ 例子
基本用法:
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>
.
§ 例子
将 an Option<String>
转换为 Option<usize>
,保留原始文件。该方法按值获取 self
参数,使用原始值,因此此技术用于 from
首先对原始值的引用。
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<Option<A>> for Option<V>where
V: FromIterator<A>,
impl<A, V> FromIterator<Option<A>> for Option<V>where
V: FromIterator<A>,
source§fn from_iter<I>(iter: I) -> Option<V>where
I: IntoIterator<Item = Option<A>>,
fn from_iter<I>(iter: I) -> Option<V>where
I: IntoIterator<Item = Option<A>>,
取 : 中的每个元素,如果是,则不会再取其他元素,并返回 。如果未发生,则返回包含每个值的类型的 V
容器。
§ 例子
下面是一个递增向量中每个整数的示例。当计算会导致溢出时 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
。
这是上一个示例的变体,表明 iter
在第一个 None
.
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 for Option<T>
impl<T> FromResidual for Option<T>
source§fn from_residual(residual: Option<Infallible>) -> Option<T>
fn from_residual(residual: Option<Infallible>) -> Option<T>
try_trait_v2
#84277)1.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 for Option<T>where
T: PartialOrd,
impl<T> PartialOrd for Option<T>where
T: PartialOrd,
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>
fn product<I>(iter: I) -> Option<T>
取 : 中的每个元素,如果它是 ,则不会取其他元素,并返回 。如果没有发生,则返回所有元素的乘积。
§ 例子
这会将字符串向量中的每个数字相乘,如果无法解析字符串,则操作返回 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>
fn sum<I>(iter: I) -> Option<T>
取 : 中的每个元素,如果它是 ,则不会取其他元素,并返回 。如果没有发生,则返回所有元素的总和。
§ 例子
这总结了字符“a”在字符串向量中的位置,如果一个单词没有字符“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);
Run