basic/result-error/result

[giscus[bot]]

basic/result-error/result

https://course.rs/basic/result-error/result.html

[overlords]

我是一只新螃蟹，为什么要告诉我try!
不听不听

[sunface]

额，你哪里新了，书中已经遍布你横行八道的脚印了 🤣

[LucasIcarus]

作为一个爬的慢的初学者, 看到这里 已经要靠很用力的回忆才能想起来 Box<dyn Error> 是啥意思了 [大哭]

[sunface]

没事，多用力几次，就不会忘了😋

[aly8246]

泛型和特征里的特征对象有讲，我猜这里不过是在特征对象的基础上加了一个自动类型提升(自动类型转换)

[yurnery]

在了解了 ? 的使用限制后，这段代码你很容易看出它无法编译：

上面这段话 ? 的使用限制并没有讲清楚, 例如?就只能用在返回值比较特殊的方法里, 如下错误提示:
the ? operator can only be used in a function that returns Result or Option (or another type that implements FromResidual)

[yurnery]

自己回答: 原来这个限制不是单纯指的是这两行

let v = xxx()?;
xxx()?.yyy()?;

对于可选值来说, 本质上还是?展开后发现是 None就 return 了. 所以函数签名的返回值需要是可选值.
这个可选链和其他语言的不太一样, 学过 Swift 表示又亲切, 又比较容易混淆, 别的语言只是这个 nil 相关的操作不执行, 但后续代码还是执行, rust 的是直接返回了.

[tjw123hh]

其实?和try!宏是几乎一样的

[ShyunnY]

我们可以看一看?的源码:

#[inline]
    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
        match self {
            // 取出Result::Ok(v)的v返回, 所以是需要绑定变量或者忽略返回值。v与函数返回值Result不匹配
            Ok(v) => ControlFlow::Continue(v), 
            // 这个是返回一个Result::Err(e), 所以是可以匹配函数返回值Result
            Err(e) => ControlFlow::Break(Err(e)), 
        }
    }

[SuanCaiYv]

讲真的，从Go过来的我觉得，?真的比if err != nil {}舒服太多了！！！

[sunface]

说实话,go的err!=nil非常的爽,可以让外人感觉代码量很惊人

这个角度无可挑剔 🤣

[orbitoo]

统一可能出错的函数的返回, 用一个错误处理函数来调用它们就好了

[lnb-wxqy]

? 在传递异常时确实方便，但是rust需要处理异常时并不比go舒服，也要一大推代码

[ghost]

rust的错误处理不也是一样的嘛，生产中应该不太会使用unwrap和expect，这样就导致还是要一个一个的处理抛出的错误，而且因为错误是包在Result中的，还需要用模式匹配，我咋感觉没多大区别呢😳

[Sube-py]

?好js啊😂

[jinliming2]

expect 那里的报错信息怎么和 unwrap 那里的一样？是复制错了吗？

[Joneyao]

有一点不一样的，expect 会把后面的自己输入的msg 打印出来。
实际看unwrap 和 expect 底层调用的接口都是一样的 unwrap_failed，只是后者会把 expect 中的msg 打印出来。

[alexniver]

[xGuangsPBD]

可以翻看前面类型的章节

[ice-jade]

因此 ? 只能用于以下形式：
let v = xxx()?;
xxx()?.yyy()?;
第二种形式是否应该是 xxx()?.yyy() ，否则返回类型又不一致了 /* OK(e) => e Err(e) => return Err(e) */

[soft5]

pub struct XXX<xx： ?Size> ,这里的？有啥用处？

[xianfuxing]

std::io::error

impl error::Error for Error {
    #[allow(deprecated, deprecated_in_future)]
    fn description(&self) -> &str {
        match self.repr.data() {
            ErrorData::Os(..) | ErrorData::Simple(..) => self.kind().as_str(),
            ErrorData::SimpleMessage(msg) => msg.message,
            ErrorData::Custom(c) => c.error.description(),
        }
    }

    #[allow(deprecated)]
    fn cause(&self) -> Option<&dyn error::Error> {
        match self.repr.data() {
            ErrorData::Os(..) => None,
            ErrorData::Simple(..) => None,
            ErrorData::SimpleMessage(..) => None,
            ErrorData::Custom(c) => c.error.cause(),
        }
    }

    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self.repr.data() {
            ErrorData::Os(..) => None,
            ErrorData::Simple(..) => None,
            ErrorData::SimpleMessage(..) => None,
            ErrorData::Custom(c) => c.error.source(),
        }
    }
}```

std::io::error 实现了 std::io::error 特征，是不是才是error转换的原因？

[xianfuxing]

写错，应该是 std::io::Error 实现了 std::error::Error 特征

[zhenzhenChange]

这个应该跟类型的逆变协变有关？

[dogloves]

let mut f = match f {
// 打开文件成功，将file句柄赋值给f
Ok(file) => file,
// 打开文件失败，将错误返回(向上传播)
Err(e) => return Err(e),
};
为什么这里的Err要加return，而其他不需要加return

[nieyuyao]

试了下，不加return也是可以的，不加的时候是隐式返回

[codecoron]

我试了一下，不加return 是不行的。return有提前返回的作用吧

[coderLanlan]

加了return把Err(e)作为函数的返回值的同时结束了函数的执行，不加return的话就只是把 Err(e)赋值给f，并不会结束函数的执行。我是这么理解的。

[sinopec]

要是用的第三方库，第三方库里自定义了error，这个就很不舒服了，需要为第三方库的error实现from trait？ 这个不就又违法孤儿原则了么, 这个工程上咋解决？

[ivicel]

自定义一个MyError然后实现 impl From<ThirdError> for MyError 相当把第三方的错误包住

[duanyuluo]

看来喜欢包的，不止女人哈

[yxd0379]

最后一段: "可以看出 ? 的优势非常明显，何况 ? 还能做链式调用。"
功能一样, 哪里优势明显了, 明显在代码形式上吗?

[ghost]

我感觉只是加了一些语法糖来把那些需要上层调用者处理的错误快速抛出而已，错误处理和go语言相比并没多大优势

[codecoron]

这两段代码是一样的效果，是因为arr的get() 已经实现了成功获取值，就返回Some(T)，没成功获取值就返回None

fn first(arr: &[i32]) -> Option<&i32> {
   arr.get(0)
}

fn first(arr: &[i32]) -> Option<&i32> {
   let v = arr.get(0)?;
   Some(v)
}

[kapaseker]

哎，还是Kotlin的?.要舒服很多。

[epitaphial]

这段代码无法通过编译，切记：? 操作符需要一个变量来承载正确的值

这句话其实不准确，报错的原因不是因为没有变量承载，而是返回的类型跟函数的返回值冲突了，

error[E0308]: `?` operator has incompatible types

改成这样也能正确运行：

#![allow(unused)]
fn main() {
    fn first(arr: &[i32]) -> Option<&i32> {
        arr.get(0)?
    }
}

[epitaphial]

发错了，应如下：

#![allow(unused)]
fn main() {
    fn first(arr: &[i32]) -> Option<&i32> {
        Some(arr.get(0)?)
    }
}

[Icemans007]

它转换为match是这样的吧？

fn main() {
    fn first(arr: &[i32]) -> Option<&i32> {
        // Some(arr.get(0)?) 
        match arr.get(0) {
            Some(i) => Some(i),
            None => return None,
       }
    }
}

[sunhaixun]

match 匹配default 原来不是必须_ ，other_error 看来只要在最后一行，随便命名啊

[uliyanjun]

我还在想为什么 other_error 也行，下面就看到你的留言了。

[Vocal-map]

fn first(arr: &[i32]) -> Option<&i32> {
        Some(arr.get(1)?)
    }

似乎这样写也行

[wangyaoyao233]

优雅

[abnereel]

作者是个人才，我的笑喷了；
我也是从go过来的，没了没完没了的if err != nil ，简直不要太爽。

[tjw123hh]

列举的?能用的形式少了个yyy(xxx()?);
例如以下代码可以编译通过：

fn first(arr: &[i32]) -> Option<&i32> {
   Some(arr.get(0)?)
}

而这段代码不能编译通过的原因是arr.get(0)返回Option<&i32>，?如果不返回直接解出来的是&i32与标记不符：

fn first(arr: &[i32]) -> Option<&i32> {
   arr.get(0)?
}

[liwuhou]

传出去，作者 5 厘米

[quhw]

Result<(), Box> 还是有点啰嗦，可以更加简化么？

[Endermanbugzjfc]

一般写包裹是会在模块中预先放个 type Result<T> = Result<T, MyError>
这样就可以在模块写 Result<()> 而忽略錯誤類型

[leo-davisf]

在入门实战那儿跳回来补课，发现这可太太太太好用了

[fuyedong]

当看到了 "?" 我的心理打出了一个大大 "?"

[iswangyi]

这章看下来终于舒服了，一直在想go的错误处理

[limuyao1996]

感觉rust很多想法和ts很像啊

[doooooit]

Rust 有好多 Typescript 的影子啊

[DylanJinx]

一开始对这段话不理解“标准库中的 std::io::Error 和 std::error::Error，前者是 IO 相关的错误结构体，后者是一个最最通用的标准错误特征，同时前者实现了后者，因此 std::io::Error 可以转换为 std:error::Error。”。

问了gpt，大概了是A如果实现了B，那就意味着B中的方法A都包含了，那么A的实例可以转换成B的实例来用。具体的解释如下：

在 Rust 中，如果一个类型（如 std::io::Error）实现了某个特征（如 std::error::Error），那么这个类型的实例可以在需要该特征的任何地方使用。具体来说，std::io::Error 实现了 std::error::Error 特征，这意味着 std::io::Error 的实例可以被当作 std::error::Error 的实例来使用。

这里的类型转换主要是通过特征多态来实现的，这是 Rust 通过特征（traits）实现的一种形式的多态性。这意味着你可以编写函数或者使用 API，这些函数或 API 接受实现了 std::error::Error 特征的任何类型的参数。由于 std::io::Error 实现了这个特征，你可以安全地将 std::io::Error 的实例传递给这些函数或 API。

例如，你可能有一个函数接受 Box<dyn std::error::Error> 类型的参数，std::io::Error 的实例可以被转换为这个类型的参数，并被传递给这样的函数。这种转换允许 Rust 程序具有很高的灵活性和错误处理的一致性，能够使用统一的接口处理各种不同的错误类型。

[yuzheng14]

fn first(arr: &[i32]) -> Option<&i32> {
   arr.get(0)?
}

这段代码的讲解感觉不太合适，这里不是没有值来承接 arr.get(0)? 的值，而是单纯的返回值类型对不上，改成下面这样就能过编译了

fn first(arr: &[i32]) -> Option<&i32> {
    Some(arr.get(0)?)
}

[simexce]

fn open() -> Result<File, Error> {
    let path = "example.txt";
    File::open(path).or_else(|e| {
        if let ErrorKind::NotFound = e.kind() {
            File::create(path)
        } else {
            Err(e)
        }
    })
}

除了这种模式处理异常外，还有其他模式吗？

[kapaseker]

fn open() -> Result<File, Error> {
    let path = "example.txt";
    File::open(path).or_else(|e| {
        if let ErrorKind::NotFound = e.kind() {
            File::create(path)
        } else {
            Err(e)
        }
    })
}

除了这种模式处理异常外，还有其他模式吗？

https://stackoverflow.com/questions/35636742/is-there-any-way-to-create-and-open-a-file-if-it-doesnt-exist-but-fail-otherwis