result & option

result与option转换

Option 转 Result

1. ok_or: 将 Option 转换为 Result，如果是 None，则使用提供的错误值。

   let opt: Option<i32> = Some(42);
   let result: Result<i32, &str> = opt.ok_or("error");
   assert_eq!(result, Ok(42));
   
   let none: Option<i32> = None;
   let result: Result<i32, &str> = none.ok_or("error");
   assert_eq!(result, Err("error"));
   

2. ok_or_else: 类似于 ok_or，但错误值是通过闭包计算得到的。

   let opt: Option<i32> = Some(42);
   let result: Result<i32, String> = opt.ok_or_else(|| "error".to_string());
   assert_eq!(result, Ok(42));
   
   let none: Option<i32> = None;
   let result: Result<i32, String> = none.ok_or_else(|| "error".to_string());
   assert_eq!(result, Err("error".to_string()));
   

Result 转 Option

1. ok: 将 Result 转换为 Option，如果是 Err，则返回 None。

   let res: Result<i32, &str> = Ok(42);
   let opt: Option<i32> = res.ok();
   assert_eq!(opt, Some(42));
   
   let res: Result<i32, &str> = Err("error");
   let opt: Option<i32> = res.ok();
   assert_eq!(opt, None);
   

2. err: 将 Result 转换为 Option，如果是 Ok，则返回 None。

   let res: Result<i32, &str> = Ok(42);
   let opt: Option<&str> = res.err();
   assert_eq!(opt, None);
   
   let res: Result<i32, &str> = Err("error");
   let opt: Option<&str> = res.err();
   assert_eq!(opt, Some("error"));
   

Result

创建和解构

1. Ok and Err Variants:

   let success: Result<i32, &str> = Ok(42);
   let failure: Result<i32, &str> = Err("error");
   

查询和提取值

2. is_ok: 检查 Result 是否是 Ok。

   assert!(success.is_ok());
   

3. is_err: 检查 Result 是否是 Err。

   assert!(failure.is_err());
   

4. ok: 将 Result 转换为 Option，丢弃 Err 值。

   let opt = success.ok(); // Some(42)
   

5. err: 将 Result 转换为 Option，丢弃 Ok 值。

   let opt = failure.err(); // Some("error")
   

变换和操作

6. map: 对 Ok 值应用函数。

   let res = success.map(|x| x + 1); // Ok(43)
   

7. map_err: 对 Err 值应用函数。

   let res = failure.map_err(|e| e.to_uppercase()); // Err("ERROR")
   

8. and_then: 链接多个可能出错的操作。

   let res = success.and_then(|x| Ok(x + 1)); // Ok(43)
   

9. or_else: 链接多个可能失败的操作。

   let res = failure.or_else(|_| Ok(0)); // Ok(0)
   

提取和解包

10. unwrap: 提取 Ok 值，如果是 Err 则 panic。

    let value = success.unwrap(); // 42
    

11. unwrap_err: 提取 Err 值，如果是 Ok 则 panic。

    let error = failure.unwrap_err(); // "error"
    

12. unwrap_or: 提取 Ok 值，如果是 Err 则返回默认值。

    let value = failure.unwrap_or(0); // 0
    

13. unwrap_or_else: 提取 Ok 值，如果是 Err 则计算一个默认值。

    let value = failure.unwrap_or_else(|_| 0); // 0
    

错误处理

14. expect: 提取 Ok 值，如果是 Err 则 panic 并打印自定义错误信息。

    let value = success.expect("Operation failed"); // 42
    

15. expect_err: 提取 Err 值，如果是 Ok 则 panic 并打印自定义错误信息。

    let error = failure.expect_err("Unexpected success"); // "error"
    

其他实用方法

16. transpose: 将 Result<Option<T>, E> 转换为 Option<Result<T, E>>。

    let opt_res: Option<Result<i32, &str>> = Ok(Some(42)).transpose();
    // opt_res: Some(Ok(42))
    

17. flatten: 将 Result<Result<T, E>, E> 扁平化为 Result<T, E>。

    let nested_res: Result<Result<i32, &str>, &str> = Ok(Ok(42));
    let flat_res: Result<i32, &str> = nested_res.flatten();
    // flat_res: Ok(42)
    

18. copied: 将 Result<&T, E> 转换为 Result<T, E>，其中 T 实现了 Copy。

    let res: Result<&i32, &str> = Ok(&42);
    let copied_res: Result<i32, &str> = res.copied();
    // copied_res: Ok(42)
    

19. cloned: 将 Result<&T, E> 转换为 Result<T, E>，其中 T 实现了 Clone。

    let res: Result<&String, &str> = Ok(&"hello".to_string());
    let cloned_res: Result<String, &str> = res.cloned();
    // cloned_res: Ok("hello".to_string())
    

Option

创建和构造

1. Some 和 None:

   let some_value: Option<i32> = Some(5);
   let none_value: Option<i32> = None;
   

检查内容

2. is_some 和 is_none:

   let x: Option<i32> = Some(2);
   assert!(x.is_some());
   assert!(!x.is_none());
   

3. contains: 检查 Option 是否包含指定的值。

   let x: Option<i32> = Some(2);
   assert!(x.contains(&2));
   

访问内容

4. unwrap: 获取值，如果是 None 则会 panic。

   let x: Option<i32> = Some(2);
   let y: i32 = x.unwrap();
   

5. unwrap_or: 获取值，如果是 None 则返回默认值。

   let x: Option<i32> = None;
   let y: i32 = x.unwrap_or(10);
   

6. unwrap_or_else: 获取值，如果是 None 则调用闭包返回默认值。

   let x: Option<i32> = None;
   let y: i32 = x.unwrap_or_else(|| 2 * 5);
   

7. unwrap_or_default: 获取值，如果是 None 则返回 Default 值。

   let x: Option<i32> = None;
   let y: i32 = x.unwrap_or_default();
   

8. expect: 获取值，如果是 None 则 panic 并打印提供的错误信息。

   let x: Option<i32> = Some(2);
   let y: i32 = x.expect("Expected a value");
   

9. expect_none: 检查是否为 None，否则 panic。

   let x: Option<i32> = None;
   x.expect_none("Expected None");
   

10. expect_some: 检查是否为 Some，否则 panic。

    let x: Option<i32> = Some(2);
    let y: i32 = x.expect_some("Expected Some");
    

转换

11. map: 对值应用函数，如果是 None 则返回 None。

    let x: Option<i32> = Some(2);
    let y: Option<i32> = x.map(|v| v + 1);
    

12. map_or: 对值应用函数，如果是 None 则返回默认值。

    let x: Option<i32> = Some(2);
    let y: i32 = x.map_or(10, |v| v + 1);
    

13. map_or_else: 对值应用函数，如果是 None 则调用闭包返回默认值。

    let x: Option<i32> = Some(2);
    let y: i32 = x.map_or_else(|| 10, |v| v + 1);
    

14. and: 如果是 Some，返回 other，否则返回 None。

    let x: Option<i32> = Some(2);
    let y: Option<&str> = Some("foo");
    let z: Option<&str> = x.and(y);
    

15. and_then: 对值应用函数，返回 Option，如果是 None 则返回 None。

    let x: Option<i32> = Some(2);
    let y: Option<i32> = x.and_then(|v| Some(v + 1));
    

16. filter: 过滤值，如果值满足谓词则返回 Some，否则返回 None。

    let x: Option<i32> = Some(2);
    let y: Option<i32> = x.filter(|&v| v > 1);
    

17. or: 如果是 None，返回 other，否则返回自身。

    let x: Option<i32> = None;
    let y: Option<i32> = Some(10);
    let z: Option<i32> = x.or(y);
    

18. or_else: 如果是 None，调用闭包返回 Option，否则返回自身。

    let x: Option<i32> = None;
    let y: Option<i32> = x.or_else(|| Some(10));
    

19. flatten: 将 Option<Option<T>> 转换为 Option<T>。

    let x: Option<Option<i32>> = Some(Some(2));
    let y: Option<i32> = x.flatten();
    

结果转换

20. ok_or: 将 Option 转换为 Result，如果是 None 则返回提供的错误值。

    let x: Option<i32> = Some(2);
    let y: Result<i32, &str> = x.ok_or("error");
    

21. ok_or_else: 将 Option 转换为 Result，如果是 None 则调用闭包返回错误值。

    let x: Option<i32> = Some(2);
    let y: Result<i32, String> = x.ok_or_else(|| "error".to_string());
    

迭代

22. iter: 返回包含 Option 值的迭代器。

    let x: Option<i32> = Some(2);
    for val in x.iter() {
        println!("{}", val);
    }
    

23. into_iter: 将 Option 转换为所有权迭代器。

    let x: Option<i32> = Some(2);
    for val in x.into_iter() {
        println!("{}", val);
    }
    

24. as_ref: 将 Option 转换为包含引用的 Option。

    let x: Option<i32> = Some(2);
    let y: Option<&i32> = x.as_ref();
    

25. as_mut: 将 Option 转换为包含可变引用的 Option。

    let mut x: Option<i32> = Some(2);
    if let Some(v) = x.as_mut() {
        *v += 1;
    }
    

排除

26. take: 将 Option 的值取出，留下 None。

    let mut x: Option<i32> = Some(2);
    let y: Option<i32> = x.take();
    assert_eq!(x, None);
    assert_eq!(y, Some(2));
    

27. replace: 替换 Option 的值，返回旧值。

    let mut x: Option<i32> = Some(2);
    let y: Option<i32> = x.replace(5);
    assert_eq!(x, Some(5));
    assert_eq!(y, Some(2));
    

常量

28. is_none: 判断是否为 None。
29. is_some: 判断是否为 Some。
30. contains: 判断是否包含指定值。
31. expect: 获取值或 panic。
32. unwrap: 获取值或 panic。
33. unwrap_or: 获取值或返回默认值。
34. unwrap_or_else: 获取值或调用闭包返回默认值。
35. unwrap_or_default: 获取值或返回默认值。

这些方法提供了丰富的操作 Option 类型的方式，帮助开发者有效处理可能为空的值。