Enum std::option::Option 1.0.0[−][src]
pub enum Option<T> {
None,
Some(T),
}Expand description
Option 类型。有关更多信息，请参见 模块级文档。
Variants
None
没有值。
Some(T)
T 类型的某些值。
Implementations
从 &Option<T> 转换为 Option<&T>。
Examples
将 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);返回包含 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");let x: Option<&str> = None;
assert_eq!(x.unwrap(), "air"); // fails返回包含的 Some 值或提供的默认值。
急切地评估传递给 unwrap_or 的参数； 如果要传递函数调用的结果，建议使用 unwrap_or_else，它是惰性求值的。
Examples
assert_eq!(Some("car").unwrap_or("bike"), "car");
assert_eq!(None.unwrap_or("bike"), "bike");pub fn unwrap_or_else<F>(self, f: F) -> T where
F: FnOnce() -> T + Drop,
pub fn unwrap_or_else<F>(self, f: F) -> T where
F: FnOnce() -> T + Drop,
返回包含的 Some 值或默认值。
消费 self 参数，如果 Some，则返回所包含的值，否则，如果 None，则返回该类型的 默认值。
Examples
将字符串转换为整数，将格式不正确的字符串转换为 0 (整数的默认值)。
parse 将字符串转换为实现 FromStr 的任何其他类型，并在出错时返回 None。
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().ok().unwrap_or_default();
let bad_year = bad_year_from_input.parse().ok().unwrap_or_default();
assert_eq!(1909, good_year);
assert_eq!(0, bad_year);通过将函数应用于包含的值，Maps 将 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));返回提供的默认结果 (如果没有)，或将函数应用于包含的值 (如果有)。
传递给 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);将 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));将 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));从 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()));如果选项为 None，则返回 None; 否则，返回 optb。
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);如果选项为 None，则返回 None; 否则，使用包装的值调用 f，并返回结果。
一些语言调用此操作平面图。
Examples
fn sq(x: u32) -> Option<u32> { Some(x * x) }
fn nope(_: u32) -> Option<u32> { None }
assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16));
assert_eq!(Some(2).and_then(sq).and_then(nope), None);
assert_eq!(Some(2).and_then(nope).and_then(sq), None);
assert_eq!(None.and_then(sq).and_then(sq), None);如果选项为 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));如果包含值，则返回选项，否则返回 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);如果选项包含值，则返回该选项，否则调用 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);如果 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);将 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);如果为 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));pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R> where
F: FnOnce(T, U) -> R + Drop,
T: Drop,
U: Drop,
pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R> where
F: FnOnce(T, U) -> R + Drop,
T: Drop,
U: Drop,
使用函数 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);将 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());从 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());展平一次只能删除一层嵌套：
let x: Option<Option<Option<u32>>> = Some(Some(Some(6)));
assert_eq!(Some(Some(6)), x.flatten());
assert_eq!(Some(6), x.flatten().flatten());Trait Implementations
从 &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));接受 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]));如您所见，这将返回预期的有效项。
这是另一个示例，尝试从另一个整数列表中减去一个，这次检查下溢：
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);由于最后一个元素为零，因此会下溢。因此，结果值为 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);由于第三个元素引起下溢，因此不再使用其他元素，因此 shared 的最终值为 6 (= 3 + 2 + 1)，而不是 16。
type Item = T
type Item = T
被迭代的元素的类型。
如果存在，则此方法返回 self 和 other 值之间的顺序。 Read more
在 ? 来决定操作符是应该生成一个值 (因为它返回了 ControlFlow::Continue)，还是将一个值传播回调用者 (因为它返回了 ControlFlow::Break)。 Read more