<!DOCTYPE HTML>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
< title > `panic!`还是不`panic!` - Rust 程序设计语言 简体中文版< / title >
< meta content = "text/html; charset=utf-8" http-equiv = "Content-Type" >
< meta name = "description" content = "Rust 程序设计语言 简体中文版" >
< meta name = "viewport" content = "width=device-width, initial-scale=1" >
< base href = "" >
< link rel = "stylesheet" href = "book.css" >
< link href = 'https://fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel = 'stylesheet' type = 'text/css' >
< link rel = "shortcut icon" href = "favicon.png" >
<!-- Font Awesome -->
< link rel = "stylesheet" href = "https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css" >
< link rel = "stylesheet" href = "highlight.css" >
< link rel = "stylesheet" href = "tomorrow-night.css" >
<!-- MathJax -->
< script type = "text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" > < / script >
<!-- Fetch JQuery from CDN but have a local fallback -->
< script src = "https://code.jquery.com/jquery-2.1.4.min.js" > < / script >
< script >
if (typeof jQuery == 'undefined') {
document.write(unescape("%3Cscript src='jquery.js'%3E%3C/script%3E"));
}
< / script >
< / head >
< body class = "light" >
<!-- Set the theme before any content is loaded, prevents flash -->
< script type = "text/javascript" >
var theme = localStorage.getItem('theme');
if (theme == null) { theme = 'light'; }
$('body').removeClass().addClass(theme);
< / script >
<!-- Hide / unhide sidebar before it is displayed -->
< script type = "text/javascript" >
var sidebar = localStorage.getItem('sidebar');
if (sidebar === "hidden") { $("html").addClass("sidebar-hidden") }
else if (sidebar === "visible") { $("html").addClass("sidebar-visible") }
< / script >
< div id = "sidebar" class = "sidebar" >
< ul class = "chapter" > < li > < a href = "ch01-00-introduction.html" > < strong > 1.< / strong > 介绍< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch01-01-installation.html" > < strong > 1.1.< / strong > 安装< / a > < / li > < li > < a href = "ch01-02-hello-world.html" > < strong > 1.2.< / strong > Hello, World!< / a > < / li > < / ul > < / li > < li > < a href = "ch02-00-guessing-game-tutorial.html" > < strong > 2.< / strong > 猜猜看教程< / a > < / li > < li > < a href = "ch03-00-common-programming-concepts.html" > < strong > 3.< / strong > 通用编程概念< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch03-01-variables-and-mutability.html" > < strong > 3.1.< / strong > 变量和可变性< / a > < / li > < li > < a href = "ch03-02-data-types.html" > < strong > 3.2.< / strong > 数据类型< / a > < / li > < li > < a href = "ch03-03-how-functions-work.html" > < strong > 3.3.< / strong > 函数如何工作< / a > < / li > < li > < a href = "ch03-04-comments.html" > < strong > 3.4.< / strong > 注释< / a > < / li > < li > < a href = "ch03-05-control-flow.html" > < strong > 3.5.< / strong > 控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch04-00-understanding-ownership.html" > < strong > 4.< / strong > 认识所有权< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch04-01-what-is-ownership.html" > < strong > 4.1.< / strong > 什么是所有权< / a > < / li > < li > < a href = "ch04-02-references-and-borrowing.html" > < strong > 4.2.< / strong > 引用 & 借用< / a > < / li > < li > < a href = "ch04-03-slices.html" > < strong > 4.3.< / strong > Slices< / a > < / li > < / ul > < / li > < li > < a href = "ch05-00-structs.html" > < strong > 5.< / strong > 结构体< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch05-01-method-syntax.html" > < strong > 5.1.< / strong > 方法语法< / a > < / li > < / ul > < / li > < li > < a href = "ch06-00-enums.html" > < strong > 6.< / strong > 枚举和模式匹配< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch06-01-defining-an-enum.html" > < strong > 6.1.< / strong > 定义枚举< / a > < / li > < li > < a href = "ch06-02-match.html" > < strong > 6.2.< / strong > < code > match< / code > 控制流运算符< / a > < / li > < li > < a href = "ch06-03-if-let.html" > < strong > 6.3.< / strong > < code > if let< / code > 简单控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch07-00-modules.html" > < strong > 7.< / strong > 模块< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch07-01-mod-and-the-filesystem.html" > < strong > 7.1.< / strong > < code > mod< / code > 和文件系统< / a > < / li > < li > < a href = "ch07-02-controlling-visibility-with-pub.html" > < strong > 7.2.< / strong > 使用< code > pub< / code > 控制可见性< / a > < / li > < li > < a href = "ch07-03-importing-names-with-use.html" > < strong > 7.3.< / strong > 使用< code > use< / code > 导入命名< / a > < / li > < / ul > < / li > < li > < a href = "ch08-00-common-collections.html" > < strong > 8.< / strong > 通用集合类型< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch08-01-vectors.html" > < strong > 8.1.< / strong > vector< / a > < / li > < li > < a href = "ch08-02-strings.html" > < strong > 8.2.< / strong > 字符串< / a > < / li > < li > < a href = "ch08-03-hash-maps.html" > < strong > 8.3.< / strong > 哈希 map< / a > < / li > < / ul > < / li > < li > < a href = "ch09-00-error-handling.html" > < strong > 9.< / strong > 错误处理< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch09-01-unrecoverable-errors-with-panic.html" > < strong > 9.1.< / strong > < code > panic!< / code > 与不可恢复的错误< / a > < / li > < li > < a href = "ch09-02-recoverable-errors-with-result.html" > < strong > 9.2.< / strong > < code > Result< / code > 与可恢复的错误< / a > < / li > < li > < a href = "ch09-03-to-panic-or-not-to-panic.html" class = "active" > < strong > 9.3.< / strong > < code > panic!< / code > 还是不< code > panic!< / code > < / a > < / li > < / ul > < / li > < li > < a href = "ch10-00-generics.html" > < strong > 10.< / strong > 泛型、trait 和生命周期< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch10-01-syntax.html" > < strong > 10.1.< / strong > 泛型数据类型< / a > < / li > < li > < a href = "ch10-02-traits.html" > < strong > 10.2.< / strong > trait： < / a > < / li > < li > < a href = "ch10-03-lifetime-syntax.html" > < strong > 10.3.< / strong > 生命周期与引用有效性< / a > < / li > < / ul > < / li > < li > < a href = "ch11-00-testing.html" > < strong > 11.< / strong > 测试< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch11-01-writing-tests.html" > < strong > 11.1.< / strong > 编写测试< / a > < / li > < li > < a href = "ch11-02-running-tests.html" > < strong > 11.2.< / strong > 运行测试< / a > < / li > < li > < a href = "ch11-03-test-organization.html" > < strong > 11.3.< / strong > 测试的组织结构< / a > < / li > < / ul > < / li > < li > < a href = "ch12-00-
< / div >
< div id = "page-wrapper" class = "page-wrapper" >
< div class = "page" >
< div id = "menu-bar" class = "menu-bar" >
< div class = "left-buttons" >
< i id = "sidebar-toggle" class = "fa fa-bars" > < / i >
< i id = "theme-toggle" class = "fa fa-paint-brush" > < / i >
< / div >
< h1 class = "menu-title" > Rust 程序设计语言 简体中文版< / h1 >
< div class = "right-buttons" >
< i id = "print-button" class = "fa fa-print" title = "Print this book" > < / i >
< / div >
< / div >
< div id = "content" class = "content" >
< a class = "header" href = "#panic还是不panic" name = "panic还是不panic" > < h2 > < code > panic!< / code > 还是不< code > panic!< / code > < / h2 > < / a >
< blockquote >
< p > < a href = "https://github.com/rust-lang/book/blob/master/src/ch09-03-to-panic-or-not-to-panic.md" > ch09-03-to-panic-or-not-to-panic.md< / a >
< br >
commit 0c1d55ef48e5f6cf6a3b221f5b6dd4c922130bb1< / p >
< / blockquote >
< p > 那么，该如何决定何时应该< code > panic!< / code > 以及何时应该返回< code > Result< / code > 呢？如果代码 panic， < code > panic!< / code > ，不管是否有可能恢复，不过这样就你代替调用者决定了这是不可恢复的。选择返回< code > Result< / code > 值的话，就将选择权交给了调用者，而不是代替他们做出决定。调用者可能会选择以符合他们场景的方式尝试恢复，或者也可能干脆就认为< code > Err< / code > 是不可恢复的，所以他们也可能会调用< code > panic!< / code > 并将可恢复的错误变成了不可恢复的错误。因此返回< code > Result< / code > 是定义可能会失败的函数的一个好的默认选择。< / p >
< p > 有一些情况 panic 比返回< code > Result< / code > 更为合适，不过他们并不常见。让我们讨论一下为何在示例、代码原型和测试中，以及那些人们认为不会失败而编译器不这么看的情况下， panic 是合适的，最后会总结一些在库代码中如何决定是否要 panic 的通用指导原则。< / p >
< a class = "header" href = "#示例代码原型和测试非常适合-panic" name = "示例代码原型和测试非常适合-panic" > < h3 > 示例、代码原型和测试：非常适合 panic< / h3 > < / a >
< p > 当你编写一个示例来展示一些概念时，在拥有健壮的错误处理代码的同时也会使得例子不那么明确。例如，调用一个类似< code > unwrap< / code > 这样可能< code > panic!< / code > 的方法可以被理解为一个你实际希望程序处理错误方式的占位符，它根据其余代码运行方式可能会各不相同。< / p >
< p > 类似的，< code > unwrap< / code > 和< code > expect< / code > 方法在原型设计时非常方便，在你决定该如何处理错误之前。他们在代码中留下了明显的记号，以便你准备使程序变得更健壮时作为参考。< / p >
< p > 如果方法调用在测试中失败了，我们希望这个测试都失败，即便这个方法并不是需要测试的功能。因为< code > panic!< / code > 是测试如何被标记为失败的，调用< code > unwrap< / code > 或< code > expect< / code > 都是非常有道理的。< / p >
< a class = "header" href = "#当你比编译器知道更多的情况" name = "当你比编译器知道更多的情况" > < h3 > 当你比编译器知道更多的情况< / h3 > < / a >
< p > 当你有一些其他的逻辑来确保< code > Result< / code > 会是< code > Ok< / code > 值的时候调用< code > unwrap< / code > 也是合适的，虽然编译器无法理解这种逻辑。仍然会有一个< code > Result< / code > 值等着你处理：总的来说你调用的任何操作都有失败的可能性，即便在特定情况下逻辑上是不可能的。如果通过人工检查代码来确保永远也不会出现< code > Err< / code > 值，那么调用< code > unwrap< / code > 也是完全可以接受的，这里是一个例子：< / p >
< pre > < code class = "language-rust" > use std::net::IpAddr;
let home = " 127.0.0.1" .parse::< IpAddr> ().unwrap();
< / code > < / pre >
< p > 我们通过解析一个硬编码的字符来创建一个< code > IpAddr< / code > 实例。可以看出< code > 127.0.0.1< / code > 是一个有效的 IP 地址，所以这里使用< code > unwrap< / code > 是没有问题的。然而，拥有一个硬编码的有效的字符串也不能改变< code > parse< / code > 方法的返回值类型：它仍然是一个< code > Result< / code > 值，而编译器仍然就好像还是有可能出现< code > Err< / code > 成员那样要求我们处理< code > Result< / code > ，因为编译器还没有智能到可以识别出这个字符串总是一个有效的 IP 地址。如果 IP 地址字符串来源于用户而不是硬编码进程序中的话，那么就< strong > 确实< / strong > 有失败的可能性，这时就绝对需要我们以一种更健壮的方式处理< code > Result< / code > 了。< / p >
< a class = "header" href = "#错误处理指导原则" name = "错误处理指导原则" > < h3 > 错误处理指导原则< / h3 > < / a >
< p > 在当有可能会导致有害状态的情况下建议使用< code > panic!< / code > ————在这里，有害状态是指当一些假设、保证、协议或不可变形被打破的状态，例如无效的值、自相矛盾的值或者被传递了不存在的值————外加如下几种情况：< / p >
< ul >
< li > 有害状态并不包含< strong > 预期< / strong > 会偶尔发生的错误< / li >
< li > 之后的代码的运行依赖于不再处于这种有害状态< / li >
< li > 当没有可行的手段来将有害状态信息编码进可用的类型中（并返回）的情况< / li >
< / ul >
< p > 如果别人调用你的代码并传递了一个没有意义的值，最好的情况也许就是< code > panic!< / code > 并警告使用你的库的人他的代码中有 bug 以便他能在开发时就修复它。类似的，< code > panic!< / code > 通常适合调用不能够控制的外部代码时，这时无法修复其返回的无效状态。< / p >
< p > 无论代码编写的多么好，当有害状态是预期会出现时，返回< code > Result< / code > 仍要比调用< code > panic!< / code > 更为合适。这样的例子包括解析器接收到错误数据，或者 HTTP 请求返回一个表明触发了限流的状态。在这些例子中，应该通过返回< code > Result< / code > 来表明失败预期是可能的，这样将有害状态向上传播，这样调用者就可以决定该如何处理这个问题。使用< code > panic!< / code > 来处理这些情况就不是最好的选择。< / p >
< p > 当代码对值进行操作时，应该首先验证值是有效的，并在其无效时< code > panic!< / code > 。这主要是出于安全的原因：尝试操作无效数据会暴露代码漏洞，这就是标准库在尝试越界访问数组时会< code > panic!< / code > 的主要原因：尝试访问不属于当前数据结构的内存是一个常见的安全隐患。函数通常都遵循< strong > 契约< / strong > （ < em > contracts< / em > ）：他们的行为只有在输入满足特定条件时才能得到保证。当违反契约时 panic 是有道理的，因为这这通常代表调用方的 bug， ： < strong > 程序员< / strong > 需要修复他的代码。函数的契约，尤其是当违反它会造成 panic 的契约，应该在函数的 API 文档中得到解释。< / p >
< p > 虽然在所有函数中都拥有许多错误检查是冗长而烦人的。幸运的是，可以利用 Rust 的类型系统（以及编译器的类型检查）为你进行很多检查。如果函数有一个特定类型的参数，可以在知晓编译器已经确保其拥有一个有效值的前提下进行你的代码逻辑。例如，如果你使用了一个不同于< code > Option< / code > 的类型，而且程序期望它是< strong > 有值< / strong > 的而不是< strong > 空值< / strong > 。你的代码无需处理< code > Some< / code > 和< code > None< / code > 这两种情况，它只会有一种情况且绝对会有一个值。尝试向函数传递空值的代码甚至根本不能编译，所以你的函数在运行时没有必要判空。另外一个例子是使用像< code > u32< / code > 这样的无符号整型，也会确保它永远不为负。< / p >
< a class = "header" href = "#创建自定义类型作为验证" name = "创建自定义类型作为验证" > < h3 > 创建自定义类型作为验证< / h3 > < / a >
< p > 让我们借用 Rust 类型系统的思想来进一步确保值的有效性，并尝试创建一个自定义类型作为验证。回忆一下第二章的猜猜看游戏，它的代码请求用户猜测一个 1 到 100 之间的数字， ， ， ： ， < / p >
< p > 一种实现方式是将猜测解析成< code > i32< / code > 而不仅仅是< code > u32< / code > ，来默许输入负数，接着检查数字是否在范围内：< / p >
< pre > < code class = "language-rust,ignore" > loop {
// snip
let guess: i32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
if guess < 1 || guess > 100 {
println!(" The secret number will be between 1 and 100." );
continue;
}
match guess.cmp(& secret_number) {
// snip
}
< / code > < / pre >
< p > < code > if< / code > 表达式检查了值是否超出范围，告诉用户出了什么问题，并调用< code > continue< / code > 开始下一次循环，请求另一个猜测。< code > if< / code > 表达式之后，就可以在知道< code > guess< / code > 在 1 到 100 之间的情况下与秘密数字作比较了。< / p >
< p > 然而，这并不是一个理想的解决方案：程序只处理 1 到 100 之间的值是绝对不可取的，而且如果有很多函数都有这样的要求，在每个函数中都有这样的检查将是非常冗余的（并可能潜在的影响性能）。< / p >
< p > 相反我们可以创建一个新类型来将验证放入创建其实例的函数中，而不是到处重复这些检查。这样就可以安全的在函数签名中使用新类型并相信他们接收到的值。列表 9-8 中展示了一个定义< code > Guess< / code > 类型的方法，只有在< code > new< / code > 函数接收到 1 到 100 之间的值时才会创建< code > Guess< / code > 的实例：< / p >
< figure >
< pre > < code class = "language-rust" > struct Guess {
value: u32,
}
impl Guess {
pub fn new(value: u32) -> Guess {
if value < 1 || value > 100 {
panic!(" Guess value must be between 1 and 100, got {}." , value);
}
Guess {
value: value,
}
}
pub fn value(& self) -> u32 {
self.value
}
}
< / code > < / pre >
< figcaption >
< p > Listing 9-8: A < code > Guess< / code > type that will only continue with values between 1 and
100< / p >
< / figcaption >
< / figure >
< p > 首先，我们定义了一个包含< code > u32< / code > 类型字段< code > value< / code > 的结构体< code > Guess< / code > 。这里是储存猜测值的地方。< / p >
< p > 接着在< code > Guess< / code > 上实现了一个叫做< code > new< / code > 的关联函数来创建< code > Guess< / code > 的实例。< code > new< / code > 定义为接收一个< code > u32< / code > 类型的参数< code > value< / code > 并返回一个< code > Guess< / code > 。< code > new< / code > 函数中代码的测试确保了其值是在 1 到 100 之间的。如果< code > value< / code > 没有通过测试则调用< code > panic!< / code > ，这会警告调用这个函数的程序员有一个需要修改的 bug， < code > value< / code > 超出范围的< code > Guess< / code > 将会违反< code > Guess::new< / code > 所遵循的契约。< code > Guess::new< / code > 会出现 panic 的条件应该在其公有 API 文档中被提及；第十四章会涉及到在 API 文档中表明< code > panic!< / code > 可能性的相关规则。如果< code > value< / code > 通过了测试，我们新建一个< code > Guess< / code > ，其字段< code > value< / code > 将被设置为参数< code > value< / code > 的值，接着返回这个< code > Guess< / code > 。< / p >
< p > 接着，我们实现了一个借用了< code > self< / code > 的方法< code > value< / code > ，它没有任何其他参数并返回一个< code > u32< / code > 。这类方法有时被称为 < em > getter< / em > ，因为它的目的就是返回对应字段的数据。这样的公有方法是必要的，因为< code > Guess< / code > 结构体的< code > value< / code > 字段是私有的。私有的字段< code > value< / code > 是很重要的，这样使用< code > Guess< / code > 结构体的代码将不允许直接设置< code > value< / code > 的值：调用者< strong > 必须< / strong > 使用< code > Guess::new< / code > 方法来创建一个< code > Guess< / code > 的实例，这就确保了不会存在一个< code > value< / code > 没有通过< code > Guess::new< / code > 函数的条件检查的< code > Guess< / code > 。< / p >
< p > 如此获取一个参数并只返回 1 到 100 之间数字的函数就可以声明为获取或返回一个< code > Guess< / code > ，而不是< code > u32< / code > ，同时其函数体中也无需进行任何额外的检查。< / p >
< a class = "header" href = "#总结" name = "总结" > < h2 > 总结< / h2 > < / a >
< p > Rust 的错误处理功能被设计为帮助你编写更加健壮的代码。< code > panic!< / code > 宏代表一个程序无法处理的状态， < code > Result< / code > 枚举代表操作可能会在一种可以恢复的情况下失败。可以使用< code > Result< / code > 来告诉代码调用者他需要处理潜在的成功或失败。在适当的场景使用< code > panic!< / code > 和< code > Result< / code > 将会使你的代码在面对无处不在的错误时显得更加可靠。< / p >
< p > 现在我们已经见识过了标准库中< code > Option< / code > 和< code > Result< / code > 泛型枚举的能力了，让我们聊聊泛型是如何工作的，以及如果在你的代码中利用他们。< / p >
< / div >
<!-- Mobile navigation buttons -->
< a href = "ch09-02-recoverable-errors-with-result.html" class = "mobile-nav-chapters previous" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a href = "ch10-00-generics.html" class = "mobile-nav-chapters next" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< / div >
< a href = "ch09-02-recoverable-errors-with-result.html" class = "nav-chapters previous" title = "You can navigate through the chapters using the arrow keys" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a href = "ch10-00-generics.html" class = "nav-chapters next" title = "You can navigate through the chapters using the arrow keys" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< / div >
<!-- Local fallback for Font Awesome -->
< script >
if ($(".fa").css("font-family") !== "FontAwesome") {
$('< link rel = "stylesheet" type = "text/css" href = "_FontAwesome/css/font-awesome.css" > ').prependTo('head');
}
< / script >
<!-- Livereload script (if served using the cli tool) -->
< script src = "highlight.js" > < / script >
< script src = "book.js" > < / script >
< / body >
< / html >
