mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2025-12-19 12:14:20 +08:00
rebuild
This commit is contained in:
chai2010
@@ -21,6 +21,10 @@
|
||||
<link rel="stylesheet" href="../gitbook/style.css">
|
||||
|
||||
|
||||
<link rel="stylesheet" href="../gitbook/plugins/gitbook-plugin-katex/katex.min.css">
|
||||
|
||||
|
||||
|
||||
<link rel="stylesheet" href="../gitbook/plugins/gitbook-plugin-highlight/website.css">
|
||||
|
||||
|
||||
@@ -44,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="3.1" data-chapter-title="整型" data-filepath="ch3/ch3-01.md" data-basepath=".." data-revision="Fri Dec 25 2015 12:32:44 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="3.1" data-chapter-title="整型" data-filepath="ch3/ch3-01.md" data-basepath=".." data-revision="Mon Dec 28 2015 16:03:52 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -238,7 +242,7 @@
|
||||
|
||||
<b>1.5.</b>
|
||||
|
||||
穫取URL
|
||||
獲取URL
|
||||
</a>
|
||||
|
||||
|
||||
@@ -253,7 +257,7 @@
|
||||
|
||||
<b>1.6.</b>
|
||||
|
||||
併發穫取多個URL
|
||||
併發獲取多個URL
|
||||
</a>
|
||||
|
||||
|
||||
@@ -802,7 +806,7 @@
|
||||
|
||||
<b>5.10.</b>
|
||||
|
||||
Recover捕穫異常
|
||||
Recover捕獲異常
|
||||
</a>
|
||||
|
||||
|
||||
@@ -1315,7 +1319,7 @@
|
||||
|
||||
<b>8.9.</b>
|
||||
|
||||
併發的退齣
|
||||
併發的退出
|
||||
</a>
|
||||
|
||||
|
||||
@@ -1834,7 +1838,7 @@
|
||||
|
||||
<b>12.7.</b>
|
||||
|
||||
穫取結構體字段標識
|
||||
獲取結構體字段標識
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2020,50 +2024,50 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="31-整型">3.1. 整型</h2>
|
||||
<p>Go語言的數值類型包括幾種不同大小的整形數, 浮點數, 和複數. 每種數值類型都決定了對應的大小范圍和是否有正負符號. 讓我們先從整形數類型開始介紹.</p>
|
||||
<p>Go同時提供了有符號和無符號的整數運算. 這里有四種int8, int16, int32 和 int64截然不同大小的有符號整形數類型, 分别對應 8, 16, 32, 64 bit 大小的有符號整形數, 與此對應的是 uint8, uint16, uint32, 和 uint64 四種無符號整形數類型.</p>
|
||||
<p>這里還有兩種對應特定平颱最天然或最有效率的大小有符號和無符號整數int和uint; 其中int是應用最廣泛的數值類型. 這兩種類型都有同樣的大小, 32 或 64 bit, 但是我們不能對此做任何的假設; 因爲不同的編譯器在相同的硬件平颱上可能産生不同的大小.</p>
|
||||
<p>字符rune類型是和int32等價的類型, 通常用於表示一個Unicode碼點. 這兩個名稱可以互換使用. 同樣byte也是uint8類型的等價類型, byte類型用於強調數值是一個原始的數據而不是一個小的整數.</p>
|
||||
<p>最好, 還有一個無符號的整數類型 uintptr, 沒有指定具體的bit大小但是足以容納指針. uintptr 類型隻有在底層編程是纔需要, 特别是Go語言和C函數庫或操作繫統相交互的地方. 我們將在第十三章的 unsafe 包相關部分看到類似的例子.</p>
|
||||
<p>不管它們的大小, int, uint, 和 uintptr 是不同類型大小的兄弟類型. 其中 int 和 int32 也是不同的類型, 卽使int的大小也是32bit, 在需要將int當作int32類型的地方需要一個顯式的類型轉換, 反之亦然.</p>
|
||||
<p>有符號數采用2的補碼形式表示, 也就是最高位用作符號位, 一個nbit的有符號數的值域是 <code>-2^(n-1)</code> 到 <code>(2^(n-1)) - 1</code>. 無符號整數的所有bit位都用於表示非負數, 值域是 0 到 <code>(2^n) - 1</code>. 例如, int8 的值域是 -128 到 127, 而 uint8 的值域是 0 到 255.</p>
|
||||
<p>下面是Go中關於算術, 邏輯和比較的二元運算符按照先級遞減的順序的列表:</p>
|
||||
<p>Go語言的數值類型包括幾種不同大小的整形數、浮點數和複數。每種數值類型都決定了對應的大小范圍和是否支持正負符號。讓我們先從整形數類型開始介紹。</p>
|
||||
<p>Go語言同時提供了有符號和無符號類型的整數運算。這里有int8、int16、int32和int64四種截然不同大小的有符號整形數類型，分别對應8、16、32、64bit大小的有符號整形數，與此對應的是uint8、uint16、uint32和uint64四種無符號整形數類型。</p>
|
||||
<p>這里還有兩種一般對應特定CPU平台機器字大小的有符號和無符號整數int和uint；其中int是應用最廣泛的數值類型。這兩種類型都有同樣的大小，32或64bit，但是我們不能對此做任何的假設；因爲不同的編譯器卽使在相同的硬件平台上可能産生不同的大小。</p>
|
||||
<p>Unicode字符rune類型是和int32等價的類型，通常用於表示一個Unicode碼點。這兩個名稱可以互換使用。同樣byte也是uint8類型的等價類型，byte類型一般用於強調數值是一個原始的數據而不是一個小的整數。</p>
|
||||
<p>最後，還有一種無符號的整數類型uintptr，沒有指定具體的bit大小但是足以容納指針。uintptr類型隻有在底層編程是才需要，特别是Go語言和C語言函數庫或操作繫統接口相交互的地方。我們將在第十三章的unsafe包相關部分看到類似的例子。</p>
|
||||
<p>不管它們的具體大小，int、uint和uintptr是不同類型的兄弟類型。其中int和int32也是不同的類型，卽使int的大小也是32bit，在需要將int當作int32類型的地方需要一個顯式的類型轉換操作，反之亦然。</p>
|
||||
<p>其中有符號整數采用2的補碼形式表示，也就是最高bit位用作表示符號位，一個n-bit的有符號數的值域是從<span class="katex"><span class="katex-mathml"><math><semantics><mrow><mo>−</mo><msup><mn>2</mn><mrow><mi>n</mi><mo>−</mo><mn>1</mn></mrow></msup></mrow><annotation encoding="application/x-tex">-2^{n-1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="strut" style="height:0.8141079999999999em;"></span><span class="strut bottom" style="height:0.897438em;vertical-align:-0.08333em;"></span><span class="base textstyle uncramped"><span class="mord">−</span><span class="mord"><span class="mord mathrm">2</span><span class="vlist"><span style="top:-0.363em;margin-right:0.05em;"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span><span class="reset-textstyle scriptstyle uncramped"><span class="mord scriptstyle uncramped"><span class="mord mathit">n</span><span class="mbin">−</span><span class="mord mathrm">1</span></span></span></span><span class="baseline-fix"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span>​</span></span></span></span></span></span>到<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mrow><mi>n</mi><mo>−</mo><mn>1</mn></mrow></msup><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2^{n-1}-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="strut" style="height:0.8141079999999999em;"></span><span class="strut bottom" style="height:0.897438em;vertical-align:-0.08333em;"></span><span class="base textstyle uncramped"><span class="mord"><span class="mord mathrm">2</span><span class="vlist"><span style="top:-0.363em;margin-right:0.05em;"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span><span class="reset-textstyle scriptstyle uncramped"><span class="mord scriptstyle uncramped"><span class="mord mathit">n</span><span class="mbin">−</span><span class="mord mathrm">1</span></span></span></span><span class="baseline-fix"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span>​</span></span></span><span class="mbin">−</span><span class="mord mathrm">1</span></span></span></span>。無符號整數的所有bit位都用於表示非負數，值域是0到<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mi>n</mi></msup><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2^n-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="strut" style="height:0.664392em;"></span><span class="strut bottom" style="height:0.747722em;vertical-align:-0.08333em;"></span><span class="base textstyle uncramped"><span class="mord"><span class="mord mathrm">2</span><span class="vlist"><span style="top:-0.363em;margin-right:0.05em;"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span><span class="reset-textstyle scriptstyle uncramped"><span class="mord mathit">n</span></span></span><span class="baseline-fix"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span>​</span></span></span><span class="mbin">−</span><span class="mord mathrm">1</span></span></span></span>。例如，int8類型整數的值域是從-128到127，而uint8類型整數的值域是從0到255。</p>
|
||||
<p>下面是Go語言中關於算術運算、邏輯運算和比較運算的二元運算符，它們按照先級遞減的順序的排列：</p>
|
||||
<pre><code>* / % << >> & &^
|
||||
+ - | ^
|
||||
== != < <= > >=
|
||||
&&
|
||||
||
|
||||
</code></pre><p>二元運算符有五種優先級. 在同一優先級, 使用左優先結合律, 使用括號可以明確優先順序, 括號也可以用於提陞優先級, 例如 <code>mask & (1 << 28)</code>.</p>
|
||||
<p>對於上表中前兩行的運算符, 例如 + 有一個相應的賦值結合運算符 +=, 可以用於簡化賦值語句.</p>
|
||||
<p>整數的算術運算符 +, -, *, 和 / 可以適用與整數, 浮點數和複數, 但是取模運算符 % 僅用於整數. 不同編程語言間, % 取模運算的行爲併不相同. 在Go語言中, % 取模運算符的符號和被取模數的符號總是一致的, 因此 <code>-5%3</code> 和 <code>-5%-3</code> 結果都是 -2.除法運算符 <code>/</code> 的行爲依賴於操作數是否爲整數, 因此 <code>5.0/4.0</code> 的結果是 1.25, 但是 5/4 的結果是 1, 因此整數除法會向着0方向截斷餘數.</p>
|
||||
<p>如果一個算術運算的結果, 不管是有符號或者是無符號的, 如果需要更多的bit位纔能表示, 就説明是溢齣了. 超齣的高位的bit位部分將被丟棄. 如果原始的數值是有符號類型, 那麽最終結果可能是負的, 如果最左邊的bit爲是1的話, 例如int8的例子:</p>
|
||||
</code></pre><p>二元運算符有五種優先級。在同一個優先級，使用左優先結合規則，但是使用括號可以明確優先順序，使用括號也可以用於提陞優先級，例如<code>mask & (1 << 28)</code>。</p>
|
||||
<p>對於上表中前兩行的運算符，例如+運算符還有一個與賦值相結合的對應運算符+=，可以用於簡化賦值語句。</p>
|
||||
<p>整數的算術運算符+、-、<code>*</code>和<code>/</code>可以適用與於整數、浮點數和複數，但是取模運算符%僅用於整數間的運算。對於不同編程語言，%取模運算的行爲可能併不相同。在Go語言中，%取模運算符的符號和被取模數的符號總是一致的，因此<code>-5%3</code>和<code>-5%-3</code>結果都是-2。除法運算符<code>/</code>的行爲則依賴於操作數是否爲全爲整數，比如<code>5.0/4.0</code>的結果是1.25，但是5/4的結果是1，因爲整數除法會向着0方向截斷餘數。</p>
|
||||
<p>如果一個算術運算的結果，不管是有符號或者是無符號的，如果需要更多的bit位才能正確表示的話，就説明計算結果是溢出了。超出的高位的bit位部分將被丟棄。如果原始的數值是有符號類型，而且最左邊的bit爲是1的話，那麽最終結果可能是負的，例如int8的例子：</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">var</span> u <span class="hljs-typename">uint8</span> = <span class="hljs-number">255</span>
|
||||
fmt.Println(u, u+<span class="hljs-number">1</span>, u*u) <span class="hljs-comment">// "255 0 1"</span>
|
||||
|
||||
<span class="hljs-keyword">var</span> i <span class="hljs-typename">int8</span> = <span class="hljs-number">127</span>
|
||||
fmt.Println(i, i+<span class="hljs-number">1</span>, i*i) <span class="hljs-comment">// "127 -128 1"</span>
|
||||
</code></pre>
|
||||
<p>兩個相同的整數類型可以使用下面的二元比較運算符進行比較; 比較表達式的結果是布爾類型.</p>
|
||||
<p>兩個相同的整數類型可以使用下面的二元比較運算符進行比較；比較表達式的結果是布爾類型。</p>
|
||||
<pre><code>== equal to
|
||||
!= not equal to
|
||||
< less than
|
||||
<= less than or equal to
|
||||
> greater than
|
||||
>= greater than or equal to
|
||||
</code></pre><p>事實上, 布爾型, 數字類型 和 字符串 等基本類型都是可比較的, 也就是説兩個相同類型的值可以用 == 和 != 進行比較. 此外, 整數, 浮點數和字符串可以根據比較結果排序. 許多其他類型的值是不可比較, 因此也就是不可排序的. 對於我們遇到的每種類型, 我們需要保證規則是類似的.</p>
|
||||
<p>這里是一元的加法和減法運算符:</p>
|
||||
</code></pre><p>事實上，布爾型、數字類型和字符串等基本類型都是可比較的，也就是説兩個相同類型的值可以用==和!=進行比較。此外，整數、浮點數和字符串可以根據比較結果排序。許多其它類型的值可能是不可比較的，因此也就可能是不可排序的。對於我們遇到的每種類型，我們需要保證規則的一致性。</p>
|
||||
<p>這里是一元的加法和減法運算符：</p>
|
||||
<pre><code>+ 一元加法 (無效果)
|
||||
- 負數
|
||||
</code></pre><p>對於整數, +x 是 0+x 的簡寫, -x 是 0-x 的簡寫; 對於浮點數和複數, +x 就是 x, -x 則是 x 的負數.</p>
|
||||
<p>Go語言還提供了以下的bit位操作運算符, 前面4個操作運算符併不區分是有符號還是無符號數:</p>
|
||||
</code></pre><p>對於整數，+x是0+x的簡寫，-x則是0-x的簡寫；對於浮點數和複數，+x就是x，-x則是x 的負數。</p>
|
||||
<p>Go語言還提供了以下的bit位操作運算符，前面4個操作運算符併不區分是有符號還是無符號數：</p>
|
||||
<pre><code>& 位運算 AND
|
||||
| 位運算 OR
|
||||
^ 位運算 XOR
|
||||
&^ 位清空 (AND NOT)
|
||||
<< 左移
|
||||
>> 右移
|
||||
</code></pre><p>位操作運算符 <code>^</code> 作爲二元運算符時是按位異或(XOR), 當用作一元運算符時表示按位取反; 也就是説, 它返迴一個每個bit位都取反的數. 位操作運算符 <code>&^</code> 用於按位置零(AND NOT): 表達式 <code>z = x &^ y</code> 結果z的bit位1, 如果對應y中bit位爲1, 否則對應的bit位等於x相應的bit位的值.</p>
|
||||
<p>下面的代碼演示了如何使用位操作解釋uint8類型值的8個獨立的bit位. 它使用了 Printf 函數的 %b 參數打印二進製格式的數字; 其中 %08b 中08表示打印至少8個數字, 不足的前綴用0填充.</p>
|
||||
</code></pre><p>位操作運算符<code>^</code>作爲二元運算符時是按位異或（XOR），當用作一元運算符時表示按位取反；也就是説，它返迴一個每個bit位都取反的數。位操作運算符<code>&^</code>用於按位置零（AND NOT）：表達式<code>z = x &^ y</code>結果z的bit位爲0，如果對應y中bit位爲1的話，否則對應的bit位等於x相應的bit位的值。</p>
|
||||
<p>下面的代碼演示了如何使用位操作解釋uint8類型值的8個獨立的bit位。它使用了Printf函數的%b參數打印二進製格式的數字；其中%08b中08表示打印至少8個字符寬度，不足的前綴部分用0填充。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">var</span> x <span class="hljs-typename">uint8</span> = <span class="hljs-number">1</span><<<span class="hljs-number">1</span> | <span class="hljs-number">1</span><<<span class="hljs-number">5</span>
|
||||
<span class="hljs-keyword">var</span> y <span class="hljs-typename">uint8</span> = <span class="hljs-number">1</span><<<span class="hljs-number">1</span> | <span class="hljs-number">1</span><<<span class="hljs-number">2</span>
|
||||
|
||||
@@ -2084,41 +2088,41 @@ fmt.Printf(<span class="hljs-string">"%08b\n"</span>, x&^y) <span
|
||||
fmt.Printf(<span class="hljs-string">"%08b\n"</span>, x<<<span class="hljs-number">1</span>) <span class="hljs-comment">// "01000100", the set {2, 6}</span>
|
||||
fmt.Printf(<span class="hljs-string">"%08b\n"</span>, x>><span class="hljs-number">1</span>) <span class="hljs-comment">// "00010001", the set {0, 4}</span>
|
||||
</code></pre>
|
||||
<p>(6.5節給齣了一個可以遠大於一個字節的整數集的實現.)</p>
|
||||
<p>在 x<<n 和="" x="">>n 移位運算中, 決定了移位操作bit數部分必鬚是無符號數; 被操作的 x 數可以是有符號或無符號數. 算術上, 一個 x<<n 左移運算等價於乘以="" 2^n,="" 一個="" x="">>n 右移運算等價於除以 2^n.</n></n></p>
|
||||
<p>左移運算用零填充右邊空缺的bit位, 無符號數的右移運算也是用0填充左邊空缺的bit位, 但是有符號數的右移運算會用符號位的值填充左邊空缺的bit位. 因爲這個原因, 最好用無符號運算, 這樣你可以將整數完全當作一個bit位模式處理.</p>
|
||||
<p>盡管Go提供了無符號數和運算, 卽使數值本身不可能齣現負數我們還是傾向於使用有符號的int類型, 就是數組的長度那樣, 雖然使用 uint 似乎是一個更合理的選擇. 事實上, 內置的 len 函數返迴一個有符號的int, 我們可以像下面這個逆序循環那樣處理.</p>
|
||||
<p>（6.5節給出了一個可以遠大於一個字節的整數集的實現。）</p>
|
||||
<p>在<code>x<<n</code>和<code>x>>n</code>移位運算中，決定了移位操作bit數部分必鬚是無符號數；被操作的x數可以是有符號或無符號數。算術上，一個<code>x<<n</code>左移運算等價於乘以<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mi>n</mi></msup></mrow><annotation encoding="application/x-tex">2^n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="strut" style="height:0.664392em;"></span><span class="strut bottom" style="height:0.664392em;vertical-align:0em;"></span><span class="base textstyle uncramped"><span class="mord"><span class="mord mathrm">2</span><span class="vlist"><span style="top:-0.363em;margin-right:0.05em;"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span><span class="reset-textstyle scriptstyle uncramped"><span class="mord mathit">n</span></span></span><span class="baseline-fix"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span>​</span></span></span></span></span></span>，一個<code>x>>n</code>右移運算等價於除以<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mi>n</mi></msup></mrow><annotation encoding="application/x-tex">2^n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="strut" style="height:0.664392em;"></span><span class="strut bottom" style="height:0.664392em;vertical-align:0em;"></span><span class="base textstyle uncramped"><span class="mord"><span class="mord mathrm">2</span><span class="vlist"><span style="top:-0.363em;margin-right:0.05em;"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span><span class="reset-textstyle scriptstyle uncramped"><span class="mord mathit">n</span></span></span><span class="baseline-fix"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span>​</span></span></span></span></span></span>。</p>
|
||||
<p>左移運算用零填充右邊空缺的bit位，無符號數的右移運算也是用0填充左邊空缺的bit位，但是有符號數的右移運算會用符號位的值填充左邊空缺的bit位。因爲這個原因，最好用無符號運算，這樣你可以將整數完全當作一個bit位模式處理。</p>
|
||||
<p>盡管Go語言提供了無符號數和運算，卽使數值本身不可能出現負數我們還是傾向於使用有符號的int類型，就像數組的長度那樣，雖然使用uint無符號類型似乎是一個更合理的選擇。事實上，內置的len函數返迴一個有符號的int，我們可以像下面例子那樣處理逆序循環。</p>
|
||||
<pre><code class="lang-Go">medals := []<span class="hljs-typename">string</span>{<span class="hljs-string">"gold"</span>, <span class="hljs-string">"silver"</span>, <span class="hljs-string">"bronze"</span>}
|
||||
<span class="hljs-keyword">for</span> i := <span class="hljs-built_in">len</span>(medals) - <span class="hljs-number">1</span>; i >= <span class="hljs-number">0</span>; i-- {
|
||||
fmt.Println(medals[i]) <span class="hljs-comment">// "bronze", "silver", "gold"</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>另一個選擇將是災難性的. 如果 len 返迴一個無符號數, 那麽 i 也將是無符號的 uint, 然後條件 i >= 0 則永遠爲眞. 在三次迭代之後, 也就是 i == 0 時, i-- 語句將不會産生 -1, 而是變成一個uint的最大值(可能是 2^64 - 1), 然後 medals[i] 表達式將發生運行時 panic 異常(§5.9), 也就是試圖訪問一個切片范圍以外的元素.</p>
|
||||
<p>齣於這個原因, 無符號數往往隻有在位運算或其它特殊的運算常見纔會使用, 就像 bit 集合, 分形二進製文件格式, 或者是哈希和加密操作等. 它們通常併不用於僅僅是表達非負數量的場合.</p>
|
||||
<p>一般來説, 需要一個顯式的轉換將一個值從一種類型轉化位另一種類型, 併且算術和邏輯運算的二元操作中必鬚是相同的類型. 雖然這偶爾會導致很長的表達式, 但是它消除了所有的類型相關的問題, 也使得程序容易理解.</p>
|
||||
<p>從其他類似場景下, 考慮下面這個代碼:</p>
|
||||
<p>另一個選擇對於上面的例子來説將是災難性的。如果len函數返迴一個無符號數，那麽i也將是無符號的uint類型，然後條件<code>i >= 0</code>則永遠爲眞。在三次迭代之後，也就是<code>i == 0</code>時，i--語句將不會産生-1，而是變成一個uint類型的最大值（可能是<span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mn>2</mn><mn>6</mn></msup><mn>4</mn><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2^64-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="strut" style="height:0.8141079999999999em;"></span><span class="strut bottom" style="height:0.897438em;vertical-align:-0.08333em;"></span><span class="base textstyle uncramped"><span class="mord"><span class="mord mathrm">2</span><span class="vlist"><span style="top:-0.363em;margin-right:0.05em;"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span><span class="reset-textstyle scriptstyle uncramped"><span class="mord mathrm">6</span></span></span><span class="baseline-fix"><span class="fontsize-ensurer reset-size5 size5"><span style="font-size:0em;">​</span></span>​</span></span></span><span class="mord mathrm">4</span><span class="mbin">−</span><span class="mord mathrm">1</span></span></span></span>），然後medals[i]表達式將發生運行時panic異常（§5.9），也就是試圖訪問一個slice范圍以外的元素。</p>
|
||||
<p>出於這個原因，無符號數往往隻有在位運算或其它特殊的運算場景才會使用，就像bit集合、分析二進製文件格式或者是哈希和加密操作等。它們通常併不用於僅僅是表達非負數量的場合。</p>
|
||||
<p>一般來説，需要一個顯式的轉換將一個值從一種類型轉化位另一種類型，併且算術和邏輯運算的二元操作中必鬚是相同的類型。雖然這偶爾會導致需要很長的表達式，但是它消除了所有和類型相關的問題，而且也使得程序容易理解。</p>
|
||||
<p>在很多場景，會遇到類似下面的代碼通用的錯誤：</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">var</span> apples <span class="hljs-typename">int32</span> = <span class="hljs-number">1</span>
|
||||
<span class="hljs-keyword">var</span> oranges <span class="hljs-typename">int16</span> = <span class="hljs-number">2</span>
|
||||
<span class="hljs-keyword">var</span> compote <span class="hljs-typename">int</span> = apples + oranges <span class="hljs-comment">// compile error</span>
|
||||
</code></pre>
|
||||
<p>當嚐試編譯這三個語句時, 將産生一個錯誤信息:</p>
|
||||
<p>當嚐試編譯這三個語句時，將産生一個錯誤信息：</p>
|
||||
<pre><code>invalid operation: apples + oranges (mismatched types int32 and int16)
|
||||
</code></pre><p>這種類型不匹配的問題可以有幾種不同的方法脩複, 最常見方法是將它們都顯式轉型位一個常見類型:</p>
|
||||
</code></pre><p>這種類型不匹配的問題可以有幾種不同的方法脩複，最常見方法是將它們都顯式轉型爲一個常見類型：</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">var</span> compote = <span class="hljs-typename">int</span>(apples) + <span class="hljs-typename">int</span>(oranges)
|
||||
</code></pre>
|
||||
<p>如2.5節所述, 對於每種類型T, 類型轉換操作T(x)將x轉換位T類型, 如果轉換允許的話. 許多 整形數之間的相互轉換併不會改變數值; 它們隻是告訴編譯器如何解釋這個值. 但是對於將一個大尺寸的整數類型轉位一個小尺寸的整數類型, 或者是將一個浮點數轉位整數, 可能會改變數值或丟失精度:</p>
|
||||
<p>如2.5節所述，對於每種類型T，如果轉換允許的話，類型轉換操作T(x)將x轉換爲T類型。許多整形數之間的相互轉換併不會改變數值；它們隻是告訴編譯器如何解釋這個值。但是對於將一個大尺寸的整數類型轉爲一個小尺寸的整數類型，或者是將一個浮點數轉爲整數，可能會改變數值或丟失精度：</p>
|
||||
<pre><code class="lang-Go">f := <span class="hljs-number">3.141</span> <span class="hljs-comment">// a float64</span>
|
||||
i := <span class="hljs-typename">int</span>(f)
|
||||
fmt.Println(f, i) <span class="hljs-comment">// "3.141 3"</span>
|
||||
f = <span class="hljs-number">1.99</span>
|
||||
fmt.Println(<span class="hljs-typename">int</span>(f)) <span class="hljs-comment">// "1"</span>
|
||||
</code></pre>
|
||||
<p>浮點數到整數的轉換將丟失任何小數部分, 向數軸零方向截斷. 你應該避免操作目標類型表示范圍的數值類型轉換, 因爲截斷的行爲依賴於具體的實現:</p>
|
||||
<p>浮點數到整數的轉換將丟失任何小數部分，然後向數軸零方向截斷。你應該避免對可能會超出目標類型表示范圍的數值類型轉換，因爲截斷的行爲可能依賴於具體的實現：</p>
|
||||
<pre><code class="lang-Go">f := <span class="hljs-number">1e100</span> <span class="hljs-comment">// a float64</span>
|
||||
i := <span class="hljs-typename">int</span>(f) <span class="hljs-comment">// 結果依賴於具體實現</span>
|
||||
</code></pre>
|
||||
<p>任何大小的整數字面值都可以用以0開始的八進製格式書寫, 例如 0666, 或用以0x或0X開頭的十六進製格式書寫, 例如 0xdeadbeef. 十六進製數字可以用大寫或小寫字母. 如今八進製數據通常用於POSIX操作繫統上的文件訪問權限標誌, 十六進製數字則更強調數字值的bit位模式.</p>
|
||||
<p>當使用 fmt 包打印一個數值時, 我們可以用 %d, %o, 或 %x 控製輸齣的進製格式, 就像下面的例子:</p>
|
||||
<p>任何大小的整數字面值都可以用以0開始的八進製格式書寫，例如0666；或用以0x或0X開頭的十六進製格式書寫，例如0xdeadbeef。十六進製數字可以用大寫或小寫字母。如今八進製數據通常用於POSIX操作繫統上的文件訪問權限標誌，十六進製數字則更強調數字值的bit位模式。</p>
|
||||
<p>當使用fmt包打印一個數值時，我們可以用%d、%o或%x參數控製輸出的進製格式，就像下面的例子：</p>
|
||||
<pre><code class="lang-Go">o := <span class="hljs-number">0666</span>
|
||||
fmt.Printf(<span class="hljs-string">"%d %[1]o %#[1]o\n"</span>, o) <span class="hljs-comment">// "438 666 0666"</span>
|
||||
x := <span class="hljs-typename">int64</span>(<span class="hljs-number">0xdeadbeef</span>)
|
||||
@@ -2126,14 +2130,14 @@ fmt.Printf(<span class="hljs-string">"%d %[1]x %#[1]x %#[1]X\n"</span>
|
||||
<span class="hljs-comment">// Output:</span>
|
||||
<span class="hljs-comment">// 3735928559 deadbeef 0xdeadbeef 0XDEADBEEF</span>
|
||||
</code></pre>
|
||||
<p>請註意 fmt 的兩個使用技巧. 通常 Printf 格式化字符串包含多個 % 參數時將對應相同數量的額外操作數, 但是 % 之後的 <code>[1]</code> 副詞告訴Printf函數再次使用第一個操作數. 第二, % 後的 <code>#</code> 副詞告訴 Printf 在用 %o, %x 或 %X 輸齣時生成 0, 0x 或 0X前綴.</p>
|
||||
<p>字符面值通過一對單引號直接包含對應字符. 最簡單的例子是 ASCII 中類似 'a' 字符面值, 但是我們可以通過轉義的數值來表示任意的Unicode碼點對應的字符, 馬上將會看到例子.</p>
|
||||
<p>字符使用 <code>%c</code> 參數打印, 或者是 <code>%q</code> 參數打印帶單引號的字符:</p>
|
||||
<p>請註意fmt的兩個使用技巧。通常Printf格式化字符串包含多個%參數時將會包含對應相同數量的額外操作數，但是%之後的<code>[1]</code>副詞告訴Printf函數再次使用第一個操作數。第二，%後的<code>#</code>副詞告訴Printf在用%o、%x或%X輸出時生成0、0x或0X前綴。</p>
|
||||
<p>字符面值通過一對單引號直接包含對應字符。最簡單的例子是ASCII中類似'a'寫法的字符面值，但是我們也可以通過轉義的數值來表示任意的Unicode碼點對應的字符，馬上將會看到這樣的例子。</p>
|
||||
<p>字符使用<code>%c</code>參數打印，或者是用<code>%q</code>參數打印帶單引號的字符：</p>
|
||||
<pre><code class="lang-Go">ascii := <span class="hljs-string">'a'</span>
|
||||
unicode := <span class="hljs-string">'國'</span>
|
||||
unicode := <span class="hljs-string">'国'</span>
|
||||
newline := <span class="hljs-string">'\n'</span>
|
||||
fmt.Printf(<span class="hljs-string">"%d %[1]c %[1]q\n"</span>, ascii) <span class="hljs-comment">// "97 a 'a'"</span>
|
||||
fmt.Printf(<span class="hljs-string">"%d %[1]c %[1]q\n"</span>, unicode) <span class="hljs-comment">// "22269 國 '國'"</span>
|
||||
fmt.Printf(<span class="hljs-string">"%d %[1]c %[1]q\n"</span>, unicode) <span class="hljs-comment">// "22269 国 '国'"</span>
|
||||
fmt.Printf(<span class="hljs-string">"%d %[1]q\n"</span>, newline) <span class="hljs-comment">// "10 '\n'"</span>
|
||||
</code></pre>
|
||||
|
||||
@@ -2167,7 +2171,7 @@ fmt.Printf(<span class="hljs-string">"%d %[1]q\n"</span>, newline)
|
||||
|
||||
<script>
|
||||
require(["gitbook"], function(gitbook) {
|
||||
var config = {"highlight":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2}};
|
||||
var config = {"katex":{},"highlight":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2}};
|
||||
gitbook.start(config);
|
||||
});
|
||||
</script>
|
||||
|
||||
Reference in New Issue
Block a user