rust
/
trpl-zh-cn
mirror of https://github.com/KaiserY/trpl-zh-cn
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

wip

Browse Source
pull/1/head
yang yue 8 years ago
parent b2198ebc4f
commit 982819c2f5
5 changed files with 437 additions and 6 deletions
Show Stats Download Patch File Download Diff File

121
docs/ch06-01-defining-an-enum.html
Unescape View File

@ -150,7 +150,126 @@ let home = IpAddr::V4(String::from("127.0.0.1"));
let loopback = IpAddr::V6(String::from("::1")); let loopback = IpAddr::V6(String::from("::1"));
</code></pre> </code></pre>
<p>我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。</p> <p>我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。</p>
<p>使用枚举而不是结构体还有另外一个优势：每个成员可以处理不同类型和数量的数据。</p> <p>使用枚举而不是结构体还有另外一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将<code>V4</code>地址储存为四个<code>u8</code>值而<code>V6</code>地址仍然表现为一个<code>String</code>，这就不能使用结构体了。枚举可以轻易处理的这个情况：</p>
<pre><code class="language-rust">enum IpAddr {
V4(u8, u8, u8, u8),
V6(String),
}
let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from(&quot;::1&quot;));
</code></pre>
<p>这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了<a href="../std/net/enum.IpAddr.html">以致标准库提供了一个可供使用的定义！</a><!-- ignore -->让我们看看标准库如何定义<code>IpAddr</code>的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员种的地址数据嵌入到了两个不同形式的结构体中，他们对不同的成员的定义是不同的：</p>
<pre><code class="language-rust">struct Ipv4Addr {
// details elided
}
struct Ipv6Addr {
// details elided
}
enum IpAddr {
V4(Ipv4Addr),
V6(Ipv6Addr),
}
</code></pre>
<p>这些代码展示了可以将任意类型的数据放入枚举成员中：例如字符串、数字类型或者结构体。甚至可以包含另一个枚举！另外，标准库中的类型通常并不比你可能设想出来的要复杂多少。</p>
<p>注意虽然标准库中包含一个<code>IpAddr</code>的定义，仍然可以创建和使用我们自己的定义而不会有冲突，因为我们并没有将标准库中的定义引入作用域。第七章会讲到如何导入类型。</p>
<p>来看看列表 6-2 中的另一个枚举的例子：它的成员中内嵌了多种多样的类型：</p>
<figure>
<pre><code class="language-rust">enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
</code></pre>
<figcaption>
<p>Listing 6-2: A <code>Message</code> enum whose variants each store different amounts and
types of values</p>
</figcaption>
</figure>
<p>这个枚举有四个含有不同类型的成员：</p>
<ul>
<li><code>Quit</code>没有关联任何数据。</li>
<li><code>Move</code>包含一个匿名结构体</li>
<li><code>Write</code>包含单独一个<code>String</code>。</li>
<li><code>ChangeColor</code>包含三个<code>i32</code>。</li>
</ul>
<p>定义一个像列表 6-2 中的枚举类似于定义不同类型的结构体，除了枚举不使用<code>struct</code>关键字而且所有成员都被组合在一起位于<code>Message</code>下。如下这些结构体可以包含与之前枚举成员中相同的数据：</p>
<pre><code class="language-rust">struct QuitMessage; // unit struct
struct MoveMessage {
x: i32,
y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct
</code></pre>
<p>不过如果我们使用不同的结构体，他们都有不同的类型，将不能轻易的定义一个获取任何这些信息类型的函数，正如可以使用列表 6-2 中定义的<code>Message</code>枚举那样因为他们是一个类型的。</p>
<p>结构体和枚举还有另一个相似点：就像可以使用<code>impl</code>来为结构体定义方法那样，也可以在枚举上定义方法。这是一个定义于我们<code>Message</code>枚举上的叫做<code>call</code>的方法：</p>
<pre><code class="language-rust"># enum Message {
# Quit,
# Move { x: i32, y: i32 },
# Write(String),
# ChangeColor(i32, i32, i32),
# }
#
impl Message {
fn call(&amp;self) {
// method body would be defined here
}
}
let m = Message::Write(String::from(&quot;hello&quot;));
m.call();
</code></pre>
<p>方法体使用了<code>self</code>来获取调用方法的值。这个例子中，创建了一个拥有类型<code>Message::Write(&quot;hello&quot;)</code>的变量<code>m</code>，而且这就是当<code>m.call()</code>运行时<code>call</code>方法中的<code>self</code>的值。</p>
<p>让我们看看标准库中的另一个非常常见和实用的枚举：<code>Option</code>。</p>
<h3><code>Option</code>枚举和其相对空值的优势</h3>
<p>在之前的部分，我们看到了<code>IpAddr</code>枚举如何利用 Rust 的类型系统编码更多信息而不单单是程序中的数据。这一部分探索一个<code>Option</code>的案例分析，它是标准库定义的另一个枚举。<code>Option</code>类型应用广泛因为它编码了一个非常普遍的场景，就是一个值可能是某个值或者什么都不是。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。</p>
<p>编程语言的设计经常从其包含功能的角度考虑问题，但是从不包含的功能的角度思考也很重要。Rust 并没有很多其他语言中有的空值功能。<strong>空值</strong>（<em>Null</em> ）是一个值它代表没有值。在有空值的语言中，变量总是这两种状态之一：空值和非空值。</p>
<p>在“Null References: The Billion Dollar Mistake”中，Tony Hoare，null 的发明者，曾经说到：</p>
<blockquote>
<p>我称之为我万亿美元的错误。当时，我在在一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的应有都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数以万计美元的苦痛和伤害。</p>
</blockquote>
<p>空值的为题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性是无处不在的，非常容易出现这类错误。</p>
<p>然而，空值尝试表达的概念仍然是有意义的：空值是一个因为某种原因目前无效或缺失的值。</p>
<p>问题不在于实际的概念而在于具体的实现。为此，Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。这个枚举是<code>Option&lt;T&gt;</code>，而且它<a href="../std/option/enum.Option.html">定义于标准库中</a><!-- ignore -->，如下:</p>
<pre><code class="language-rust">enum Option&lt;T&gt; {
Some(T),
None,
}
</code></pre>
<p><code>Option&lt;T&gt;</code>是如此有用以至于它甚至被包含在了 prelude 之中：不需要显式导入它。另外，它的成员也是如此：可以不需要<code>Option::</code>前缀来直接使用<code>Some</code>和<code>None</code>。即便如此<code>Option&lt;T&gt;</code>也仍是常规的枚举，<code>Some(T)</code>和<code>None</code>仍是<code>Option&lt;T&gt;</code>的成员。</p>
<p><code>&lt;T&gt;</code>语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是<code>&lt;T&gt;</code>意味着<code>Option</code>枚举的<code>Some</code>成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型<code>Option</code>值的例子：</p>
<pre><code class="language-rust">let some_number = Some(5);
let some_string = Some(&quot;a string&quot;);
let absent_number: Option&lt;i32&gt; = None;
</code></pre>
<p>如果使用<code>None</code>而不是<code>Some</code>，需要告诉 Rust <code>Option&lt;T&gt;</code>是什么类型的，因为编译器只通过<code>None</code>值无法推断出<code>Some</code>成员的类型。</p>
<p>当有一个<code>Some</code>值时，我们就知道存在一个值，而这个值保存在<code>Some</code>中。当有个<code>None</code>值时，在某种意义上它跟空值是相同的意义：并没有一个有效的值。那么，<code>Option&lt;T&gt;</code>为什么就比空值要好呢？</p>
<p>简而言之，因为<code>Option&lt;T&gt;</code>和<code>T</code>（这里<code>T</code>可以是任何类型）是不同的类型，编译器不允许像一个被定义的有效的类型那样使用<code>Option&lt;T&gt;</code>。例如，这些代码不能编译，因为它尝试将<code>Option&lt;i8&gt;</code>与<code>i8</code>相比：</p>
<pre><code class="language-rust,ignore">let x: i8 = 5;
let y: Option&lt;i8&gt; = Some(5);
let sum = x + y;
</code></pre>
<p>如果运行这些代码，将得到类似这样的错误信息：</p>
<pre><code>error[E0277]: the trait bound `i8: std::ops::Add&lt;std::option::Option&lt;i8&gt;&gt;` is
not satisfied
--&gt;
|
7 | let sum = x + y;
| ^^^^^
|
</code></pre>
<p>哇哦！事实上，错误信息意味着 Rust 不知道该如何将<code>Option&lt;i8&gt;</code>与<code>i8</code>相加。当在 Rust 中拥有一个像<code>i8</code>这样类型的值时，编译器确保它总是有一个有效的值。我们可以自信使用而无需判空。只有当使用<code>Option&lt;i8&gt;</code>（或者任何用到的类型）是需要担心可能没有一个值，而编译器会确保我们在使用值之前处理为空的情况。</p>
<p>换句话说，在对<code>Option&lt;T&gt;</code>进行<code>T</code>的运算之前必须转为<code>T</code>。通常这能帮助我们捕获空值最常见的问题之一：假设某值不为空但实际上为空。</p>
<p>无需担心错过非空值的假设（和处理）让我们对代码更加有信心，为了拥有一个可能为空的值，必须显式的将其放入对应类型的<code>Option&lt;T&gt;</code>中。接着，当使用这个值时，必须明确的处理值为空的情况。任何地方一个值不是<code>Option&lt;T&gt;</code>类型的话，<strong>可以</strong>安全的假设它的值不为空。这是 Rust 的一个有意为之的设计选择，来限制空值的泛滥和增加 Rust 代码的安全性。</p>
<p>那么当有一个<code>Option&lt;T&gt;</code>的值时，如何从<code>Some</code>成员中取出<code>T</code>的值来使用它呢？<code>Option&lt;T&gt;</code>枚举拥有大量用于各种情况的方法：你可以查看<a href="../std/option/enum.Option.html">相关代码</a><!-- ignore -->。熟悉<code>Option&lt;T&gt;</code>的方法将对你的 Rust 之旅提供巨大的帮助。</p>
<p>总的来说，为了使用<code>Option&lt;T&gt;</code>值，需要编写处理每个成员的代码。我们想要一些代码只当拥有<code>Some(T)</code>值时运行，这些代码允许使用其中的<code>T</code>。也希望一些代码当在<code>None</code>值时运行，这些代码并没有一个可用的<code>T</code>值。<code>match</code>表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。</p>
</div> </div>

8
docs/ch06-02-match.html
Unescape View File

@ -67,7 +67,13 @@
</div> </div>
<div id="content" class="content"> <div id="content" class="content">
<h1>The <code>match</code> Control Flow Operator</h1> <h2><code>match</code>控制流运算符</h2>
<blockquote>
<p><a href="https://github.com/rust-lang/book/blob/master/src/ch06-02-match.md">ch06-02-match.md</a>
<br>
commit 396e2db4f7de2e5e7869b1f8bc905c45c631ad7d</p>
</blockquote>
<p>Rust 有一个叫做<code>match</code>的极为强大的控制流运算符，</p>
</div> </div>

129
docs/print.html
Unescape View File

@ -2741,8 +2741,133 @@ let home = IpAddr::V4(String::from(&quot;127.0.0.1&quot;));
let loopback = IpAddr::V6(String::from(&quot;::1&quot;)); let loopback = IpAddr::V6(String::from(&quot;::1&quot;));
</code></pre> </code></pre>
<p>我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。</p> <p>我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。</p>
<p>使用枚举而不是结构体还有另外一个优势：每个成员可以处理不同类型和数量的数据。</p> <p>使用枚举而不是结构体还有另外一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将<code>V4</code>地址储存为四个<code>u8</code>值而<code>V6</code>地址仍然表现为一个<code>String</code>，这就不能使用结构体了。枚举可以轻易处理的这个情况：</p>
<h1>The <code>match</code> Control Flow Operator</h1> <pre><code class="language-rust">enum IpAddr {
V4(u8, u8, u8, u8),
V6(String),
}
let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from(&quot;::1&quot;));
</code></pre>
<p>这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了<a href="../std/net/enum.IpAddr.html">以致标准库提供了一个可供使用的定义！</a><!-- ignore -->让我们看看标准库如何定义<code>IpAddr</code>的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员种的地址数据嵌入到了两个不同形式的结构体中，他们对不同的成员的定义是不同的：</p>
<pre><code class="language-rust">struct Ipv4Addr {
// details elided
}
struct Ipv6Addr {
// details elided
}
enum IpAddr {
V4(Ipv4Addr),
V6(Ipv6Addr),
}
</code></pre>
<p>这些代码展示了可以将任意类型的数据放入枚举成员中：例如字符串、数字类型或者结构体。甚至可以包含另一个枚举！另外，标准库中的类型通常并不比你可能设想出来的要复杂多少。</p>
<p>注意虽然标准库中包含一个<code>IpAddr</code>的定义，仍然可以创建和使用我们自己的定义而不会有冲突，因为我们并没有将标准库中的定义引入作用域。第七章会讲到如何导入类型。</p>
<p>来看看列表 6-2 中的另一个枚举的例子：它的成员中内嵌了多种多样的类型：</p>
<figure>
<pre><code class="language-rust">enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
</code></pre>
<figcaption>
<p>Listing 6-2: A <code>Message</code> enum whose variants each store different amounts and
types of values</p>
</figcaption>
</figure>
<p>这个枚举有四个含有不同类型的成员：</p>
<ul>
<li><code>Quit</code>没有关联任何数据。</li>
<li><code>Move</code>包含一个匿名结构体</li>
<li><code>Write</code>包含单独一个<code>String</code>。</li>
<li><code>ChangeColor</code>包含三个<code>i32</code>。</li>
</ul>
<p>定义一个像列表 6-2 中的枚举类似于定义不同类型的结构体，除了枚举不使用<code>struct</code>关键字而且所有成员都被组合在一起位于<code>Message</code>下。如下这些结构体可以包含与之前枚举成员中相同的数据：</p>
<pre><code class="language-rust">struct QuitMessage; // unit struct
struct MoveMessage {
x: i32,
y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct
</code></pre>
<p>不过如果我们使用不同的结构体，他们都有不同的类型，将不能轻易的定义一个获取任何这些信息类型的函数，正如可以使用列表 6-2 中定义的<code>Message</code>枚举那样因为他们是一个类型的。</p>
<p>结构体和枚举还有另一个相似点：就像可以使用<code>impl</code>来为结构体定义方法那样，也可以在枚举上定义方法。这是一个定义于我们<code>Message</code>枚举上的叫做<code>call</code>的方法：</p>
<pre><code class="language-rust"># enum Message {
# Quit,
# Move { x: i32, y: i32 },
# Write(String),
# ChangeColor(i32, i32, i32),
# }
#
impl Message {
fn call(&amp;self) {
// method body would be defined here
}
}
let m = Message::Write(String::from(&quot;hello&quot;));
m.call();
</code></pre>
<p>方法体使用了<code>self</code>来获取调用方法的值。这个例子中，创建了一个拥有类型<code>Message::Write(&quot;hello&quot;)</code>的变量<code>m</code>，而且这就是当<code>m.call()</code>运行时<code>call</code>方法中的<code>self</code>的值。</p>
<p>让我们看看标准库中的另一个非常常见和实用的枚举：<code>Option</code>。</p>
<h3><code>Option</code>枚举和其相对空值的优势</h3>
<p>在之前的部分，我们看到了<code>IpAddr</code>枚举如何利用 Rust 的类型系统编码更多信息而不单单是程序中的数据。这一部分探索一个<code>Option</code>的案例分析，它是标准库定义的另一个枚举。<code>Option</code>类型应用广泛因为它编码了一个非常普遍的场景，就是一个值可能是某个值或者什么都不是。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。</p>
<p>编程语言的设计经常从其包含功能的角度考虑问题，但是从不包含的功能的角度思考也很重要。Rust 并没有很多其他语言中有的空值功能。<strong>空值</strong>（<em>Null</em> ）是一个值它代表没有值。在有空值的语言中，变量总是这两种状态之一：空值和非空值。</p>
<p>在“Null References: The Billion Dollar Mistake”中，Tony Hoare，null 的发明者，曾经说到：</p>
<blockquote>
<p>我称之为我万亿美元的错误。当时，我在在一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的应有都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数以万计美元的苦痛和伤害。</p>
</blockquote>
<p>空值的为题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性是无处不在的，非常容易出现这类错误。</p>
<p>然而，空值尝试表达的概念仍然是有意义的：空值是一个因为某种原因目前无效或缺失的值。</p>
<p>问题不在于实际的概念而在于具体的实现。为此，Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。这个枚举是<code>Option&lt;T&gt;</code>，而且它<a href="../std/option/enum.Option.html">定义于标准库中</a><!-- ignore -->，如下:</p>
<pre><code class="language-rust">enum Option&lt;T&gt; {
Some(T),
None,
}
</code></pre>
<p><code>Option&lt;T&gt;</code>是如此有用以至于它甚至被包含在了 prelude 之中：不需要显式导入它。另外，它的成员也是如此：可以不需要<code>Option::</code>前缀来直接使用<code>Some</code>和<code>None</code>。即便如此<code>Option&lt;T&gt;</code>也仍是常规的枚举，<code>Some(T)</code>和<code>None</code>仍是<code>Option&lt;T&gt;</code>的成员。</p>
<p><code>&lt;T&gt;</code>语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是<code>&lt;T&gt;</code>意味着<code>Option</code>枚举的<code>Some</code>成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型<code>Option</code>值的例子：</p>
<pre><code class="language-rust">let some_number = Some(5);
let some_string = Some(&quot;a string&quot;);
let absent_number: Option&lt;i32&gt; = None;
</code></pre>
<p>如果使用<code>None</code>而不是<code>Some</code>，需要告诉 Rust <code>Option&lt;T&gt;</code>是什么类型的，因为编译器只通过<code>None</code>值无法推断出<code>Some</code>成员的类型。</p>
<p>当有一个<code>Some</code>值时，我们就知道存在一个值，而这个值保存在<code>Some</code>中。当有个<code>None</code>值时，在某种意义上它跟空值是相同的意义：并没有一个有效的值。那么，<code>Option&lt;T&gt;</code>为什么就比空值要好呢？</p>
<p>简而言之，因为<code>Option&lt;T&gt;</code>和<code>T</code>（这里<code>T</code>可以是任何类型）是不同的类型，编译器不允许像一个被定义的有效的类型那样使用<code>Option&lt;T&gt;</code>。例如，这些代码不能编译，因为它尝试将<code>Option&lt;i8&gt;</code>与<code>i8</code>相比：</p>
<pre><code class="language-rust,ignore">let x: i8 = 5;
let y: Option&lt;i8&gt; = Some(5);
let sum = x + y;
</code></pre>
<p>如果运行这些代码，将得到类似这样的错误信息：</p>
<pre><code>error[E0277]: the trait bound `i8: std::ops::Add&lt;std::option::Option&lt;i8&gt;&gt;` is
not satisfied
--&gt;
|
7 | let sum = x + y;
| ^^^^^
|
</code></pre>
<p>哇哦！事实上，错误信息意味着 Rust 不知道该如何将<code>Option&lt;i8&gt;</code>与<code>i8</code>相加。当在 Rust 中拥有一个像<code>i8</code>这样类型的值时，编译器确保它总是有一个有效的值。我们可以自信使用而无需判空。只有当使用<code>Option&lt;i8&gt;</code>（或者任何用到的类型）是需要担心可能没有一个值，而编译器会确保我们在使用值之前处理为空的情况。</p>
<p>换句话说，在对<code>Option&lt;T&gt;</code>进行<code>T</code>的运算之前必须转为<code>T</code>。通常这能帮助我们捕获空值最常见的问题之一：假设某值不为空但实际上为空。</p>
<p>无需担心错过非空值的假设（和处理）让我们对代码更加有信心，为了拥有一个可能为空的值，必须显式的将其放入对应类型的<code>Option&lt;T&gt;</code>中。接着，当使用这个值时，必须明确的处理值为空的情况。任何地方一个值不是<code>Option&lt;T&gt;</code>类型的话，<strong>可以</strong>安全的假设它的值不为空。这是 Rust 的一个有意为之的设计选择，来限制空值的泛滥和增加 Rust 代码的安全性。</p>
<p>那么当有一个<code>Option&lt;T&gt;</code>的值时，如何从<code>Some</code>成员中取出<code>T</code>的值来使用它呢？<code>Option&lt;T&gt;</code>枚举拥有大量用于各种情况的方法：你可以查看<a href="../std/option/enum.Option.html">相关代码</a><!-- ignore -->。熟悉<code>Option&lt;T&gt;</code>的方法将对你的 Rust 之旅提供巨大的帮助。</p>
<p>总的来说，为了使用<code>Option&lt;T&gt;</code>值，需要编写处理每个成员的代码。我们想要一些代码只当拥有<code>Some(T)</code>值时运行，这些代码允许使用其中的<code>T</code>。也希望一些代码当在<code>None</code>值时运行，这些代码并没有一个可用的<code>T</code>值。<code>match</code>表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。</p>
<h2><code>match</code>控制流运算符</h2>
<blockquote>
<p><a href="https://github.com/rust-lang/book/blob/master/src/ch06-02-match.md">ch06-02-match.md</a>
<br>
commit 396e2db4f7de2e5e7869b1f8bc905c45c631ad7d</p>
</blockquote>
<p>Rust 有一个叫做<code>match</code>的极为强大的控制流运算符，</p>
<h1>Concise Control Flow with <code>if let</code></h1> <h1>Concise Control Flow with <code>if let</code></h1>
</div> </div>

177
src/ch06-01-defining-an-enum.md
Unescape View File

@ -109,4 +109,179 @@ let loopback = IpAddr::V6(String::from("::1"));
我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。 我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。
使用枚举而不是结构体还有另外一个优势：每个成员可以处理不同类型和数量的数据。 使用枚举而不是结构体还有另外一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将`V4`地址储存为四个`u8`值而`V6`地址仍然表现为一个`String`，这就不能使用结构体了。枚举可以轻易处理的这个情况：
```rust
enum IpAddr {
V4(u8, u8, u8, u8),
V6(String),
}
let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));
```
这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了[以致标准库提供了一个可供使用的定义！][IpAddr]<!-- ignore -->让我们看看标准库如何定义`IpAddr`的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员种的地址数据嵌入到了两个不同形式的结构体中，他们对不同的成员的定义是不同的：
[IpAddr]: ../std/net/enum.IpAddr.html
```rust
struct Ipv4Addr {
// details elided
}
struct Ipv6Addr {
// details elided
}
enum IpAddr {
V4(Ipv4Addr),
V6(Ipv6Addr),
}
```
这些代码展示了可以将任意类型的数据放入枚举成员中：例如字符串、数字类型或者结构体。甚至可以包含另一个枚举！另外，标准库中的类型通常并不比你可能设想出来的要复杂多少。
注意虽然标准库中包含一个`IpAddr`的定义，仍然可以创建和使用我们自己的定义而不会有冲突，因为我们并没有将标准库中的定义引入作用域。第七章会讲到如何导入类型。
来看看列表 6-2 中的另一个枚举的例子：它的成员中内嵌了多种多样的类型：
<figure>
```rust
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
```
<figcaption>
Listing 6-2: A `Message` enum whose variants each store different amounts and
types of values
</figcaption>
</figure>
这个枚举有四个含有不同类型的成员：
* `Quit`没有关联任何数据。
* `Move`包含一个匿名结构体
* `Write`包含单独一个`String`。
* `ChangeColor`包含三个`i32`。
定义一个像列表 6-2 中的枚举类似于定义不同类型的结构体，除了枚举不使用`struct`关键字而且所有成员都被组合在一起位于`Message`下。如下这些结构体可以包含与之前枚举成员中相同的数据：
```rust
struct QuitMessage; // unit struct
struct MoveMessage {
x: i32,
y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct
```
不过如果我们使用不同的结构体，他们都有不同的类型，将不能轻易的定义一个获取任何这些信息类型的函数，正如可以使用列表 6-2 中定义的`Message`枚举那样因为他们是一个类型的。
结构体和枚举还有另一个相似点：就像可以使用`impl`来为结构体定义方法那样，也可以在枚举上定义方法。这是一个定义于我们`Message`枚举上的叫做`call`的方法：
```rust
# enum Message {
# Quit,
# Move { x: i32, y: i32 },
# Write(String),
# ChangeColor(i32, i32, i32),
# }
#
impl Message {
fn call(&self) {
// method body would be defined here
}
}
let m = Message::Write(String::from("hello"));
m.call();
```
方法体使用了`self`来获取调用方法的值。这个例子中，创建了一个拥有类型`Message::Write("hello")`的变量`m`，而且这就是当`m.call()`运行时`call`方法中的`self`的值。
让我们看看标准库中的另一个非常常见和实用的枚举：`Option`。
### `Option`枚举和其相对空值的优势
在之前的部分，我们看到了`IpAddr`枚举如何利用 Rust 的类型系统编码更多信息而不单单是程序中的数据。这一部分探索一个`Option`的案例分析，它是标准库定义的另一个枚举。`Option`类型应用广泛因为它编码了一个非常普遍的场景，就是一个值可能是某个值或者什么都不是。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。
编程语言的设计经常从其包含功能的角度考虑问题，但是从不包含的功能的角度思考也很重要。Rust 并没有很多其他语言中有的空值功能。**空值**（*Null* ）是一个值它代表没有值。在有空值的语言中，变量总是这两种状态之一：空值和非空值。
在“Null References: The Billion Dollar Mistake”中，Tony Hoare，null 的发明者，曾经说到：
> 我称之为我万亿美元的错误。当时，我在在一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的应有都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数以万计美元的苦痛和伤害。
空值的为题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性是无处不在的，非常容易出现这类错误。
然而，空值尝试表达的概念仍然是有意义的：空值是一个因为某种原因目前无效或缺失的值。
问题不在于实际的概念而在于具体的实现。为此，Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。这个枚举是`Option<T>`，而且它[定义于标准库中][option]<!-- ignore -->，如下:
[option]: ../std/option/enum.Option.html
```rust
enum Option<T> {
Some(T),
None,
}
```
`Option<T>`是如此有用以至于它甚至被包含在了 prelude 之中：不需要显式导入它。另外，它的成员也是如此：可以不需要`Option::`前缀来直接使用`Some`和`None`。即便如此`Option<T>`也仍是常规的枚举，`Some(T)`和`None`仍是`Option<T>`的成员。
`<T>`语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是`<T>`意味着`Option`枚举的`Some`成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型`Option`值的例子：
```rust
let some_number = Some(5);
let some_string = Some("a string");
let absent_number: Option<i32> = None;
```
如果使用`None`而不是`Some`，需要告诉 Rust `Option<T>`是什么类型的，因为编译器只通过`None`值无法推断出`Some`成员的类型。
当有一个`Some`值时，我们就知道存在一个值，而这个值保存在`Some`中。当有个`None`值时，在某种意义上它跟空值是相同的意义：并没有一个有效的值。那么，`Option<T>`为什么就比空值要好呢？
简而言之，因为`Option<T>`和`T`（这里`T`可以是任何类型）是不同的类型，编译器不允许像一个被定义的有效的类型那样使用`Option<T>`。例如，这些代码不能编译，因为它尝试将`Option<i8>`与`i8`相比：
```rust,ignore
let x: i8 = 5;
let y: Option<i8> = Some(5);
let sum = x + y;
```
如果运行这些代码，将得到类似这样的错误信息：
```
error[E0277]: the trait bound `i8: std::ops::Add<std::option::Option<i8>>` is
not satisfied
-->
|
7 | let sum = x + y;
| ^^^^^
|
```
哇哦！事实上，错误信息意味着 Rust 不知道该如何将`Option<i8>`与`i8`相加。当在 Rust 中拥有一个像`i8`这样类型的值时，编译器确保它总是有一个有效的值。我们可以自信使用而无需判空。只有当使用`Option<i8>`（或者任何用到的类型）是需要担心可能没有一个值，而编译器会确保我们在使用值之前处理为空的情况。
换句话说，在对`Option<T>`进行`T`的运算之前必须转为`T`。通常这能帮助我们捕获空值最常见的问题之一：假设某值不为空但实际上为空。
无需担心错过非空值的假设（和处理）让我们对代码更加有信心，为了拥有一个可能为空的值，必须显式的将其放入对应类型的`Option<T>`中。接着，当使用这个值时，必须明确的处理值为空的情况。任何地方一个值不是`Option<T>`类型的话，**可以**安全的假设它的值不为空。这是 Rust 的一个有意为之的设计选择，来限制空值的泛滥和增加 Rust 代码的安全性。
那么当有一个`Option<T>`的值时，如何从`Some`成员中取出`T`的值来使用它呢？`Option<T>`枚举拥有大量用于各种情况的方法：你可以查看[相关代码][docs]<!-- ignore -->。熟悉`Option<T>`的方法将对你的 Rust 之旅提供巨大的帮助。
[docs]: ../std/option/enum.Option.html
总的来说，为了使用`Option<T>`值，需要编写处理每个成员的代码。我们想要一些代码只当拥有`Some(T)`值时运行，这些代码允许使用其中的`T`。也希望一些代码当在`None`值时运行，这些代码并没有一个可用的`T`值。`match`表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。

8
src/ch06-02-match.md
Unescape View File

@ -1 +1,7 @@
# The `match` Control Flow Operator ## `match`控制流运算符
> [ch06-02-match.md](https://github.com/rust-lang/book/blob/master/src/ch06-02-match.md)
> <br>
> commit 396e2db4f7de2e5e7869b1f8bc905c45c631ad7d
Rust 有一个叫做`match`的极为强大的控制流运算符，
Write Preview
Loading…
Cancel
Save