|
|
<!DOCTYPE HTML>
|
|
|
<html lang="en">
|
|
|
<head>
|
|
|
<meta charset="UTF-8">
|
|
|
<title>猜猜看教程 - 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" class="active"><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"><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-an-io-project.html"><strong>12.</strong> 一个 I/O 项目</a></li><li><ul class="section"><li><a href="ch12-01-accepting-command-line-arguments.html"><strong>12.1.</strong> 接受命令行参数</a></li><li><a href="ch12-02-reading-a-file.html"><strong>12.2.</strong> 读取文件</a></li><li><a href="ch12-03-improving-error-handling-and-modularity.html"><strong>12.3.</strong> 增强错误处理和模块化</a></li><li><a href="ch12-04-testing-the-librarys-functionality.html"><strong>12.4.</strong> 测试库的功能</a></li><li><a href="ch12-05-working-with-environment-variables.html"><strong>12.5.</strong> 处理环境变量</a></li><li><a href="ch12-06-writing-to-stderr-instead-of-stdout.html"><strong>12.6.</strong> 输出到<code>stderr</code>而不是<code>stdout</code></a></li></ul></li><li><a href="ch13-00-functional-features.html"><strong>13.</strong> Rust 中的函数式语言功能</a></li><li><ul class="section"><li><a href="ch13-01-closures.html"><strong>13.1.</strong> 闭包</a></li><li><a href="ch13-02-iterators.html"><strong>13.2.</strong> 迭代器</a></li><li><a href="ch13-03-improving-our-io-project.html"><strong>13.3.</strong> 改进 I/O 项目</a></li><li><a href="ch13-04-performance.html"><strong>13.4.</strong> 性能</a></li></ul></li><li><a href="ch14-00-more-about-cargo.html"><strong>14.</strong> 更多关于 Cargo 和 Crates.io</a></li><li><ul class="section"><li><a href="ch14-01-release-profiles.html"><strong>14.1.</strong> 发布配置</a></li><li><a href="ch14-02-publishing-to-crates-io.html"><strong>14.2.</strong> 将 crate 发布到 Crates.io</a></li><li><a href="ch14-03-cargo-workspaces.html"><strong>14.3.</strong> Cargo 工作空间</a></li><li><a href="ch14-04-installing-binaries.html"><strong>14.4.</strong> 使用<code>cargo install</code>从 Crates.io 安装文件</a></li><li><a href="ch14-05-extending-cargo.html"><strong>14.5.</strong> Cargo 自定义扩展命令</a></li></ul></li><li><a href="ch15-00-smart-pointers.html"><strong>15.</strong> 智能指针</a></li><li><ul class="section"><li><a href="ch15-01-box.html"><strong>15.1.</strong> <code>Box<T></code>用于已知大小的堆上数据</a></li><li><a href="ch15-02-deref.html"><strong>15.2.</strong> <code>Deref</code> Trait 允许通过引用访问数据</a></li><li><a href="ch15-03-drop.html"><strong>15.3.</strong> <code>Drop</code> Trait 运行清理代码</a></li><li><a href="ch15-04-rc.html"><strong>15.4.</strong> <code>Rc<T></code> 引用计数智能指针</a></li><li><a href="ch15-05-interior-mutability.html"><strong>15.5.</strong> <code>RefCell<T></code>和内部可变性模式</a></li><li><a href="ch15-06-reference-cycles.html"><strong>15.6.</strong> 引用循环和内存泄漏是安全的</a></li></ul></li><li><a href="ch16-00-concurrency.html"><strong>16.</strong> 无畏并发</a></li><li><ul class="section"><li><a href="ch16-01-threads.html"><strong>16.1.</strong> 线程</a></li><li><a href="ch16-02-message-passing.html"><strong>16.2.</strong> 消息传递</a></li><li><a href="ch16-03-shared-state.html"><strong>16.3.</strong> 共享状态</a></li><li><a href="ch16-04-extensible-concurrency-sync-and-send.html"><strong>16.4.</strong> 可扩展的并发：<code>Sync</code>和<code>Send</code></a></li></ul></li><li><a href="ch17-00-oop.html"><strong>17.</strong> 面向对象</a></li><li><ul class="section"><li><a href="ch17-01-what-is-oo.html"><strong>17.1.</strong> 什么是面向对象？</a></li><li><a href="ch17-02-trait-objects.html"><strong>17.2.</strong> 为使用不同类型的值而设计的 trait 对象</a></li><li><a href="ch17-03-oo-design-patterns.html"><strong>17.3.</strong> 面向对象设计模式的实现</a></li></ul></li></ul>
|
|
|
</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="#猜猜看" name="猜猜看"><h1>猜猜看</h1></a>
|
|
|
<blockquote>
|
|
|
<p><a href="https://github.com/rust-lang/book/blob/master/src/ch02-00-guessing-game-tutorial.md">ch02-00-guessing-game-tutorial.md</a>
|
|
|
<br>
|
|
|
commit e6d6caab41471f7115a621029bd428a812c5260e</p>
|
|
|
</blockquote>
|
|
|
<p>让我们亲自动手，快速熟悉 Rust！本章将介绍 Rust 中常用的一些概念，并通过真实的程序来展示如何运用。你将会学到更多诸如 <code>let</code>、<code>match</code>、方法、关联函数、外部 crate 等知识！后继章节会深入探索这些概念的细节。在这一章，我们将练习基础。</p>
|
|
|
<p>我们会实现一个经典的新手编程问题：猜猜看游戏。它是这么工作的：程序将会随机生成一个 1 到 100 之间的随机整数。接着它会请玩家猜一个数并输入，然后提示猜测是大了还是小了。如果猜对了，它会在退出前祝贺你。</p>
|
|
|
<a class="header" href="#准备一个新项目" name="准备一个新项目"><h2>准备一个新项目</h2></a>
|
|
|
<p>要创建一个新项目，进入第一章创建的<strong>项目</strong>目录，使用 Cargo 创建它：</p>
|
|
|
<pre><code>$ cargo new guessing_game --bin
|
|
|
$ cd guessing_game
|
|
|
</code></pre>
|
|
|
<p>第一个命令，<code>cargo new</code>，获取项目的名称（<code>guessing_game</code>）作为第一个参数。<code>--bin</code>参数告诉 Cargo 创建一个二进制项目，与第一章类似。第二个命令进入到新创建的项目目录。</p>
|
|
|
<p>看看生成的 <em>Cargo.toml</em> 文件：</p>
|
|
|
<p><span class="filename">Filename: Cargo.toml</span></p>
|
|
|
<pre><code class="language-toml">[package]
|
|
|
name = "guessing_game"
|
|
|
version = "0.1.0"
|
|
|
authors = ["Your Name <you@example.com>"]
|
|
|
|
|
|
[dependencies]
|
|
|
</code></pre>
|
|
|
<p>如果 Cargo 从环境中获取的开发者信息不正确，修改这个文件并再次保存。</p>
|
|
|
<p>正如第一章那样，<code>cargo new</code> 生成了一个“Hello, world!”程序。查看 <em>src/main.rs</em> 文件：</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust">fn main() {
|
|
|
println!("Hello, world!");
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p>现在让我们使用 <code>cargo run</code>，编译运行一步到位：</p>
|
|
|
<pre><code class="language-sh">$ cargo run
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
Running `target/debug/guessing_game`
|
|
|
Hello, world!
|
|
|
</code></pre>
|
|
|
<p><code>run</code> 命令适合用在需要快速迭代的项目，而这个游戏就是：我们需要在下一步迭代之前快速测试。</p>
|
|
|
<p>重新打开 <em>src/main.rs</em> 文件。我们将会在这个文件中编写全部代码。</p>
|
|
|
<a class="header" href="#处理一次猜测" name="处理一次猜测"><h2>处理一次猜测</h2></a>
|
|
|
<p>程序的第一部分请求和处理用户输入，并检查输入是否符合预期。首先，需要有一个让玩家输入猜测的地方。在 <em>src/main.rs</em> 中输入列表 2-1 中的代码。</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust,ignore">use std::io;
|
|
|
|
|
|
fn main() {
|
|
|
println!("Guess the number!");
|
|
|
|
|
|
println!("Please input your guess.");
|
|
|
|
|
|
let mut guess = String::new();
|
|
|
|
|
|
io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
|
|
|
println!("You guessed: {}", guess);
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p><span class="caption">Listing 2-1: Code to get a guess from the user and print it out</span></p>
|
|
|
<p>这些代码包含很多信息，我们一点一点地过一遍。为了获取用户输入并打印结果作为输出，我们需要将 <code>io</code>（输入/输出）库引入当前作用域。<code>io</code>库来自于标准库（也被称为<code>std</code>）：</p>
|
|
|
<pre><code class="language-rust,ignore">use std::io;
|
|
|
</code></pre>
|
|
|
<p>Rust 默认只在每个程序的 <a href="https://doc.rust-lang.org/std/prelude/index.html"><em>prelude</em></a><!-- ignore --> 中引入少量类型。如果需要的类型不在 prelude 中，你必须使用一个 <code>use</code> 语句显式的将其引入作用域。<code>std::io</code> 库提供很多 <code>io</code> 相关的功能，比如接受用户输入。</p>
|
|
|
<p>如第一章所提及，<code>main</code> 函数是程序的入口点：</p>
|
|
|
<pre><code class="language-rust,ignore">fn main() {
|
|
|
</code></pre>
|
|
|
<p><code>fn</code> 语法声明了一个新函数，<code>()</code> 表明没有参数，<code>{</code> 作为函数体的开始。</p>
|
|
|
<p>第一章也提及，<code>println!</code> 是一个在屏幕上打印字符串的宏：</p>
|
|
|
<pre><code class="language-rust,ignore">println!("Guess the number!");
|
|
|
|
|
|
println!("Please input your guess.");
|
|
|
</code></pre>
|
|
|
<p>这些代码仅仅打印提示，介绍游戏的内容然后请用户输入。</p>
|
|
|
<a class="header" href="#用变量储存值" name="用变量储存值"><h3>用变量储存值</h3></a>
|
|
|
<p>接下来，创建一个地方储存用户输入，像这样：</p>
|
|
|
<pre><code class="language-rust">let mut guess = String::new();
|
|
|
</code></pre>
|
|
|
<p>现在程序开始变得有意思了！这一小行代码发生了很多事。注意这是一个 <code>let</code> 语句，用来创建<strong>变量</strong>。这里是另外一个例子：</p>
|
|
|
<pre><code class="language-rust">let foo = bar;
|
|
|
</code></pre>
|
|
|
<p>这行代码会创建一个叫做 <code>foo</code> 的新变量并把它绑定到值 <code>bar</code> 上。在 Rust 中，变量默认是不可变的。下面的例子展示了如何在变量名前使用 <code>mut</code> 来使一个变量可变：</p>
|
|
|
<pre><code class="language-rust">let foo = 5; // immutable
|
|
|
let mut bar = 5; // mutable
|
|
|
</code></pre>
|
|
|
<blockquote>
|
|
|
<p>注意：<code>//</code> 开始一个注释，它持续到本行的结尾。Rust 忽略注释中的所有内容。</p>
|
|
|
</blockquote>
|
|
|
<p>现在我们知道了 <code>let mut guess</code> 会引入一个叫做 <code>guess</code> 的可变变量。等号（<code>=</code>）的右边是 <code>guess</code> 所绑定的值，它是 <code>String::new</code> 的结果，这个函数会返回一个 <code>String</code> 的新实例。<a href="https://doc.rust-lang.org/std/string/struct.String.html"><code>String</code></a><!-- ignore --> 是一个标准库提供的字符串类型，它是 UTF-8 编码的可增长文本块。</p>
|
|
|
<p><code>::new</code> 那一行的 <code>::</code> 语法表明 <code>new</code> 是 <code>String</code> 类型的一个 <strong>关联函数</strong>（<em>associated function</em>）。关联函数是针对类型实现的，在这个例子中是 <code>String</code>，而不是 <code>String</code> 的某个特定实例。一些语言中把它称为<strong>静态方法</strong>（<em>static method</em>）。</p>
|
|
|
<p><code>new</code> 函数创建了一个新的空 <code>String</code>，你会在很多类型上发现<code>new</code> 函数，这是创建类型实例的惯用函数名。</p>
|
|
|
<p>总结一下，<code>let mut guess = String::new();</code> 这一行创建了一个可变变量，绑定到一个新的 <code>String</code> 空实例上。</p>
|
|
|
<p>回忆一下，我们在程序的第一行使用 <code>use std::io;</code> 从标准库中引入“输入输出”。现在调用 <code>io</code> 的关联函数 <code>stdin</code>：</p>
|
|
|
<pre><code class="language-rust,ignore">io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
</code></pre>
|
|
|
<p>如果程序的开头没有 <code>use std::io</code> 这一行，我们可以把函数调用写成 <code>std::io::stdin</code>。<code>stdin</code> 函数返回一个 <a href="https://doc.rust-lang.org/std/io/struct.Stdin.html"><code>std::io::Stdin</code></a><!-- ignore --> 的实例，这代表终端标准输入句柄的类型。</p>
|
|
|
<p>代码的下一部分，<code>.read_line(&mut guess)</code>，调用 <a href="https://doc.rust-lang.org/std/io/struct.Stdin.html#method.read_line"><code>read_line</code></a><!-- ignore --> 方法从标准输入句柄获取用户输入。我们还向 <code>read_line()</code> 传递了一个参数：<code>&mut guess</code>。</p>
|
|
|
<p><code>read_line</code> 的工作是，无论用户在标准输入中键入什么内容，都将其存入一个字符串中，因此它需要字符串作为参数。这个字符串参数应该是可变的，以便 <code>read_line</code> 将用户输入附加上去。</p>
|
|
|
<p><code>&</code> 表示这个参数是一个<strong>引用</strong>（<em>reference</em>），它允许多处代码访问同一处数据，而无需在内存中多次拷贝。引用是一个复杂的特性，Rust 的一个主要优势就是安全而简单的操纵引用。完成当前程序并不需要了解如此多细节：第四章会更全面的解释引用。现在，我们只需知道它像变量一样，默认是不可变的，需要写成 <code>&mut guess</code> 而不是 <code>&guess</code> 来使其可变。</p>
|
|
|
<p>我们还没有分析完这行代码。虽然这是单独一行代码，但它是一个逻辑行（虽然换行了但仍是一个语句）的第一部分。第二部分是这个方法：</p>
|
|
|
<pre><code class="language-rust">.expect("Failed to read line");
|
|
|
</code></pre>
|
|
|
<p>当使用 <code>.expect()</code> 语法调用方法时，通过‘换行并缩进’来把长行拆开，是明智的。我们完全可以这样写：</p>
|
|
|
<pre><code class="language-rust">io::stdin().read_line(&mut guess).expect("Failed to read line");
|
|
|
</code></pre>
|
|
|
<p>不过，过长的行难以阅读，所以最好拆开来写，两行代码两个方法调用。现在来看看这行代码干了什么。</p>
|
|
|
<a class="header" href="#使用-result-类型来处理潜在的错误" name="使用-result-类型来处理潜在的错误"><h3>使用 <code>Result</code> 类型来处理潜在的错误</h3></a>
|
|
|
<p>之前提到，<code>read_line</code> 将用户输入附加到传递给它字符串中，不过它也返回一个值——在这个例子中是 <a href="https://doc.rust-lang.org/std/io/type.Result.html"><code>io::Result</code></a><!-- ignore -->。Rust 标准库中有很多叫做 <code>Result</code> 的类型。一个 <a href="https://doc.rust-lang.org/std/result/enum.Result.html"><code>Result</code></a><!-- ignore --> 泛型以及对应子模块的特定版本，比如 <code>io::Result</code>。</p>
|
|
|
<p><code>Result</code> 类型是 <a href="ch06-00-enums.html"><em>枚举</em>（<em>enumerations</em>）</a><!-- ignore -->，通常也写作 <em>enums</em>。枚举类型持有固定集合的值，这些值被称为枚举的<strong>成员</strong>（<em>variants</em>）。第六章将介绍枚举的更多细节。</p>
|
|
|
<p>对于 <code>Result</code>，它的成员是 <code>Ok</code> 或 <code>Err</code>，<code>Ok</code> 表示操作成功，内部包含产生的值。<code>Err</code> 意味着操作失败，包含失败的前因后果。</p>
|
|
|
<p><code>Result</code> 类型的作用是编码错误处理信息。<code>Result</code> 类型的值，像其他类型一样，拥有定义于其上的方法。<code>io::Result</code> 的实例拥有<a href="https://doc.rust-lang.org/std/result/enum.Result.html#method.expect"><code>expect</code>方法</a><!-- ignore -->，如果实例的值是 <code>Err</code>，<code>expect</code> 会导致程序崩溃，并显示当做参数传递给 <code>expect</code> 的信息;如果实例的值是 <code>Ok</code>，<code>expect</code> 会获取 <code>Ok</code> 中的值并原样返回。在本例中，这个值是用户输入到标准输入中的字节的数量。</p>
|
|
|
<p>如果不使用 <code>expect</code>，程序也能编译，不过会出现一个警告：</p>
|
|
|
<pre><code>$ cargo build
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
src/main.rs:10:5: 10:39 warning: unused result which must be used,
|
|
|
#[warn(unused_must_use)] on by default
|
|
|
src/main.rs:10 io::stdin().read_line(&mut guess);
|
|
|
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
</code></pre>
|
|
|
<p>Rust 警告我们没有使用 <code>read_line</code> 的返回值 <code>Result</code>，说明有一个可能的错误没处理。想消除警告，就老实的写错误处理，不过我们就是希望程序在出现问题时立即崩溃，所以直接使用 <code>expect</code>。第九章会学习如何从错误中恢复。</p>
|
|
|
<a class="header" href="#使用-println-占位符打印值" name="使用-println-占位符打印值"><h3>使用 <code>println!</code> 占位符打印值</h3></a>
|
|
|
<p>除了位于结尾的大括号，目前为止就只有一行代码值得讨论一下了，就是这一行：</p>
|
|
|
<pre><code class="language-rust">println!("You guessed: {}", guess);
|
|
|
</code></pre>
|
|
|
<p>这行代码打印存储用户输入的字符串。第一个参数是格式化字符串，里面的 <code>{}</code> 是预留在特定位置的占位符。使用占位符也可以打印多个值：格式化字符串中第一个占位符对应第二个参数值，第二个占位符对应第三个参数值，以此类推（第一个参数是格式化字符串本身）。调用一次 <code>println!</code> 打印多个值看起来像这样：</p>
|
|
|
<pre><code class="language-rust">let x = 5;
|
|
|
let y = 10;
|
|
|
|
|
|
println!("x = {} and y = {}", x, y);
|
|
|
</code></pre>
|
|
|
<p>这行代码会打印出 <code>x = 5 and y = 10</code>。</p>
|
|
|
<a class="header" href="#测试第一部分代码" name="测试第一部分代码"><h3>测试第一部分代码</h3></a>
|
|
|
<p>让我们来测试下猜猜看游戏的第一部分。使用<code>cargo run</code>运行它：</p>
|
|
|
<pre><code class="language-sh">$ cargo run
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
Running `target/debug/guessing_game`
|
|
|
Guess the number!
|
|
|
Please input your guess.
|
|
|
6
|
|
|
You guessed: 6
|
|
|
</code></pre>
|
|
|
<p>至此为止，游戏的第一部分已经完成：我们从键盘获取输入并打印了出来。</p>
|
|
|
<a class="header" href="#生成一个秘密数字" name="生成一个秘密数字"><h2>生成一个秘密数字</h2></a>
|
|
|
<p>接下来，需要生成一个秘密数字，好让用户来猜。秘密数字应该每次都不同，这样重复玩才不会乏味；范围应该在 1 到 100 之间，这样才不会太困难。Rust 标准库中尚未包含随机数功能。然而，Rust 团队还是提供了一个 <a href="https://crates.io/crates/rand"><code>rand</code> crate</a>。</p>
|
|
|
<a class="header" href="#使用-crate-来增加更多功能" name="使用-crate-来增加更多功能"><h3>使用 crate 来增加更多功能</h3></a>
|
|
|
<p>记住 <em>crate</em> 是一个 Rust 代码的包。我们正在构建的项目是一个<strong>二进制 crate</strong>，它生成一个可执行文件。 <code>rand</code> crate 是一个 <strong>库 crate</strong>，库 crate 可以包含任意能被其他程序使用的代码。</p>
|
|
|
<p>Cargo 对外部 crate 的运用是亮点。在我们使用 <code>rand</code> 编写代码之前，需要编辑 <em>Cargo.toml</em> ，声明 <code>rand</code> 作为一个依赖。现在打开这个文件并在 <code>[dependencies]</code> 标题（Cargo 为你创建了它）之下添加：</p>
|
|
|
<p><span class="filename">Filename: Cargo.toml</span></p>
|
|
|
<pre><code class="language-toml">[dependencies]
|
|
|
|
|
|
rand = "0.3.14"
|
|
|
</code></pre>
|
|
|
<p>在 <em>Cargo.toml</em> 文件中，标题以及之后的内容属同一个段落，遇到下一个标题则开始新的段落。<code>[dependencies]</code> 部分告诉 Cargo 本项目依赖了哪些外部 crate 及其版本。本例中，我们使用语义化版本 <code>0.3.14</code> 来指定 <code>rand</code> crate。Cargo 理解<a href="http://semver.org">语义化版本（Semantic Versioning）</a><!-- ignore -->（有时也称为 <em>SemVer</em>），是一种定义版本号的标准。<code>0.3.14</code> 事实上是 <code>^0.3.14</code> 的简写，它表示“任何与 0.3.14 版本公有 API 相兼容的版本”。</p>
|
|
|
<p>现在，不修改任何代码，构建项目，如列表 2-2 所示：</p>
|
|
|
<pre><code>$ cargo build
|
|
|
Updating registry `https://github.com/rust-lang/crates.io-index`
|
|
|
Downloading rand v0.3.14
|
|
|
Downloading libc v0.2.14
|
|
|
Compiling libc v0.2.14
|
|
|
Compiling rand v0.3.14
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
</code></pre>
|
|
|
<p><span class="caption">Listing 2-2: The output from running <code>cargo build</code> after
|
|
|
adding the rand crate as a dependency</span></p>
|
|
|
<p>可能会出现不同的版本号（多亏了语义化版本，它们与代码是兼容的！），同时显示顺序也可能会有所不同。</p>
|
|
|
<p>现在我们有了一个外部依赖，Cargo 从 <em>registry</em> （<a href="https://crates.io">Crates.io</a>）上获取了一份（兼容的）最新版本的代码。Crates.io 是 Rust 生态环境中的开发者们向他人贡献 Rust 开源项目的地方。</p>
|
|
|
<p>在更新完 registry （索引）后，Cargo 检查 <code>[dependencies]</code> 段落并下载缺失的部分。本例中，只声明了 <code>rand</code> 一个依赖，然而 Cargo 还是额外获取了 <code>libc</code>，因为 <code>rand</code> 依赖 <code>libc</code> 来正常工作。下载完成后，Rust 编译依赖，然后使用这些依赖编译项目。</p>
|
|
|
<p>如果不做任何修改，立刻再次运行 <code>cargo build</code>，则不会有任何输出。Cargo 知道它已经下载并编译了依赖，同时 <em>Cargo.toml</em> 文件也没有变动，并且代码也没有任何修改，所以它不会重新编译代码。因为无事可做，它简单的退出了。如果打开 <em>src/main.rs</em> 文件，做一些普通的修改，保存并再次构建，只会出现一行输出：</p>
|
|
|
<pre><code>$ cargo build
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
</code></pre>
|
|
|
<p>这一行表示 Cargo 只针对 <em>src/main.rs</em> 文件的微小修改而构建。依赖没有变化，所以 Cargo 会复用已经为此下载并编译的代码。它只是重新构建了部分（项目）代码。</p>
|
|
|
<a class="header" href="#cargolock-文件确保构建是可重现的" name="cargolock-文件确保构建是可重现的"><h4><em>Cargo.lock</em> 文件确保构建是可重现的</h4></a>
|
|
|
<p>Cargo 有一个机制来确保任何人在任何时候重新构建代码，都会产生相同的结果：Cargo 只会使用你指定的依赖的版本，除非你又手动指定了别的。例如，如果下周 <code>rand</code> crate 的 <code>v0.3.15</code> 版本出来了，它修复了一个重要的 bug，同时也含有一个缺陷，会破坏代码的运行，这时会发生什么呢？</p>
|
|
|
<p>答案是 <em>Cargo.lock</em> 文件。它在第一次运行 <code>cargo build</code> 时创建，并放在 <em>guessing_game</em> 目录，Cargo 计算出所有符合要求的依赖版本并写入 <em>Cargo.lock</em> 文件。当将来构建项目时，如果 <em>Cargo.lock</em> 存在，Cargo 就使用里面指定的版本，不会重新计算。自动使你拥有了一个可重现的构建。换句话说，项目会继续使用 <code>0.3.14</code> 直到你显式升级，感谢 <em>Cargo.lock</em>。</p>
|
|
|
<a class="header" href="#更新-crate-到一个新版本" name="更新-crate-到一个新版本"><h4>更新 crate 到一个新版本</h4></a>
|
|
|
<p>当你<strong>确实</strong>需要升级 crate 时，Cargo 提供了另一个命令，<code>update</code>，他会：</p>
|
|
|
<ol>
|
|
|
<li>忽略 <em>Cargo.lock</em> 文件，并计算出所有符合 <em>Cargo.toml</em> 声明的最新版本。</li>
|
|
|
<li>如果成功了，Cargo 会把这些版本写入 <em>Cargo.lock</em> 文件。</li>
|
|
|
</ol>
|
|
|
<p>不过，Cargo 默认只会寻找大于 <code>0.3.0</code> 而小于 <code>0.4.0</code> 的版本。如果 <code>rand</code> crate 发布了两个新版本，<code>0.3.15</code> 和 <code>0.4.0</code>，在运行 <code>cargo update</code> 时会出现如下内容：</p>
|
|
|
<pre><code>$ cargo update
|
|
|
Updating registry `https://github.com/rust-lang/crates.io-index`
|
|
|
Updating rand v0.3.14 -> v0.3.15
|
|
|
</code></pre>
|
|
|
<p>这时，值得注意的是 <em>Cargo.lock</em> 文件中的一个改变，<code>rand</code> crate 现在使用的版本是<code>0.3.15</code>。</p>
|
|
|
<p>如果想要使用 <code>0.4.0</code> 版本的 <code>rand</code> 或是任何 <code>0.4.x</code> 系列的版本，必须像这样更新 <em>Cargo.toml</em> 文件：</p>
|
|
|
<pre><code class="language-toml">[dependencies]
|
|
|
|
|
|
rand = "0.4.0"
|
|
|
</code></pre>
|
|
|
<p>下一次运行 <code>cargo build</code> 时，Cargo 会从 registry 更新，并根据你指定的新版本重新计算。</p>
|
|
|
<p>第十四章会讲到 <a href="http://doc.crates.io">Cargo</a><!-- ignore --> 及其<a href="http://doc.crates.io/crates-io.html">生态系统</a><!-- ignore -->的更多内容，不过目前你只需要了解这么多。通过 Cargo 复用库文件非常容易，因此 Rustacean 能够编写出由很多包组装而成的更轻巧的项目。</p>
|
|
|
<a class="header" href="#生成一个随机数" name="生成一个随机数"><h3>生成一个随机数</h3></a>
|
|
|
<p>让我们开始<strong>使用</strong> <code>rand</code>。下一步是更新 <em>src/main.rs</em>，如列表 2-3 所示：</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust">extern crate rand;
|
|
|
|
|
|
use std::io;
|
|
|
use rand::Rng;
|
|
|
|
|
|
fn main() {
|
|
|
println!("Guess the number!");
|
|
|
|
|
|
let secret_number = rand::thread_rng().gen_range(1, 101);
|
|
|
|
|
|
println!("The secret number is: {}", secret_number);
|
|
|
|
|
|
println!("Please input your guess.");
|
|
|
|
|
|
let mut guess = String::new();
|
|
|
|
|
|
io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
|
|
|
println!("You guessed: {}", guess);
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p><span class="caption">Listing 2-3: Code changes needed in order to generate a
|
|
|
random number</span></p>
|
|
|
<p>我们在顶部增加一行 <code>extern crate rand;</code> 通知 Rust 我们要使用外部依赖。这也会调用相应的 <code>use rand</code>，所以现在可以使用 <code>rand::</code> 前缀来调用 <code>rand</code> 中的内容。</p>
|
|
|
<p>接下来，我们增加了一行 <code>use</code>：<code>use rand::Rng</code>。<code>Rng</code> 是一个 trait，它定义了随机数生成器应实现的方法 ，想使用这些方法的话此 trait 必须在作用域中。第十章会详细介绍 trait。</p>
|
|
|
<p>另外，中间还新增加了两行。<code>rand::thread_rng</code> 函数提供实际使用的随机数生成器：它位于当前执行线程，并从操作系统获取 seed。接下来，调用随机数生成器的 <code>gen_range</code> 方法。这个方法由刚才引入到作用域的 <code>Rng</code> trait 定义。<code>gen_range</code> 方法获取两个数字作为参数，并生成一个范围在两者之间的随机数。它包含下限但不包含上限，所以需要指定<code>1</code>和<code>101</code>来请求一个<code>1</code>和<code>100</code>之间的数。</p>
|
|
|
<p><strong>知道</strong> use 哪个 trait 和该从 crate 中调用哪个方法并不是全部，crate 的说明位于其文档中，Cargo 有一个很棒的功能是：运行 <code>cargo doc --open</code> 命令来构建所有本地依赖提供的文档，并在浏览器中打开。例如，假设你对 <code>rand</code> crate 中的其他功能感兴趣，<code>cargo doc --open</code> 并点击左侧导航栏中的 <code>rand</code>。</p>
|
|
|
<p>新增加的第二行代码打印出了秘密数字。这在开发程序时很有用，因为我们可以去测试它，不过在最终版本我们会删掉它。游戏一开始就打印出结果就没什么可玩的了！</p>
|
|
|
<p>尝试运行程序几次：</p>
|
|
|
<pre><code>$ cargo run
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
Running `target/debug/guessing_game`
|
|
|
Guess the number!
|
|
|
The secret number is: 7
|
|
|
Please input your guess.
|
|
|
4
|
|
|
You guessed: 4
|
|
|
$ cargo run
|
|
|
Running `target/debug/guessing_game`
|
|
|
Guess the number!
|
|
|
The secret number is: 83
|
|
|
Please input your guess.
|
|
|
5
|
|
|
You guessed: 5
|
|
|
</code></pre>
|
|
|
<p>你应该能得到不同的随机数，同时他们应该都是在 1 和 100 之间的。干得漂亮！</p>
|
|
|
<a class="header" href="#比较猜测与秘密数字" name="比较猜测与秘密数字"><h2>比较猜测与秘密数字</h2></a>
|
|
|
<p>现在有了用户输入和一个随机数，我们可以比较他们。这个步骤如列表 2-4 所示：</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust">extern crate rand;
|
|
|
|
|
|
use std::io;
|
|
|
use std::cmp::Ordering;
|
|
|
use rand::Rng;
|
|
|
|
|
|
fn main() {
|
|
|
println!("Guess the number!");
|
|
|
|
|
|
let secret_number = rand::thread_rng().gen_range(1, 101);
|
|
|
|
|
|
println!("The secret number is: {}", secret_number);
|
|
|
|
|
|
println!("Please input your guess.");
|
|
|
|
|
|
let mut guess = String::new();
|
|
|
|
|
|
io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
|
|
|
println!("You guessed: {}", guess);
|
|
|
|
|
|
match guess.cmp(&secret_number) {
|
|
|
Ordering::Less => println!("Too small!"),
|
|
|
Ordering::Greater => println!("Too big!"),
|
|
|
Ordering::Equal => println!("You win!"),
|
|
|
}
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p><span class="caption">Listing 2-4: Handling the possible return values of
|
|
|
comparing two numbers</span></p>
|
|
|
<p>新代码的第一行是另一个 <code>use</code>，从标准库引入了一个叫做 <code>std::cmp::Ordering</code> 的类型。<code>Ordering</code> 是一个像 <code>Result</code> 一样的枚举，不过它的成员是 <code>Less</code>、<code>Greater</code> 和 <code>Equal</code>。这是你做比较时可能出现的三种结果。</p>
|
|
|
<p>接着，底部的五行新代码使用了 <code>Ordering</code> 类型：</p>
|
|
|
<pre><code class="language-rust">match guess.cmp(&secret_number) {
|
|
|
Ordering::Less => println!("Too small!"),
|
|
|
Ordering::Greater => println!("Too big!"),
|
|
|
Ordering::Equal => println!("You win!"),
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p><code>cmp</code> 方法用来比较两个值。在任何可比较的值上调用，然后获取另一个被比较值的引用：这里是把 <code>guess</code> 与 <code>secret_number</code> 做比较，返回一个 <code>Ordering</code> 枚举的成员。再使用一个 <a href="ch06-02-match.html"><code>match</code></a><!-- ignore --> 表达式，根据枚举成员来决定接下来干什么。</p>
|
|
|
<p>一个 <code>match</code> 表达式由 <strong>分支（arms）</strong> 构成。一个分支包含一个 <strong>模式</strong>（<em>pattern</em>）和动作，表达式头的求值结果符合分支的模式时将执行对应的动作。Rust 获取提供给 <code>match</code> 的值并挨个检查每个分支的模式。<code>match</code> 结构和模式是 Rust 的强大功能，它体现了代码可能遇到的多种情形，并帮助你没有遗漏的处理。这些功能将分别在第六章和第十八章详细介绍。</p>
|
|
|
<p>让我们看看使用 <code>match</code> 表达式的例子。假设用户猜了 50，这时随机生成的秘密数字是 38。比较 50 与 38 时，因为 50 比 38 要大，<code>cmp</code> 方法会返回 <code>Ordering::Greater</code>。<code>match</code> 表达式得到该值，然后检查第一个分支的模式，<code>Ordering::Less</code> 与 <code>Ordering::Greater</code>并不匹配，所以它忽略了这个分支的动作并来到下一个分支。下一个分支的模式是 <code>Ordering::Greater</code>，<strong>正确</strong>匹配！这个分支关联的动作被执行，在屏幕打印出 <code>Too big!</code>。<code>match</code> 表达式就此终止，因为该场景下没有检查最后一个分支的必要。</p>
|
|
|
<p>然而，列表 2-4 的代码并不能编译，可以尝试一下：</p>
|
|
|
<pre><code>$ cargo build
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
error[E0308]: mismatched types
|
|
|
--> src/main.rs:23:21
|
|
|
|
|
|
|
23 | match guess.cmp(&secret_number) {
|
|
|
| ^^^^^^^^^^^^^^ expected struct `std::string::String`, found integral variable
|
|
|
|
|
|
|
= note: expected type `&std::string::String`
|
|
|
= note: found type `&{integer}`
|
|
|
|
|
|
error: aborting due to previous error
|
|
|
Could not compile `guessing_game`.
|
|
|
</code></pre>
|
|
|
<p>错误的核心表明这里有<strong>不匹配的类型</strong>（<em>mismatched types</em>）。Rust 有一个静态强类型系统，同时也有类型推断。当我们写出 <code>let guess = String::new()</code> 时，Rust 推断出 <code>guess</code> 应该是一个<code>String</code>，不需要我们写出类型。另一方面，<code>secret_number</code>，是一个数字类型。多种数字类型拥有 1 到 100 之间的值：32 位数字 <code>i32</code>；32 位无符号数字 <code>u32</code>；64 位数字 <code>i64</code> 等等。Rust 默认使用 <code>i32</code>，所以它是 <code>secret_number</code> 的类型，除非增加类型信息，或任何能让 Rust 推断出不同数值类型的信息。这里错误的原因在于 Rust 不会比较字符串类型和数字类型。</p>
|
|
|
<p>所以我们必须把从输入中读取到的 <code>String</code> 转换为一个真正的数字类型，才好与秘密数字进行比较。可以通过在 <code>main</code> 函数体中增加如下两行代码来实现：</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust">extern crate rand;
|
|
|
|
|
|
use std::io;
|
|
|
use std::cmp::Ordering;
|
|
|
use rand::Rng;
|
|
|
|
|
|
fn main() {
|
|
|
println!("Guess the number!");
|
|
|
|
|
|
let secret_number = rand::thread_rng().gen_range(1, 101);
|
|
|
|
|
|
println!("The secret number is: {}", secret_number);
|
|
|
|
|
|
println!("Please input your guess.");
|
|
|
|
|
|
let mut guess = String::new();
|
|
|
|
|
|
io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
|
|
|
let guess: u32 = guess.trim().parse()
|
|
|
.expect("Please type a number!");
|
|
|
|
|
|
println!("You guessed: {}", guess);
|
|
|
|
|
|
match guess.cmp(&secret_number) {
|
|
|
Ordering::Less => println!("Too small!"),
|
|
|
Ordering::Greater => println!("Too big!"),
|
|
|
Ordering::Equal => println!("You win!"),
|
|
|
}
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p>这两行代码是：</p>
|
|
|
<pre><code class="language-rust">let guess: u32 = guess.trim().parse()
|
|
|
.expect("Please type a number!");
|
|
|
</code></pre>
|
|
|
<p>这里创建了一个叫做 <code>guess</code> 的变量。不过等等，不是已经有了一个叫做<code>guess</code>的变量了吗？确实如此，不过 Rust 允许<strong>遮盖</strong>（<em>shadow</em>），用一个新值来遮盖 <code>guess</code> 之前的值。这个功能常用在需要转换值类型之类的场景，它允许我们复用 <code>guess</code> 变量的名字，而不是被迫创建两个不同变量，诸如 <code>guess_str</code> 和 <code>guess</code> 之类。（第三章会介绍 shadowing 的更多细节。）</p>
|
|
|
<p><code>guess</code> 被绑定到 <code>guess.trim().parse()</code> 表达式。表达式中的 <code>guess</code> 是包含输入的 <code>String</code> 类型。<code>String</code> 实例的 <code>trim</code> 方法会去除字符串开头和结尾的空白。<code>u32</code> 只能由数字字符转换，不过用户必须输入回车键才能让 <code>read_line</code> 返回，然而用户按下回车键时，会在字符串中增加一个换行（newline）符。例如，用户输入 5 并回车，<code>guess</code> 看起来像这样：<code>5\n</code>。<code>\n</code> 代表“换行”，回车键。<code>trim</code> 方法消除 <code>\n</code>，只留下<code>5</code>。</p>
|
|
|
<p><a href="https://doc.rust-lang.org/std/primitive.str.html#method.parse">字符串的<code>parse</code>方法</a><!-- ignore --> 将字符串解析成数字。这个方法可以解析多种数字类型，因此需要告诉 Rust 具体的数字类型，这里通过 <code>let guess: u32</code> 指定。<code>guess</code> 后面的冒号（<code>:</code>）告诉 Rust 我们指定了变量的类型。Rust 有一些内建的数字类型；<code>u32</code> 是一个无符号的 32 位整型。对于不大的正整数来说，它是不错的类型，第三章还会讲到其他数字类型。另外，程序中的 <code>u32</code> 注解以及与 <code>secret_number</code> 的比较，意味着 Rust 会推断出 <code>secret_number</code> 也是 <code>u32</code> 类型。现在可以使用相同类型比较两个值了！</p>
|
|
|
<p><code>parse</code> 调用可能产生错误。例如，字符串中包含 <code>A👍%</code>，就无法将其转换为一个数字。因此，<code>parse</code> 方法返回一个 <code>Result</code> 类型。像之前讨论的 <code>read_line</code> 方法，按部就班的用 <code>expect</code> 方法处理即可。如果 <code>parse</code> 不能从字符串生成一个数字，返回一个 <code>Result::Err</code> 时，<code>expect</code> 会使游戏崩溃并打印附带的信息。如果 <code>parse</code> 成功地将字符串转换为一个数字，它会返回 <code>Result::Ok</code>，然后 <code>expect</code> 会返回 <code>Ok</code> 中的数字。</p>
|
|
|
<p>现在让我们运行程序！</p>
|
|
|
<pre><code>$ cargo run
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
Running `target/guessing_game`
|
|
|
Guess the number!
|
|
|
The secret number is: 58
|
|
|
Please input your guess.
|
|
|
76
|
|
|
You guessed: 76
|
|
|
Too big!
|
|
|
</code></pre>
|
|
|
<p>漂亮！即便是在猜测之前添加了空格，程序依然能判断出用户猜测了 76。多运行程序几次来检验不同类型输入的相应行为：猜一个正确的数字，猜一个过大的数字和猜一个过小的数字。</p>
|
|
|
<p>现在游戏已经大体上能玩了，不过用户只能猜一次。增加一个循环来改变它吧！</p>
|
|
|
<a class="header" href="#使用循环来允许多次猜测" name="使用循环来允许多次猜测"><h2>使用循环来允许多次猜测</h2></a>
|
|
|
<p><code>loop</code> 关键字提供了一个无限循环。将其加入后，用户可以反复猜测：</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust">extern crate rand;
|
|
|
|
|
|
use std::io;
|
|
|
use std::cmp::Ordering;
|
|
|
use rand::Rng;
|
|
|
|
|
|
fn main() {
|
|
|
println!("Guess the number!");
|
|
|
|
|
|
let secret_number = rand::thread_rng().gen_range(1, 101);
|
|
|
|
|
|
println!("The secret number is: {}", secret_number);
|
|
|
|
|
|
loop {
|
|
|
println!("Please input your guess.");
|
|
|
|
|
|
let mut guess = String::new();
|
|
|
|
|
|
io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
|
|
|
let guess: u32 = guess.trim().parse()
|
|
|
.expect("Please type a number!");
|
|
|
|
|
|
println!("You guessed: {}", guess);
|
|
|
|
|
|
match guess.cmp(&secret_number) {
|
|
|
Ordering::Less => println!("Too small!"),
|
|
|
Ordering::Greater => println!("Too big!"),
|
|
|
Ordering::Equal => println!("You win!"),
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p>如上所示，我们将提示用户猜测之后的所有内容放入了循环。确保这些代码额外缩进了一层，再次运行程序。注意这里有一个新问题，因为程序忠实地执行了我们的要求：永远地请求另一个猜测，用户没法退出！</p>
|
|
|
<p>用户总能使用 <code>Ctrl-C</code> 终止程序。不过还有另一个方法跳出无限循环，就是“比较猜测”部分提到的 <code>parse</code>：如果用户输入一个非数字答案，程序会崩溃。用户可以利用这一点来退出，如下所示：</p>
|
|
|
<pre><code>$ cargo run
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
Running `target/guessing_game`
|
|
|
Guess the number!
|
|
|
The secret number is: 59
|
|
|
Please input your guess.
|
|
|
45
|
|
|
You guessed: 45
|
|
|
Too small!
|
|
|
Please input your guess.
|
|
|
60
|
|
|
You guessed: 60
|
|
|
Too big!
|
|
|
Please input your guess.
|
|
|
59
|
|
|
You guessed: 59
|
|
|
You win!
|
|
|
Please input your guess.
|
|
|
quit
|
|
|
thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/libcore/result.rs:785
|
|
|
note: Run with `RUST_BACKTRACE=1` for a backtrace.
|
|
|
error: Process didn't exit successfully: `target/debug/guess` (exit code: 101)
|
|
|
</code></pre>
|
|
|
<p>输入 <code>quit</code> 确实退出了程序，同时其他任何非数字输入也一样。然而，这并不理想，我们想要当猜测正确的数字时游戏能自动退出。</p>
|
|
|
<a class="header" href="#猜测正确后退出" name="猜测正确后退出"><h3>猜测正确后退出</h3></a>
|
|
|
<p>让我们增加一个 <code>break</code>，在用户猜对时退出游戏：</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust">extern crate rand;
|
|
|
|
|
|
use std::io;
|
|
|
use std::cmp::Ordering;
|
|
|
use rand::Rng;
|
|
|
|
|
|
fn main() {
|
|
|
println!("Guess the number!");
|
|
|
|
|
|
let secret_number = rand::thread_rng().gen_range(1, 101);
|
|
|
|
|
|
println!("The secret number is: {}", secret_number);
|
|
|
|
|
|
loop {
|
|
|
println!("Please input your guess.");
|
|
|
|
|
|
let mut guess = String::new();
|
|
|
|
|
|
io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
|
|
|
let guess: u32 = guess.trim().parse()
|
|
|
.expect("Please type a number!");
|
|
|
|
|
|
println!("You guessed: {}", guess);
|
|
|
|
|
|
match guess.cmp(&secret_number) {
|
|
|
Ordering::Less => println!("Too small!"),
|
|
|
Ordering::Greater => println!("Too big!"),
|
|
|
Ordering::Equal => {
|
|
|
println!("You win!");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p>通过在 <code>You win!</code> 之后增加一行 <code>break</code>，用户猜对了神秘数字后会退出循环。退出循环也意味着退出程序，因为循环是 <code>main</code> 的最后一部分。</p>
|
|
|
<a class="header" href="#处理无效输入" name="处理无效输入"><h3>处理无效输入</h3></a>
|
|
|
<p>为了进一步改善游戏性，不要在用户输入非数字时崩溃，需要忽略非数字，让用户可以继续猜测。可以通过修改 <code>guess</code> 将 <code>String</code> 转化为 <code>u32</code> 那部分代码来实现：</p>
|
|
|
<pre><code class="language-rust">let guess: u32 = match guess.trim().parse() {
|
|
|
Ok(num) => num,
|
|
|
Err(_) => continue,
|
|
|
};
|
|
|
</code></pre>
|
|
|
<p>将 <code>expect</code> 调用换成 <code>match</code> 语句,是从“立即崩溃”转到真正处理错误的惯用方法。须知 <code>parse</code> 返回一个 <code>Result</code> 类型，而 <code>Result</code> 是一个拥有 <code>Ok</code> 或 <code>Err</code> 成员的枚举。这里使用的 <code>match</code> 表达式，和之前处理 <code>cmp</code> 方法返回 <code>Ordering</code> 时用的一样。</p>
|
|
|
<p>如果 <code>parse</code> 能够成功的将字符串转换为一个数字，它会返回一个包含结果数字的 <code>Ok</code>。这个 <code>Ok</code> 值与<code>match</code> 第一个分支的模式相匹配，该分支对应的动作返回 <code>Ok</code> 值中的数字 <code>num</code>，最后如愿变成新创建的 <code>guess</code> 变量。</p>
|
|
|
<p>如果 <code>parse</code> <em>不</em>能将字符串转换为一个数字，它会返回一个包含更多错误信息的 <code>Err</code>。<code>Err</code> 值不能匹配第一个 <code>match</code> 分支的 <code>Ok(num)</code> 模式，但是会匹配第二个分支的 <code>Err(_)</code> 模式：<code>_</code> 是一个兜底值，用来匹配所有 <code>Err</code> 值，不管其中有何种信息。所以程序会执行第二个分支的动作，<code>continue</code> 意味着进入 <code>loop</code> 的下一次循环，请求另一个猜测。这样程序就忽略了 <code>parse</code> 可能遇到的所有错误！</p>
|
|
|
<p>现在万事俱备，只需运行 <code>cargo run</code>：</p>
|
|
|
<pre><code>$ cargo run
|
|
|
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
|
|
Running `target/guessing_game`
|
|
|
Guess the number!
|
|
|
The secret number is: 61
|
|
|
Please input your guess.
|
|
|
10
|
|
|
You guessed: 10
|
|
|
Too small!
|
|
|
Please input your guess.
|
|
|
99
|
|
|
You guessed: 99
|
|
|
Too big!
|
|
|
Please input your guess.
|
|
|
foo
|
|
|
Please input your guess.
|
|
|
61
|
|
|
You guessed: 61
|
|
|
You win!
|
|
|
</code></pre>
|
|
|
<p>太棒了！再有最后一个小的修改，就能完成猜猜看游戏了：还记得程序依然会打印出秘密数字。在测试时还好，但正式发布时会毁了游戏。删掉打印秘密数字的 <code>println!</code>。列表 2-5 为最终代码：</p>
|
|
|
<p><span class="filename">Filename: src/main.rs</span></p>
|
|
|
<pre><code class="language-rust">extern crate rand;
|
|
|
|
|
|
use std::io;
|
|
|
use std::cmp::Ordering;
|
|
|
use rand::Rng;
|
|
|
|
|
|
fn main() {
|
|
|
println!("Guess the number!");
|
|
|
|
|
|
let secret_number = rand::thread_rng().gen_range(1, 101);
|
|
|
|
|
|
loop {
|
|
|
println!("Please input your guess.");
|
|
|
|
|
|
let mut guess = String::new();
|
|
|
|
|
|
io::stdin().read_line(&mut guess)
|
|
|
.expect("Failed to read line");
|
|
|
|
|
|
let guess: u32 = match guess.trim().parse() {
|
|
|
Ok(num) => num,
|
|
|
Err(_) => continue,
|
|
|
};
|
|
|
|
|
|
println!("You guessed: {}", guess);
|
|
|
|
|
|
match guess.cmp(&secret_number) {
|
|
|
Ordering::Less => println!("Too small!"),
|
|
|
Ordering::Greater => println!("Too big!"),
|
|
|
Ordering::Equal => {
|
|
|
println!("You win!");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
</code></pre>
|
|
|
<p><span class="caption">Listing 2-5: Complete code of the guessing game</span></p>
|
|
|
<a class="header" href="#总结" name="总结"><h2>总结</h2></a>
|
|
|
<p>此时此刻，你顺利完成了猜猜看游戏！恭喜！</p>
|
|
|
<p>这是一个通过动手实践学习 Rust 新概念的项目：<code>let</code>、<code>match</code>、方法、关联函数、使用外部 crate 等等，接下来的几章，我们将会继续深入。第三章涉及到大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用他们。第四章探索所有权（ownership），这是一个 Rust 同其他语言都不相同的功能。第五章讨论结构体和方法的语法，而第六章侧重解释枚举。</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
<!-- Mobile navigation buttons -->
|
|
|
|
|
|
<a href="ch01-02-hello-world.html" class="mobile-nav-chapters previous">
|
|
|
<i class="fa fa-angle-left"></i>
|
|
|
</a>
|
|
|
|
|
|
|
|
|
|
|
|
<a href="ch03-00-common-programming-concepts.html" class="mobile-nav-chapters next">
|
|
|
<i class="fa fa-angle-right"></i>
|
|
|
</a>
|
|
|
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
<a href="ch01-02-hello-world.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="ch03-00-common-programming-concepts.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>
|
