generate

Author: KeenS

public/1.6/book/loops.html

@@ -4,7 +4,7 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <meta name="generator" content="rustdoc">
-    <title>Loops</title>
+    <title>ループ</title>
 
     <link rel="stylesheet" type="text/css" href="rustbook.css">
 
@@ -185,11 +185,19 @@
 <div id='page'>
 
 
-    <h1 class="title">Loops</h1>
-    <p>Rust currently provides three approaches to performing some kind of iterative activity. They are: <code>loop</code>, <code>while</code> and <code>for</code>. Each approach has its own set of uses.</p>
+    <h1 class="title">ループ</h1>
+    <!-- % Loops -->
+
+<!-- Rust currently provides three approaches to performing some kind of iterative activity. They are: `loop`, `while` and `for`. Each approach has its own set of uses. -->
+
+<p>なんらかの繰り返しを伴う処理に対して、Rust言語は3種類のアプローチ: <code>loop</code>, <code>while</code>, <code>for</code> を提供します。
+各アプローチにはそれぞれの使い道があります。</p>
 
 <h2 id='loop' class='section-header'><a href='#loop'>loop</a></h2>
-<p>The infinite <code>loop</code> is the simplest form of loop available in Rust. Using the keyword <code>loop</code>, Rust provides a way to loop indefinitely until some terminating statement is reached. Rust&#39;s infinite <code>loop</code>s look like this:</p>
+<!-- The infinite `loop` is the simplest form of loop available in Rust. Using the keyword `loop`, Rust provides a way to loop indefinitely until some terminating statement is reached. Rust's infinite `loop`s look like this: -->
+
+<p>Rustで使えるループなかで最もシンプルな形式が、無限 <code>loop</code> です。Rustのキーワード <code>loop</code> によって、
+何らかの終了状態に到達するまでずっとループし続ける手段を提供します。Rustの無限 <code>loop</code> はこのように:</p>
 <span class='rusttest'>fn main() {
     loop {
         println!(&quot;Loop forever!&quot;);
@@ -200,7 +208,9 @@ <h2 id='loop' class='section-header'><a href='#loop'>loop</a></h2>
 }</pre>
 
 <h2 id='while' class='section-header'><a href='#while'>while</a></h2>
-<p>Rust also has a <code>while</code> loop. It looks like this:</p>
+<!-- Rust also has a `while` loop. It looks like this: -->
+
+<p>Rustには <code>while</code> ループもあります。このように:</p>
 <span class='rusttest'>fn main() {
     let mut x = 5; // mut x: i32
     let mut done = false; // mut done: bool
@@ -228,37 +238,60 @@ <h2 id='while' class='section-header'><a href='#while'>while</a></h2>
     }
 }</pre>
 
-<p><code>while</code> loops are the correct choice when you’re not sure how many times
-you need to loop.</p>
+<!-- `while` loops are the correct choice when you’re not sure how many times -->
+
+<!-- you need to loop. -->
+
+<p>何回ループする必要があるか明らかではない状況で、<code>while</code> ループは正しい選択肢です。</p>
+
+<!-- If you need an infinite loop, you may be tempted to write this: -->
 
-<p>If you need an infinite loop, you may be tempted to write this:</p>
+<p>無限ループの必要があるとき、次のように書きたくなるかもしれません:</p>
 <span class='rusttest'>fn main() {
     while true {
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>while</span> <span class='boolval'>true</span> {</pre>
 
-<p>However, <code>loop</code> is far better suited to handle this case:</p>
+<!-- However, `loop` is far better suited to handle this case: -->
+
+<p>しかし、こういった場合には <code>loop</code> の方がずっと適しています。</p>
 <span class='rusttest'>fn main() {
     loop {
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>loop</span> {</pre>
 
-<p>Rust’s control-flow analysis treats this construct differently than a <code>while true</code>, since we know that it will always loop. In general, the more information
-we can give to the compiler, the better it can do with safety and code
-generation, so you should always prefer <code>loop</code> when you plan to loop
-infinitely.</p>
+<!-- Rust’s control-flow analysis treats this construct differently than a `while -->
+
+<!-- true`, since we know that it will always loop. In general, the more information -->
+
+<!-- we can give to the compiler, the better it can do with safety and code -->
+
+<!-- generation, so you should always prefer `loop` when you plan to loop -->
+
+<!-- infinitely. -->
+
+<p>Rustの制御フロー解析では、必ずループすると知っていることから、これを <code>while true</code> とは異なる構造として扱います。
+一般に、コンパイラへ与える情報量が多いほど、安全性が高くより良いコード生成につながるため、
+無限にループするつもりなら常に <code>loop</code> を使うべきです。</p>
 
 <h2 id='for' class='section-header'><a href='#for'>for</a></h2>
-<p>The <code>for</code> loop is used to loop a particular number of times. Rust’s <code>for</code> loops
-work a bit differently than in other systems languages, however. Rust’s <code>for</code>
-loop doesn’t look like this “C-style” <code>for</code> loop:</p>
+<!-- The `for` loop is used to loop a particular number of times. Rust’s `for` loops -->
+
+<!-- work a bit differently than in other systems languages, however. Rust’s `for` -->
+
+<!-- loop doesn’t look like this “C-style” `for` loop: -->
+
+<p>特定の回数だけループするときには <code>for</code> ループを使います。しかし、Rustの <code>for</code> ループは他のシステムプログラミング言語のそれとは少し異なる働きをします。
+Rustの <code>for</code> ループは、次のような「Cスタイル」 <code>for</code> ループとは似ていません:</p>
 
 <pre><code class="language-c">for (x = 0; x &lt; 10; x++) {
     printf( &quot;%d\n&quot;, x );
 }
 </code></pre>
 
-<p>Instead, it looks like this:</p>
+<!-- Instead, it looks like this: -->
+
+<p>代わりに、このように書きます:</p>
 <span class='rusttest'>fn main() {
     for x in 0..10 {
         println!(&quot;{}&quot;, x); // x: i32
@@ -268,7 +301,9 @@ <h2 id='for' class='section-header'><a href='#for'>for</a></h2>
     <span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>&quot;{}&quot;</span>, <span class='ident'>x</span>); <span class='comment'>// x: i32</span>
 }</pre>
 
-<p>In slightly more abstract terms,</p>
+<!-- In slightly more abstract terms, -->
+
+<p>もう少し抽象的な用語を使うと、</p>
 <span class='rusttest'>fn main() {
     for var in expression {
         code
@@ -278,25 +313,52 @@ <h2 id='for' class='section-header'><a href='#for'>for</a></h2>
     <span class='ident'>code</span>
 }</pre>
 
-<p>The expression is an item that can be converted into an <a href="iterators.html">iterator</a> using
-<a href="../std/iter/trait.IntoIterator.html"><code>IntoIterator</code></a>. The iterator gives back a series of elements. Each element is
-one iteration of the loop. That value is then bound to the name <code>var</code>, which is
-valid for the loop body. Once the body is over, the next value is fetched from
-the iterator, and we loop another time. When there are no more values, the <code>for</code>
-loop is over.</p>
+<!-- The expression is an item that can be converted into an [iterator] using -->
+
+<!-- [`IntoIterator`]. The iterator gives back a series of elements. Each element is -->
+
+<!-- one iteration of the loop. That value is then bound to the name `var`, which is -->
+
+<!-- valid for the loop body. Once the body is over, the next value is fetched from -->
+
+<!-- the iterator, and we loop another time. When there are no more values, the `for` -->
+
+<!-- loop is over. -->
+
+<p>式(expression)は<a href="../std/iter/trait.IntoIterator.html"><code>IntoIterator</code></a>を用いて<a href="iterators.html">イテレータ</a>へと変換可能なアイテムです。
+イテレータは要素の連なりを返します。それぞれの要素がループの1回の反復になります。
+その値は名前 <code>var</code> に束縛されて、ループ本体にて有効になります。いったんループ本体を抜けると、
+次の値がイテレータから取り出され、次のループ処理を行います。それ以上の値が存在しない時は、
+<code>for</code> ループは終了します。</p>
+
+<!-- In our example, `0..10` is an expression that takes a start and an end position, -->
+
+<!-- and gives an iterator over those values. The upper bound is exclusive, though, -->
+
+<!-- so our loop will print `0` through `9`, not `10`. -->
 
-<p>In our example, <code>0..10</code> is an expression that takes a start and an end position,
-and gives an iterator over those values. The upper bound is exclusive, though,
-so our loop will print <code>0</code> through <code>9</code>, not <code>10</code>.</p>
+<p>例示では、<code>0..10</code> が開始位置と終了位置をとる式であり、同範囲の値を返すイテレータを与えます。
+上界はその値自身を含まないため、このループは <code>0</code> から <code>9</code> までを表示します。 <code>10</code> ではありません。</p>
 
-<p>Rust does not have the “C-style” <code>for</code> loop on purpose. Manually controlling
-each element of the loop is complicated and error prone, even for experienced C
-developers.</p>
+<!-- Rust does not have the “C-style” `for` loop on purpose. Manually controlling -->
 
-<h3 id='enumerate' class='section-header'><a href='#enumerate'>Enumerate</a></h3>
-<p>When you need to keep track of how many times you already looped, you can use the <code>.enumerate()</code> function.</p>
+<!-- each element of the loop is complicated and error prone, even for experienced C -->
 
-<h4 id='on-ranges' class='section-header'><a href='#on-ranges'>On ranges:</a></h4><span class='rusttest'>fn main() {
+<!-- developers. -->
+
+<p>Rustでは意図的に「Cスタイル」 <code>for</code> ループを持ちません。経験豊富なC開発者でさえ、
+ループの各要素を手動制御することは複雑であり、また間違いを犯しやすいのです。</p>
+
+<!-- ### Enumerate -->
+
+<h3 id='列挙' class='section-header'><a href='#列挙'>列挙</a></h3>
+<!-- When you need to keep track of how many times you already looped, you can use the `.enumerate()` function. -->
+
+<p>ループ中で何回目の繰り返しかを知る必要があるなら、 <code>.enumerate()</code> 関数が使えます。</p>
+
+<!-- #### On ranges: -->
+
+<h4 id='レンジを対象に' class='section-header'><a href='#レンジを対象に'>レンジを対象に:</a></h4><span class='rusttest'>fn main() {
     for (i,j) in (5..10).enumerate() {
         println!(&quot;i = {} and j = {}&quot;, i, j);
     }
@@ -305,7 +367,9 @@ <h4 id='on-ranges' class='section-header'><a href='#on-ranges'>On ranges:</a></h
     <span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>&quot;i = {} and j = {}&quot;</span>, <span class='ident'>i</span>, <span class='ident'>j</span>);
 }</pre>
 
-<p>Outputs:</p>
+<!-- Outputs: -->
+
+<p>出力:</p>
 
 <pre><code class="language-text">i = 0 and j = 5
 i = 1 and j = 6
@@ -314,9 +378,13 @@ <h4 id='on-ranges' class='section-header'><a href='#on-ranges'>On ranges:</a></h
 i = 4 and j = 9
 </code></pre>
 
-<p>Don&#39;t forget to add the parentheses around the range.</p>
+<!-- Don't forget to add the parentheses around the range. -->
 
-<h4 id='on-iterators' class='section-header'><a href='#on-iterators'>On iterators:</a></h4><span class='rusttest'>fn main() {
+<p>レンジを括弧で囲うのを忘れないで下さい。</p>
+
+<!-- #### On iterators: -->
+
+<h4 id='イテレータを対象に' class='section-header'><a href='#イテレータを対象に'>イテレータを対象に:</a></h4><span class='rusttest'>fn main() {
     let lines = &quot;hello\nworld&quot;.lines();
     for (linenumber, line) in lines.enumerate() {
         println!(&quot;{}: {}&quot;, linenumber, line);
@@ -326,16 +394,22 @@ <h4 id='on-iterators' class='section-header'><a href='#on-iterators'>On iterator
     <span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>&quot;{}: {}&quot;</span>, <span class='ident'>linenumber</span>, <span class='ident'>line</span>);
 }</pre>
 
-<p>Outputs:</p>
+<!-- Outputs: -->
+
+<p>出力:</p>
 
 <pre><code class="language-text">0: Content of line one
 1: Content of line two
 2: Content of line three
 3: Content of line four
 </code></pre>
 
-<h2 id='ending-iteration-early' class='section-header'><a href='#ending-iteration-early'>Ending iteration early</a></h2>
-<p>Let’s take a look at that <code>while</code> loop we had earlier:</p>
+<!-- ## Ending iteration early -->
+
+<h2 id='反復の早期終了' class='section-header'><a href='#反復の早期終了'>反復の早期終了</a></h2>
+<!-- Let’s take a look at that `while` loop we had earlier: -->
+
+<p>さきほどの <code>while</code> ループを見てみましょう:</p>
 <span class='rusttest'>fn main() {
     let mut x = 5;
     let mut done = false;
@@ -363,11 +437,18 @@ <h2 id='ending-iteration-early' class='section-header'><a href='#ending-iteratio
     }
 }</pre>
 
-<p>We had to keep a dedicated <code>mut</code> boolean variable binding, <code>done</code>, to know
-when we should exit out of the loop. Rust has two keywords to help us with
-modifying iteration: <code>break</code> and <code>continue</code>.</p>
+<!-- We had to keep a dedicated `mut` boolean variable binding, `done`, to know -->
+
+<!-- when we should exit out of the loop. Rust has two keywords to help us with -->
+
+<!-- modifying iteration: `break` and `continue`. -->
 
-<p>In this case, we can write the loop in a better way with <code>break</code>:</p>
+<p>ループをいつ終了すべきか知るため、ここでは専用の <code>mut</code> なboolean変数束縛 <code>done</code> を用いました。
+Rustには反復の変更を手伝う2つキーワード: <code>break</code> と <code>continue</code> があります。</p>
+
+<!-- In this case, we can write the loop in a better way with `break`: -->
+
+<p>この例では、 <code>break</code> を使ってループを記述した方が良いでしょう:</p>
 <span class='rusttest'>fn main() {
     let mut x = 5;
 
@@ -389,10 +470,17 @@ <h2 id='ending-iteration-early' class='section-header'><a href='#ending-iteratio
     <span class='kw'>if</span> <span class='ident'>x</span> <span class='op'>%</span> <span class='number'>5</span> <span class='op'>==</span> <span class='number'>0</span> { <span class='kw'>break</span>; }
 }</pre>
 
-<p>We now loop forever with <code>loop</code> and use <code>break</code> to break out early. Issuing an explicit <code>return</code> statement will also serve to terminate the loop early.</p>
+<!-- We now loop forever with `loop` and use `break` to break out early. Issuing an explicit `return` statement will also serve to terminate the loop early. -->
+
+<p>ここでは <code>loop</code> による永久ループと <code>break</code> による早期脱出を使っています。
+明示的な <code>return</code> 文の発行でもループの早期終了になります。</p>
+
+<!-- `continue` is similar, but instead of ending the loop, goes to the next -->
 
-<p><code>continue</code> is similar, but instead of ending the loop, goes to the next
-iteration. This will only print the odd numbers:</p>
+<!-- iteration. This will only print the odd numbers: -->
+
+<p><code>continue</code> も似ていますが、ループを終了させるのではなく、次の反復へと進めます。
+これは奇数だけを表示するでしょう:</p>
 <span class='rusttest'>fn main() {
     for x in 0..10 {
         if x % 2 == 0 { continue; }
@@ -406,27 +494,42 @@ <h2 id='ending-iteration-early' class='section-header'><a href='#ending-iteratio
     <span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>&quot;{}&quot;</span>, <span class='ident'>x</span>);
 }</pre>
 
-<h2 id='loop-labels' class='section-header'><a href='#loop-labels'>Loop labels</a></h2>
-<p>You may also encounter situations where you have nested loops and need to
-specify which one your <code>break</code> or <code>continue</code> statement is for. Like most
-other languages, by default a <code>break</code> or <code>continue</code> will apply to innermost
-loop. In a situation where you would like to a <code>break</code> or <code>continue</code> for one
-of the outer loops, you can use labels to specify which loop the <code>break</code> or
- <code>continue</code> statement applies to. This will only print when both <code>x</code> and <code>y</code> are
- odd:</p>
+<!-- ## Loop labels -->
+
+<h2 id='ループラベル' class='section-header'><a href='#ループラベル'>ループラベル</a></h2>
+<!-- You may also encounter situations where you have nested loops and need to -->
+
+<!-- specify which one your `break` or `continue` statement is for. Like most -->
+
+<!-- other languages, by default a `break` or `continue` will apply to innermost -->
+
+<!-- loop. In a situation where you would like to a `break` or `continue` for one -->
+
+<!-- of the outer loops, you can use labels to specify which loop the `break` or -->
+
+<!--  `continue` statement applies to. This will only print when both `x` and `y` are -->
+
+<!--  odd: -->
+
+<p>入れ子のループがあり、<code>break</code> や <code>continue</code> 文がどのループに対応するか指定する必要がある、
+そんな状況に出会うこともあるでしょう。大抵の他言語と同様に、 <code>break</code> や <code>continue</code> は最内ループに適用されるのがデフォルトです。
+外側のループに <code>break</code> や <code>continue</code> を使いたいという状況では、 <code>break</code> や <code>continue</code> 文の適用先を指定するラベルを使えます。
+これは <code>x</code> と <code>y</code> 両方が奇数のときだけ表示を行います:</p>
 <span class='rusttest'>fn main() {
     &#39;outer: for x in 0..10 {
         &#39;inner: for y in 0..10 {
-            if x % 2 == 0 { continue &#39;outer; } // continues the loop over x
-            if y % 2 == 0 { continue &#39;inner; } // continues the loop over y
+    //    if x % 2 == 0 { continue &#39;outer; } // continues the loop over x
+            if x % 2 == 0 { continue &#39;outer; } // x のループを継続
+    //    if y % 2 == 0 { continue &#39;inner; } // continues the loop over y
+            if y % 2 == 0 { continue &#39;inner; } // y のループを継続
             println!(&quot;x: {}, y: {}&quot;, x, y);
         }
     }
 }</span><pre class='rust rust-example-rendered'>
 <span class='lifetime'>&#39;outer</span>: <span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='number'>10</span> {
     <span class='lifetime'>&#39;inner</span>: <span class='kw'>for</span> <span class='ident'>y</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='number'>10</span> {
-        <span class='kw'>if</span> <span class='ident'>x</span> <span class='op'>%</span> <span class='number'>2</span> <span class='op'>==</span> <span class='number'>0</span> { <span class='kw'>continue</span> <span class='lifetime'>&#39;outer</span>; } <span class='comment'>// continues the loop over x</span>
-        <span class='kw'>if</span> <span class='ident'>y</span> <span class='op'>%</span> <span class='number'>2</span> <span class='op'>==</span> <span class='number'>0</span> { <span class='kw'>continue</span> <span class='lifetime'>&#39;inner</span>; } <span class='comment'>// continues the loop over y</span>
+        <span class='kw'>if</span> <span class='ident'>x</span> <span class='op'>%</span> <span class='number'>2</span> <span class='op'>==</span> <span class='number'>0</span> { <span class='kw'>continue</span> <span class='lifetime'>&#39;outer</span>; } <span class='comment'>// x のループを継続</span>
+        <span class='kw'>if</span> <span class='ident'>y</span> <span class='op'>%</span> <span class='number'>2</span> <span class='op'>==</span> <span class='number'>0</span> { <span class='kw'>continue</span> <span class='lifetime'>&#39;inner</span>; } <span class='comment'>// y のループを継続</span>
         <span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>&quot;x: {}, y: {}&quot;</span>, <span class='ident'>x</span>, <span class='ident'>y</span>);
     }
 }</pre>