前言：

Option定制小程序开发是组成程序的基石，熟练使用Rust的Option定制小程序开发可以帮助我们进行程序的开发。但是Option定制小程序开发这里的知识和细节比较绕，定制小程序开发说白了就是各种套娃，定制小程序开发本篇文章意在梳理Option定制小程序开发的一些细节。

关于Option定制小程序开发的基本构成，定制小程序开发这里不讲了，定制小程序开发想必读者应当都会。

首先，提供Rust定制小程序开发标准库的官方文档供读者查阅。

区分Option<T>中的T为&的情况


fn work_1() {
    let foo1 = Foo;
    let foo2  = Foo;
    let val_some = Some(foo1);
    let ref_some = Some(&foo2);
}

Option<T>，对于val_some的类型，T为Foo，对于ref_some的类型T为Foo&。也就是说

val_some: Option<Foo>

ref_some: OPtion<&Foo>

定制小程序开发对于后续的文章，定制小程序开发我会将其两者分开说明。

Some定制小程序开发包装遵守赋值操作符的规则

让我们回想一个规则。Rust中的某一个类型如果没有实现Copy trait，那么其赋值操作是所有权的转移，如果实现了，就是复制。如果对一个变量进行包装，同样遵循这个道理。


#[allow(unused)]
fn work_1() {
    let foo = Foo;
    let some = Some(foo);
    let ref_foo = &foo; //error
 
    let a = 10;
    let some = Some(a);
    let ref_a = &a;
}


jan@jan:~/code/rust/option_$ cargo run
   Compiling option_ v0.1.0 (/home/jan/code/rust/option_)
error[E0382]: borrow of moved value: `foo`
  --> src/main.rs:11:19
   |
9  |     let foo = Foo;
   |         --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
10 |     let some = Some(foo);
   |                     --- value moved here
11 |     let ref_foo = &foo; //error
   |                   ^^^^ value borrowed here after move
 
For more information about this error, try `rustc --explain E0382`.
error: could not compile `option_` due to previous error

所有的内置类型都实现了Copy trait，所以上面的三行不能通过编译，下面的三行可以。

区别&mut; mut &; mut & mut

这里的问题就像C++中的const *, * const, const * const一样。你完全可以类比。


#[allow(unused)]
fn work_2() {
    let mut a = 10;
    {
        let b = 20;
        let ref_a = &a; // -> &i32
        ref_a = &b;            //将引用指向b不可以
        let mut mut_ref_a = &a; //mut &i32
        *mut_ref_a = 20;       //更改变量本身，不可以
        mut_ref_a = &b;        //将引用指向b，可以
    }
    let ref_mut_a = &mut a; // -> &mut i32
    *ref_mut_a = 20;  //更改变量本身的值，可以
}

& mut代表着对一个变量的可变引用，引用的变量是可变的，但是引用本身是不可变的，也就是说当我确定引用一个变量的时候，就不能再引用其他变量了。
mut &代表着引用本身是可变的，即这个引用既可以引用a，又可以引用b，但是引用的变量是不可变的。
& mut & 即代表着上述两者的结合，引用本身是可变的，并且引用的变量也是可变的。


jan@jan:~/code/rust/option_$ cargo run
   Compiling option_ v0.1.0 (/home/jan/code/rust/option_)
error[E0384]: cannot assign twice to immutable variable `ref_a`
  --> src/main.rs:24:9
   |
23 |         let ref_a = &a; // -> &i32
   |             -----
   |             |
   |             first assignment to `ref_a`
   |             help: consider making this binding mutable: `mut ref_a`
24 |         ref_a = &b;            //将引用指向b不可以
   |         ^^^^^^^^^^ cannot assign twice to immutable variable
 
error[E0594]: cannot assign to `*mut_ref_a`, which is behind a `&` reference
  --> src/main.rs:26:9
   |
25 |         let mut mut_ref_a = &a; //mut &i32
   |                             -- help: consider changing this to be a mutable reference: `&mut a`
26 |         *mut_ref_a = 20;       //更改变量本身，不可以
   |         ^^^^^^^^^^^^^^^ `mut_ref_a` is a `&` reference, so the data it refers to cannot be written
 
Some errors have detailed explanations: E0384, E0594.
For more information about an error, try `rustc --explain E0384`.
error: could not compile `option_` due to 2 previous errors

match和Option

match匹配Option是开发中经常使用的组合。


#[allow(unused)]
fn match_ref_some() {
    let some = Some(String::from("hello"));
    let ref_some = &some;
    match ref_some {
        Some(s) => println!("{}",s),
        None => println!("no string"),
    }
 
    match some {
        Some(s) => println!("{}",s),
        None => println!("no string"),
    }
 
    println!("{}",some.unwrap()); //error
}

对于引用来说，匹配出来的值依旧是引用，也就是&T，对于变量本身来说，匹配出来的值就是T本身。


jan@jan:~/code/rust/some__$ cargo check
    Checking some__ v0.1.0 (/home/jan/code/rust/some__)
error[E0382]: use of partially moved value: `some`
   --> src/main.rs:188:19
    |
184 |         Some(s) => println!("{}",s),
    |              - value partially moved here
...
188 |     println!("{}",some.unwrap());
    |                   ^^^^ value used here after partial move
    |
    = note: partial move occurs because value has type `String`, which does not implement the `Copy` trait
help: borrow this field in the pattern to avoid moving `some.0`
    |
184 |         Some(ref s) => println!("{}",s),
    |              +++
 
For more information about this error, try `rustc --explain E0382`.
error: could not compile `some__` due to previous error

这里匹配的是一个&Option，所以s是一个&String，不会造成所有权的转移。


    match ref_some {
        Some(s) => println!("{}",s),
        None => println!("no string"),
    }

而这里匹配的是Option，所以s为String，会发生所有权的转移，就是原来的some：Option<String>变量中的值，被转移到了匿名Option<String>中，就是代码Some(s)中的s，编译给出了一个部分移动的警告，也就是所some本身并没有被移动，而是其中的值被移动了，但是Option枚举中的Some就那么一个值，所以看着像是整个some都移动了，实则不然。


    match some {
        Some(s) => println!("{}",s),
        None => println!("no string"),
    }

Option和迭代器

就连Option上也有迭代器，真是不可思议。和其他的迭代器一样，只不过因为Option中只能是Some或者None，当是Some的时候，第一次调用next返回Some中的值，其余情况，包括None，均返回None。


#[allow(unused)]
#[test]
fn work_4() {
    let some = Some(String::from("hello"));
    let mut i = some.into_iter();
    assert_eq!(i.next().as_deref(),Some("hello"));
    assert_eq!(i.next(),None);
 
    let none: Option<String> = None;
    assert_eq!(none.iter().next(),None);
 
}

as系列方法

as系类方法提供在不结构的请款下改变T的类型，这些as方法十分的方便，但是却有些不好掌握。

在了解as系列方法前：请先记住一个规则：所谓的as_XXX，均对于T来说，而不是Option<T>来as说，这样可能更好的理解。

as_ref和map


pub const fn as_ref(&self) -> Option<&T>
从 &Option<T> 转换为 Option<&T>。

就是将T变为 &T。

我想你一定有个疑问，什么情况下需要这样转变。答案是你想使用Option中存放的值，但是却又不想失去其所有权的情况下，也就是平常所说的按照引用的方式传参。

例如标Option的impl中有一个名为map的方法，就和迭代器的map功能是一样的，但注意，Option的此方法非缓式评估，或者说非惰性求值，因为完全没有必要，我们看其函数原型。


pub fn map<U, F>(self, f: F) -> Option<U>
where
    F: FnOnce(T) -> U,

如果我们将Option<T> 传入，那么就原先的Some就会失去所有权，就像是这样。


#[allow(unused)]
#[test]
fn work_5() {
    let some = Some(String::from("hello"));
    let size = some.map(|s| s.len());
    println!("{}",some.unwrap());
}


error[E0382]: use of moved value: `some`
   --> src/main.rs:64:19
    |
62  |     let some = Some(String::from("hello"));
    |         ---- move occurs because `some` has type `Option<String>`, which does not implement the `Copy` trait
63  |     let size = some.map(|s| s.len());
    |                     ---------------- `some` moved due to this method call
64  |     println!("{}",some.unwrap());
    |                   ^^^^ value used here after move
    |
note: this function takes ownership of the receiver `self`, which moves `some`
   --> /home/jan/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/option.rs:903:28
    |
903 |     pub const fn map<U, F>(self, f: F) -> Option<U>
    |                            ^^^^
help: consider calling `.as_ref()` to borrow the type's contents
    |
63  |     let size = some.as_ref().map(|s| s.len());
    |                     +++++++++
 
For more information about this error, try `rustc --explain E0382`.

但如果我们将Option<T>变为Option<&T>就是不一样的了，对于引用来说，仅仅就是一个指针而已，也无所谓移动不移动的了，就像是这样。


#[allow(unused)]
#[test]
fn work_5() {
    let some = Some(String::from("hello"));
    let size = some.map(|s| s.len());
    // println!("{}",some.unwrap()); //error
 
    let some = Some(String::from("hello"));
    let size = some.as_ref().map(|s| s.len());
    println!("{}",some.unwrap()); 
}

标准库的实现也是非常的简单。


    pub const fn as_ref(&self) -> Option<&T> {
        match *self {
            Some(ref x) => Some(x),
            None => None,
        }
    }

as_deref


pub fn as_deref(&self) -> Option<&<T as Deref>::Target>
从 Option<T> (或 &Option<T>) 转换为 Option<&T::Target>。
 
将原始 Option 保留在原位，创建一个带有对原始 Option 的引用的新 Option，并通过 Deref 强制执行其内容。

也就是说，as_deref相当于对T进行了一次解引用操作并加上引用。当然，T必须实现了Deref这个trait。

如果你对None调用这个方法，结果依旧是None。


#[allow(unused)]
#[test]
fn work_3() {
    let s = String::from("hello");
    let some = Some(s);
    assert_eq!(some.as_deref(),Some("hello"));
    println!("{:?}",some);
 
    let some: Option<i32> = None;
    // some.as_deref(); //error
 
    let some: Option<String> = None;
    assert_eq!(some.as_deref(),None);
}

将原始 Option 保留在原位，创建一个带有对原始 Option 的引用的新 Option，并通过 Deref 强制执行其内容。这句话是不是让你很不解，我们一点点分析。

所谓的保留在原位，即是不发生move语义，也就是我们上面所说的as_ref的情形。我们进入源码，可看见这样简短的实现方法。


    pub fn as_deref(&self) -> Option<&T::Target> {
        self.as_ref().map(|t| t.deref())
    }

所说的并通过 Deref 强制执行其内容，就是调用deref方法而已。总结的来说，就是获得Option<&T>然后再进行解引用（注意，deref返回值为&T::Target，所以返回值并没有什么好疑惑的)。

或者说更加新版的标准库是这样实现的


    pub const fn as_deref(&self) -> Option<&T::Target>
    where
        T: ~const Deref,
    {
        match self.as_ref() {
            Some(t) => Some(t.deref()),
            None => None,
        }
    }

这里t的类型为&T。

as_deref_mut

和as_deref很像，就对在返回类型的可变性进行了更改。


pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>
从 Option<T> (或 &mut Option<T>) 转换为 Option<&mut T::Target>。
 
在这里保留原始的 Option，创建一个包含对内部类型的 Deref::Target 类型的可变引用的新的 Option。

实战演练

as系列方法能够帮助我们做什么呢，难道仅仅是令人头疼的类型转换吗？为了能够更好的理解，我们可以看一下这个题，合并链表。

这是一份实现代码——你可以在题解中找到这份答案，这份代码并不知作者写的。


// Definition for singly-linked list.
// #[derive(PartialEq, Eq, Clone, Debug)]
// pub struct ListNode {
//   pub val: i32,
//   pub next: Option<Box<ListNode>>
// }
 
// impl ListNode {
//   #[inline]
//   fn new(val: i32) -> Self {
//     ListNode {
//       next: None,
//       val
//     }
//   }
// }
impl Solution {
    pub fn merge_two_lists(list1: Option<Box<ListNode>>, list2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        //考虑使用转移所有权的方法，这样构造的新的链表效率会更高
        //因为要转移所有权，所以list应当更改mut属性
        let mut list1 = list1;
        let mut list2 = list2;
        //新的链表
        let mut ret = ListNode::new(0);
        //一个mut & mut ，当作指针
        let mut p = &mut ret;
        //我们不应当获得list的所有权，因为是在一个loop中
        while let (Some(n1), Some(n2)) = (list1.as_ref(),list2.as_ref()) {
            if n1.val < n2.val {
                //转移所有权
                p.next = list1;
                //p指向list1:就是指针向后移动，因为p值&mut，所以应当使用as_mut
                p = p.next.as_mut().unwrap();
                //list1领导list1剩余的尾部
                list1 = p.next.take();
        } else {
                //逻辑同上
                p.next = list2;
                p = p.next.as_mut().unwrap();
                list2 = p.next.take();
            }
            //这里这样写是因为隐式解引用规则，全部样貌应当是
            //p = p.next.as_mut().unwrap().as_mut();
            //或者是
            // &mut **p.next.as_mut().unwrap();
            // p = &mut **p.next.as_mut().unwrap();
            //首先next返回Option<T>，
            //使用as_mut方法，-> Option<&mut T>
            //再使用unwrap方法得到的应当是一个&mut Box<ListNode>
            //根据隐式解引用转换规则，可实现Box<T> -> &T
            p = p.next.as_mut().unwrap();
        }
        p.next = if list1.is_some() { list1 } else {list2 };
        ret.next
    }

常用方法

filter

一个过滤器


pub fn filter<P>(self, predicate: P) -> Option<T>
where
    P: FnOnce(&T) -> bool, 
如果选项为 None，则返回 None; 否则，使用包装的值调用 predicate 并返回：

predicate指的是一个一元谓词。可以这样使用。


#[allow(unused)]
fn is_even(x: &i32) -> bool {
    x % 2 == 0
}
#[allow(unused)]
#[test]
fn work_6() {
    let some = Some(3);
    assert_eq!(some.filter(|x| is_even(x)),None);
 
    let some = Some(4);
    assert_eq!(some.filter(|x| is_even(x)),Some(4));
 
    assert_eq!(None.filter(|x| is_even(x)),None);
}

or


pub fn or(self, optb: Option<T>) -> Option<T>
如果包含值，则返回选项，否则返回 optb。
 
传递给 or 的参数会被急切地评估； 如果要传递函数调用的结果，建议使用 or_else，它是延迟计算的。

Box和Option

todo

总结

关于Option的用法还有很多，不能一一列举，如果日后作者在开发过程中踩坑，还会来继续更新的。

定制小程序开发Rust——关于Option详解