ehlxr/gopl-zh.github.com
1
0
Fork 0
mirror of https://github.com/gopl-zh/gopl-zh.github.com.git synced 2026-09-26 06:46:16 +00:00
Code Issues Projects Releases Wiki Activity

回到简体

Browse Source
This commit is contained in:
chai2010
2016-02-15 11:06:34 +08:00
parent 9e878f9944
commit 2b37b23285
177 changed files with 2354 additions and 2354 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ch3/ch3-01.md
+42 -42
View File
@@ -1,20 +1,20 @@
## 3.1. 整型
Go語言的數值類型包括幾種不同大小的整形數、浮點數和複數。每種數值類型都決定了對應的大小范圍和是否支持正負符號。讓我們先從整形數類型開始介紹。
Go语言的数值类型包括几种不同大小的整形数、浮点数和复数。每种数值类型都决定了对应的大小范围和是否支持正负符号。让我们先从整形数类型开始介绍。
Go語言同時提供了有符號和無符號類型的整數運算。這里有int8、int16、int32和int64四種截然不同大小的有符號整形數類型，分别對應8、16、32、64bit大小的有符號整形數，與此對應的是uint8、uint16、uint32和uint64四種無符號整形數類型。
Go语言同时提供了有符号和无符号类型的整数运算。这里有int8、int16、int32和int64四种截然不同大小的有符号整形数类型，分别对应8、16、32、64bit大小的有符号整形数，与此对应的是uint8、uint16、uint32和uint64四种无符号整形数类型。
這里還有兩種一般對應特定CPU平台機器字大小的有符號和無符號整數int和uint；其中int是應用最廣泛的數值類型。這兩種類型都有同樣的大小，32或64bit，但是我們不能對此做任何的假設；因爲不同的編譯器卽使在相同的硬件平台上可能産生不同的大小。
这里还有两种一般对应特定CPU平台机器字大小的有符号和无符号整数int和uint；其中int是应用最广泛的数值类型。这两种类型都有同样的大小，32或64bit，但是我们不能对此做任何的假设；因为不同的编译器即使在相同的硬件平台上可能产生不同的大小。
Unicode字符rune類型是和int32等價的類型，通常用於表示一個Unicode碼點。這兩個名稱可以互換使用。同樣byte也是uint8類型的等價類型，byte類型一般用於強調數值是一個原始的數據而不是一個小的整數。
Unicode字符rune类型是和int32等价的类型，通常用于表示一个Unicode码点。这两个名称可以互换使用。同样byte也是uint8类型的等价类型，byte类型一般用于强调数值是一个原始的数据而不是一个小的整数。
最後，還有一種無符號的整數類型uintptr，沒有指定具體的bit大小但是足以容納指針。uintptr類型隻有在底層編程是才需要，特别是Go語言和C語言函數庫或操作繫統接口相交互的地方。我們將在第十三章的unsafe包相關部分看到類似的例子。
最后，还有一种无符号的整数类型uintptr，没有指定具体的bit大小但是足以容纳指针。uintptr类型只有在底层编程是才需要，特别是Go语言和C语言函数库或操作系统接口相交互的地方。我们将在第十三章的unsafe包相关部分看到类似的例子。
不管它們的具體大小，int、uint和uintptr是不同類型的兄弟類型。其中int和int32也是不同的類型，卽使int的大小也是32bit，在需要將int當作int32類型的地方需要一個顯式的類型轉換操作，反之亦然。
不管它们的具体大小，int、uint和uintptr是不同类型的兄弟类型。其中int和int32也是不同的类型，即使int的大小也是32bit，在需要将int当作int32类型的地方需要一个显式的类型转换操作，反之亦然。
其中有符號整數采用2的補碼形式表示，也就是最高bit位用作表示符號位，一個n-bit的有符號數的值域是從$$-2^{n-1}$$到$$2^{n-1}-1$$。無符號整數的所有bit位都用於表示非負數，值域是0到$$2^n-1$$。例如，int8類型整數的值域是從-128到127，而uint8類型整數的值域是從0到255。
其中有符号整数采用2的补码形式表示，也就是最高bit位用作表示符号位，一个n-bit的有符号数的值域是从$$-2^{n-1}$$到$$2^{n-1}-1$$。无符号整数的所有bit位都用于表示非负数，值域是0到$$2^n-1$$。例如，int8类型整数的值域是从-128到127，而uint8类型整数的值域是从0到255。
下面是Go語言中關於算術運算、邏輯運算和比較運算的二元運算符，它們按照先級遞減的順序的排列：
下面是Go语言中关于算术运算、逻辑运算和比较运算的二元运算符，它们按照先级递减的顺序的排列：
```
* / % << >> & &^
@@ -24,13 +24,13 @@ Unicode字符rune類型是和int32等價的類型，通常用於表示一個Unic
||
```
二元運算符有五種優先級。在同一個優先級，使用左優先結合規則，但是使用括號可以明確優先順序，使用括號也可以用於提陞優先級，例如`mask & (1 << 28)`。
二元运算符有五种优先级。在同一个优先级，使用左优先结合规则，但是使用括号可以明确优先顺序，使用括号也可以用于提升优先级，例如`mask & (1 << 28)`。
對於上表中前兩行的運算符，例如+運算符還有一個與賦值相結合的對應運算符+=，可以用於簡化賦值語句。
对于上表中前两行的运算符，例如+运算符还有一个与赋值相结合的对应运算符+=，可以用于简化赋值语句。
算術運算符+、-、`*`和`/`可以適用與於整數、浮點數和複數，但是取模運算符%僅用於整數間的運算。對於不同編程語言，%取模運算的行爲可能併不相同。在Go語言中，%取模運算符的符號和被取模數的符號總是一致的，因此`-5%3`和`-5%-3`結果都是-2。除法運算符`/`的行爲則依賴於操作數是否爲全爲整數，比如`5.0/4.0`的結果是1.25，但是5/4的結果是1，因爲整數除法會向着0方向截斷餘數。
算术运算符+、-、`*`和`/`可以适用与于整数、浮点数和复数，但是取模运算符%仅用于整数间的运算。对于不同编程语言，%取模运算的行为可能并不相同。在Go语言中，%取模运算符的符号和被取模数的符号总是一致的，因此`-5%3`和`-5%-3`结果都是-2。除法运算符`/`的行为则依赖于操作数是否为全为整数，比如`5.0/4.0`的结果是1.25，但是5/4的结果是1，因为整数除法会向着0方向截断余数。
如果一個算術運算的結果，不管是有符號或者是無符號的，如果需要更多的bit位才能正確表示的話，就説明計算結果是溢出了。超出的高位的bit位部分將被丟棄。如果原始的數值是有符號類型，而且最左邊的bit爲是1的話，那麽最終結果可能是負的，例如int8的例子：
如果一个算术运算的结果，不管是有符号或者是无符号的，如果需要更多的bit位才能正确表示的话，就说明计算结果是溢出了。超出的高位的bit位部分将被丢弃。如果原始的数值是有符号类型，而且最左边的bit为是1的话，那么最终结果可能是负的，例如int8的例子：
```Go
var u uint8 = 255
@@ -40,7 +40,7 @@ var i int8 = 127
fmt.Println(i, i+1, i*i) // "127 -128 1"
```
兩個相同的整數類型可以使用下面的二元比較運算符進行比較；比較表達式的結果是布爾類型。
两个相同的整数类型可以使用下面的二元比较运算符进行比较；比较表达式的结果是布尔类型。
```
== equal to
@@ -51,31 +51,31 @@ fmt.Println(i, i+1, i*i) // "127 -128 1"
>= greater than or equal to
```
事實上，布爾型、數字類型和字符串等基本類型都是可比較的，也就是説兩個相同類型的值可以用==和!=進行比較。此外，整數、浮點數和字符串可以根據比較結果排序。許多其它類型的值可能是不可比較的，因此也就可能是不可排序的。對於我們遇到的每種類型，我們需要保證規則的一致性。
事实上，布尔型、数字类型和字符串等基本类型都是可比较的，也就是说两个相同类型的值可以用==和!=进行比较。此外，整数、浮点数和字符串可以根据比较结果排序。许多其它类型的值可能是不可比较的，因此也就可能是不可排序的。对于我们遇到的每种类型，我们需要保证规则的一致性。
這里是一元的加法和減法運算符：
这里是一元的加法和减法运算符：
```
+ 一元加法 (無效果)
- 負數
+ 一元加法 (无效果)
- 负数
```
對於整數，+x是0+x的簡寫，-x則是0-x的簡寫；對於浮點數和複數，+x就是x，-x則是x 的負數。
对于整数，+x是0+x的简写，-x则是0-x的简写；对于浮点数和复数，+x就是x，-x则是x 的负数。
Go語言還提供了以下的bit位操作運算符，前面4個操作運算符併不區分是有符號還是無符號數：
Go语言还提供了以下的bit位操作运算符，前面4个操作运算符并不区分是有符号还是无符号数：
```
& 位運算 AND
| 位運算 OR
^ 位運算 XOR
& 位运算 AND
| 位运算 OR
^ 位运算 XOR
&^ 位清空 (AND NOT)
<< 左移
>> 右移
```
位操作運算符`^`作爲二元運算符時是按位異或（XOR），當用作一元運算符時表示按位取反；也就是説，它返迴一個每個bit位都取反的數。位操作運算符`&^`用於按位置零（AND NOT）：表達式`z = x &^ y`結果z的bit位爲0，如果對應y中bit位爲1的話，否則對應的bit位等於x相應的bit位的值。
位操作运算符`^`作为二元运算符时是按位异或（XOR），当用作一元运算符时表示按位取反；也就是说，它返回一个每个bit位都取反的数。位操作运算符`&^`用于按位置零（AND NOT）：表达式`z = x &^ y`结果z的bit位为0，如果对应y中bit位为1的话，否则对应的bit位等于x相应的bit位的值。
下面的代碼演示了如何使用位操作解釋uint8類型值的8個獨立的bit位。它使用了Printf函數的%b參數打印二進製格式的數字；其中%08b中08表示打印至少8個字符寬度，不足的前綴部分用0填充。
下面的代码演示了如何使用位操作解释uint8类型值的8个独立的bit位。它使用了Printf函数的%b参数打印二进制格式的数字；其中%08b中08表示打印至少8个字符宽度，不足的前缀部分用0填充。
```Go
var x uint8 = 1<<1 | 1<<5
@@ -99,13 +99,13 @@ fmt.Printf("%08b\n", x<<1) // "01000100", the set {2, 6}
fmt.Printf("%08b\n", x>>1) // "00010001", the set {0, 4}
```
（6.5節給出了一個可以遠大於一個字節的整數集的實現。）
（6.5节给出了一个可以远大于一个字节的整数集的实现。）
在`x<<n`和`x>>n`移位運算中，決定了移位操作bit數部分必須是無符號數；被操作的x數可以是有符號或無符號數。算術上，一個`x<<n`左移運算等價於乘以$$2^n$$，一個`x>>n`右移運算等價於除以$$2^n$$。
在`x<<n`和`x>>n`移位运算中，决定了移位操作bit数部分必须是无符号数；被操作的x数可以是有符号或无符号数。算术上，一个`x<<n`左移运算等价于乘以$$2^n$$，一个`x>>n`右移运算等价于除以$$2^n$$。
左移運算用零填充右邊空缺的bit位，無符號數的右移運算也是用0填充左邊空缺的bit位，但是有符號數的右移運算會用符號位的值填充左邊空缺的bit位。因爲這個原因，最好用無符號運算，這樣你可以將整數完全當作一個bit位模式處理。
左移运算用零填充右边空缺的bit位，无符号数的右移运算也是用0填充左边空缺的bit位，但是有符号数的右移运算会用符号位的值填充左边空缺的bit位。因为这个原因，最好用无符号运算，这样你可以将整数完全当作一个bit位模式处理。
盡管Go語言提供了無符號數和運算，卽使數值本身不可能出現負數我們還是傾向於使用有符號的int類型，就像數組的長度那樣，雖然使用uint無符號類型似乎是一個更合理的選擇。事實上，內置的len函數返迴一個有符號的int，我們可以像下面例子那樣處理逆序循環。
尽管Go语言提供了无符号数和运算，即使数值本身不可能出现负数我们还是倾向于使用有符号的int类型，就像数组的长度那样，虽然使用uint无符号类型似乎是一个更合理的选择。事实上，内置的len函数返回一个有符号的int，我们可以像下面例子那样处理逆序循环。
```Go
medals := []string{"gold", "silver", "bronze"}
@@ -114,13 +114,13 @@ for i := len(medals) - 1; i >= 0; i-- {
}
```
另一個選擇對於上面的例子來説將是災難性的。如果len函數返迴一個無符號數，那麽i也將是無符號的uint類型，然後條件`i >= 0`則永遠爲眞。在三次迭代之後，也就是`i == 0`時，i--語句將不會産生-1，而是變成一個uint類型的最大值（可能是$$2^64-1$$），然後medals[i]表達式將發生運行時panic異常（§5.9），也就是試圖訪問一個slice范圍以外的元素。
另一个选择对于上面的例子来说将是灾难性的。如果len函数返回一个无符号数，那么i也将是无符号的uint类型，然后条件`i >= 0`则永远为真。在三次迭代之后，也就是`i == 0`时，i--语句将不会产生-1，而是变成一个uint类型的最大值（可能是$$2^64-1$$），然后medals[i]表达式将发生运行时panic异常（§5.9），也就是试图访问一个slice范围以外的元素。
出於這個原因，無符號數往往隻有在位運算或其它特殊的運算場景才會使用，就像bit集合、分析二進製文件格式或者是哈希和加密操作等。它們通常併不用於僅僅是表達非負數量的場合。
出于这个原因，无符号数往往只有在位运算或其它特殊的运算场景才会使用，就像bit集合、分析二进制文件格式或者是哈希和加密操作等。它们通常并不用于仅仅是表达非负数量的场合。
一般來説，需要一個顯式的轉換將一個值從一種類型轉化位另一種類型，併且算術和邏輯運算的二元操作中必須是相同的類型。雖然這偶爾會導致需要很長的表達式，但是它消除了所有和類型相關的問題，而且也使得程序容易理解。
一般来说，需要一个显式的转换将一个值从一种类型转化位另一种类型，并且算术和逻辑运算的二元操作中必须是相同的类型。虽然这偶尔会导致需要很长的表达式，但是它消除了所有和类型相关的问题，而且也使得程序容易理解。
在很多場景，會遇到類似下面的代碼通用的錯誤：
在很多场景，会遇到类似下面的代码通用的错误：
```Go
var apples int32 = 1
@@ -128,19 +128,19 @@ var oranges int16 = 2
var compote int = apples + oranges // compile error
```
當嚐試編譯這三個語句時，將産生一個錯誤信息：
当尝试编译这三个语句时，将产生一个错误信息：
```
invalid operation: apples + oranges (mismatched types int32 and int16)
```
這種類型不匹配的問題可以有幾種不同的方法脩複，最常見方法是將它們都顯式轉型爲一個常見類型：
这种类型不匹配的问题可以有几种不同的方法修复，最常见方法是将它们都显式转型为一个常见类型：
```Go
var compote = int(apples) + int(oranges)
```
如2.5節所述，對於每種類型T，如果轉換允許的話，類型轉換操作T(x)將x轉換爲T類型。許多整形數之間的相互轉換併不會改變數值；它們隻是告訴編譯器如何解釋這個值。但是對於將一個大尺寸的整數類型轉爲一個小尺寸的整數類型，或者是將一個浮點數轉爲整數，可能會改變數值或丟失精度：
如2.5节所述，对于每种类型T，如果转换允许的话，类型转换操作T(x)将x转换为T类型。许多整形数之间的相互转换并不会改变数值；它们只是告诉编译器如何解释这个值。但是对于将一个大尺寸的整数类型转为一个小尺寸的整数类型，或者是将一个浮点数转为整数，可能会改变数值或丢失精度：
```Go
f := 3.141 // a float64
@@ -150,16 +150,16 @@ f = 1.99
fmt.Println(int(f)) // "1"
```
浮點數到整數的轉換將丟失任何小數部分，然後向數軸零方向截斷。你應該避免對可能會超出目標類型表示范圍的數值類型轉換，因爲截斷的行爲可能依賴於具體的實現：
浮点数到整数的转换将丢失任何小数部分，然后向数轴零方向截断。你应该避免对可能会超出目标类型表示范围的数值类型转换，因为截断的行为可能依赖于具体的实现：
```Go
f := 1e100 // a float64
i := int(f) // 結果依賴於具體實現
i := int(f) // 结果依赖于具体实现
```
任何大小的整數字面值都可以用以0開始的八進製格式書寫，例如0666；或用以0x或0X開頭的十六進製格式書寫，例如0xdeadbeef。十六進製數字可以用大寫或小寫字母。如今八進製數據通常用於POSIX操作繫統上的文件訪問權限標誌，十六進製數字則更強調數字值的bit位模式。
任何大小的整数字面值都可以用以0开始的八进制格式书写，例如0666；或用以0x或0X开头的十六进制格式书写，例如0xdeadbeef。十六进制数字可以用大写或小写字母。如今八进制数据通常用于POSIX操作系统上的文件访问权限标志，十六进制数字则更强调数字值的bit位模式。
當使用fmt包打印一個數值時，我們可以用%d、%o或%x參數控製輸出的進製格式，就像下面的例子：
当使用fmt包打印一个数值时，我们可以用%d、%o或%x参数控制输出的进制格式，就像下面的例子：
```Go
o := 0666
@@ -170,11 +170,11 @@ fmt.Printf("%d %[1]x %#[1]x %#[1]X\n", x)
// 3735928559 deadbeef 0xdeadbeef 0XDEADBEEF
```
請註意fmt的兩個使用技巧。通常Printf格式化字符串包含多個%參數時將會包含對應相同數量的額外操作數，但是%之後的`[1]`副詞告訴Printf函數再次使用第一個操作數。第二，%後的`#`副詞告訴Printf在用%o、%x或%X輸出時生成0、0x或0X前綴。
请注意fmt的两个使用技巧。通常Printf格式化字符串包含多个%参数时将会包含对应相同数量的额外操作数，但是%之后的`[1]`副词告诉Printf函数再次使用第一个操作数。第二，%后的`#`副词告诉Printf在用%o、%x或%X输出时生成0、0x或0X前缀。
字符面值通過一對單引號直接包含對應字符。最簡單的例子是ASCII中類似'a'寫法的字符面值，但是我們也可以通過轉義的數值來表示任意的Unicode碼點對應的字符，馬上將會看到這樣的例子。
字符面值通过一对单引号直接包含对应字符。最简单的例子是ASCII中类似'a'写法的字符面值，但是我们也可以通过转义的数值来表示任意的Unicode码点对应的字符，马上将会看到这样的例子。
字符使用`%c`參數打印，或者是用`%q`參數打印帶單引號的字符：
字符使用`%c`参数打印，或者是用`%q`参数打印带单引号的字符：
```Go
ascii := 'a'
ch3/ch3-02.md
+25 -25
View File
@@ -1,30 +1,30 @@
## 3.2. 浮點數
## 3.2. 浮点数
Go語言提供了兩種精度的浮點數，float32和float64。它們的算術規范由IEEE754浮點數国際標準定義，該浮點數規范被所有現代的CPU支持。
Go语言提供了两种精度的浮点数，float32和float64。它们的算术规范由IEEE754浮点数国际标准定义，该浮点数规范被所有现代的CPU支持。
這些浮點數類型的取值范圍可以從很微小到很鉅大。浮點數的范圍極限值可以在math包找到。常量math.MaxFloat32表示float32能表示的最大數值，大約是 3.4e38；對應的math.MaxFloat64常量大約是1.8e308。它們分别能表示的最小值近似爲1.4e-45和4.9e-324。
这些浮点数类型的取值范围可以从很微小到很巨大。浮点数的范围极限值可以在math包找到。常量math.MaxFloat32表示float32能表示的最大数值，大约是 3.4e38；对应的math.MaxFloat64常量大约是1.8e308。它们分别能表示的最小值近似为1.4e-45和4.9e-324。
一個float32類型的浮點數可以提供大約6個十進製數的精度，而float64則可以提供約15個十進製數的精度；通常應該優先使用float64類型，因爲float32類型的纍計計算誤差很容易擴散，併且float32能精確表示的正整數併不是很大（譯註：因爲float32的有效bit位隻有23個，其它的bit位用於指數和符號；當整數大於23bit能表達的范圍時，float32的表示將出現誤差）：
一个float32类型的浮点数可以提供大约6个十进制数的精度，而float64则可以提供约15个十进制数的精度；通常应该优先使用float64类型，因为float32类型的累计计算误差很容易扩散，并且float32能精确表示的正整数并不是很大（译注：因为float32的有效bit位只有23个，其它的bit位用于指数和符号；当整数大于23bit能表达的范围时，float32的表示将出现误差）：
```Go
var f float32 = 16777216 // 1 << 24
fmt.Println(f == f+1) // "true"!
```
浮點數的字面值可以直接寫小數部分，像這樣：
浮点数的字面值可以直接写小数部分，像这样：
```Go
const e = 2.71828 // (approximately)
```
小數點前面或後面的數字都可能被省略（例如.707或1.）。很小或很大的數最好用科學計數法書寫，通過e或E來指定指數部分：
小数点前面或后面的数字都可能被省略（例如.707或1.）。很小或很大的数最好用科学计数法书写，通过e或E来指定指数部分：
```Go
const Avogadro = 6.02214129e23 // 阿伏伽德羅常數
const Planck = 6.62606957e-34 // 普朗剋常數
const Avogadro = 6.02214129e23 // 阿伏伽德罗常数
const Planck = 6.62606957e-34 // 普朗克常数
```
用Printf函數的%g參數打印浮點數，將采用更緊湊的表示形式打印，併提供足夠的精度，但是對應表格的數據，使用%e（帶指數）或%f的形式打印可能更合適。所有的這三個打印形式都可以指定打印的寬度和控製打印精度。
用Printf函数的%g参数打印浮点数，将采用更紧凑的表示形式打印，并提供足够的精度，但是对应表格的数据，使用%e（带指数）或%f的形式打印可能更合适。所有的这三个打印形式都可以指定打印的宽度和控制打印精度。
```Go
for x := 0; x < 8; x++ {
@@ -32,7 +32,7 @@ for x := 0; x < 8; x++ {
}
```
上面代碼打印e的冪，打印精度是小數點後三個小數精度和8個字符寬度：
上面代码打印e的幂，打印精度是小数点后三个小数精度和8个字符宽度：
```
x = 0 e^x = 1.000
@@ -45,21 +45,21 @@ x = 6 e^x = 403.429
x = 7 e^x = 1096.633
```
math包中除了提供大量常用的數學函數外，還提供了IEEE754浮點數標準中定義的特殊值的創建和測試：正無窮大和負無窮大，分别用於表示太大溢出的數字和除零的結果；還有NaN非數，一般用於表示無效的除法操作結果0/0或Sqrt(-1).
math包中除了提供大量常用的数学函数外，还提供了IEEE754浮点数标准中定义的特殊值的创建和测试：正无穷大和负无穷大，分别用于表示太大溢出的数字和除零的结果；还有NaN非数，一般用于表示无效的除法操作结果0/0或Sqrt(-1).
```Go
var z float64
fmt.Println(z, -z, 1/z, -1/z, z/z) // "0 -0 +Inf -Inf NaN"
```
函數math.IsNaN用於測試一個數是否是非數NaN，math.NaN則返迴非數對應的值。雖然可以用math.NaN來表示一個非法的結果，但是測試一個結果是否是非數NaN則是充滿風險的，因爲NaN和任何數都是不相等的（譯註：在浮點數中，NaN、正無窮大和負無窮大都不是唯一的，每個都有非常多種的bit模式表示）：
函数math.IsNaN用于测试一个数是否是非数NaN，math.NaN则返回非数对应的值。虽然可以用math.NaN来表示一个非法的结果，但是测试一个结果是否是非数NaN则是充满风险的，因为NaN和任何数都是不相等的（译注：在浮点数中，NaN、正无穷大和负无穷大都不是唯一的，每个都有非常多种的bit模式表示）：
```Go
nan := math.NaN()
fmt.Println(nan == nan, nan < nan, nan > nan) // "false false false"
```
如果一個函數返迴的浮點數結果可能失敗，最好的做法是用單獨的標誌報告失敗，像這樣：
如果一个函数返回的浮点数结果可能失败，最好的做法是用单独的标志报告失败，像这样：
```Go
func compute() (value float64, ok bool) {
@@ -71,7 +71,7 @@ func compute() (value float64, ok bool) {
}
```
接下來的程序演示了通過浮點計算生成的圖形。它是帶有兩個參數的z = f(x, y)函數的三維形式，使用了可縮放矢量圖形（SVG）格式輸出，SVG是一個用於矢量線繪製的XML標準。圖3.1顯示了sin(r)/r函數的輸出圖形，其中r是sqrt(x*x+y*y)。
接下来的程序演示了通过浮点计算生成的图形。它是带有两个参数的z = f(x, y)函数的三维形式，使用了可缩放矢量图形（SVG）格式输出，SVG是一个用于矢量线绘制的XML标准。图3.1显示了sin(r)/r函数的输出图形，其中r是sqrt(x*x+y*y)。
![](../images/ch3-01.png)
@@ -133,30 +133,30 @@ func f(x, y float64) float64 {
}
```
要註意的是corner函數返迴了兩個結果，分别對應每個網格頂點的坐標參數。
要注意的是corner函数返回了两个结果，分别对应每个网格顶点的坐标参数。
要解釋這個程序是如何工作的需要一些基本的幾何學知識，但是我們可以跳過幾何學原理，因爲程序的重點是演示浮點數運算。程序的本質是三個不同的坐標繫中映射關繫，如圖3.2所示。第一個是100x100的二維網格，對應整數整數坐標(i,j)，從遠處的(0, 0)位置開始。我們從遠處向前面繪製，因此遠處先繪製的多邊形有可能被前面後繪製的多邊形覆蓋。
要解释这个程序是如何工作的需要一些基本的几何学知识，但是我们可以跳过几何学原理，因为程序的重点是演示浮点数运算。程序的本质是三个不同的坐标系中映射关系，如图3.2所示。第一个是100x100的二维网格，对应整数整数坐标(i,j)，从远处的(0, 0)位置开始。我们从远处向前面绘制，因此远处先绘制的多边形有可能被前面后绘制的多边形覆盖。
第二個坐標繫是一個三維的網格浮點坐標(x,y,z)，其中x和y是i和j的線性函數，通過平移轉換位網格單元的中心，然後用xyrange繫數縮放。高度z是函數f(x,y)的值。
第二个坐标系是一个三维的网格浮点坐标(x,y,z)，其中x和y是i和j的线性函数，通过平移转换位网格单元的中心，然后用xyrange系数缩放。高度z是函数f(x,y)的值。
第三個坐標繫是一個二維的畵布，起點(0,0)在左上角。畵布中點的坐標用(sx, sy)表示。我們使用等角投影將三維點
第三个坐标系是一个二维的画布，起点(0,0)在左上角。画布中点的坐标用(sx, sy)表示。我们使用等角投影将三维点
![](../images/ch3-02.png)
(x,y,z)投影到二維的畵布中。畵布中從遠處到右邊的點對應較大的x值和較大的y值。併且畵布中x和y值越大，則對應的z值越小。x和y的垂直和水平縮放繫數來自30度角的正絃和餘絃值。z的縮放繫數0.4，是一個任意選擇的參數。
(x,y,z)投影到二维的画布中。画布中从远处到右边的点对应较大的x值和较大的y值。并且画布中x和y值越大，则对应的z值越小。x和y的垂直和水平缩放系数来自30度角的正弦和余弦值。z的缩放系数0.4，是一个任意选择的参数。
對於二維網格中的每一個網格單元，main函數計算單元的四個頂點在畵布中對應多邊形ABCD的頂點，其中B對應(i,j)頂點位置，A、C和D是其它相鄰的頂點，然後輸出SVG的繪製指令。
对于二维网格中的每一个网格单元，main函数计算单元的四个顶点在画布中对应多边形ABCD的顶点，其中B对应(i,j)顶点位置，A、C和D是其它相邻的顶点，然后输出SVG的绘制指令。
**練習 3.1：** 如果f函數返迴的是無限製的float64值，那麽SVG文件可能輸出無效的<polygon>多邊形元素（雖然許多SVG渲染器會妥善處理這類問題）。脩改程序跳過無效的多邊形。
**练习 3.1：** 如果f函数返回的是无限制的float64值，那么SVG文件可能输出无效的<polygon>多边形元素（虽然许多SVG渲染器会妥善处理这类问题）。修改程序跳过无效的多边形。
**練習 3.2：** 試驗math包中其他函數的渲染圖形。你是否能輸出一個egg box、moguls或a saddle圖案?
**练习 3.2：** 试验math包中其他函数的渲染图形。你是否能输出一个egg box、moguls或a saddle图案?
**練習 3.3：** 根據高度給每個多邊形上色，那樣峯值部將是紅色(#ff0000)，谷部將是藍色(#0000ff)。
**练习 3.3：** 根据高度给每个多边形上色，那样峰值部将是红色(#ff0000)，谷部将是蓝色(#0000ff)。
**練習 3.4：** 參考1.7節Lissajous例子的函數，構造一個web服務器，用於計算函數麴面然後返迴SVG數據給客戶端。服務器必須設置Content-Type頭部：
**练习 3.4：** 参考1.7节Lissajous例子的函数，构造一个web服务器，用于计算函数曲面然后返回SVG数据给客户端。服务器必须设置Content-Type头部：
```Go
w.Header().Set("Content-Type", "image/svg+xml")
```
（這一步在Lissajous例子中不是必須的，因爲服務器使用標準的PNG圖像格式，可以根據前面的512個字節自動輸出對應的頭部。）允許客戶端通過HTTP請求參數設置高度、寬度和顔色等參數。
（这一步在Lissajous例子中不是必须的，因为服务器使用标准的PNG图像格式，可以根据前面的512个字节自动输出对应的头部。）允许客户端通过HTTP请求参数设置高度、宽度和颜色等参数。
ch3/ch3-03.md
+13 -13
View File
@@ -1,6 +1,6 @@
## 3.3. 複數
## 3.3. 复数
Go語言提供了兩種精度的複數類型：complex64和complex128，分别對應float32和float64兩種浮點數精度。內置的complex函數用於構建複數，內建的real和imag函數分别返迴複數的實部和虛部：
Go语言提供了两种精度的复数类型：complex64和complex128，分别对应float32和float64两种浮点数精度。内置的complex函数用于构建复数，内建的real和imag函数分别返回复数的实部和虚部：
```Go
var x complex128 = complex(1, 2) // 1+2i
@@ -10,28 +10,28 @@ fmt.Println(real(x*y)) // "-5"
fmt.Println(imag(x*y)) // "10"
```
如果一個浮點數面值或一個十進製整數面值後面跟着一個i，例如3.141592i或2i，它將構成一個複數的虛部，複數的實部是0：
如果一个浮点数面值或一个十进制整数面值后面跟着一个i，例如3.141592i或2i，它将构成一个复数的虚部，复数的实部是0：
```Go
fmt.Println(1i * 1i) // "(-1+0i)", i^2 = -1
```
在常量算術規則下，一個複數常量可以加到另一個普通數值常量（整數或浮點數、實部或虛部），我們可以用自然的方式書寫複數，就像1+2i或與之等價的寫法2i+1。上面x和y的聲明語句還可以簡化：
在常量算术规则下，一个复数常量可以加到另一个普通数值常量（整数或浮点数、实部或虚部），我们可以用自然的方式书写复数，就像1+2i或与之等价的写法2i+1。上面x和y的声明语句还可以简化：
```Go
x := 1 + 2i
y := 3 + 4i
```
複數也可以用==和!=進行相等比較。隻有兩個複數的實部和虛部都相等的時候它們才是相等的（譯註：浮點數的相等比較是危險的，需要特别小心處理精度問題）。
复数也可以用==和!=进行相等比较。只有两个复数的实部和虚部都相等的时候它们才是相等的（译注：浮点数的相等比较是危险的，需要特别小心处理精度问题）。
math/cmplx包提供了複數處理的許多函數，例如求複數的平方根函數和求冪函數。
math/cmplx包提供了复数处理的许多函数，例如求复数的平方根函数和求幂函数。
```Go
fmt.Println(cmplx.Sqrt(-1)) // "(0+1i)"
```
下面的程序使用complex128複數算法來生成一個Mandelbrot圖像。
下面的程序使用complex128复数算法来生成一个Mandelbrot图像。
<u><i>gopl.io/ch3/mandelbrot</i></u>
```Go
@@ -81,16 +81,16 @@ func mandelbrot(z complex128) color.Color {
}
```
用於遍歷1024x1024圖像每個點的兩個嵌套的循環對應-2到+2區間的複數平面。程序反複測試每個點對應複數值平方值加一個增量值對應的點是否超出半徑爲2的圓。如果超過了，通過根據預設置的逃逸迭代次數對應的灰度顔色來代替。如果不是，那麽該點屬於Mandelbrot集合，使用黑色顔色標記。最終程序將生成的PNG格式分形圖像圖像輸出到標準輸出，如圖3.3所示。
用于遍历1024x1024图像每个点的两个嵌套的循环对应-2到+2区间的复数平面。程序反复测试每个点对应复数值平方值加一个增量值对应的点是否超出半径为2的圆。如果超过了，通过根据预设置的逃逸迭代次数对应的灰度颜色来代替。如果不是，那么该点属于Mandelbrot集合，使用黑色颜色标记。最终程序将生成的PNG格式分形图像图像输出到标准输出，如图3.3所示。
![](../images/ch3-03.png)
**練習 3.5：** 實現一個綵色的Mandelbrot圖像，使用image.NewRGBA創建圖像，使用color.RGBA或color.YCbCr生成顔色。
**练习 3.5：** 实现一个彩色的Mandelbrot图像，使用image.NewRGBA创建图像，使用color.RGBA或color.YCbCr生成颜色。
**練習 3.6：** 陞采樣技術可以降低每個像素對計算顔色值和平均值的影響。簡單的方法是將每個像素分層四個子像素，實現它。
**练习 3.6：** 升采样技术可以降低每个像素对计算颜色值和平均值的影响。简单的方法是将每个像素分层四个子像素，实现它。
**練習 3.7：** 另一個生成分形圖像的方式是使用牛頓法來求解一個複數方程，例如$$z^4-1=0$$。每個起點到四個根的迭代次數對應陰影的灰度。方程根對應的點用顔色表示。
**练习 3.7：** 另一个生成分形图像的方式是使用牛顿法来求解一个复数方程，例如$$z^4-1=0$$。每个起点到四个根的迭代次数对应阴影的灰度。方程根对应的点用颜色表示。
**練習 3.8：** 通過提高精度來生成更多級别的分形。使用四種不同精度類型的數字實現相同的分形：complex64、complex128、big.Float和big.Rat。（後面兩種類型在math/big包聲明。Float是有指定限精度的浮點數；Rat是無效精度的有理數。）它們間的性能和內存使用對比如何？當渲染圖可見時縮放的級别是多少？
**练习 3.8：** 通过提高精度来生成更多级别的分形。使用四种不同精度类型的数字实现相同的分形：complex64、complex128、big.Float和big.Rat。（后面两种类型在math/big包声明。Float是有指定限精度的浮点数；Rat是无效精度的有理数。）它们间的性能和内存使用对比如何？当渲染图可见时缩放的级别是多少？
**練習 3.9：** 編寫一個web服務器，用於給客戶端生成分形的圖像。運行客戶端用過HTTP參數參數指定x,y和zoom參數。
**练习 3.9：** 编写一个web服务器，用于给客户端生成分形的图像。运行客户端用过HTTP参数参数指定x,y和zoom参数。
ch3/ch3-04.md
+8 -8
View File
@@ -1,16 +1,16 @@
## 3.4. 布爾型
## 3.4. 布尔型
一個布爾類型的值隻有兩種：true和false。if和for語句的條件部分都是布爾類型的值，併且==和<等比較操作也會産生布爾型的值。一元操作符`!`對應邏輯非操作，因此`!true`的值爲`false`，更羅嗦的説法是`(!true==false)==true`，雖然表達方式不一樣，不過我們一般會采用簡潔的布爾表達式，就像用x來表示`x==true`。
一个布尔类型的值只有两种：true和false。if和for语句的条件部分都是布尔类型的值，并且==和<等比较操作也会产生布尔型的值。一元操作符`!`对应逻辑非操作，因此`!true`的值为`false`，更罗嗦的说法是`(!true==false)==true`，虽然表达方式不一样，不过我们一般会采用简洁的布尔表达式，就像用x来表示`x==true`。
布爾值可以和&&（AND）和||（OR）操作符結合，併且可能會有短路行爲：如果運算符左邊值已經可以確定整個布爾表達式的值，那麽運算符右邊的值將不在被求值，因此下面的表達式總是安全的：
布尔值可以和&&（AND）和||（OR）操作符结合，并且可能会有短路行为：如果运算符左边值已经可以确定整个布尔表达式的值，那么运算符右边的值将不在被求值，因此下面的表达式总是安全的：
```Go
s != "" && s[0] == 'x'
```
其中s[0]操作如果應用於空字符串將會導致panic異常。
其中s[0]操作如果应用于空字符串将会导致panic异常。
因爲`&&`的優先級比`||`高（助記：`&&`對應邏輯乘法，`||`對應邏輯加法，乘法比加法優先級要高），下面形式的布爾表達式是不需要加小括弧的：
因为`&&`的优先级比`||`高（助记：`&&`对应逻辑乘法，`||`对应逻辑加法，乘法比加法优先级要高），下面形式的布尔表达式是不需要加小括弧的：
```Go
if 'a' <= c && c <= 'z' ||
@@ -20,7 +20,7 @@ if 'a' <= c && c <= 'z' ||
}
```
布爾值併不會隱式轉換爲數字值0或1，反之亦然。必須使用一個顯式的if語句輔助轉換：
布尔值并不会隐式转换为数字值0或1，反之亦然。必须使用一个显式的if语句辅助转换：
```Go
i := 0
@@ -29,7 +29,7 @@ if b {
}
```
如果需要經常做類似的轉換, 包裝成一個函數會更方便:
如果需要经常做类似的转换, 包装成一个函数会更方便:
```Go
// btoi returns 1 if b is true and 0 if false.
@@ -41,7 +41,7 @@ func btoi(b bool) int {
}
```
數字到布爾型的逆轉換則非常簡單, 不過爲了保持對稱, 我們也可以包裝一個函數:
数字到布尔型的逆转换则非常简单, 不过为了保持对称, 我们也可以包装一个函数:
```Go
// itob reports whether i is non-zero.
ch3/ch3-05-1.md
+15 -15
View File
@@ -1,6 +1,6 @@
### 3.5.1. 字符串面值
字符串值也可以用字符串面值方式編寫，隻要將一繫列字節序列包含在雙引號卽可：
字符串值也可以用字符串面值方式编写，只要将一系列字节序列包含在双引号即可：
```
"Hello, 世界"
@@ -8,28 +8,28 @@
![](../images/ch3-04.png)
因爲Go語言源文件總是用UTF8編碼，併且Go語言的文本字符串也以UTF8編碼的方式處理，因此我們可以將Unicode碼點也寫到字符串面值中。
因为Go语言源文件总是用UTF8编码，并且Go语言的文本字符串也以UTF8编码的方式处理，因此我们可以将Unicode码点也写到字符串面值中。
在一個雙引號包含的字符串面值中，可以用以反斜槓`\`開頭的轉義序列插入任意的數據。下面的換行、迴車和製表符等是常見的ASCII控製代碼的轉義方式：
在一个双引号包含的字符串面值中，可以用以反斜杠`\`开头的转义序列插入任意的数据。下面的换行、回车和制表符等是常见的ASCII控制代码的转义方式：
```
\a 響鈴
\a 响铃
\b 退格
\f 換頁
\n 換行
\r 迴車
\t 製表符
\v 垂直製表符
\' 單引號 (隻用在 '\'' 形式的rune符號面值中)
\" 雙引號 (隻用在 "..." 形式的字符串面值中)
\\ 反斜槓
\f 换页
\n 换行
\r 回车
\t 制表符
\v 垂直制表符
\' 单引号 (只用在 '\'' 形式的rune符号面值中)
\" 双引号 (只用在 "..." 形式的字符串面值中)
\\ 反斜杠
```
可以通過十六進製或八進製轉義在字符串面值包含任意的字節。一個十六進製的轉義形式是\xhh，其中兩個h表示十六進製數字（大寫或小寫都可以）。一個八進製轉義形式是\ooo，包含三個八進製的o數字（0到7），但是不能超過`\377`（譯註：對應一個字節的范圍，十進製爲255）。每一個單一的字節表達一個特定的值。稍後我們將看到如何將一個Unicode碼點寫到字符串面值中。
可以通过十六进制或八进制转义在字符串面值包含任意的字节。一个十六进制的转义形式是\xhh，其中两个h表示十六进制数字（大写或小写都可以）。一个八进制转义形式是\ooo，包含三个八进制的o数字（0到7），但是不能超过`\377`（译注：对应一个字节的范围，十进制为255）。每一个单一的字节表达一个特定的值。稍后我们将看到如何将一个Unicode码点写到字符串面值中。
一個原生的字符串面值形式是`...`，使用反引號```代替雙引號。在原生的字符串面值中，沒有轉義操作；全部的內容都是字面的意思，包含退格和換行，因此一個程序中的原生字符串面值可能跨越多行（譯註：在原生字符串面值內部是無法直接寫```字符的，可以用八進製或十六進製轉義或+"```"鏈接字符串常量完成）。唯一的特殊處理是會刪除迴車以保證在所有平台上的值都是一樣的，包括那些把迴車也放入文本文件的繫統（譯註：Windows繫統會把迴車和換行一起放入文本文件中）。
一个原生的字符串面值形式是`...`，使用反引号```代替双引号。在原生的字符串面值中，没有转义操作；全部的内容都是字面的意思，包含退格和换行，因此一个程序中的原生字符串面值可能跨越多行（译注：在原生字符串面值内部是无法直接写```字符的，可以用八进制或十六进制转义或+"```"链接字符串常量完成）。唯一的特殊处理是会删除回车以保证在所有平台上的值都是一样的，包括那些把回车也放入文本文件的系统（译注：Windows系统会把回车和换行一起放入文本文件中）。
原生字符串面值用於編寫正則表達式會很方便，因爲正則表達式往往會包含很多反斜槓。原生字符串面值同時被廣泛應用於HTML模闆、JSON面值、命令行提示信息以及那些需要擴展到多行的場景。
原生字符串面值用于编写正则表达式会很方便，因为正则表达式往往会包含很多反斜杠。原生字符串面值同时被广泛应用于HTML模板、JSON面值、命令行提示信息以及那些需要扩展到多行的场景。
```Go
const GoUsage = `Go is a tool for managing Go source code.
ch3/ch3-05-2.md
+4 -4
View File
@@ -1,12 +1,12 @@
### 3.5.2. Unicode
在很久以前，世界還是比較簡單的，起碼計算機世界就隻有一個ASCII字符集：美国信息交換標準代碼。ASCII，更準確地説是美国的ASCII，使用7bit來表示128個字符：包含英文字母的大小寫、數字、各種標點符號和設置控製符。對於早期的計算機程序來説，這些就足夠了，但是這也導致了世界上很多其他地區的用戶無法直接使用自己的符號繫統。隨着互聯網的發展，混合多種語言的數據變得很常見（譯註：比如本身的英文原文或中文翻譯都包含了ASCII、中文、日文等多種語言字符）。如何有效處理這些包含了各種語言的豐富多樣的文本數據呢？
在很久以前，世界还是比较简单的，起码计算机世界就只有一个ASCII字符集：美国信息交换标准代码。ASCII，更准确地说是美国的ASCII，使用7bit来表示128个字符：包含英文字母的大小写、数字、各种标点符号和设置控制符。对于早期的计算机程序来说，这些就足够了，但是这也导致了世界上很多其他地区的用户无法直接使用自己的符号系统。随着互联网的发展，混合多种语言的数据变得很常见（译注：比如本身的英文原文或中文翻译都包含了ASCII、中文、日文等多种语言字符）。如何有效处理这些包含了各种语言的丰富多样的文本数据呢？
答案就是使用Unicode（ http://unicode.org ），它收集了這個世界上所有的符號繫統，包括重音符號和其它變音符號，製表符和迴車符，還有很多神祕的符號，每個符號都分配一個唯一的Unicode碼點，Unicode碼點對應Go語言中的rune整數類型（譯註：rune是int32等價類型）。
答案就是使用Unicode（ http://unicode.org ），它收集了这个世界上所有的符号系统，包括重音符号和其它变音符号，制表符和回车符，还有很多神秘的符号，每个符号都分配一个唯一的Unicode码点，Unicode码点对应Go语言中的rune整数类型（译注：rune是int32等价类型）。
在第八版本的Unicode標準收集了超過120,000個字符，涵蓋超過100多種語言。這些在計算機程序和數據中是如何體現的呢？通用的表示一個Unicode碼點的數據類型是int32，也就是Go語言中rune對應的類型；它的同義詞rune符文正是這個意思。
在第八版本的Unicode标准收集了超过120,000个字符，涵盖超过100多种语言。这些在计算机程序和数据中是如何体现的呢？通用的表示一个Unicode码点的数据类型是int32，也就是Go语言中rune对应的类型；它的同义词rune符文正是这个意思。
我們可以將一個符文序列表示爲一個int32序列。這種編碼方式叫UTF-32或UCS-4，每個Unicode碼點都使用同樣的大小32bit來表示。這種方式比較簡單統一，但是它會浪費很多存儲空間，因爲大數據計算機可讀的文本是ASCII字符，本來每個ASCII字符隻需要8bit或1字節就能表示。而且卽使是常用的字符也遠少於65,536個，也就是説用16bit編碼方式就能表達常用字符。但是，還有其它更好的編碼方法嗎？
我们可以将一个符文序列表示为一个int32序列。这种编码方式叫UTF-32或UCS-4，每个Unicode码点都使用同样的大小32bit来表示。这种方式比较简单统一，但是它会浪费很多存储空间，因为大数据计算机可读的文本是ASCII字符，本来每个ASCII字符只需要8bit或1字节就能表示。而且即使是常用的字符也远少于65,536个，也就是说用16bit编码方式就能表达常用字符。但是，还有其它更好的编码方法吗？
ch3/ch3-05-3.md
+25 -25
View File
@@ -1,6 +1,6 @@
### 3.5.3. UTF-8
UTF8是一個將Unicode碼點編碼爲字節序列的變長編碼。UTF8編碼由Go語言之父Ken Thompson和Rob Pike共同發明的，現在已經是Unicode的標準。UTF8編碼使用1到4個字節來表示每個Unicode碼點，ASCII部分字符隻使用1個字節，常用字符部分使用2或3個字節表示。每個符號編碼後第一個字節的高端bit位用於表示總共有多少編碼個字節。如果第一個字節的高端bit爲0，則表示對應7bit的ASCII字符，ASCII字符每個字符依然是一個字節，和傳統的ASCII編碼兼容。如果第一個字節的高端bit是110，則説明需要2個字節；後續的每個高端bit都以10開頭。更大的Unicode碼點也是采用類似的策略處理。
UTF8是一个将Unicode码点编码为字节序列的变长编码。UTF8编码由Go语言之父Ken Thompson和Rob Pike共同发明的，现在已经是Unicode的标准。UTF8编码使用1到4个字节来表示每个Unicode码点，ASCII部分字符只使用1个字节，常用字符部分使用2或3个字节表示。每个符号编码后第一个字节的高端bit位用于表示总共有多少编码个字节。如果第一个字节的高端bit为0，则表示对应7bit的ASCII字符，ASCII字符每个字符依然是一个字节，和传统的ASCII编码兼容。如果第一个字节的高端bit是110，则说明需要2个字节；后续的每个高端bit都以10开头。更大的Unicode码点也是采用类似的策略处理。
```
0xxxxxxx runes 0-127 (ASCII)
@@ -9,11 +9,11 @@ UTF8是一個將Unicode碼點編碼爲字節序列的變長編碼。UTF8編碼
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 65536-0x10ffff (other values unused)
```
變長的編碼無法直接通過索引來訪問第n個字符，但是UTF8編碼獲得了很多額外的優點。首先UTF8編碼比較緊湊，完全兼容ASCII碼，併且可以自動同步：它可以通過向前迴朔最多2個字節就能確定當前字符編碼的開始字節的位置。它也是一個前綴編碼，所以當從左向右解碼時不會有任何歧義也併不需要向前査看（譯註：像GBK之類的編碼，如果不知道起點位置則可能會出現歧義）。沒有任何字符的編碼是其它字符編碼的子串，或是其它編碼序列的字串，因此蒐索一個字符時隻要蒐索它的字節編碼序列卽可，不用擔心前後的上下文會對蒐索結果産生榦擾。同時UTF8編碼的順序和Unicode碼點的順序一致，因此可以直接排序UTF8編碼序列。同時因爲沒有嵌入的NUL(0)字節，可以很好地兼容那些使用NUL作爲字符串結尾的編程語言。
变长的编码无法直接通过索引来访问第n个字符，但是UTF8编码获得了很多额外的优点。首先UTF8编码比较紧凑，完全兼容ASCII码，并且可以自动同步：它可以通过向前回朔最多2个字节就能确定当前字符编码的开始字节的位置。它也是一个前缀编码，所以当从左向右解码时不会有任何歧义也并不需要向前查看（译注：像GBK之类的编码，如果不知道起点位置则可能会出现歧义）。没有任何字符的编码是其它字符编码的子串，或是其它编码序列的字串，因此搜索一个字符时只要搜索它的字节编码序列即可，不用担心前后的上下文会对搜索结果产生干扰。同时UTF8编码的顺序和Unicode码点的顺序一致，因此可以直接排序UTF8编码序列。同时因为没有嵌入的NUL(0)字节，可以很好地兼容那些使用NUL作为字符串结尾的编程语言。
Go語言的源文件采用UTF8編碼，併且Go語言處理UTF8編碼的文本也很出色。unicode包提供了諸多處理rune字符相關功能的函數（比如區分字母和數組，或者是字母的大寫和小寫轉換等），unicode/utf8包則提供了用於rune字符序列的UTF8編碼和解碼的功能。
Go语言的源文件采用UTF8编码，并且Go语言处理UTF8编码的文本也很出色。unicode包提供了诸多处理rune字符相关功能的函数（比如区分字母和数组，或者是字母的大写和小写转换等），unicode/utf8包则提供了用于rune字符序列的UTF8编码和解码的功能。
有很多Unicode字符很難直接從鍵盤輸入，併且還有很多字符有着相似的結構；有一些甚至是不可見的字符（譯註：中文和日文就有很多相似但不同的字）。Go語言字符串面值中的Unicode轉義字符讓我們可以通過Unicode碼點輸入特殊的字符。有兩種形式：\uhhhh對應16bit的碼點值，\Uhhhhhhhh對應32bit的碼點值，其中h是一個十六進製數字；一般很少需要使用32bit的形式。每一個對應碼點的UTF8編碼。例如：下面的字母串面值都表示相同的值：
有很多Unicode字符很难直接从键盘输入，并且还有很多字符有着相似的结构；有一些甚至是不可见的字符（译注：中文和日文就有很多相似但不同的字）。Go语言字符串面值中的Unicode转义字符让我们可以通过Unicode码点输入特殊的字符。有两种形式：\uhhhh对应16bit的码点值，\Uhhhhhhhh对应32bit的码点值，其中h是一个十六进制数字；一般很少需要使用32bit的形式。每一个对应码点的UTF8编码。例如：下面的字母串面值都表示相同的值：
```
"世界"
@@ -22,17 +22,17 @@ Go語言的源文件采用UTF8編碼，併且Go語言處理UTF8編碼的文本
"\U00004e16\U0000754c"
```
上面三個轉義序列都爲第一個字符串提供替代寫法，但是它們的值都是相同的。
上面三个转义序列都为第一个字符串提供替代写法，但是它们的值都是相同的。
Unicode轉義也可以使用在rune字符中。下面三個字符是等價的：
Unicode转义也可以使用在rune字符中。下面三个字符是等价的：
```
'世' '\u4e16' '\U00004e16'
```
對於小於256碼點值可以寫在一個十六進製轉義字節中，例如'\x41'對應字符'A'，但是對於更大的碼點則必須使用\u或\U轉義形式。因此，'\xe4\xb8\x96'併不是一個合法的rune字符，雖然這三個字節對應一個有效的UTF8編碼的碼點。
对于小于256码点值可以写在一个十六进制转义字节中，例如'\x41'对应字符'A'，但是对于更大的码点则必须使用\u或\U转义形式。因此，'\xe4\xb8\x96'并不是一个合法的rune字符，虽然这三个字节对应一个有效的UTF8编码的码点。
得益於UTF8編碼優良的設計，諸多字符串操作都不需要解碼操作。我們可以不用解碼直接測試一個字符串是否是另一個字符串的前綴：
得益于UTF8编码优良的设计，诸多字符串操作都不需要解码操作。我们可以不用解码直接测试一个字符串是否是另一个字符串的前缀：
```Go
func HasPrefix(s, prefix string) bool {
@@ -40,7 +40,7 @@ func HasPrefix(s, prefix string) bool {
}
```
或者是後綴測試：
或者是后缀测试：
```Go
func HasSuffix(s, suffix string) bool {
@@ -48,7 +48,7 @@ func HasSuffix(s, suffix string) bool {
}
```
或者是包含子串測試：
或者是包含子串测试：
```Go
func Contains(s, substr string) bool {
@@ -61,9 +61,9 @@ func Contains(s, substr string) bool {
}
```
對於UTF8編碼後文本的處理和原始的字節處理邏輯是一樣的。但是對應很多其它編碼則併不是這樣的。（上面的函數都來自strings字符串處理包，眞實的代碼包含了一個用哈希技術優化的Contains 實現。）
对于UTF8编码后文本的处理和原始的字节处理逻辑是一样的。但是对应很多其它编码则并不是这样的。（上面的函数都来自strings字符串处理包，真实的代码包含了一个用哈希技术优化的Contains 实现。）
另一方面，如果我們眞的關心每個Unicode字符，我們可以使用其它處理方式。考慮前面的第一個例子中的字符串，它包混合了中西兩種字符。圖3.5展示了它的內存表示形式。字符串包含13個字節，以UTF8形式編碼，但是隻對應9個Unicode字符：
另一方面，如果我们真的关心每个Unicode字符，我们可以使用其它处理方式。考虑前面的第一个例子中的字符串，它包混合了中西两种字符。图3.5展示了它的内存表示形式。字符串包含13个字节，以UTF8形式编码，但是只对应9个Unicode字符：
```Go
import "unicode/utf8"
@@ -73,7 +73,7 @@ fmt.Println(len(s)) // "13"
fmt.Println(utf8.RuneCountInString(s)) // "9"
```
爲了處理這些眞實的字符，我們需要一個UTF8解碼器。unicode/utf8包提供了該功能，我們可以這樣使用：
为了处理这些真实的字符，我们需要一个UTF8解码器。unicode/utf8包提供了该功能，我们可以这样使用：
```Go
for i := 0; i < len(s); {
@@ -83,7 +83,7 @@ for i := 0; i < len(s); {
}
```
每一次調用DecodeRuneInString函數都返迴一個r和長度，r對應字符本身，長度對應r采用UTF8編碼後的編碼字節數目。長度可以用於更新第i個字符在字符串中的字節索引位置。但是這種編碼方式是笨拙的，我們需要更簡潔的語法。幸運的是，Go語言的range循環在處理字符串的時候，會自動隱式解碼UTF8字符串。下面的循環運行如圖3.5所示；需要註意的是對於非ASCII，索引更新的步長將超過1個字節。
每一次调用DecodeRuneInString函数都返回一个r和长度，r对应字符本身，长度对应r采用UTF8编码后的编码字节数目。长度可以用于更新第i个字符在字符串中的字节索引位置。但是这种编码方式是笨拙的，我们需要更简洁的语法。幸运的是，Go语言的range循环在处理字符串的时候，会自动隐式解码UTF8字符串。下面的循环运行如图3.5所示；需要注意的是对于非ASCII，索引更新的步长将超过1个字节。
![](../images/ch3-05.png)
@@ -93,7 +93,7 @@ for i, r := range "Hello, 世界" {
}
```
我們可以使用一個簡單的循環來統計字符串中字符的數目，像這樣：
我们可以使用一个简单的循环来统计字符串中字符的数目，像这样：
```Go
n := 0
@@ -102,7 +102,7 @@ for _, _ = range s {
}
```
像其它形式的循環那樣，我們也可以忽略不需要的變量：
像其它形式的循环那样，我们也可以忽略不需要的变量：
```Go
n := 0
@@ -111,15 +111,15 @@ for range s {
}
```
或者我們可以直接調用utf8.RuneCountInString(s)函數。
或者我们可以直接调用utf8.RuneCountInString(s)函数。
正如我們前面提到的，文本字符串采用UTF8編碼隻是一種慣例，但是對於循環的眞正字符串併不是一個慣例，這是正確的。如果用於循環的字符串隻是一個普通的二進製數據，或者是含有錯誤編碼的UTF8數據，將會發送什麽呢？
正如我们前面提到的，文本字符串采用UTF8编码只是一种惯例，但是对于循环的真正字符串并不是一个惯例，这是正确的。如果用于循环的字符串只是一个普通的二进制数据，或者是含有错误编码的UTF8数据，将会发送什么呢？
每一個UTF8字符解碼，不管是顯式地調用utf8.DecodeRuneInString解碼或是在range循環中隱式地解碼，如果遇到一個錯誤的UTF8編碼輸入，將生成一個特别的Unicode字符'\uFFFD'，在印刷中這個符號通常是一個黑色六角或鑽石形狀，里面包含一個白色的問號"�"。當程序遇到這樣的一個字符，通常是一個危險信號，説明輸入併不是一個完美沒有錯誤的UTF8字符串。
每一个UTF8字符解码，不管是显式地调用utf8.DecodeRuneInString解码或是在range循环中隐式地解码，如果遇到一个错误的UTF8编码输入，将生成一个特别的Unicode字符'\uFFFD'，在印刷中这个符号通常是一个黑色六角或钻石形状，里面包含一个白色的问号"�"。当程序遇到这样的一个字符，通常是一个危险信号，说明输入并不是一个完美没有错误的UTF8字符串。
UTF8字符串作爲交換格式是非常方便的，但是在程序內部采用rune序列可能更方便，因爲rune大小一致，支持數組索引和方便切割。
UTF8字符串作为交换格式是非常方便的，但是在程序内部采用rune序列可能更方便，因为rune大小一致，支持数组索引和方便切割。
string接受到[]rune的類型轉換，可以將一個UTF8編碼的字符串解碼爲Unicode字符序列：
string接受到[]rune的类型转换，可以将一个UTF8编码的字符串解码为Unicode字符序列：
```Go
// "program" in Japanese katakana
@@ -129,22 +129,22 @@ r := []rune(s)
fmt.Printf("%x\n", r) // "[30d7 30ed 30b0 30e9 30e0]"
```
（在第一個Printf中的`% x`參數用於在每個十六進製數字前插入一個空格。）
（在第一个Printf中的`% x`参数用于在每个十六进制数字前插入一个空格。）
如果是將一個[]rune類型的Unicode字符slice或數組轉爲string，則對它們進行UTF8編碼：
如果是将一个[]rune类型的Unicode字符slice或数组转为string，则对它们进行UTF8编码：
```Go
fmt.Println(string(r)) // "プログラム"
```
將一個整數轉型爲字符串意思是生成以隻包含對應Unicode碼點字符的UTF8字符串：
将一个整数转型为字符串意思是生成以只包含对应Unicode码点字符的UTF8字符串：
```Go
fmt.Println(string(65)) // "A", not "65"
fmt.Println(string(0x4eac)) // "京"
```
如果對應碼點的字符是無效的，則用'\uFFFD'無效字符作爲替換：
如果对应码点的字符是无效的，则用'\uFFFD'无效字符作为替换：
```Go
fmt.Println(string(1234567)) // "�"
ch3/ch3-05-4.md
+22 -22
View File
@@ -1,14 +1,14 @@
### 3.5.4. 字符串和Byte切片
標準庫中有四個包對字符串處理尤爲重要：bytes、strings、strconv和unicode包。strings包提供了許多如字符串的査詢、替換、比較、截斷、拆分和合併等功能。
标准库中有四个包对字符串处理尤为重要：bytes、strings、strconv和unicode包。strings包提供了许多如字符串的查询、替换、比较、截断、拆分和合并等功能。
bytes包也提供了很多類似功能的函數，但是針對和字符串有着相同結構的[]byte類型。因爲字符串是隻讀的，因此逐步構建字符串會導致很多分配和複製。在這種情況下，使用bytes.Buffer類型將會更有效，稍後我們將展示。
bytes包也提供了很多类似功能的函数，但是针对和字符串有着相同结构的[]byte类型。因为字符串是只读的，因此逐步构建字符串会导致很多分配和复制。在这种情况下，使用bytes.Buffer类型将会更有效，稍后我们将展示。
strconv包提供了布爾型、整型數、浮點數和對應字符串的相互轉換，還提供了雙引號轉義相關的轉換。
strconv包提供了布尔型、整型数、浮点数和对应字符串的相互转换，还提供了双引号转义相关的转换。
unicode包提供了IsDigit、IsLetter、IsUpper和IsLower等類似功能，它們用於給字符分類。每個函數有一個單一的rune類型的參數，然後返迴一個布爾值。而像ToUpper和ToLower之類的轉換函數將用於rune字符的大小寫轉換。所有的這些函數都是遵循Unicode標準定義的字母、數字等分類規范。strings包也有類似的函數，它們是ToUpper和ToLower，將原始字符串的每個字符都做相應的轉換，然後返迴新的字符串。
unicode包提供了IsDigit、IsLetter、IsUpper和IsLower等类似功能，它们用于给字符分类。每个函数有一个单一的rune类型的参数，然后返回一个布尔值。而像ToUpper和ToLower之类的转换函数将用于rune字符的大小写转换。所有的这些函数都是遵循Unicode标准定义的字母、数字等分类规范。strings包也有类似的函数，它们是ToUpper和ToLower，将原始字符串的每个字符都做相应的转换，然后返回新的字符串。
下面例子的basename函數靈感於Unix shell的同名工具。在我們實現的版本中，basename(s)將看起來像是繫統路徑的前綴刪除，同時將看似文件類型的後綴名部分刪除：
下面例子的basename函数灵感于Unix shell的同名工具。在我们实现的版本中，basename(s)将看起来像是系统路径的前缀删除，同时将看似文件类型的后缀名部分删除：
```Go
fmt.Println(basename("a/b/c.go")) // "c"
@@ -16,7 +16,7 @@ fmt.Println(basename("c.d.go")) // "c.d"
fmt.Println(basename("abc")) // "abc"
```
第一個版本併沒有使用任何庫，全部手工硬編碼實現：
第一个版本并没有使用任何库，全部手工硬编码实现：
<u><i>gopl.io/ch3/basename1</i></u>
```Go
@@ -41,7 +41,7 @@ func basename(s string) string {
}
```
簡化個版本使用了strings.LastIndex庫函數：
简化个版本使用了strings.LastIndex库函数：
<u><i>gopl.io/ch3/basename2</i></u>
```Go
@@ -55,9 +55,9 @@ func basename(s string) string {
}
```
path和path/filepath包提供了關於文件路徑名更一般的函數操作。使用斜槓分隔路徑可以在任何操作繫統上工作。斜槓本身不應該用於文件名，但是在其他一些領域可能會用於文件名，例如URL路徑組件。相比之下，path/filepath包則使用操作繫統本身的路徑規則，例如POSIX繫統使用/foo/bar，而Microsoft Windows使用c:\foo\bar等。
path和path/filepath包提供了关于文件路径名更一般的函数操作。使用斜杠分隔路径可以在任何操作系统上工作。斜杠本身不应该用于文件名，但是在其他一些领域可能会用于文件名，例如URL路径组件。相比之下，path/filepath包则使用操作系统本身的路径规则，例如POSIX系统使用/foo/bar，而Microsoft Windows使用c:\foo\bar等。
讓我們繼續另一個字符串的例子。函數的功能是將一個表示整值的字符串，每隔三個字符插入一個逗號分隔符，例如“12345”處理後成爲“12,345”。這個版本隻適用於整數類型；支持浮點數類型的支持留作練習。
让我们继续另一个字符串的例子。函数的功能是将一个表示整值的字符串，每隔三个字符插入一个逗号分隔符，例如“12345”处理后成为“12,345”。这个版本只适用于整数类型；支持浮点数类型的支持留作练习。
<u><i>gopl.io/ch3/comma</i></u>
```Go
@@ -71,11 +71,11 @@ func comma(s string) string {
}
```
輸入comma函數的參數是一個字符串。如果輸入字符串的長度小於或等於3的話，則不需要插入逗分隔符。否則，comma函數將在最後三個字符前位置將字符串切割爲兩個兩個子串併插入逗號分隔符，然後通過遞歸調用自身來出前面的子串。
输入comma函数的参数是一个字符串。如果输入字符串的长度小于或等于3的话，则不需要插入逗分隔符。否则，comma函数将在最后三个字符前位置将字符串切割为两个两个子串并插入逗号分隔符，然后通过递归调用自身来出前面的子串。
一個字符串是包含的隻讀字節數組，一旦創建，是不可變的。相比之下，一個字節slice的元素則可以自由地脩改。
一个字符串是包含的只读字节数组，一旦创建，是不可变的。相比之下，一个字节slice的元素则可以自由地修改。
字符串和字節slice之間可以相互轉換：
字符串和字节slice之间可以相互转换：
```Go
s := "abc"
@@ -83,9 +83,9 @@ b := []byte(s)
s2 := string(b)
```
從概念上講，一個[]byte(s)轉換是分配了一個新的字節數組用於保存字符串數據的拷貝，然後引用這個底層的字節數組。編譯器的優化可以避免在一些場景下分配和複製字符串數據，但總的來説需要確保在變量b被脩改的情況下，原始的s字符串也不會改變。將一個字節slice轉到字符串的string(b)操作則是構造一個字符串拷貝，以確保s2字符串是隻讀的。
从概念上讲，一个[]byte(s)转换是分配了一个新的字节数组用于保存字符串数据的拷贝，然后引用这个底层的字节数组。编译器的优化可以避免在一些场景下分配和复制字符串数据，但总的来说需要确保在变量b被修改的情况下，原始的s字符串也不会改变。将一个字节slice转到字符串的string(b)操作则是构造一个字符串拷贝，以确保s2字符串是只读的。
爲了避免轉換中不必要的內存分配，bytes包和strings同時提供了許多實用函數。下面是strings包中的六個函數：
为了避免转换中不必要的内存分配，bytes包和strings同时提供了许多实用函数。下面是strings包中的六个函数：
```Go
func Contains(s, substr string) bool
@@ -96,7 +96,7 @@ func Index(s, sep string) int
func Join(a []string, sep string) string
```
bytes包中也對應的六個函數：
bytes包中也对应的六个函数：
```Go
func Contains(b, subslice []byte) bool
@@ -107,9 +107,9 @@ func Index(s, sep []byte) int
func Join(s [][]byte, sep []byte) []byte
```
它們之間唯一的區别是字符串類型參數被替換成了字節slice類型的參數。
它们之间唯一的区别是字符串类型参数被替换成了字节slice类型的参数。
bytes包還提供了Buffer類型用於字節slice的緩存。一個Buffer開始是空的，但是隨着string、byte或[]byte等類型數據的寫入可以動態增長，一個bytes.Buffer變量併不需要處理化，因爲零值也是有效的：
bytes包还提供了Buffer类型用于字节slice的缓存。一个Buffer开始是空的，但是随着string、byte或[]byte等类型数据的写入可以动态增长，一个bytes.Buffer变量并不需要处理化，因为零值也是有效的：
<u><i>gopl.io/ch3/printints</i></u>
```Go
@@ -132,12 +132,12 @@ func main() {
}
```
當向bytes.Buffer添加任意字符的UTF8編碼時，最好使用bytes.Buffer的WriteRune方法，但是WriteByte方法對於寫入類似'['和']'等ASCII字符則會更加有效。
当向bytes.Buffer添加任意字符的UTF8编码时，最好使用bytes.Buffer的WriteRune方法，但是WriteByte方法对于写入类似'['和']'等ASCII字符则会更加有效。
bytes.Buffer類型有着很多實用的功能，我們在第七章討論接口時將會涉及到，我們將看看如何將它用作一個I/O的輸入和輸出對象，例如當做Fprintf的io.Writer輸出對象，或者當作io.Reader類型的輸入源對象。
bytes.Buffer类型有着很多实用的功能，我们在第七章讨论接口时将会涉及到，我们将看看如何将它用作一个I/O的输入和输出对象，例如当做Fprintf的io.Writer输出对象，或者当作io.Reader类型的输入源对象。
**練習 3.10：** 編寫一個非遞歸版本的comma函數，使用bytes.Buffer代替字符串鏈接操作。
**练习 3.10：** 编写一个非递归版本的comma函数，使用bytes.Buffer代替字符串链接操作。
**練習 3.11：** 完善comma函數，以支持浮點數處理和一個可選的正負號的處理。
**练习 3.11：** 完善comma函数，以支持浮点数处理和一个可选的正负号的处理。
**練習 3.12：** 編寫一個函數，判斷兩個字符串是否是是相互打亂的，也就是説它們有着相同的字符，但是對應不同的順序。
**练习 3.12：** 编写一个函数，判断两个字符串是否是是相互打乱的，也就是说它们有着相同的字符，但是对应不同的顺序。
ch3/ch3-05-5.md
+8 -8
View File
@@ -1,8 +1,8 @@
### 3.5.5. 字符串和數字的轉換
### 3.5.5. 字符串和数字的转换
除了字符串、字符、字節之間的轉換，字符串和數值之間的轉換也比較常見。由strconv包提供這類轉換功能。
除了字符串、字符、字节之间的转换，字符串和数值之间的转换也比较常见。由strconv包提供这类转换功能。
將一個整數轉爲字符串，一種方法是用fmt.Sprintf返迴一個格式化的字符串；另一個方法是用strconv.Itoa(“整數到ASCII”)：
将一个整数转为字符串，一种方法是用fmt.Sprintf返回一个格式化的字符串；另一个方法是用strconv.Itoa(“整数到ASCII”)：
```Go
x := 123
@@ -10,28 +10,28 @@ y := fmt.Sprintf("%d", x)
fmt.Println(y, strconv.Itoa(x)) // "123 123"
```
FormatInt和FormatUint函數可以用不同的進製來格式化數字：
FormatInt和FormatUint函数可以用不同的进制来格式化数字：
```Go
fmt.Println(strconv.FormatInt(int64(x), 2)) // "1111011"
```
fmt.Printf函數的%b、%d、%o和%x等參數提供功能往往比strconv包的Format函數方便很多，特别是在需要包含附加額外信息的時候：
fmt.Printf函数的%b、%d、%o和%x等参数提供功能往往比strconv包的Format函数方便很多，特别是在需要包含附加额外信息的时候：
```Go
s := fmt.Sprintf("x=%b", x) // "x=1111011"
```
如果要將一個字符串解析爲整數，可以使用strconv包的Atoi或ParseInt函數，還有用於解析無符號整數的ParseUint函數：
如果要将一个字符串解析为整数，可以使用strconv包的Atoi或ParseInt函数，还有用于解析无符号整数的ParseUint函数：
```Go
x, err := strconv.Atoi("123") // x is an int
y, err := strconv.ParseInt("123", 10, 64) // base 10, up to 64 bits
```
ParseInt函數的第三個參數是用於指定整型數的大小；例如16表示int16，0則表示int。在任何情況下，返迴的結果y總是int64類型，你可以通過強製類型轉換將它轉爲更小的整數類型。
ParseInt函数的第三个参数是用于指定整型数的大小；例如16表示int16，0则表示int。在任何情况下，返回的结果y总是int64类型，你可以通过强制类型转换将它转为更小的整数类型。
有時候也會使用fmt.Scanf來解析輸入的字符串和數字，特别是當字符串和數字混合在一行的時候，它可以靈活處理不完整或不規則的輸入。
有时候也会使用fmt.Scanf来解析输入的字符串和数字，特别是当字符串和数字混合在一行的时候，它可以灵活处理不完整或不规则的输入。
ch3/ch3-05.md
+13 -13
View File
@@ -1,8 +1,8 @@
## 3.5. 字符串
一個字符串是一個不可改變的字節序列。字符串可以包含任意的數據，包括byte值0，但是通常是用來包含人類可讀的文本。文本字符串通常被解釋爲采用UTF8編碼的Unicode碼點（rune）序列，我們稍後會詳細討論這個問題。
一个字符串是一个不可改变的字节序列。字符串可以包含任意的数据，包括byte值0，但是通常是用来包含人类可读的文本。文本字符串通常被解释为采用UTF8编码的Unicode码点（rune）序列，我们稍后会详细讨论这个问题。
內置的len函數可以返迴一個字符串中的字節數目（不是rune字符數目），索引操作s[i]返迴第i個字節的字節值，i必須滿足0 ≤ i< len(s)條件約束。
内置的len函数可以返回一个字符串中的字节数目（不是rune字符数目），索引操作s[i]返回第i个字节的字节值，i必须满足0 ≤ i< len(s)条件约束。
```Go
s := "hello, world"
@@ -10,23 +10,23 @@ fmt.Println(len(s)) // "12"
fmt.Println(s[0], s[7]) // "104 119" ('h' and 'w')
```
如果試圖訪問超出字符串索引范圍的字節將會導致panic異常：
如果试图访问超出字符串索引范围的字节将会导致panic异常：
```Go
c := s[len(s)] // panic: index out of range
```
第i個字節併不一定是字符串的第i個字符，因爲對於非ASCII字符的UTF8編碼會要兩個或多個字節。我們先簡單説下字符的工作方式。
第i个字节并不一定是字符串的第i个字符，因为对于非ASCII字符的UTF8编码会要两个或多个字节。我们先简单说下字符的工作方式。
子字符串操作s[i:j]基於原始的s字符串的第i個字節開始到第j個字節（併不包含j本身）生成一個新字符串。生成的新字符串將包含j-i個字節。
子字符串操作s[i:j]基于原始的s字符串的第i个字节开始到第j个字节（并不包含j本身）生成一个新字符串。生成的新字符串将包含j-i个字节。
```Go
fmt.Println(s[0:5]) // "hello"
```
同樣，如果索引超出字符串范圍或者j小於i的話將導致panic異常。
同样，如果索引超出字符串范围或者j小于i的话将导致panic异常。
不管i還是j都可能被忽略，當它們被忽略時將采用0作爲開始位置，采用len(s)作爲結束的位置。
不管i还是j都可能被忽略，当它们被忽略时将采用0作为开始位置，采用len(s)作为结束的位置。
```Go
fmt.Println(s[:5]) // "hello"
@@ -34,15 +34,15 @@ fmt.Println(s[7:]) // "world"
fmt.Println(s[:]) // "hello, world"
```
其中+操作符將兩個字符串鏈接構造一個新字符串：
其中+操作符将两个字符串链接构造一个新字符串：
```Go
fmt.Println("goodbye" + s[5:]) // "goodbye, world"
```
字符串可以用==和<進行比較；比較通過逐個字節比較完成的，因此比較的結果是字符串自然編碼的順序。
字符串可以用==和<进行比较；比较通过逐个字节比较完成的，因此比较的结果是字符串自然编码的顺序。
字符串的值是不可變的：一個字符串包含的字節序列永遠不會被改變，當然我們也可以給一個字符串變量分配一個新字符串值。可以像下面這樣將一個字符串追加到另一個字符串：
字符串的值是不可变的：一个字符串包含的字节序列永远不会被改变，当然我们也可以给一个字符串变量分配一个新字符串值。可以像下面这样将一个字符串追加到另一个字符串：
```Go
s := "left foot"
@@ -50,20 +50,20 @@ t := s
s += ", right foot"
```
這併不會導致原始的字符串值被改變，但是變量s將因爲+=語句持有一個新的字符串值，但是t依然是包含原先的字符串值。
这并不会导致原始的字符串值被改变，但是变量s将因为+=语句持有一个新的字符串值，但是t依然是包含原先的字符串值。
```Go
fmt.Println(s) // "left foot, right foot"
fmt.Println(t) // "left foot"
```
因爲字符串是不可脩改的，因此嚐試脩改字符串內部數據的操作也是被禁止的：
因为字符串是不可修改的，因此尝试修改字符串内部数据的操作也是被禁止的：
```Go
s[0] = 'L' // compile error: cannot assign to s[0]
```
不變性意味如果兩個字符串共享相同的底層數據的話也是安全的，這使得複製任何長度的字符串代價是低廉的。同樣，一個字符串s和對應的子字符串切片s[7:]的操作也可以安全地共享相同的內存，因此字符串切片操作代價也是低廉的。在這兩種情況下都沒有必要分配新的內存。 圖3.4演示了一個字符串和兩個字串共享相同的底層數據。
不变性意味如果两个字符串共享相同的底层数据的话也是安全的，这使得复制任何长度的字符串代价是低廉的。同样，一个字符串s和对应的子字符串切片s[7:]的操作也可以安全地共享相同的内存，因此字符串切片操作代价也是低廉的。在这两种情况下都没有必要分配新的内存。 图3.4演示了一个字符串和两个字串共享相同的底层数据。
{% include "./ch3-05-1.md" %}
ch3/ch3-06-1.md
+8 -8
View File
@@ -1,8 +1,8 @@
### 3.6.1. iota 常量生成器
常量聲明可以使用iota常量生成器初始化，它用於生成一組以相似規則初始化的常量，但是不用每行都寫一遍初始化表達式。在一個const聲明語句中，在第一個聲明的常量所在的行，iota將會被置爲0，然後在每一個有常量聲明的行加一。
常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。
下面是來自time包的例子，它首先定義了一個Weekday命名類型，然後爲一週的每天定義了一個常量，從週日0開始。在其它編程語言中，這種類型一般被稱爲枚舉類型。
下面是来自time包的例子，它首先定义了一个Weekday命名类型，然后为一周的每天定义了一个常量，从周日0开始。在其它编程语言中，这种类型一般被称为枚举类型。
```Go
type Weekday int
@@ -18,9 +18,9 @@ const (
)
```
週一將對應0，週一爲1，如此等等。
周一将对应0，周一为1，如此等等。
我們也可以在複雜的常量表達式中使用iota，下面是來自net包的例子，用於給一個無符號整數的最低5bit的每個bit指定一個名字：
我们也可以在复杂的常量表达式中使用iota，下面是来自net包的例子，用于给一个无符号整数的最低5bit的每个bit指定一个名字：
```Go
type Flags uint
@@ -34,7 +34,7 @@ const (
)
```
隨着iota的遞增，每個常量對應表達式1 << iota，是連續的2的冪，分别對應一個bit位置。使用這些常量可以用於測試、設置或清除對應的bit位的值：
随着iota的递增，每个常量对应表达式1 << iota，是连续的2的幂，分别对应一个bit位置。使用这些常量可以用于测试、设置或清除对应的bit位的值：
<u><i>gopl.io/ch3/netflag</i></u>
```Go
@@ -54,7 +54,7 @@ unc main() {
}
```
下面是一個更複雜的例子，每個常量都是1024的冪：
下面是一个更复杂的例子，每个常量都是1024的幂：
```Go
const (
@@ -70,6 +70,6 @@ const (
)
```
不過iota常量生成規則也有其局限性。例如，它併不能用於産生1000的冪（KB、MB等），因爲Go語言併沒有計算冪的運算符。
不过iota常量生成规则也有其局限性。例如，它并不能用于产生1000的幂（KB、MB等），因为Go语言并没有计算幂的运算符。
**練習 3.13：** 編寫KB、MB的常量聲明，然後擴展到YB。
**练习 3.13：** 编写KB、MB的常量声明，然后扩展到YB。
ch3/ch3-06-2.md
+15 -15
View File
@@ -1,14 +1,14 @@
### 3.6.2. 無類型常量
### 3.6.2. 无类型常量
Go語言的常量有個不同尋常之處。雖然一個常量可以有任意有一個確定的基礎類型，例如int或float64，或者是類似time.Duration這樣命名的基礎類型，但是許多常量併沒有一個明確的基礎類型。編譯器爲這些沒有明確的基礎類型的數字常量提供比基礎類型更高精度的算術運算；你可以認爲至少有256bit的運算精度。這里有六種未明確類型的常量類型，分别是無類型的布爾型、無類型的整數、無類型的字符、無類型的浮點數、無類型的複數、無類型的字符串。
Go语言的常量有个不同寻常之处。虽然一个常量可以有任意有一个确定的基础类型，例如int或float64，或者是类似time.Duration这样命名的基础类型，但是许多常量并没有一个明确的基础类型。编译器为这些没有明确的基础类型的数字常量提供比基础类型更高精度的算术运算；你可以认为至少有256bit的运算精度。这里有六种未明确类型的常量类型，分别是无类型的布尔型、无类型的整数、无类型的字符、无类型的浮点数、无类型的复数、无类型的字符串。
通過延遲明確常量的具體類型，無類型的常量不僅可以提供更高的運算精度，而且可以直接用於更多的表達式而不需要顯式的類型轉換。例如，例子中的ZiB和YiB的值已經超出任何Go語言中整數類型能表達的范圍，但是它們依然是合法的常量，而且可以像下面常量表達式依然有效（譯註：YiB/ZiB是在編譯期計算出來的，併且結果常量是1024，是Go語言int變量能有效表示的）：
通过延迟明确常量的具体类型，无类型的常量不仅可以提供更高的运算精度，而且可以直接用于更多的表达式而不需要显式的类型转换。例如，例子中的ZiB和YiB的值已经超出任何Go语言中整数类型能表达的范围，但是它们依然是合法的常量，而且可以像下面常量表达式依然有效（译注：YiB/ZiB是在编译期计算出来的，并且结果常量是1024，是Go语言int变量能有效表示的）：
```Go
fmt.Println(YiB/ZiB) // "1024"
```
另一個例子，math.Pi無類型的浮點數常量，可以直接用於任意需要浮點數或複數的地方：
另一个例子，math.Pi无类型的浮点数常量，可以直接用于任意需要浮点数或复数的地方：
```Go
var x float32 = math.Pi
@@ -16,7 +16,7 @@ var y float64 = math.Pi
var z complex128 = math.Pi
```
如果math.Pi被確定爲特定類型，比如float64，那麽結果精度可能會不一樣，同時對於需要float32或complex128類型值的地方則會強製需要一個明確的類型轉換：
如果math.Pi被确定为特定类型，比如float64，那么结果精度可能会不一样，同时对于需要float32或complex128类型值的地方则会强制需要一个明确的类型转换：
```Go
const Pi64 float64 = math.Pi
@@ -26,9 +26,9 @@ var y float64 = Pi64
var z complex128 = complex128(Pi64)
```
對於常量面值，不同的寫法可能會對應不同的類型。例如0、0.0、0i和'\u0000'雖然有着相同的常量值，但是它們分别對應無類型的整數、無類型的浮點數、無類型的複數和無類型的字符等不同的常量類型。同樣，true和false也是無類型的布爾類型，字符串面值常量是無類型的字符串類型。
对于常量面值，不同的写法可能会对应不同的类型。例如0、0.0、0i和'\u0000'虽然有着相同的常量值，但是它们分别对应无类型的整数、无类型的浮点数、无类型的复数和无类型的字符等不同的常量类型。同样，true和false也是无类型的布尔类型，字符串面值常量是无类型的字符串类型。
前面説過除法運算符/會根據操作數的類型生成對應類型的結果。因此，不同寫法的常量除法表達式可能對應不同的結果：
前面说过除法运算符/会根据操作数的类型生成对应类型的结果。因此，不同写法的常量除法表达式可能对应不同的结果：
```Go
var f float64 = 212
@@ -37,7 +37,7 @@ fmt.Println(5 / 9 * (f - 32)) // "0"; 5/9 is an untyped integer, 0
fmt.Println(5.0 / 9.0 * (f - 32)) // "100"; 5.0/9.0 is an untyped float
```
隻有常量可以是無類型的。當一個無類型的常量被賦值給一個變量的時候，就像上面的第一行語句，或者是像其餘三個語句中右邊表達式中含有明確類型的值，無類型的常量將會被隱式轉換爲對應的類型，如果轉換合法的話。
只有常量可以是无类型的。当一个无类型的常量被赋值给一个变量的时候，就像上面的第一行语句，或者是像其余三个语句中右边表达式中含有明确类型的值，无类型的常量将会被隐式转换为对应的类型，如果转换合法的话。
```Go
var f float64 = 3 + 0i // untyped complex -> float64
@@ -46,7 +46,7 @@ f = 1e123 // untyped floating-point -> float64
f = 'a' // untyped rune -> float64
```
上面的語句相當於:
上面的语句相当于:
```Go
var f float64 = float64(3 + 0i)
@@ -55,7 +55,7 @@ f = float64(1e123)
f = float64('a')
```
無論是隱式或顯式轉換，將一種類型轉換爲另一種類型都要求目標可以表示原始值。對於浮點數和複數，可能會有舍入處理：
无论是隐式或显式转换，将一种类型转换为另一种类型都要求目标可以表示原始值。对于浮点数和复数，可能会有舍入处理：
```Go
const (
@@ -69,7 +69,7 @@ const (
)
```
對於一個沒有顯式類型的變量聲明語法（包括短變量聲明語法），無類型的常量會被隱式轉爲默認的變量類型，就像下面的例子：
对于一个没有显式类型的变量声明语法（包括短变量声明语法），无类型的常量会被隐式转为默认的变量类型，就像下面的例子：
```Go
i := 0 // untyped integer; implicit int(0)
@@ -78,16 +78,16 @@ f := 0.0 // untyped floating-point; implicit float64(0.0)
c := 0i // untyped complex; implicit complex128(0i)
```
註意默認類型是規則的：無類型的整數常量默認轉換爲int，對應不確定的內存大小，但是浮點數和複數常量則默認轉換爲float64和complex128。Go語言本身併沒有不確定內存大小的浮點數和複數類型，而且如果不知道浮點數類型的話將很難寫出正確的數值算法。
注意默认类型是规则的：无类型的整数常量默认转换为int，对应不确定的内存大小，但是浮点数和复数常量则默认转换为float64和complex128。Go语言本身并没有不确定内存大小的浮点数和复数类型，而且如果不知道浮点数类型的话将很难写出正确的数值算法。
如果要給變量一個不同的類型，我們必須顯式地將無類型的常量轉化爲所需的類型，或給聲明的變量指定明確的類型，像下面例子這樣：
如果要给变量一个不同的类型，我们必须显式地将无类型的常量转化为所需的类型，或给声明的变量指定明确的类型，像下面例子这样：
```Go
var i = int8(0)
var i int8 = 0
```
當嚐試將這些無類型的常量轉爲一個接口值時（見第7章），這些默認類型將顯得尤爲重要，因爲要靠它們明確接口對應的動態類型。
当尝试将这些无类型的常量转为一个接口值时（见第7章），这些默认类型将显得尤为重要，因为要靠它们明确接口对应的动态类型。
```Go
fmt.Printf("%T\n", 0) // "int"
@@ -96,7 +96,7 @@ fmt.Printf("%T\n", 0i) // "complex128"
fmt.Printf("%T\n", '\000') // "int32" (rune)
```
現在我們已經講述了Go語言中全部的基礎數據類型。下一步將演示如何用基礎數據類型組合成數組或結構體等複雜數據類型，然後構建用於解決實際編程問題的數據結構，這將是第四章的討論主題。
现在我们已经讲述了Go语言中全部的基础数据类型。下一步将演示如何用基础数据类型组合成数组或结构体等复杂数据类型，然后构建用于解决实际编程问题的数据结构，这将是第四章的讨论主题。
ch3/ch3-06.md
+9 -9
View File
@@ -1,14 +1,14 @@
## 3.6. 常量
常量表達式的值在編譯期計算，而不是在運行期。每種常量的潛在類型都是基礎類型：boolean、string或數字。
常量表达式的值在编译期计算，而不是在运行期。每种常量的潜在类型都是基础类型：boolean、string或数字。
一個常量的聲明語句定義了常量的名字，和變量的聲明語法類似，常量的值不可脩改，這樣可以防止在運行期被意外或惡意的脩改。例如，常量比變量更適合用於表達像π之類的數學常數，因爲它們的值不會發生變化：
一个常量的声明语句定义了常量的名字，和变量的声明语法类似，常量的值不可修改，这样可以防止在运行期被意外或恶意的修改。例如，常量比变量更适合用于表达像π之类的数学常数，因为它们的值不会发生变化：
```Go
const pi = 3.14159 // approximately; math.Pi is a better approximation
```
和變量聲明一樣，可以批量聲明多個常量；這比較適合聲明一組相關的常量：
和变量声明一样，可以批量声明多个常量；这比较适合声明一组相关的常量：
```Go
const (
@@ -17,11 +17,11 @@ const (
)
```
所有常量的運算都可以在編譯期完成，這樣可以減少運行時的工作，也方便其他編譯優化。當操作數是常量時，一些運行時的錯誤也可以在編譯時被發現，例如整數除零、字符串索引越界、任何導致無效浮點數的操作等。
所有常量的运算都可以在编译期完成，这样可以减少运行时的工作，也方便其他编译优化。当操作数是常量时，一些运行时的错误也可以在编译时被发现，例如整数除零、字符串索引越界、任何导致无效浮点数的操作等。
常量間的所有算術運算、邏輯運算和比較運算的結果也是常量，對常量的類型轉換操作或以下函數調用都是返迴常量結果：len、cap、real、imag、complex和unsafe.Sizeof（§13.1）。
常量间的所有算术运算、逻辑运算和比较运算的结果也是常量，对常量的类型转换操作或以下函数调用都是返回常量结果：len、cap、real、imag、complex和unsafe.Sizeof（§13.1）。
因爲它們的值是在編譯期就確定的，因此常量可以是構成類型的一部分，例如用於指定數組類型的長度：
因为它们的值是在编译期就确定的，因此常量可以是构成类型的一部分，例如用于指定数组类型的长度：
```Go
const IPv4Len = 4
@@ -33,7 +33,7 @@ func parseIPv4(s string) IP {
}
```
一個常量的聲明也可以包含一個類型和一個值，但是如果沒有顯式指明類型，那麽將從右邊的表達式推斷類型。在下面的代碼中，time.Duration是一個命名類型，底層類型是int64，time.Minute是對應類型的常量。下面聲明的兩個常量都是time.Duration類型，可以通過%T參數打印類型信息：
一个常量的声明也可以包含一个类型和一个值，但是如果没有显式指明类型，那么将从右边的表达式推断类型。在下面的代码中，time.Duration是一个命名类型，底层类型是int64，time.Minute是对应类型的常量。下面声明的两个常量都是time.Duration类型，可以通过%T参数打印类型信息：
```Go
const noDelay time.Duration = 0
@@ -43,7 +43,7 @@ fmt.Printf("%T %[1]v\n", timeout) // "time.Duration 5m0s"
fmt.Printf("%T %[1]v\n", time.Minute) // "time.Duration 1m0s"
```
如果是批量聲明的常量，除了第一個外其它的常量右邊的初始化表達式都可以省略，如果省略初始化表達式則表示使用前面常量的初始化表達式寫法，對應的常量類型也一樣的。例如：
如果是批量声明的常量，除了第一个外其它的常量右边的初始化表达式都可以省略，如果省略初始化表达式则表示使用前面常量的初始化表达式写法，对应的常量类型也一样的。例如：
```Go
const (
@@ -56,7 +56,7 @@ const (
fmt.Println(a, b, c, d) // "1 1 2 2"
```
如果隻是簡單地複製右邊的常量表達式，其實併沒有太實用的價值。但是它可以帶來其它的特性，那就是iota常量生成器語法。
如果只是简单地复制右边的常量表达式，其实并没有太实用的价值。但是它可以带来其它的特性，那就是iota常量生成器语法。
{% include "./ch3-06-1.md" %}
ch3/ch3.md
+3 -3
View File
@@ -1,5 +1,5 @@
# 第3章 基礎數據類型
# 第3章 基础数据类型
雖然從底層而言，所有的數據都是由比特組成，但計算機一般操作的是固定大小的數，如整數、浮點數、比特數組、內存地址等。進一步將這些數組織在一起，就可表達更多的對象，例如數據包、像素點、詩歌，甚至其他任何對象。Go語言提供了豐富的數據組織形式，這依賴於Go語言內置的數據類型。這些內置的數據類型，兼顧了硬件的特性和表達複雜數據結構的便捷性。
虽然从底层而言，所有的数据都是由比特组成，但计算机一般操作的是固定大小的数，如整数、浮点数、比特数组、内存地址等。进一步将这些数组织在一起，就可表达更多的对象，例如数据包、像素点、诗歌，甚至其他任何对象。Go语言提供了丰富的数据组织形式，这依赖于Go语言内置的数据类型。这些内置的数据类型，兼顾了硬件的特性和表达复杂数据结构的便捷性。
Go語言將數據類型分爲四類：基礎類型、複合類型、引用類型和接口類型。本章介紹基礎類型，包括：數字、字符串和布爾型。複合數據類型——數組（§4.1）和結構體（§4.2）——是通過組合簡單類型，來表達更加複雜的數據結構。引用類型包括指針（§2.3.2）、切片（§4.2)）字典（§4.3）、函數（§5）、通道（§8），雖然數據種類很多，但它們都是對程序中一個變量或狀態的間接引用。這意味着對任一引用類型數據的脩改都會影響所有該引用的拷貝。我們將在第7章介紹接口類型。
Go语言将数据类型分为四类：基础类型、复合类型、引用类型和接口类型。本章介绍基础类型，包括：数字、字符串和布尔型。复合数据类型——数组（§4.1）和结构体（§4.2）——是通过组合简单类型，来表达更加复杂的数据结构。引用类型包括指针（§2.3.2）、切片（§4.2)）字典（§4.3）、函数（§5）、通道（§8），虽然数据种类很多，但它们都是对程序中一个变量或状态的间接引用。这意味着对任一引用类型数据的修改都会影响所有该引用的拷贝。我们将在第7章介绍接口类型。