Rust - Option 常用方法

学习Rust不仅需要知道标准库的常用triat 以外,还需要知道 常用类型的常用方法
Option 枚举应该是最常用的类型了

推荐文章

Rust 标准库中的 Trait 之旅

开始

简述: Option 就是一个枚举,用来代表null的概念

pub enum Option<T> {
    None,//没有价值,也就是null
    Some(T),//存有T类型值
}

常用方法

T 代表 Some(T) 中的T类型
v 代表 Some(v) 中的 v 值

impl Option

pub const fn is_some (&self) -> bool 
// 若是 Some 则返回 true 

pub const fn is_none (&self) -> bool 
// 若是 None 则返回 true 

pub fn is_some_and (&self, f: impl FnOnce ( & T) -> bool ) -> bool
// 若是 Some 且 f函数返回true,则返回true

pub fn unwrap(self) -> T
// 若是 Some(v) ,则返回 v 
// 若是 None 则直接 panic!

pub fn expect(self, msg: &str) -> T
// 和上面的 unwrap 一样,只不过 None 后,附带 msg 信息

pub fn unwrap_or(self, default: T) -> T
// 若是 Some(v) 则返回v 
// 若是 None 则返回 default

pub fn unwrap_or_else<F>(self, f: F) -> T where
    F: FnOnce() -> T, 
// 若是 Some(v) 则返回v 
// 若是 None 则返回 f函数提供的返回值

pub fn unwrap_or_default (self) -> T where
    T: Default, 
// 若是 Some(v) 则返回v
// 若是 None 则返回 T::default() 的返回值    

pub fn map<U, F>(self, f: F) -> Option<U> where
    F: FnOnce(T) -> U, 
// 将 Option 类型 通过 f函数 转为 Option 类型

pub fn map_or<U, F>(self, default: U, f: F) -> U where
    F: FnOnce(T) -> U, 
// 和上面的 map 一样,不同的是 若是 None 则返回 default 
// 所以 map_or 返回的不是 Option 而是 U ,因为它一定存在返回值    

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U where
    D: FnOnce() -> U,
    F: FnOnce(T) -> U, 
// 和上面的 map_or 一样,无非是默认值变为 default() 的返回值 
  
pub fn inspect<F>(self, f: F) -> Option<T> where
    F: FnOnce(&T), 
// 若是 Some(v) 则调用 f(&v) ,随后返回Self   

pub fn ok_or<E>(self, err: E) -> Result<T, E>
// 由 Option 变为 Resuilt
// 很明显,若是 None 则返回 Err(err)

pub fn ok_or_else<E, F>(self, err: F) -> Result<T, E> where
    F: FnOnce() -> E, 
// 和上面的 ok_or 一样,无非是err值变为 err() 的返回值
    
pub fn as_deref(&self) -> Option<&<T as Deref>::Target> where
    T: Deref, 
// 将 Option 转为 Deref解引用后的D值 Option

pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target> where
    T: DerefMut, 
// 和上面的 as_deref 一样,不同的是 是DerefMut解引用后的值

pub fn and<U>(self, optb: Option<U>) -> Option<U>
// self和optb若都是Some , 则返回optb ,否则返回None

pub fn and_then<U, F>(self, f: F) -> Option<U> where
    F: FnOnce(T) -> Option<U>, 
// 和上面的 and 一样 , 不同的是 optb 是 f()函数的返回值
 
pub fn filter<P>(self, predicate: P) -> Option<T> where
    P: FnOnce(&T) -> bool, 
// 若是 None ,则直接返回 None
// 若是 Some(v) ,则判断 predicate(v)的返回值
// 若predicate返回ture,则返回 Some(v) ,否则返回None

pub fn or(self, optb: Option<T>) -> Option<T>
// self和optb都是None,则返回None
// self和optb其中一个是Some,则返回是Some的那一个
// self和optb都是Some,优先返回self

pub fn or_else<F>(self, f: F) -> Option<T> where
    F: FnOnce() -> Option<T>, 
// 和上面的 or 一样 , 不同的是 optb 是 f()函数的返回值

pub fn xor(self, optb: Option<T>) -> Option<T>
// self和optb其中一个是Some,则返回是Some的那一个
// self和optb一样,则返回None

pub fn insert(&mut self, value: T) -> &mut T
// 插入一个新值,旧值被删除
// 注意返回值是 插入后 的可变借用,而非是 旧值

pub fn get_or_insert(&mut self, value: T) -> &mut T
// 若self是None,则可以插入值,并返回插入后的 可变借用
// 若self是Some(v),则无法插入,并返回 v 的可变借用

pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut T where
    F: FnOnce() -> T, 
// 和上面的 get_or_insert 一样,不同的是 插入值是 f()函数的返回值
   
pub fn take(&mut self) -> Option<T>
// 取出值，在其位置留下 None

pub fn replace(&mut self, value: T) -> Option<T>
// 插入新值,返回旧值

pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 
// 若 Some(v) 中的 v==x , 则返回 true

pub fn zip<U>(self, other: Option<U>) -> Option<(T, U)>
// 若self和other都是Some,则返回 Option<(T,U)>
// 其他情况则都返回 None

pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R> where
    F: FnOnce(T, U) -> R, 
// 若self和other都是Some,则返回 Some(f(T,U)),也就是返回f()函数的返回值
// 其他情况则都返回 None   

impl Option>

pub fn flatten(self) -> Option<T>
// 从 Option> 转换为 Option。

实际的方法是非常多的,若有兴趣自己可以去 标准库文档 里去看

若有描述错误,或描述不清晰,麻烦亲~ 热心指出~

参考

标准库文档