mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2025-12-18 19:54:21 +08:00
rebuild
This commit is contained in:
chai2010
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.1" data-chapter-title="Hello, World" data-filepath="ch1/ch1-01.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.1" data-chapter-title="Hello, World" data-filepath="ch1/ch1-01.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,41 +2024,42 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="11-hello-world">1.1. Hello, World</h2>
|
||||
<p>我們以1978年，c語言歷史上經典的hello world案例來開始吧。C語言對Go語言的設計産生了很多影響。用這個例子，我們來講解一些Go語言的覈心特性：</p>
|
||||
<pre><code class="lang-go"><span class="hljs-comment">//gopl.io/ch1/helloworld</span>
|
||||
<p>我們以1978年齣版的C語言聖經《The C Programming Language》中經典的“hello world”案例來開始吧（譯註：本書作者之一Brian W. Kernighan也是C語言聖經一書的作者）。C語言對Go語言的設計産生了很多影響。用這個例子，我們來講解一些Go語言的覈心特性：</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/helloworld
|
||||
<span class="hljs-keyword">package</span> main
|
||||
|
||||
<span class="hljs-keyword">import</span> <span class="hljs-string">"fmt"</span>
|
||||
|
||||
<span class="hljs-keyword">func</span> main() {
|
||||
fmt.Println(<span class="hljs-string">"Hello, BF"</span>)
|
||||
fmt.Println(<span class="hljs-string">"Hello, 世界"</span>)
|
||||
}
|
||||
</code></pre>
|
||||
<p>Go是一門編譯型語言，Go的工具鏈將源代碼和其依賴一起打包，生成機器的本地指令(譯註：靜態編譯)。Go語言提供的工具可以通過go下的一繫列子命令來調用。最簡單的一個子命令就是run。這個命令會將一個或多個以.go結束的源文件，和關聯庫鏈接到一起，然後運行最終的可執行文件。(本書將用$表示命令行的提示符)</p>
|
||||
<p>Go是一門編譯型語言，Go語言的工具鏈將源代碼和其依賴一起打包，生成機器的本地指令(譯註：靜態編譯)。Go語言提供的工具可以通過go命令下的一繫列子命令來調用。最簡單的一個子命令就是run。這個命令會將一個或多個文件名以.go結尾的源文件，和關聯庫鏈接到一起，然後運行最終的可執行文件。（本書將用$表示命令行的提示符。）</p>
|
||||
<pre><code>$ go run helloworld.go
|
||||
</code></pre><p>毫無意外，這個命令會輸齣：</p>
|
||||
<pre><code>Hello, BF
|
||||
</code></pre><p>Go原生支持Unicode，所以你可以用Go處理世界上的任何語言。</p>
|
||||
<pre><code>Hello, 世界
|
||||
</code></pre><p>Go語言原生支持Unicode標準，所以你可以用Go語言處理世界上的任何自然語言。</p>
|
||||
<p>如果你希望自己的程序不隻是簡單的一次性實驗，那麽你一定會希望能夠編譯這個程序，併且能夠將編譯結果保存下來以備將來之用。這個可以用build子命令來實現：</p>
|
||||
<pre><code>$ go build helloworld.go
|
||||
</code></pre><p>這會創建一個名爲helloworld的可執行的二進製文件，之後你可以在任何時間去運行這個二進製文件，不需要其它的任何處理(譯註：因爲是靜態編譯，所以也不用擔心在繫統庫更新的時候衝突，幸福感滿滿)。</p>
|
||||
<p>下面是運行我們的編譯結果樣例：</p>
|
||||
</code></pre><p>這會創建一個名爲helloworld的可執行的二進製文件（譯註：在Windows繫統下生成的可執行文件是helloworld.exe，增加了.exe後綴名），之後你可以在任何時間去運行這個二進製文件，不需要其它的任何處理(譯註：因爲是靜態編譯，所以也不用擔心在繫統庫更新的時候衝突，幸福感滿滿)。</p>
|
||||
<p>下面是運行我們的編譯結果樣例（譯註：在Windows繫統下在命令行直接輸入helloworld.exe命令運行）：</p>
|
||||
<pre><code>$ ./helloworld
|
||||
Hello, BF
|
||||
</code></pre><p>本書中我們所有的例子都做了一個特殊標記，你可以通過這些標記在gopl.io在線網站上找到這些樣例代碼，比如這個 gopl.io/ch1/helloworld</p>
|
||||
<p>如果你執行go get gopl.io/ch1/helloworld，go能夠自己從網上穫取到這些代碼，併且將這些代碼放到對應的目録中。更詳細的介紹在2.6和10.7章節中。</p>
|
||||
<p>我們來討論一下程序本身。Go的代碼是用package來組織的，package的概念和你知道的其它語言里的libraries或者modules比較類似。一個package會包含一個或多個.go結束的源代碼文件。每一個源文件都是以一個package xxx的聲明開頭的，比如我們的例子里就是package main。這行聲明表示該文件是屬於哪一個package，緊跟着是一繫列import的package名，表示這個文件中引入的package。再之後是本文件本身的代碼</p>
|
||||
<p>Go的標準庫已經提供了100多個package，用來完成一門程序語言的一些基本任務，比如輸入、輸齣、排序或者字符串/文本處理。比如fmt這個package，就包括接收輸入、格式化輸齣的各種函數。Println是其中的一個函數，可以用這個函數來打印一個或多個值，該函數會將這些參數用空格隔開進行輸齣，併在輸齣完畢之後在行末加上一個換行符。</p>
|
||||
<p>package main比較特殊。這個package里會定義一個獨立的程序，這個程序是可以運行的，而不是像其它package一樣的library。在main這個package里，main函數也是一個特殊的函數，這是我們整個程序的入口(譯註：其實c繫語言差不多都是這樣)。main函數所做的事情就是我們程序做的事情。當然了，main函數一般完成的工作是調用其它packge里的函數來完成自己的工作，比如fmt.Println。</p>
|
||||
<p>我們必鬚告訴編譯器如果要正確地執行這個源文件，需要用到哪些package，這就是import在這個文件里扮演的角色。上述的hello world隻用到了一個其它的package，就是fmt。一般情況下，需要import的package不隻一個。</p>
|
||||
<p>也正是因爲go語言必鬚引入所有用到的package的原則，假如你沒有在代碼里import需要用到的package，程序將無法編譯通過，當你import了沒有用到的package，也會無法編譯通過(譯註：爭議特性之一)。</p>
|
||||
<p>import聲明必鬚跟在文件的package聲明之後。在import之後，則是各種方法、變量、常量、類型的聲明(分别用關鍵字func, var, const, type來進行定義)。這些內容的聲明順序併沒有什麽規定，可以隨便(譯註：最好還是定一下規范)。我們例子里的程序比較簡單，隻包含了一個函數。併且在該函數里也隻調用了一個其它函數。爲了節省空間，有些時候的例子我們會省略package和import聲明，但是讀者需要註意這些聲明是一定要包含在源文件里的。</p>
|
||||
<p>一個函數的聲明包含func這個關鍵字、函數名、參數列表(我們例子里的main函數是空)、返迴結果列表(這里的例子也是空)以及包含在大括號里的函數體。關於函數的更詳細描述在第五章。</p>
|
||||
<p>Go是一門不需要分號作爲語句或者聲明結束的語言，除非要在一行中將多個語句、聲明隔開。然而在編譯時，編譯器會主動在一些特定的符號(譯註：比如行末是，一個標識符、一個整數、浮點數、虛數、字符或字符串文字、關鍵字break、continue、fallthrough或return中的一個、運算符和分隔符++、--、)、]或}中的一個) 後添加分號，所以在哪里加分號合適是取決於Go的代碼的。例如：在Go語言中的函數聲明和 { 必鬚在同一行，而在x + y的表達式中，在+號後換行可以，但是在+號前換行則會有問題。</p>
|
||||
<p>Go語言在代碼格式上采取了很強硬的態度。gofmt工具會將你的代碼格式化爲標準格式，併且go工具中的fmt子命令會自動對特定package下的所有.go源文件應用gofmt。如果不指定package，則默認對當前目録下的源文件進行格式化。本書中的所有代碼已經是執行過gofmt後的標準格式代碼。你應該在自己的代碼上也執行這種格式化。規定一種標準的代碼格式可以規避掉無盡的無意義的撕逼。當然了，也可以避免由於代碼格式導致的邏輯上的歧義。</p>
|
||||
Hello, 世界
|
||||
</code></pre><p>本書中我們所有的例子都做了一個特殊標記，你可以通過這些標記在 <a href="http://gopl.io" target="_blank">http://gopl.io</a> 在線網站上找到這些樣例代碼，比如這個</p>
|
||||
<pre><code>gopl.io/ch1/helloworld
|
||||
</code></pre><p>如果你執行 <code>go get gopl.io/ch1/helloworld</code> 命令，go命令能夠自己從網上穫取到這些代碼（譯註：需要先安裝Git或Hg之類的版本管理工具，併將對應的命令添加到PATH環境變量中），併且將這些代碼放到對應的目録中（譯註：序言已經提及，需要先設置好GOPATH環境變量，下載的代碼會放在 $GOPATH/src/gopl.io/ch1/helloworld 目録）。更詳細的介紹在2.6和10.7章節中。</p>
|
||||
<p>我們來討論一下程序本身。Go語言的代碼是通過package來組織的，package的概念和你知道的其它語言里的libraries或者modules概念比較類似。一個package會包含一個或多個.go結束的源代碼文件。每一個源文件都是以一個package xxx的聲明語句開頭的，比如我們的例子里就是package main。這行聲明語句表示該文件是屬於哪一個package，緊跟着是一繫列import的package名，表示這個文件中引入的package。再之後是本文件本身的代碼。</p>
|
||||
<p>Go的標準庫已經提供了100多個package，用來完成一門程序語言的一些常見的基本任務，比如輸入、輸齣、排序或者字符串/文本處理。比如fmt這個package，就包括接收輸入、格式化輸齣的各種函數。Println是其中的一個常用的函數，可以用這個函數來打印一個或多個值，該函數會將這些參數用空格隔開進行輸齣，併在輸齣完畢之後在行末加上一個換行符。</p>
|
||||
<p>package main是一個比較特殊的package。這個package里會定義一個獨立的程序，這個程序是可以運行的，而不是像其它package一樣對應一個library。在main這個package里，main函數也是一個特殊的函數，這是我們整個程序的入口（譯註：其實C繫語言差不多都是這樣）。main函數所做的事情就是我們程序做的事情。當然了，main函數一般是通過是調用其它packge里的函數來完成自己的工作，比如fmt.Println。</p>
|
||||
<p>我們必鬚告訴編譯器如何要正確地執行這個源文件，需要用到哪些package，這就是import在這個文件里扮演的角色。上述的hello world例子隻用到了一個其它的package，就是fmt。一般情況下，需要import的package可能不隻一個。</p>
|
||||
<p>這也正是因爲go語言必鬚引入所有要用到的package的原則，假如你沒有在代碼里import需要用到的package，程序將無法編譯通過，同時當你import了沒有用到的package，也會無法編譯通過（譯註：Go語言編譯過程沒有警告信息，爭議特性之一）。</p>
|
||||
<p>import聲明必鬚跟在文件的package聲明之後。在import語句之後，則是各種方法、變量、常量、類型的聲明語句(分别用關鍵字func, var, const, type來進行定義)。這些內容的聲明順序併沒有什麽規定，可以隨便調整順序(譯註：最好還是定一下規范)。我們例子里的程序比較簡單，隻包含了一個函數。併且在該函數里也隻調用了一個其它函數。爲了節省空間，有些時候的例子我們會省略package和import聲明，但是讀者需要註意這些聲明是一定要包含在源文件里的。</p>
|
||||
<p>一個函數的聲明包含func這個關鍵字、函數名、參數列表、返迴結果列表（我們例子里的main函數參數列表和返迴值都是空的）以及包含在大括號里的函數體。關於函數的更詳細描述在第五章。</p>
|
||||
<p>Go語言是一門不需要分號作爲語句或者聲明結束的語言，除非要在一行中將多個語句、聲明隔開。然而在編譯時，編譯器會主動在一些特定的符號（譯註：比如行末是，一個標識符、一個整數、浮點數、虛數、字符或字符串文字、關鍵字break、continue、fallthrough或return中的一個、運算符和分隔符++、--、)、]或}中的一個） 後添加分號，所以在哪里加分號合適是取決於Go語言代碼的。例如：在Go語言中的函數聲明和 { 大括號必鬚在同一行，而在x + y這樣的表達式中，在+號後換行可以，但是在+號前換行則會有問題（譯註：以+結尾的話不會被插入分號分隔符，但是以x結尾的話則會被分號分隔符，從而導致編譯錯誤）。</p>
|
||||
<p>Go語言在代碼格式上采取了很強硬的態度。gofmt工具會將你的代碼格式化爲標準格式（譯註：這個格式化工具沒有任何可以調整代碼格式的參數，Go語言就是這麽任性），併且go工具中的fmt子命令會自動對特定package下的所有.go源文件應用gofmt工具格式化。如果不指定package，則默認對當前目録下的源文件進行格式化。本書中的所有代碼已經是執行過gofmt後的標準格式代碼。你應該在自己的代碼上也執行這種格式化。規定一種標準的代碼格式可以規避掉無盡的無意義的撕逼（譯註：也導致了Go語言的TIOBE排名較低，因爲缺少撕逼的話題）。當然了，這可以避免由於代碼格式導致的邏輯上的歧義。</p>
|
||||
<p>很多文本編輯器都可以設置爲保存文件時自動執行gofmt，所以你的源代碼應該總是會被格式化。這里還有一個相關的工具，goimports，會自動地添加你代碼里需要用到的import聲明以及需要移除的import聲明。這個工具併沒有包含在標準的分發包中，然而你可以自行安裝：</p>
|
||||
<pre><code>$ go get golang.org/x/tools/cmd/goimports
|
||||
</code></pre><p>對於大多數用戶來説，下載、build package、運行測試用例、顯示go的文檔等等常用功能都是可以用go的工具來實現的。這些工具的詳細介紹我們會在10.7節中提到。</p>
|
||||
</code></pre><p>對於大多數用戶來説，下載、build package、運行測試用例、顯示Go語言的文檔等等常用功能都是可以用go的工具來實現的。這些工具的詳細介紹我們會在10.7節中提到。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.2" data-chapter-title="命令行參數" data-filepath="ch1/ch1-02.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.2" data-chapter-title="命令行參數" data-filepath="ch1/ch1-02.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2025,49 +2025,51 @@
|
||||
|
||||
<h2 id="12-命令行參數">1.2. 命令行參數</h2>
|
||||
<p>大多數的程序都是處理輸入，産生輸齣；這也正是“計算”的定義。但是一個程序要如何穫取輸入呢？一些程序會生成自己的數據，但通常情況下，輸入都來自於程序外部：比如文件、網絡連接、其它程序的輸齣、用戶的鍵盤、命令行的參數或其它類似輸入源。下面幾個例子會討論其中的一些輸入類型，首先是命令行參數。</p>
|
||||
<p>os這個package提供了操作繫統無關(跨平颱)的，與繫統交互的一些函數和相關的變量，運行時程序的命令行參數可以用一個叫os包中的Args這個變量來穫取；在外部需要使用該變量時，需要用os.Args來訪問。</p>
|
||||
<p>os.Args這個變量是一個字符串(string)的slice，slice在go語言里是一個基礎的數據結構，之後我們很快會提到。現在可以先把slice當一個簡單的元素序列，可以用類似s[i]的下標訪問形式穫取其內容，併且可以用形如s[m:n]的形式來穫取到一個slice的子集(譯註：和python里的差不多)。其長度可以用len(s)函數來穫取。和其它大多數語言差不多，go語言里的這種索引形式也采用了開區間，包括m~n的第一個元素，但不包括最後那個元素(譯註：比如a = [1, 2, 3, 4, 5], a[0: 3] =[1, 2, 3]，不包含最後一個元素)。這樣可以簡化我們的邏輯。比如s[m:n]這個slice，0 ≤ m ≤ n ≤ len(s)，包含n-m個元素。</p>
|
||||
<p>os.Args的第一個元素，卽os.Args[0]是命令行執行時的命令本身；其它的元素則是執行該命令時傳給這個程序的參數。前面提到的切片表達式，s[m:n]會返迴第m到第n-1個元素，所以下一個例子里需要用到的os.Args[1:len(os.Args)]卽是除了命令本身外的所有傳入參數。如果我們省略s[m:n]里的m和n，那麽默認這個表達式會填入0:len(s)，所以這里我們還可以省略掉n，寫os.Args[1:]。</p>
|
||||
<p>下面是一個Unix里echo命令的實現，這個命令會在單行內打印齣命令行參數。這個程序import了兩個package，併且用括號把這兩個package包了起來，這是分别import各個package聲明的簡化寫法。當然了你分開來寫import也沒有什麽問題，隻是一般爲了方便我們都會像下面這樣來導入多個package。我們自己寫的導入順序併不重要，因爲gofmt工具會幫助我們按照字母順序來排列好這些導入包名。(本書中如果一個例子有多種版本時，我們會用編號標記齣來)</p>
|
||||
<p>os這個package提供了操作繫統無關（跨平颱）的，與繫統交互的一些函數和相關的變量，運行時程序的命令行參數可以通過os包中一個叫Args的這個變量來穫取；當在os包外部使用該變量時，需要用os.Args來訪問。</p>
|
||||
<p>os.Args這個變量是一個字符串（string）的slice（譯註：slice和Python語言中的切片類似，是一個簡版的動態數組），slice在Go語言里是一個基礎的數據結構，之後我們很快會提到。現在可以先把slice當一個簡單的元素序列，可以用類似s[i]的下標訪問形式穫取其內容，併且可以用形如s[m:n]的形式來穫取到一個slice的子集(譯註：和python里的語法差不多)。其長度可以用len(s)函數來穫取。和其它大多數編程語言類似，Go語言里的這種索引形式也采用了左閉右開區間，包括m~n的第一個元素，但不包括最後那個元素（譯註：比如a = [1, 2, 3, 4, 5], a[0:3] = [1, 2, 3]，不包含最後一個元素）。這樣可以簡化我們的處理邏輯。比如s[m:n]這個slice，0 ≤ m ≤ n ≤ len(s)，包含n-m個元素。</p>
|
||||
<p>os.Args的第一個元素，卽os.Args[0]是命令行執行時的命令本身；其它的元素則是執行該命令時傳給這個程序的參數。前面提到的切片表達式，s[m:n]會返迴第m到第n-1個元素，所以下一個例子里需要用到的os.Args[1:len(os.Args)]卽是除了命令本身外的所有傳入參數。如果我們省略s[m:n]里的m和n，那麽默認這個表達式會填入0:len(s)，所以這里我們還可以省略掉n，寫成os.Args[1:]。</p>
|
||||
<p>下面是一個Unix里echo命令的實現，這個命令會在單行內打印齣命令行參數。這個程序import了兩個package，併且用括號把這兩個package包了起來，這是分别import各個package聲明的簡化寫法。當然了你分開來寫import也沒有什麽問題，隻是一般爲了方便我們都會像下面這樣來導入多個package。我們自己寫的導入順序併不重要，因爲gofmt工具會幫助我們按照字母順序來排列好這些導入包名。（本書中如果一個例子有多種版本時，我們會用編號標記齣來）</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/echo1
|
||||
<span class="hljs-comment">// Echo1 prints its command-line arguments.</span>
|
||||
<span class="hljs-keyword">package</span> main
|
||||
|
||||
<span class="hljs-keyword">import</span> (
|
||||
<span class="hljs-string">"fmt"</span>
|
||||
<span class="hljs-string">"os"</span>
|
||||
)
|
||||
|
||||
<span class="hljs-keyword">func</span> main() {
|
||||
<span class="hljs-keyword">var</span> s, sep <span class="hljs-typename">string</span>
|
||||
<span class="hljs-keyword">for</span> i := <span class="hljs-number">1</span>; i < <span class="hljs-built_in">len</span>(os.Args); i++ {
|
||||
s += sep + os.Args[i]
|
||||
sep = <span class="hljs-string">" "</span>
|
||||
}
|
||||
fmt.Println(s)
|
||||
<span class="hljs-keyword">var</span> s, sep <span class="hljs-typename">string</span>
|
||||
<span class="hljs-keyword">for</span> i := <span class="hljs-number">1</span>; i < <span class="hljs-built_in">len</span>(os.Args); i++ {
|
||||
s += sep + os.Args[i]
|
||||
sep = <span class="hljs-string">" "</span>
|
||||
}
|
||||
fmt.Println(s)
|
||||
}
|
||||
</code></pre>
|
||||
<p>Go里的註釋是以//來表示。//後的內容一直到行末都是這條註釋的一部分，併且這些註釋會被編譯器忽略。</p>
|
||||
<p>Go語言里的註釋是以//來表示。//之後的內容一直到行末都是這條註釋的一部分，併且這些註釋會被編譯器忽略。</p>
|
||||
<p>按照慣例，我們會在每一個package前面放上這個package的詳盡的註釋對其進行説明；對於一個main package來説，一般這段評論會包含幾句話來説明這個項目/程序整體是做什麽用的。</p>
|
||||
<p>var關鍵字用來做變量聲明。這里聲明了s和sep兩個string變量。變量可以在聲明期間直接進行初始化。如果沒有顯式地初始化的話，Go會隱式地給這些未初始化的變量賦予對應其類型的零值，比如數值類型就是0，字符串類型就是“”空字符串。在這個例子里的s和sep被隱式地賦值爲了空字符串。在第2章中我們會更詳細地講解變量和聲明。</p>
|
||||
<p>對於數字類型，Go語言提供了常規的數值計算和邏輯運算符。而對於string類型，+號表示字符串的連接(譯註：和C++或者js是一樣的)。所以下面這個表達式：</p>
|
||||
<p>var關鍵字用來做變量聲明。這個程序聲明了s和sep兩個string變量。變量可以在聲明期間直接進行初始化。如果沒有顯式地初始化的話，Go語言會隱式地給這些未初始化的變量賦予對應其類型的零值，比如數值類型就是0，字符串類型就是空字符串“”。在這個例子里的s和sep被隱式地賦值爲了空字符串。在第2章中我們會更詳細地講解變量和聲明。</p>
|
||||
<p>對於數字類型，Go語言提供了常規的數值計算和邏輯運算符。而對於string類型，+號表示字符串的連接（譯註：和C++或者js是一樣的）。所以下面這個表達式：</p>
|
||||
<pre><code class="lang-go">sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>表示將sep字符串和os.Args[i]字符串進行連接。我們在程序里用的另外一個表達式：</p>
|
||||
<pre><code class="lang-go">s += sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>會將sep與os.Args[i]連接，然後再將得到的結果與s進行連接，這種方式和下面的表達是等價的：</p>
|
||||
<p>會將sep與os.Args[i]連接，然後再將得到的結果與s進行連接併賦值運給s，這種方式和下面的表達是等價的：</p>
|
||||
<pre><code class="lang-go">s = s + sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>運算符+=是一個賦值運算符(assignment operator)，每一種數值和邏輯運算符，例如*或者+都有其對應的賦值運算符。</p>
|
||||
<p>echo程序可以每循環一次輸齣一個參數，不過我們這里的版本是不斷地將其結果連接到一個字符串的末尾。s這個字符串在聲明的時候是一個空字符串，而之後循環每次都會被在末尾添加一段字符串；第一次迭代之後，一個空格會被插入到字符串末尾，所以每插入一個新值，都會和前一個中間有一個空格隔開。這是一種非線性的操作，當我們的參數數量變得龐大的時候(當然不是説這里的echo，一般echo也不會有太多參數)其運行開銷也會變得龐大。下面我們會介紹一繫列的echo改進版，來應對這里説到的運行效率低下。</p>
|
||||
<p>在for循環中，我們用到了i來做下標索引，可以看到我們用了:=符號來給i進行初始化和賦值，這是var xxx=yyy的一種簡寫形式，Go會根據等號右邊的值的類型自動判斷左邊的值類型，下一章會對這一點進行詳細説明。</p>
|
||||
<p>自增表達式i++會爲i加上1；這個i += 1以及i = i + 1都是等價的。對應的還有i--是給i減去1。這些在go語言里是語句，而不像C繫的其它語言里是表達式。所以在Go語言里j = i++是非法的，而且++和--都隻能放在變量名後面，因此--i也是非法的。</p>
|
||||
<p>echo程序可以每循環一次輸齣一個參數，不過我們這里的版本是不斷地將其結果連接到一個字符串的末尾。s這個字符串在聲明的時候是一個空字符串，而之後循環每次都會被在末尾添加一段字符串；第一次迭代之後，一個空格會被插入到字符串末尾，所以每插入一個新值，都會和前一個中間有一個空格隔開。這是一種非線性的操作，當我們的參數數量變得龐大的時候（當然不是説這里的echo，一般echo也不會有太多參數）其運行開銷也會變得龐大。下面我們會介紹一繫列的echo改進版，來應對這里説到的運行效率低下。</p>
|
||||
<p>在for循環中，我們用到了i來做下標索引，可以看到我們用了:=符號來給i進行初始化和賦值，這是var xxx=yyy的一種簡寫形式，Go語言會根據等號右邊的值的類型自動判斷左邊的值類型，下一章會對這一點進行詳細説明。</p>
|
||||
<p>自增表達式i++會爲i加上1；這和i += 1以及i = i + 1都是等價的。對應的還有i--是給i減去1。這些在Go語言里是語句，而不像C繫的其它語言里是表達式。所以在Go語言里j = i++是非法的，而且++和--都隻能放在變量名後面，因此--i也是非法的。</p>
|
||||
<p>在Go語言里隻有for循環一種循環。當然了爲了滿足需求，Go的for循環有很多種形式，下面是其中的一種：</p>
|
||||
<pre><code class="lang-go"><span class="hljs-keyword">for</span> initialization; condition; post {
|
||||
<span class="hljs-comment">// zero or more statements</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>這里需要註意，for循環的兩邊是不需要像其它語言一樣寫括號的。併且左大括號需要和for語句在同一行。</p>
|
||||
<p>initialization部分是可選的，如果你寫了這部分的話，在for循環之前這部分的邏輯會被執行。需要註意的是這部分必鬚是一個簡單的語句，也就是説是一個簡短的變量聲明，一個賦值語句，或是一個函數調用。condition部分必鬚是一個結果爲boolean值的表達式，在每次循環之前，語言都會檢査當前是否滿足這個條件，如果不滿足的話便會結束循環；post部分的語句則是在每次循環結束之後被執行，之後conditon部分會在下一次執行前再被執行，依此往複。當condition條件里的判斷結果變爲false之後，循環卽結束。</p>
|
||||
<p>initialization部分是可選的，如果你寫了這部分的話，在for循環之前這部分的邏輯會被執行。需要註意的是這部分必鬚是一個簡單的語句，也就是説是一個簡短的變量聲明，一個賦值語句，或是一個函數調用。condition部分必鬚是一個結果爲boolean值的表達式，在每次循環之前，語言都會檢査當前是否滿足這個條件，如果不滿足的話便會結束循環；post部分的語句則是在每次循環迭代結束之後被執行，之後conditon部分會在下一次執行前再被執行，依此往複。當condition條件里的判斷結果變爲false之後，循環卽結束。</p>
|
||||
<p>上面提到是for循環里的三個部分都是可以被省略的，如果你把initialization和post部分都省略的話，那麽連中間隔離他們的分號也是可以被省略的，比如下面這種for循環，就和傳統的while循環是一樣的：</p>
|
||||
<pre><code class="lang-go"><span class="hljs-comment">// a traditional "while" loop</span>
|
||||
<span class="hljs-keyword">for</span> condition {
|
||||
@@ -2080,8 +2082,8 @@
|
||||
<span class="hljs-comment">// ...</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>在無限循環中，你還是可以靠break或者return來終止掉循環。</p>
|
||||
<p>如果你的遍歷對象是string或者slice里的值的話，還有另外一種循環的寫法，我們來看看另一個版本的echo：</p>
|
||||
<p>在無限循環中，你還是可以靠break或者return語句來終止掉循環。</p>
|
||||
<p>如果你的遍歷對象是string或者slice類型值的話，還有另外一種循環的寫法，我們來看看另一個版本的echo：</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/echo2
|
||||
<span class="hljs-comment">// Echo2 prints its command-line arguments.</span>
|
||||
<span class="hljs-keyword">package</span> main
|
||||
@@ -2099,18 +2101,17 @@
|
||||
fmt.Println(s)
|
||||
}
|
||||
</code></pre>
|
||||
<p>每一次循環迭代，range都會返迴一對結果；當前迭代的下標以及在該下標處的元素的值。在這個例子里，我們不需要這個下標，但是因爲range的處理要求我們必鬚要同時處理下標和值。我們可以在這里聲明一個接收index的臨時變量來解決這個問題，但是go語言又不允許隻聲明而在後續代碼里不使用這個變量，如果你這樣做了編譯器會返迴一個編譯錯誤。</p>
|
||||
<p>在Go語言中，應對這種情況的解決方法是用空白標識符，對，就是上面那個下劃線<em>。空白標識符可以在任何你接收自己不需要處理的值時使用。在這里，我們用他來忽略掉range返迴的那個沒用的下標值。大多數的Go程序員都會像上面這樣來寫類似的os.Args遍歷，可以避免錯誤的下標引用。(這里可能有翻譯錯，附上原文)
|
||||
Most Go programmers would likely use range and </em> to write the echo program as above, since the indexing over os.Args is implicit, not explicit, and thus easier to get right.</p>
|
||||
<p>每一次循環迭代，range都會返迴一對結果；當前迭代的下標以及在該下標處的元素的值。在這個例子里，我們不需要這個下標，但是因爲range的處理要求我們必鬚要同時處理下標和值。我們可以在這里聲明一個接收index的臨時變量來解決這個問題，但是Go語言又不允許隻聲明而在後續代碼里不使用這個變量，如果你這樣做了編譯器會返迴一個編譯錯誤。</p>
|
||||
<p>在Go語言中，應對這種情況的解決方法是用空白標識符，對，就是上面那個下劃線_。空白標識符可以在任何你接收自己不需要處理的值時使用。在這里，我們用它來忽略掉range返迴的那個沒用的下標值。大多數的Go程序員都會像上面這樣來寫類似的os.Args遍歷，由於遍歷os.Args的下標索引是隱式自動生成的，可以避免因顯式更新索引導致的錯誤。</p>
|
||||
<p>上面這個版本將s和sep的聲明和初始化都放到了一起，但是我們可以等價地將聲明和賦值分開來寫，下面這些寫法都是等價的</p>
|
||||
<pre><code class="lang-go">s := <span class="hljs-string">""</span>
|
||||
<span class="hljs-keyword">var</span> s <span class="hljs-typename">string</span>
|
||||
<span class="hljs-keyword">var</span> s = <span class="hljs-string">""</span>
|
||||
<span class="hljs-keyword">var</span> s <span class="hljs-typename">string</span> = <span class="hljs-string">""</span>
|
||||
</code></pre>
|
||||
<p>那麽這些等價的形式應該怎麽做選擇呢？這里提供一些建議：第一種形式，最好隻用在一個函數內部，而package級别的變量，請不要使用這樣的聲明方式。第二種形式依賴於string類型的內部初始化機製，被初始化爲空字符串。第三種形式使用得很少，除非同時聲明多個變量。第四種形式會顯式地標明變量的類型，在多變量同時聲明時可以用到。實踐中你應該隻使用上面的前兩種形式，顯式地指定變量的類型，讓編譯器自己去初始化其值，或者直接用隱式初始化，表明初始值怎麽樣併不重要。</p>
|
||||
<p>像上面提到的，每次循環中字符串s都會得到一個新內容。+=語句會分配一個新的字符串，併將老字符串連接起來的值賦予給它。而目標字符串的老字面值在得到新值以後就失去了用處，這些臨時值會被go的垃圾收集器榦掉。</p>
|
||||
<p>如果不斷連接的數據量很大，那麽上面這種操作就是成本非常高的操作。更簡單併且有效的一種方式是使用字符串的Join函數，像下面這樣：</p>
|
||||
<p>那麽這些等價的形式應該怎麽做選擇呢？這里提供一些建議：第一種形式，隻能用在一個函數內部，而package級别的變量，禁止用這樣的聲明方式。第二種形式依賴於string類型的內部初始化機製，被初始化爲空字符串。第三種形式使用得很少，除非同時聲明多個變量。第四種形式會顯式地標明變量的類型，在多變量同時聲明時可以用到。實踐中你應該隻使用上面的前兩種形式，顯式地指定變量的類型，讓編譯器自己去初始化其值，或者直接用隱式初始化，表明初始值怎麽樣併不重要。</p>
|
||||
<p>像上面提到的，每次循環迭代中字符串s都會得到一個新內容。+=語句會分配一個新的字符串，併將老字符串連接起來的值賦予給它。而目標字符串的老字面值在得到新值以後就失去了用處，這些臨時值會被Go語言的垃圾收集器榦掉。</p>
|
||||
<p>如果不斷連接的數據量很大，那麽上面這種操作就是成本非常高的操作。更簡單併且有效的一種方式是使用strings包提供的Join函數，像下面這樣：</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/echo3
|
||||
<span class="hljs-keyword">func</span> main() {
|
||||
fmt.Println(strings.Join(os.Args[<span class="hljs-number">1</span>:], <span class="hljs-string">" "</span>))
|
||||
@@ -2119,12 +2120,11 @@ Most Go programmers would likely use range and </em> to write the echo program a
|
||||
<p>最後，如果我們對輸齣的格式也不是很關心，隻是想簡單地輸齣值得的話，還可以像下面這麽寫，Println函數會爲我們自動格式化輸齣。</p>
|
||||
<pre><code class="lang-go">fmt.Println(os.Args[<span class="hljs-number">1</span>:])
|
||||
</code></pre>
|
||||
<p>這個輸齣結果和前面的string.Join得到的結果很相似，隻是被自動地放到了一個括號里，對slice調用Println函數都會被打印成這樣形式的結果。</p>
|
||||
<p>下面是幾道練習題：</p>
|
||||
<pre><code>Exercise 1.1:脩改echo程序，使其能夠打印os.Args[0]。
|
||||
Exercise 1.2:脩改echo程序，使其打印value和index，每個value和index顯示一行。
|
||||
Exercise 1.3:上手實踐前面提到的strings.Join和直接Println，併觀察輸齣結果的區别。
|
||||
</code></pre>
|
||||
<p>這個輸齣結果和前面的string.Join得到的結果很相似，隻是被自動地放到了一個方括號里，對slice調用Println函數都會被打印成這樣形式的結果。</p>
|
||||
<p><strong>練習 1.1：</strong> 脩改echo程序，使其能夠打印os.Args[0]。</p>
|
||||
<p><strong>練習 1.2：</strong> 脩改echo程序，使其打印value和index，每個value和index顯示一行。</p>
|
||||
<p><strong>練習 1.3：</strong> 上手實踐前面提到的strings.Join和直接Println，併觀察輸齣結果的區别。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.3" data-chapter-title="査找重複的行" data-filepath="ch1/ch1-03.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.3" data-chapter-title="査找重複的行" data-filepath="ch1/ch1-03.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,8 +2024,8 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="13-査找重複的行">1.3. 査找重複的行</h2>
|
||||
<p>文件拷貝、文件打印、文件蒐索、文件排序、文件統計類的程序一般都會有比較相似的程序結構：處理輸入的一個循環，在每一個輸入元素上執行計算處理，在處理的同時或者處理完成之後進行結果輸齣。我們會展示一個叫dup程序的三個版本；這個程序的靈感來自於linux的uniq命令，我們的程序將會找到相鄰的重複的行。這個程序提供的模式可以很方便地被脩改來完成不同的需求。</p>
|
||||
<p>第一個版本的dup會輸齣標準輸入流中的齣現多次的行，在行內容前會有其齣現次數的計數。這個程序將引入if表達式，map內置數據結果和bufio的package。</p>
|
||||
<p>文件拷貝、文件打印、文件蒐索、文件排序、文件統計類的程序一般都會有比較相似的程序結構：一個處理輸入的循環，在每一個輸入元素上執行計算處理，在處理的同時或者處理完成之後進行結果輸齣。我們會展示一個叫dup程序的三個版本；這個程序的靈感來自於linux的uniq命令，我們的程序將會找到相鄰的重複的行。這個程序提供的模式可以很方便地被脩改來完成不同的需求。</p>
|
||||
<p>第一個版本的dup會輸齣標準輸入流中的齣現多次的行，在行內容前會有其齣現次數的計數。這個程序將引入if表達式，map內置數據結構和bufio的package。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/dup1
|
||||
<span class="hljs-comment">// Dup1 prints the text of each line that appears more than</span>
|
||||
<span class="hljs-comment">// once in the standard input, preceded by its count.</span>
|
||||
@@ -2051,31 +2051,31 @@
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>和我們前面提到的for循環一樣，在if條件的兩邊，我們也不需要加括號，但是if表達式後的邏輯體的花括號是不能省略的。如果需要的話，像其它語言一樣，這個表達式也可以有else部分，這部分邏輯會在if中的條件結果爲false時被執行。</p>
|
||||
<p>map是go語言內置的key/value數據結構，這個數據結構能夠提供常數時間的存儲、穫取、測試操作。key可以是任意數據類型，隻要該類型能夠用==來進行比較，string是最常用的key類型。而value類型的范圍就更大了，基本上什麽類型都是可以的。這個例子中的key都是string類型，value用的是int類型。我們用內置make函數來創建一個空的map，當然了，make方法還可以有别的用處。在4.3章中我們還會對map進行更深度的討論。</p>
|
||||
<p>和我們前面提到的for循環一樣，在if條件的兩邊，我們也不需要加括號，但是if表達式後的邏輯體的花括號是不能省略的。如果需要的話，像其它編程語言一樣，這個if表達式也可以有else部分，這部分邏輯會在if中的條件結果爲false時被執行。</p>
|
||||
<p>map是Go語言內置的key/value型數據結構，這個數據結構能夠提供常數時間的存儲、穫取、測試操作。key可以是任意數據類型，隻要該類型能夠用==運算符來進行比較，string是最常用的key類型。而value類型的范圍就更大了，基本上什麽類型都是可以的。這個例子中的key都是string類型，value用的是int類型。我們用內置make函數來創建一個空的map，當然了，make方法還可以有别的用處。在4.3章中我們還會對map進行更深入的討論。</p>
|
||||
<p>dup程序每次讀取輸入的一行，這一行的內容會被當做一個map的key，而其value值會被+1。counts[input.Text()]++這個語句和下面的兩句是等價的：</p>
|
||||
<pre><code class="lang-go">line := input.Text()
|
||||
counts[line] = counts[line] + <span class="hljs-number">1</span>
|
||||
</code></pre>
|
||||
<p>當然了，在這個例子里我們併不用擔心map在沒有當前的key時就對其進行++操作會有什麽問題，因爲go語言在碰到這種情況時，會自動將其初始化爲0，然後再進行操作。</p>
|
||||
<p>在這里我們又用了一個range的循環來打印結果，這次range是被用在map這個數據結果上。這一次的情況和上次比較類型，range會返迴兩個值，一個key和在map對應這個key的value。對map進行range循環時，其順序是不確定的，從實踐來看，很可能每次運行都會有不一樣的結果(譯註：這是go的設計者有意爲之的，因爲其底層實現不保證插入順序和遍歷順序一致，而希望程序員不要依賴遍歷時的順序，所以榦脆直接在遍歷的時候做了隨機化處理，醉了)，來避免程序員在業務中依賴遍歷時的順序。</p>
|
||||
<p>當然了，在這個例子里我們併不用擔心map在沒有當前的key時就對其進行++操作會有什麽問題，因爲Go語言在碰到這種情況時，會自動將其初始化爲0，然後再進行操作。</p>
|
||||
<p>在這里我們又用了一個range的循環來打印結果，這次range是被用在map這個數據結構之上。這一次的情況和上次比較類似，range會返迴兩個值，一個key和在map對應這個key的value。對map進行range循環時，其迭代順序是不確定的，從實踐來看，很可能每次運行都會有不一樣的結果（譯註：這是Go語言的設計者有意爲之的，因爲其底層實現不保證插入順序和遍歷順序一致，也希望程序員不要依賴遍歷時的順序，所以榦脆直接在遍歷的時候做了隨機化處理，醉了。補充：好像説隨機序可以防止某種類型的攻擊，雖然不太明白，但是感覺還蠻厲害的），來避免程序員在業務中依賴遍歷時的順序。</p>
|
||||
<p>然後輪到我們例子中的bufio這個package了，這個package主要的目的是幫助我們更方便有效地處理程序的輸入和輸齣。而這個包最有用的一個特性就是其中的一個Scanner類型，用它可以簡單地接收輸入，或者把輸入打散成行或者單詞；這個類型通常是處理行形式的輸入最簡單的方法了。</p>
|
||||
<p>本程序中用了一個短變量聲明，來創建一個buffio.Scanner對象：</p>
|
||||
<pre><code>input := bufio.NewScanner(os.Stdin)
|
||||
</code></pre><p>scanner對象可以從程序的標準輸入中讀取內容。對input.Scanner的每一次調用都會調入一個新行，併且會自動將其行末的換行符去掉；其結果可以用input.Text()得到。Scan方法在讀到了新行的時候會返迴true，而在沒有新行被讀入時，會返迴false。</p>
|
||||
<p>例子中還有一個fmt.Printf，這個函數和C繫的其它語言里的那個printf函數差不多，都是格式化輸齣的方法。fmt.Printf的第一個參數卽是輸齣內容的格式規約，每一個參數如果格式化是取決於在格式化字符串里齣現的“轉換字符”，這個字符串是跟着%號後的一個字母。比如%d表示以一個整數的形式來打印一個變量，而%s，則表示以string形式來打印一個變量。</p>
|
||||
<p>Printf有一大堆這種轉換，Go程序員把這些叫做verb(動詞)。下面的表格列齣了常用的動詞，當然了不是全部，但基本也夠用了。</p>
|
||||
<p>例子中還有一個fmt.Printf，這個函數和C繫的其它語言里的那個printf函數差不多，都是格式化輸齣的方法。fmt.Printf的第一個參數卽是輸齣內容的格式規約，每一個參數如何格式化是取決於在格式化字符串里齣現的“轉換字符”，這個字符串是跟着%號後的一個字母。比如%d表示以一個整數的形式來打印一個變量，而%s，則表示以string形式來打印一個變量。</p>
|
||||
<p>Printf有一大堆這種轉換，Go語言程序員把這些叫做verb（動詞）。下面的表格列齣了常用的動詞，當然了不是全部，但基本也夠用了。</p>
|
||||
<pre><code>%d int變量
|
||||
%x, %o, %b 分别爲16進製，8進製，2進製形式的int
|
||||
%f, %g, %e 浮點數： 3.141593 3.141592653589793 3.141593e+00
|
||||
%t 布爾變量：true 或 false
|
||||
%c rune (Unicode code point)，go語言里特有的Unicode字符類型
|
||||
%c rune (Unicode碼點)，Go語言里特有的Unicode字符類型
|
||||
%s string
|
||||
%q quoted string "abc" or rune 'c'
|
||||
%q 帶雙引號的字符串 "abc" 或 帶單引號的 rune 'c'
|
||||
%v 會將任意變量以易讀的形式打印齣來
|
||||
%T 打印變量的類型
|
||||
%% 字符型百分比標誌(不確定) literal percent sign (no operand)
|
||||
</code></pre><p>dup1中的程序還包含了一個\t和\n的格式化字符串。在字符串中會以這些特殊的轉義字符來表示不可見字符。Printf默認不會在輸齣內容後加上換行符。按照慣例，用來格式化的函數都會在末尾以f字母結尾，比如log.Printf，fmt.Errorf，同時還有一繫列對應以ln結尾的函數，這些函數默認以%v來格式化他們的參數，併且會在輸齣結束後在最後自動加上一個換行符。</p>
|
||||
%% 字符型百分比標誌（%符號本身，沒有其他操作）
|
||||
</code></pre><p>dup1中的程序還包含了一個\t和\n的格式化字符串。在字符串中會以這些特殊的轉義字符來表示不可見字符。Printf默認不會在輸齣內容後加上換行符。按照慣例，用來格式化的函數都會在末尾以f字母結尾（譯註：f後綴對應format或fmt縮寫），比如log.Printf，fmt.Errorf，同時還有一繫列對應以ln結尾的函數（譯註：ln後綴對應line縮寫），這些函數默認以%v來格式化他們的參數，併且會在輸齣結束後在最後自動加上一個換行符。</p>
|
||||
<p>許多程序從標準輸入中讀取數據，像上面的例子那樣。除此之外，還可能從一繫列的文件中讀取。下一個dup程序就是從標準輸入中讀到一些文件名，用os.Open函數來打開每一個文件穫取內容的。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/dup2
|
||||
<span class="hljs-comment">// Dup2 prints the count and text of lines that appear more than once</span>
|
||||
@@ -2120,12 +2120,12 @@ counts[line] = counts[line] + <span class="hljs-number">1</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>os.Open函數會返迴兩個值。第一個值是一個打開的文件類型(*os.File)，這個對象在下面的程序中被Scanner讀取。</p>
|
||||
<p>os.Open返迴的第二個值是一個go內置的error類型。如果這個error和內置值的nil(譯註：相當於其它語言里的NULL)相等的話，説明文件被成功的打開了。之後文件被讀取，一直到文件的最後，Close函數關閉該文件，併釋放相應的占用一切資源。另一方面，如果err的值不是nil的話，那説明在打開文件的時候齣了某種錯誤。這種情況下，error類型的值會描述具體的問題。我們例子里的簡單錯誤處理會在標準錯誤流中用Fprintf和%v來格式化該錯誤字符串。然後繼續處理下一個文件；continue語句會直接跳過之後的語句，直接開始執行下一次循環。</p>
|
||||
<p>我們在本書中早期的例子中做了比較詳盡的錯誤處理，當然了，在實際編碼過程中，像os.Open這類的函數是一定要檢査其返迴的error值的；爲了減少例子程序的代碼量，我們姑且簡化掉這些不太可能返迴錯誤的邏輯。後面的例子里我們會跳過錯誤檢査。在5.4節中我們會對錯誤處理做更詳細的闡述。</p>
|
||||
<p>讀者可以再觀察一下上面的例子，我們的countLines函數是在其聲明之前就被調用了。在Go語言里，函數和包級别的變量可以以任意的順序被聲明，併不影響其被調用。(譯註：最好還是遵循一定的規范)</p>
|
||||
<p>再來講講map這個數據結構，map是用make函數創建的數據結構的一個引用。當一個map被作爲參數傳遞給一個函數時，函數接收到的是一份引用的拷貝，雖然本身併不是一個東西，但因爲他們指向的是同一塊數據對象(譯註：類似於C艹里的引用傳遞)，所以你在函數里對map里的值進行脩改時，原始的map內的值也會改變。在我們的例子中，我們在countLines函數中插入到counts這個map里的值，在主函數中也是看得到的。</p>
|
||||
<p>上面這個版本的dup是以流的形式來處理輸入，併將其打散爲行。理論上這些程序也是可以以二進製形式來處理輸入的。我們也可以一次性的把整個輸入內容全部讀到內存中，然後再把其分割爲多行，然後再去處理這些行內的數據。下面的dup3這個例子就是以這種形式來進行操作的。這個例子引入了一個新函數ReadFile(從io/ioutil這個包)，這個函數會把一個指定名字的文件內容一次性調入，之後我們用strings.Split函數把文件分割爲多個子字符串，併存儲到slice結構中。(Split函數是strings.Join的逆函數，Join函數之前提到過)</p>
|
||||
<p>我們簡化了dup3這個程序。首先，他隻讀取命名的文件，而不去讀標準輸入，因爲ReadFile函數需要一個文件名參數。其次，我們將行計數邏輯移迴到了main函數，因爲現在這個邏輯隻有一個地方需要用到。</p>
|
||||
<p>os.Open返迴的第二個值是一個Go語言內置的error類型。如果這個error和內置值的nil（譯註：相當於其它語言里的NULL）相等的話，説明文件被成功的打開了。之後文件被讀取，一直到文件的最後，文件的Close方法關閉該文件，併釋放相應的占用一切資源。另一方面，如果err的值不是nil的話，那説明在打開文件的時候齣了某種錯誤。這種情況下，error類型的值會描述具體的問題。我們例子里的簡單錯誤處理會在標準錯誤流中用Fprintf和%v來格式化該錯誤字符串。然後繼續處理下一個文件；continue語句會直接跳過之後的語句，直接開始執行下一個循環迭代。</p>
|
||||
<p>我們在本書中早期的例子中做了比較詳盡的錯誤處理，當然了，在實際編碼過程中，像os.Open這類的函數是一定要檢査其返迴的error值的；爲了減少例子程序的代碼量，我們姑且簡化掉這些不太可能返迴錯誤的處理邏輯。後面的例子里我們會跳過錯誤檢査。在5.4節中我們會對錯誤處理做更詳細的闡述。</p>
|
||||
<p>讀者可以再觀察一下上面的例子，我們的countLines函數是在其聲明之前就被調用了。在Go語言里，函數和包級别的變量可以以任意的順序被聲明，併不影響其被調用。（譯註：最好還是遵循一定的規范）</p>
|
||||
<p>再來講講map這個數據結構，map是用make函數創建的數據結構的一個引用。當一個map被作爲參數傳遞給一個函數時，函數接收到的是一份引用的拷貝，雖然本身併不是一個東西，但因爲他們指向的是同一塊數據對象（譯註：類似於C++里的引用傳遞），所以你在函數里對map里的值進行脩改時，原始的map內的值也會改變。在我們的例子中，我們在countLines函數中插入到counts這個map里的值，在主函數中也是看得到的。</p>
|
||||
<p>上面這個版本的dup是以流的形式來處理輸入，併將其打散爲行。理論上這些程序也是可以以二進製形式來處理輸入的。我們也可以一次性的把整個輸入內容全部讀到內存中，然後再把其分割爲多行，然後再去處理這些行內的數據。下面的dup3這個例子就是以這種形式來進行操作的。這個例子引入了一個新函數ReadFile（從io/ioutil包提供），這個函數會把一個指定名字的文件內容一次性調入，之後我們用strings.Split函數把文件分割爲多個子字符串，併存儲到slice結構中。（Split函數是strings.Join的逆函數，Join函數之前提到過）</p>
|
||||
<p>我們簡化了dup3這個程序。首先，它隻讀取命名的文件，而不去讀標準輸入，因爲ReadFile函數需要一個文件名參數。其次，我們將行計數邏輯移迴到了main函數，因爲現在這個邏輯隻有一個地方需要用到。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/dup3
|
||||
<span class="hljs-keyword">package</span> main
|
||||
|
||||
@@ -2155,10 +2155,10 @@ counts[line] = counts[line] + <span class="hljs-number">1</span>
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>ReadFile函數返迴一個byte的slice，這個slice必鬚被轉換爲string，之後纔能夠用string.Split方法來進行處理。我們在3.5.4節中會更詳細地講解string和byte slice(字節數組)。</p>
|
||||
<p>ReadFile函數返迴一個byte的slice，這個slice必鬚被轉換爲string，之後纔能夠用string.Split方法來進行處理。我們在3.5.4節中會更詳細地講解string和byte slice（字節數組）。</p>
|
||||
<p>在更底層一些的地方，bufio.Scanner，ioutil.ReadFile和ioutil.WriteFile使用的是*os.File的Read和Write方法，不過一般程序員併不需要去直接了解到其底層實現細節，在bufio和io/ioutil包中提供的方法已經足夠好用。</p>
|
||||
<pre><code>Exercise 1.4: 脩改dup2，使其可以打印重複的行分别齣現在哪些文件。
|
||||
</code></pre>
|
||||
<p><strong>練習 1.4：</strong> 脩改dup2，使其可以打印重複的行分别齣現在哪些文件。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.4" data-chapter-title="GIF動畵" data-filepath="ch1/ch1-04.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.4" data-chapter-title="GIF動畵" data-filepath="ch1/ch1-04.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,15 +2024,16 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="14-gif動畵">1.4. GIF動畵</h2>
|
||||
<p>下面的程序會演示Go語言標準庫里的image這個package的用法，我們會用這個包來生成一繫列的bit-mapped圖，然後將這些圖片編碼爲一個GIF動畵。我們生成的圖形名字叫利薩如圖形(Lissajous figures)，這種效果是在1960年代的老電影里齣現的一種視覺特效。他們是協振子在兩個緯度上振動所産生的麴線，比如兩個sin正絃波分别在x軸和y軸輸入會産生的麴線。圖1.1是這樣的一個例子：</p>
|
||||
<p>下面的程序會演示Go語言標準庫里的image這個package的用法，我們會用這個包來生成一繫列的bit-mapped圖，然後將這些圖片編碼爲一個GIF動畵。我們生成的圖形名字叫利薩如圖形(Lissajous figures)，這種效果是在1960年代的老電影里齣現的一種視覺特效。它們是協振子在兩個緯度上振動所産生的麴線，比如兩個sin正絃波分别在x軸和y軸輸入會産生的麴線。圖1.1是這樣的一個例子：</p>
|
||||
<p><img src="../images/ch1-01.png" alt=""></p>
|
||||
<p>這段代碼里我們用了一些新的結構，包括const聲明，數據struct類型，複合聲明。和我們舉的其它的例子不太一樣，這一個例子包含了浮點數運算。這些概念我們隻在這里簡單地説明一下，之後的章節會更詳細地講解。</p>
|
||||
<p>譯註：要看這個程序的結果，需要將標準輸齣重定向到一個GIF圖像文件（使用 <code>./lissajous > output.gif</code> 命令）。下面是GIF圖像動畵效果：</p>
|
||||
<p><img src="../images/ch1-01.gif" alt=""></p>
|
||||
<p>這段代碼里我們用了一些新的結構，包括const聲明，struct結構體類型，複合聲明。和我們舉的其它的例子不太一樣，這一個例子包含了浮點數運算。這些概念我們隻在這里簡單地説明一下，之後的章節會更詳細地講解。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/lissajous
|
||||
|
||||
<span class="hljs-comment">// Lissajous generates GIF animations of random Lissajous figures.</span>
|
||||
<span class="hljs-keyword">package</span> main
|
||||
|
||||
|
||||
<span class="hljs-keyword">import</span> (
|
||||
<span class="hljs-string">"image"</span>
|
||||
<span class="hljs-string">"image/color"</span>
|
||||
@@ -2044,10 +2045,12 @@
|
||||
)
|
||||
|
||||
<span class="hljs-keyword">var</span> palette = []color.Color{color.White, color.Black}
|
||||
|
||||
<span class="hljs-keyword">const</span> (
|
||||
whiteIndex = <span class="hljs-number">0</span> <span class="hljs-comment">// first color in palette</span>
|
||||
blackIndex = <span class="hljs-number">1</span> <span class="hljs-comment">// next color in palette</span>
|
||||
)
|
||||
|
||||
<span class="hljs-keyword">func</span> main() {
|
||||
lissajous(os.Stdout)
|
||||
}
|
||||
@@ -2071,7 +2074,7 @@
|
||||
x := math.Sin(t)
|
||||
y := math.Sin(t*freq + phase)
|
||||
img.SetColorIndex(size+<span class="hljs-typename">int</span>(x*size+<span class="hljs-number">0.5</span>), size+<span class="hljs-typename">int</span>(y*size+<span class="hljs-number">0.5</span>),
|
||||
blackIndex)
|
||||
bla kIndex)
|
||||
}
|
||||
phase += <span class="hljs-number">0.1</span>
|
||||
anim.Delay = <span class="hljs-built_in">append</span>(anim.Delay, delay)
|
||||
@@ -2080,19 +2083,18 @@ blackIndex)
|
||||
gif.EncodeAll(out, &anim) <span class="hljs-comment">// <span class="hljs-doctag">NOTE:</span> ignoring encoding errors</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>當我們import了一個包路徑包含有多個單詞的package時，比如image/color(image和color兩個單詞)，我們隻需要用最後那個單詞表示這個包就可以。所以當我們寫color.White時，這個變量指向的是image/color包里的變量，同理gif.GIF是屬於image/gif包里的變量。</p>
|
||||
<p>這個程序里的常量聲明給齣了一繫列的常量值，常量是指在程序編譯後運行時始終都不會變化的值，比如圈數、幀數、延遲值。常量聲明和變量聲明一般都會齣現在包級别，所以這些常量在整個包中都是可以共享的，或者你也可以把常量聲明定義在函數體內部，那麽這種常量就隻能在函數體內用。常量聲明的值必鬚是一個數字值、字符串或者一個固定的boolean值。</p>
|
||||
<p>[]color.Color{...}和gif.GIF{...}這兩個表達式就是我們説的複合聲明(4.2和4.4.1節有説明)。這是實例化Go語言里的複合類型的一種寫法。這里的前者生成的是一個slice，後者生成的是一個struct。</p>
|
||||
<p>gif.GIF是一個struct類型(參考4.4節)。struct是一組值或者叫字段的集合，不同的類型集合在一個struct可以讓我們以一個統一的單元進行處理。anim是一個gif.GIF類型的struct變量。這種寫法會生成一個struct變量，併且其內部變量LoopCount字段會被設置爲nframes；而其它的字段會被設置爲各自類型默認的零值。struct內部的變量可以以一個點(.)來進行訪問，就像在最後兩個賦值語句中顯式地更新了anim這個struct的Delay和Image字段。</p>
|
||||
<p>lissajous函數內部有兩層嵌太的for循環。外層循環會循環64次，每一次都會生成一個單獨的動畵幀。它生成了一個包含兩種顔色的201&201大小的圖片，白色和黑色。所有像素點都會被默認設置爲其零值(也就是palette里的第0個值)，這里我們設置的是白色。每次經過內存循環都會通過設置像素爲黑色，生成一張新圖片。其結果會append到之前結果之後。這里我們用到了append(參考4.2.1)這個內置函數，將結果appen到anim中的幀列表末尾，併會設置一個默認的80ms的延遲值。最終循環結束，所有的延遲值也被編碼進了GIF圖片中，併將結果寫入到輸齣流。out這個變量是io.Writer類型，這個類型讓我們可以可以讓我們把輸齣結果寫到很多目標，很快我們就可以看到了。</p>
|
||||
<p>當我們import了一個包路徑包含有多個單詞的package時，比如image/color（image和color兩個單詞），通常我們隻需要用最後那個單詞表示這個包就可以。所以當我們寫color.White時，這個變量指向的是image/color包里的變量，同理gif.GIF是屬於image/gif包里的變量。</p>
|
||||
<p>這個程序里的常量聲明給齣了一繫列的常量值，常量是指在程序編譯後運行時始終都不會變化的值，比如圈數、幀數、延遲值。常量聲明和變量聲明一般都會齣現在包級别，所以這些常量在整個包中都是可以共享的，或者你也可以把常量聲明定義在函數體內部，那麽這種常量就隻能在函數體內用。目前常量聲明的值必鬚是一個數字值、字符串或者一個固定的boolean值。</p>
|
||||
<p>[]color.Color{...}和gif.GIF{...}這兩個表達式就是我們説的複合聲明（4.2和4.4.1節有説明）。這是實例化Go語言里的複合類型的一種寫法。這里的前者生成的是一個slice切片，後者生成的是一個struct結構體。</p>
|
||||
<p>gif.GIF是一個struct類型（參考4.4節）。struct是一組值或者叫字段的集合，不同的類型集合在一個struct可以讓我們以一個統一的單元進行處理。anim是一個gif.GIF類型的struct變量。這種寫法會生成一個struct變量，併且其內部變量LoopCount字段會被設置爲nframes；而其它的字段會被設置爲各自類型默認的零值。struct內部的變量可以以一個點(.)來進行訪問，就像在最後兩個賦值語句中顯式地更新了anim這個struct的Delay和Image字段。</p>
|
||||
<p>lissajous函數內部有兩層嵌套的for循環。外層循環會循環64次，每一次都會生成一個單獨的動畵幀。它生成了一個包含兩種顔色的201&201大小的圖片，白色和黑色。所有像素點都會被默認設置爲其零值（也就是palette里的第0個值），這里我們設置的是白色。每次經過內存循環都會通過設置像素爲黑色，生成一張新圖片。其結果會append到之前結果之後。這里我們用到了append(參考4.2.1)這個內置函數，將結果appen到anim中的幀列表末尾，併會設置一個默認的80ms的延遲值。最終循環結束，所有的延遲值也被編碼進了GIF圖片中，併將結果寫入到輸齣流。out這個變量是io.Writer類型，這個類型讓我們可以可以讓我們把輸齣結果寫到很多目標，很快我們就可以看到了。</p>
|
||||
<p>內存循環設置了兩個偏振。x軸偏振使用的是一個sin函數。y軸偏振也是一個正絃波，但是其其相對x軸的偏振是一個0-3的隨機值，併且初始偏振值是一個零值，併隨着動畵的每一幀逐漸增加。循環會一直跑到x軸完成五次完整的循環。每一步它都會調用SetColorIndex來爲(x, y)點來染黑色。</p>
|
||||
<p>main函數調用了lissajous函數，併且用它來向標準輸齣中打印信息，所以下面這個命令會像圖1.1中産生一個GIF動畵。</p>
|
||||
<pre><code class="lang-bash">$ go build gopl.io/ch1/lissajous
|
||||
<pre><code>$ go build gopl.io/ch1/lissajous
|
||||
$ ./lissajous >out.gif
|
||||
</code></pre>
|
||||
<pre><code>Exercise 1.5: 脩改前面的Lissajous程序里的調色闆，由緑色改爲黑色。我們可以用color.RGBA{0xRR, 0xGG, 0xBB}來得到#RRGGBB這個色值，三個十六進製的字符串分别代表紅、緑、藍像素。
|
||||
Exercise 1.6: 脩改Lissajous程序，脩改其調色闆來生成更豐富的顔色，然後脩改SetColorIndex的第三個參數，看看顯示結果吧。
|
||||
</code></pre>
|
||||
</code></pre><p><strong>練習 1.5：</strong> 脩改前面的Lissajous程序里的調色闆，由緑色改爲黑色。我們可以用color.RGBA{0xRR, 0xGG, 0xBB}來得到#RRGGBB這個色值，三個十六進製的字符串分别代表紅、緑、藍像素。</p>
|
||||
<p><strong>練習 1.6：</strong> 脩改Lissajous程序，脩改其調色闆來生成更豐富的顔色，然後脩改SetColorIndex的第三個參數，看看顯示結果吧。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.5" data-chapter-title="穫取URL" data-filepath="ch1/ch1-05.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.5" data-chapter-title="穫取URL" data-filepath="ch1/ch1-05.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2023,12 +2023,13 @@
|
||||
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="15-穫取url">1.5 穫取URL</h2>
|
||||
<p>對於很多應用來説，訪問互聯網上的信息和訪問本地文件繫統一樣重要。Go在net這個大package下提供了一繫列的package來做這件事情，使用這些包可以更簡單地用網絡收發信息，還可以建立更底層的網絡連接，編寫服務器程序。在這些情景下，Go原生的併發特性(在第八章中會介紹)就顯得尤其好用了。</p>
|
||||
<p>爲了最簡單地展示基於HTTP穫取信息的方式，下面給齣一個示例程序fetch，這個程序將穫取對應的url，併將其源文本打印齣來；這個例子的靈感來源於curl工具(譯註：unix下的一個工具)。當然了，curl提供的功能更爲複雜豐富，這里我們隻編寫最簡單的樣例。之後我們還會在本書中經常用到這個例子。</p>
|
||||
<h2 id="15-穫取url">1.5. 穫取URL</h2>
|
||||
<p>對於很多現代應用來説，訪問互聯網上的信息和訪問本地文件繫統一樣重要。Go語言在net這個強大package的幫助下提供了一繫列的package來做這件事情，使用這些包可以更簡單地用網絡收發信息，還可以建立更底層的網絡連接，編寫服務器程序。在這些情景下，Go語言原生的併發特性（在第八章中會介紹）就顯得尤其好用了。</p>
|
||||
<p>爲了最簡單地展示基於HTTP穫取信息的方式，下面給齣一個示例程序fetch，這個程序將穫取對應的url，併將其源文本打印齣來；這個例子的靈感來源於curl工具（譯註：unix下的一個網絡相關的工具）。當然了，curl提供的功能更爲複雜豐富，這里我們隻編寫最簡單的樣例。之後我們還會在本書中經常用到這個例子。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/fetch
|
||||
<span class="hljs-comment">// Fetch prints the content found at a URL.</span>
|
||||
<span class="hljs-keyword">package</span> main
|
||||
|
||||
<span class="hljs-keyword">import</span> (
|
||||
<span class="hljs-string">"fmt"</span>
|
||||
<span class="hljs-string">"io/ioutil"</span>
|
||||
@@ -2053,23 +2054,24 @@
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>這個程序從兩個package中導入了函數，net/http和io/ioutil，http.Get函數是創建HTTP請求的函數，如果穫取過程沒有齣錯，那麽會在resp這個結構體中得到訪問的請求結果。resp的Body字段包括一個可讀的服務器響應流。這之後ioutil.ReadAll函數從response中讀取到全部內容；其結果保存在變量b中。resp.Body.Close這一句會關閉resp的Body流，防止資源洩露，Printf函數會將結果b寫齣到標準輸齣流中。</p>
|
||||
<pre><code class="lang-bash">$ go build gopl.io/ch1/fetch
|
||||
<p>這個程序從兩個package中導入了函數，net/http和io/ioutil包，http.Get函數是創建HTTP請求的函數，如果穫取過程沒有齣錯，那麽會在resp這個結構體中得到訪問的請求結果。resp的Body字段包括一個可讀的服務器響應流。這之後ioutil.ReadAll函數從response中讀取到全部內容；其結果保存在變量b中。resp.Body.Close這一句會關閉resp的Body流，防止資源洩露，Printf函數會將結果b寫齣到標準輸齣流中。</p>
|
||||
<pre><code>$ go build gopl.io/ch1/fetch
|
||||
$ ./fetch http://gopl.io
|
||||
<html>
|
||||
<head>
|
||||
<title>The Go Programming Language</title>title>
|
||||
...
|
||||
</code></pre>
|
||||
<p>HTTP請求如果失敗了的話，會得到下面這樣的結果：</p>
|
||||
<pre><code class="lang-bash">$ ./fetch http://bad.gopl.io
|
||||
</code></pre><p>HTTP請求如果失敗了的話，會得到下面這樣的結果：</p>
|
||||
<pre><code>$ ./fetch http://bad.gopl.io
|
||||
fetch: Get http://bad.gopl.io: dial tcp: lookup bad.gopl.io: no such host
|
||||
</code></pre>
|
||||
<p>無論哪種失敗原因，我們的程序都用了os.Exit函數來終止進程，併且返迴一個status錯誤碼，其值爲1。</p>
|
||||
<pre><code>Exercise1.7: 函數調用io.Copy(dst, src)會從src中讀取內容，併將讀到的結果寫入到dst中，使用這個函數替代掉例子中的ioutil.ReadAll來拷貝響應結構體到os.Stdout，避免申請一個緩衝區(例子中的b)來存儲。記得處理io.Copy返迴結果中的錯誤。
|
||||
Exercise 1.8: 脩改fetch這個范例，如果輸入的url參數沒有http://前綴的話，爲這個url加上該前綴。你可能會用到strings.HasPrefix這個函數。
|
||||
Exercise 1.9: 脩改fetch打印齣HTTP協議的狀態碼，可以從resp.Status變量得到該狀態碼。
|
||||
</code></pre>
|
||||
</code></pre><p>譯註：在大兲朝的網絡環境下很容易重現這種錯誤，下面是Windows下運行得到的錯誤信息：</p>
|
||||
<pre><code>$ go run main.go http://gopl.io
|
||||
fetch: Get http://gopl.io: dial tcp: lookup gopl.io: getaddrinfow: No such host is known.
|
||||
</code></pre><p>無論哪種失敗原因，我們的程序都用了os.Exit函數來終止進程，併且返迴一個status錯誤碼，其值爲1。</p>
|
||||
<p><strong>練習 1.7：</strong> 函數調用io.Copy(dst, src)會從src中讀取內容，併將讀到的結果寫入到dst中，使用這個函數替代掉例子中的ioutil.ReadAll來拷貝響應結構體到os.Stdout，避免申請一個緩衝區（例子中的b）來存儲。記得處理io.Copy返迴結果中的錯誤。</p>
|
||||
<p><strong>練習 1.8：</strong> 脩改fetch這個范例，如果輸入的url參數沒有 <code>http://</code> 前綴的話，爲這個url加上該前綴。你可能會用到strings.HasPrefix這個函數。</p>
|
||||
<p><strong>練習 1.9：</strong> 脩改fetch打印齣HTTP協議的狀態碼，可以從resp.Status變量得到該狀態碼。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.6" data-chapter-title="併發穫取多個URL" data-filepath="ch1/ch1-06.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.6" data-chapter-title="併發穫取多個URL" data-filepath="ch1/ch1-06.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2023,8 +2023,8 @@
|
||||
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="16-併發穫取多個url">1.6 併發穫取多個URL</h2>
|
||||
<p>Go語言最有意思併且最新奇的特性就是其對併發編程的支持了。併發編程是一個大話題，在第八章和第九章中會講到。這里我們隻淺嚐輒止地來體驗一下Go語言里的goroutine和channel。</p>
|
||||
<h2 id="16-併發穫取多個url">1.6. 併發穫取多個URL</h2>
|
||||
<p>Go語言最有意思併且最新奇的特性就是其對併發編程的支持了。併發編程是一個大話題，在第八章和第九章中會專門講到。這里我們隻淺嚐輒止地來體驗一下Go語言里的goroutine和channel。</p>
|
||||
<p>下面的例子fetchall，和上面的fetch程序所要做的工作是一致的，但是這個fetchall的特别之處在於它會同時去穫取所有的URL，所以這個程序的穫取時間不會超過執行時間最長的那一個任務，而不會像前面的fetch程序一樣，執行時間是所有任務執行時間之和。這次的fetchall程序隻會打印穫取的內容大小和經過的時間，不會像上面那樣打印齣穫取的內容。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/fetchall
|
||||
<span class="hljs-comment">// Fetchall fetches URLs in parallel and reports their times and sizes.</span>
|
||||
@@ -2069,17 +2069,16 @@
|
||||
}
|
||||
</code></pre>
|
||||
<p>下面是一個使用的例子</p>
|
||||
<pre><code class="lang-bash">$ go build gopl.io/ch1/fetchall
|
||||
<pre><code>$ go build gopl.io/ch1/fetchall
|
||||
$ ./fetchall https://golang.org http://gopl.io https://godoc.org
|
||||
<span class="hljs-number">0.14</span>s <span class="hljs-number">6852</span> https://godoc.org
|
||||
<span class="hljs-number">0.16</span>s <span class="hljs-number">7261</span> https://golang.org
|
||||
<span class="hljs-number">0.48</span>s <span class="hljs-number">2475</span> http://gopl.io
|
||||
<span class="hljs-number">0.48</span>s elapsed
|
||||
</code></pre>
|
||||
<p>goroutine是一種函數的併行執行方式，而channel是用來在goroutine之間進行參數傳遞。main函數卽運行在一個goroutine中，而go function則表示創建一個新的goroutine，併讓這個函數去這個新的goroutine里執行。</p>
|
||||
<p>main函數中用make函數創建了一個傳遞string類型參數的channel，對每一個命令行參數，我們都用go這個關鍵字來創建一個goroutine，併且讓函數在這個goroutine異步執行http.Get方法。這個程序里的io.Copy會把響應的Body內容拷貝到ioutil.Discard輸齣流中，因爲我們需要這個方法返迴的字節數，但是又不想要其內容。每當請求返迴內容時，fetch函數都會往ch這個channel里寫入一個字符串，由main函數里的第二個for循環來處理併打印channel里的這個字符串。</p>
|
||||
0.14s 6852 https://godoc.org
|
||||
0.16s 7261 https://golang.org
|
||||
0.48s 2475 http://gopl.io
|
||||
0.48s elapsed
|
||||
</code></pre><p>goroutine是一種函數的併發執行方式，而channel是用來在goroutine之間進行參數傳遞。main函數也是運行在一個goroutine中，而go function則表示創建一個新的goroutine，併在這個這個新的goroutine里執行這個函數。</p>
|
||||
<p>main函數中用make函數創建了一個傳遞string類型參數的channel，對每一個命令行參數，我們都用go這個關鍵字來創建一個goroutine，併且讓函數在這個goroutine異步執行http.Get方法。這個程序里的io.Copy會把響應的Body內容拷貝到ioutil.Discard輸齣流中（譯註：這是一個垃圾桶，可以向里面寫一些不需要的數據），因爲我們需要這個方法返迴的字節數，但是又不想要其內容。每當請求返迴內容時，fetch函數都會往ch這個channel里寫入一個字符串，由main函數里的第二個for循環來處理併打印channel里的這個字符串。</p>
|
||||
<p>當一個goroutine嚐試在一個channel上做send或者receive操作時，這個goroutine會阻塞在調用處，直到另一個goroutine往這個channel里寫入、或者接收了值，這樣兩個goroutine纔會繼續執行操作channel完成之後的邏輯。在這個例子中，每一個fetch函數在執行時都會往channel里發送一個值(ch <- expression)，主函數接收這些值(<-ch)。這個程序中我們用main函數來所有fetch函數傳迴的字符串，可以避免在goroutine異步執行時同時結束。</p>
|
||||
<p>Exercise 1.10: 找一個數據量比較大的網站，用本小節中的程序調研網站的緩存策略，對每個URL執行兩遍請求，査看兩次時間是否有較大的差别，併且每次穫取到的響應內容是否一致，脩改本節中的程序，將響應結果輸齣，以便於進行對比。</p>
|
||||
<p><strong>練習 1.10：</strong> 找一個數據量比較大的網站，用本小節中的程序調研網站的緩存策略，對每個URL執行兩遍請求，査看兩次時間是否有較大的差别，併且每次穫取到的響應內容是否一致，脩改本節中的程序，將響應結果輸齣，以便於進行對比。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.7" data-chapter-title="Web服務" data-filepath="ch1/ch1-07.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.7" data-chapter-title="Web服務" data-filepath="ch1/ch1-07.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,7 +2024,7 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="17-web服務">1.7. Web服務</h2>
|
||||
<p>Go的內置庫讓我們寫一個像fetch這樣例子的web服務器變得異常地簡單。在本節中，我們會展示一個微型服務器，這個服務的功能是返迴當前用戶正在訪問的URL。也就是説比如用戶訪問的是<a href="http://localhost:8000/hello，那麽響應是URL.Path" target="_blank">http://localhost:8000/hello，那麽響應是URL.Path</a> = "hello"。</p>
|
||||
<p>Go語言的內置庫讓我們寫一個像fetch這樣例子的web服務器變得異常地簡單。在本節中，我們會展示一個微型服務器，這個服務的功能是返迴當前用戶正在訪問的URL。也就是説比如用戶訪問的是 <a href="http://localhost:8000/hello" target="_blank">http://localhost:8000/hello</a> ，那麽響應是URL.Path = "hello"。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/server1
|
||||
<span class="hljs-comment">// Server1 is a minimal "echo" server.</span>
|
||||
<span class="hljs-keyword">package</span> main
|
||||
@@ -2042,10 +2042,10 @@
|
||||
|
||||
<span class="hljs-comment">// handler echoes the Path component of the request URL r.</span>
|
||||
<span class="hljs-keyword">func</span> handler(w http.ResponseWriter, r *http.Request) {
|
||||
fmt.Fprintf(w, <span class="hljs-string">"URL.Path = %q\n"</span>, r.URL.Path)
|
||||
fmt.Fprintf(w, <span class="hljs-string">"URL.Path = %q\n"</span>, r.URL.Path)
|
||||
}
|
||||
</code></pre>
|
||||
<p>我們隻用了八九行就實現了這個程序，這都是多虧了標準庫里的方法已經幫我們處理了大多數的工作。main函數會將所有發送到/目録下的請求和handler函數關聯起來，/開頭的請求其實就是所有發送到當前站點上的請求，我們的服務跑在了8000端口上。發送到這個服務的“請求”是一個http.Request類型的對象，這個對象中包含了請求中的一繫列相關字段，其中就包括我們需要的URL。當請求到達服務器時，這個請求會被傳給handler函數來處理，這個函數會將/hello這個路徑從請求的URL中解析齣來，然後把其發送到響應中，這里我們用的是標準輸齣流的fmt.Fprintf。Web服務會在第7.7節中詳細闡述。</p>
|
||||
<p>我們隻用了八九行代碼就實現了一個個Web服務程序，這都是多虧了標準庫里的方法已經幫我們處理了大量的工作。main函數會將所有發送到/路徑下的請求和handler函數關聯起來，/開頭的請求其實就是所有發送到當前站點上的請求，我們的服務跑在了8000端口上。發送到這個服務的“請求”是一個http.Request類型的對象，這個對象中包含了請求中的一繫列相關字段，其中就包括我們需要的URL。當請求到達服務器時，這個請求會被傳給handler函數來處理，這個函數會將/hello這個路徑從請求的URL中解析齣來，然後把其發送到響應中，這里我們用的是標準輸齣流的fmt.Fprintf。Web服務會在第7.7節中詳細闡述。</p>
|
||||
<p>讓我們在後颱運行這個服務程序。如果你的操作繫統是Mac OS X或者Linux，那麽在運行命令的末尾加上一個&符號，卽可讓程序簡單地跑在後颱，而在windows下，你需要在另外一個命令行窗口去運行這個程序了。</p>
|
||||
<pre><code>$ go run src/gopl.io/ch1/server1/main.go &
|
||||
</code></pre><p>現在我們可以通過命令行來發送客戶端請求了：</p>
|
||||
@@ -2054,8 +2054,8 @@ $ ./fetch http://localhost:8000
|
||||
URL.Path = "/"
|
||||
$ ./fetch http://localhost:8000/help
|
||||
URL.Path = "/help"
|
||||
</code></pre><p>另外我們還可以直接在瀏覽器里訪問這個URL，然後得到返迴結果，如圖1.2：
|
||||
<img src="../images/ch1-02.png" alt=""></p>
|
||||
</code></pre><p>另外我們還可以直接在瀏覽器里訪問這個URL，然後得到返迴結果，如圖1.2：</p>
|
||||
<p><img src="../images/ch1-02.png" alt=""></p>
|
||||
<p>在這個服務的基礎上疊加特性是很容易的。一種比較實用的脩改是爲訪問的url添加某種狀態。比如，下面這個版本輸齣了同樣的內容，但是會對請求的次數進行計算；對URL的請求結果會包含各種URL被訪問的總次數，直接對/count這個URL的訪問要除外。</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/server2
|
||||
<span class="hljs-comment">// Server2 is a minimal "echo" and counter server.</span>
|
||||
@@ -2092,8 +2092,8 @@ URL.Path = "/help"
|
||||
mu.Unlock()
|
||||
}
|
||||
</code></pre>
|
||||
<p>這個服務器有兩個請求處理函數，請求的url會決定具體調用哪一個：對/count這個url的請求會調用到count這個函數，其它所有的url都會調用默認的處理函數。如果你的請求pattern是以/結尾，那麽所有以該url爲前綴的url都會被這條規則匹配。在這些代碼的背後，服務器每一次接收請求處理時都會另起一個goroutine，這樣服務器就可以同一時間處理多數請求。然而在併發情況下，假如眞的有兩個請求同一時刻去更新count，那麽這個值可能併不會被正確地增加；這個程序可能會被引發一個嚴重的bug：競態條件(參見9.1)。爲了避免這個問題，我們必鬚保證每次脩改變量的最多隻能有一個goroutine，這也就是代碼里的mu.Lock()和mu.Unlock()調用將脩改count的所有行爲包在中間的目的。第九章中我們會進一步講解共享變量。</p>
|
||||
<p>下面是一個更爲豐富的例子，handler函數會把請求的http頭和請求的form數據都打印齣來，這樣可以讓檢査和調試這個服務更爲方便</p>
|
||||
<p>這個服務器有兩個請求處理函數，請求的url會決定具體調用哪一個：對/count這個url的請求會調用到count這個函數，其它所有的url都會調用默認的處理函數。如果你的請求pattern是以/結尾，那麽所有以該url爲前綴的url都會被這條規則匹配。在這些代碼的背後，服務器每一次接收請求處理時都會另起一個goroutine，這樣服務器就可以同一時間處理多數請求。然而在併發情況下，假如眞的有兩個請求同一時刻去更新count，那麽這個值可能併不會被正確地增加；這個程序可能會被引發一個嚴重的bug：競態條件（參見9.1）。爲了避免這個問題，我們必鬚保證每次脩改變量的最多隻能有一個goroutine，這也就是代碼里的mu.Lock()和mu.Unlock()調用將脩改count的所有行爲包在中間的目的。第九章中我們會進一步講解共享變量。</p>
|
||||
<p>下面是一個更爲豐富的例子，handler函數會把請求的http頭和請求的form數據都打印齣來，這樣可以讓檢査和調試這個服務更爲方便：</p>
|
||||
<pre><code class="lang-go">gopl.io/ch1/server3
|
||||
<span class="hljs-comment">// handler echoes the HTTP request.</span>
|
||||
<span class="hljs-keyword">func</span> handler(w http.ResponseWriter, r *http.Request) {
|
||||
@@ -2107,7 +2107,7 @@ URL.Path = "/help"
|
||||
log.Print(err)
|
||||
}
|
||||
<span class="hljs-keyword">for</span> k, v := <span class="hljs-keyword">range</span> r.Form {
|
||||
fmt.Fprintf(w, <span class="hljs-string">"Form[%q] = %q\n"</span>, k, v)
|
||||
fmt.Fprintf(w, <span class="hljs-string">"Form[%q] = %q\n"</span>, k, v)
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
@@ -2118,7 +2118,7 @@ Header["Connection"] = ["keep-alive"]
|
||||
Header["Accept"] = ["text/html,application/xhtml+xml,application/xml;..."] Header["User-Agent"] = ["Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5)..."] Host = "localhost:8000"
|
||||
RemoteAddr = "127.0.0.1:59911"
|
||||
Form["q"] = ["query"]
|
||||
</code></pre><p>可以看到這里的ParseForm被嵌套在了if語句中。Go語言允許這樣的一個簡單的語句結果作爲循環的變量聲明齣現在if語句的最前面，這一點對錯誤處理很有用處。我們還可以像下面這樣寫(當然看起來就長了一些)：</p>
|
||||
</code></pre><p>可以看到這里的ParseForm被嵌套在了if語句中。Go語言允許這樣的一個簡單的語句結果作爲循環的變量聲明齣現在if語句的最前面，這一點對錯誤處理很有用處。我們還可以像下面這樣寫（當然看起來就長了一些）：</p>
|
||||
<pre><code class="lang-go">err := r.ParseForm()
|
||||
<span class="hljs-keyword">if</span> err != <span class="hljs-constant">nil</span> {
|
||||
log.Print(err)
|
||||
@@ -2127,19 +2127,21 @@ Form["q"] = ["query"]
|
||||
<p>用if和ParseForm結合可以讓代碼更加簡單，併且可以限製err這個變量的作用域，這麽做是很不錯的。我們會在2.7節中講解作用域。</p>
|
||||
<p>在這些程序中，我們看到了很多不同的類型被輸齣到標準輸齣流中。比如前面的fetch程序，就把HTTP的響應數據拷貝到了os.Stdout，或者在lissajous程序里我們輸齣的是一個文件。fetchall程序則完全忽略到了HTTP的響應體，隻是計算了一下響應體的大小，這個程序中把響應體拷貝到了ioutil.Discard。在本節的web服務器程序中則是用fmt.Fprintf直接寫到了http.ResponseWriter中。</p>
|
||||
<p>盡管這三種具體的實現流程併不太一樣，他們都實現一個共同的接口，卽當它們被調用需要一個標準流輸齣時都可以滿足。這個接口叫作io.Writer，在7.1節中會詳細討論。</p>
|
||||
<p>Go的接口機製會在第7章中講解，爲了在這里簡單説明接口能做什麽，讓我們簡單地將這里的web服務器和之前寫的lissajous函數結合起來，這樣GIF動畵可以被寫到HTTP的客戶端，而不是之前的標準輸齣流。隻要在web服務器的代碼里加入下面這幾行。</p>
|
||||
<pre><code>handler := func(w http.ResponseWriter, r *http.Request) {
|
||||
lissajous(w)
|
||||
<p>Go語言的接口機製會在第7章中講解，爲了在這里簡單説明接口能做什麽，讓我們簡單地將這里的web服務器和之前寫的lissajous函數結合起來，這樣GIF動畵可以被寫到HTTP的客戶端，而不是之前的標準輸齣流。隻要在web服務器的代碼里加入下面這幾行。</p>
|
||||
<pre><code class="lang-Go">handler := <span class="hljs-keyword">func</span>(w http.ResponseWriter, r *http.Request) {
|
||||
lissajous(w)
|
||||
}
|
||||
http.HandleFunc("/", handler)
|
||||
</code></pre><p>或者另一種等價形式：</p>
|
||||
<pre><code>http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
||||
http.HandleFunc(<span class="hljs-string">"/"</span>, handler)
|
||||
</code></pre>
|
||||
<p>或者另一種等價形式：</p>
|
||||
<pre><code class="lang-Go">http.HandleFunc(<span class="hljs-string">"/"</span>, <span class="hljs-keyword">func</span>(w http.ResponseWriter, r *http.Request) {
|
||||
lissajous(w)
|
||||
})
|
||||
</code></pre><p>HandleFunc函數的第二個參數是一個函數的字面值，也就是一個在使用時定義的匿名函數。這些內容我們會在5.6節中講解。</p>
|
||||
<p>做完這些脩改之後，在瀏覽器里訪問<a href="http://localhost:8000。每次你載入這個頁面都可以看到一個像圖1.3那樣的動畵。" target="_blank">http://localhost:8000。每次你載入這個頁面都可以看到一個像圖1.3那樣的動畵。</a></p>
|
||||
<pre><code>Exercise 1.12:脩改Lissajour服務，從URL讀取變量，比如你可以訪問http://localhost:8000/?cycles=20這個URL，這樣訪問可以將程序里的cycles默認的5脩改爲20。字符串轉換爲數字可以調用strconv.Atoi函數。你可以在dodoc里査看strconv.Atoi的詳細説明。
|
||||
</code></pre><p><img src="../images/ch1-03.png" alt=""></p>
|
||||
</code></pre>
|
||||
<p>HandleFunc函數的第二個參數是一個函數的字面值，也就是一個在使用時定義的匿名函數。這些內容我們會在5.6節中講解。</p>
|
||||
<p>做完這些脩改之後，在瀏覽器里訪問 <a href="http://localhost:8000" target="_blank">http://localhost:8000</a> 。每次你載入這個頁面都可以看到一個像圖1.3那樣的動畵。</p>
|
||||
<p><strong>練習 1.12：</strong> 脩改Lissajour服務，從URL讀取變量，比如你可以訪問 <a href="http://localhost:8000/?cycles=20" target="_blank">http://localhost:8000/?cycles=20</a> 這個URL，這樣訪問可以將程序里的cycles默認的5脩改爲20。字符串轉換爲數字可以調用strconv.Atoi函數。你可以在dodoc里査看strconv.Atoi的詳細説明。</p>
|
||||
<p><img src="../images/ch1-03.png" alt=""></p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1.8" data-chapter-title="本章要點" data-filepath="ch1/ch1-08.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1.8" data-chapter-title="本章要點" data-filepath="ch1/ch1-08.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,52 +2024,52 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="18-本章要點">1.8. 本章要點</h2>
|
||||
<p>本章中對Go語言做了一些介紹，實際上Go語言還有很多方面在這有限的篇幅中還沒有覆蓋到。這里我們會把沒有講到的內容也做一些簡單的介紹，這樣讀者在之後看到完整的內容之前，也可以簡單有個印象。</p>
|
||||
<p>控製流：在本章我們隻介紹了if控製和for，但是沒有提到switch多路選擇。這里是一個簡單的switch的例子：</p>
|
||||
<p>本章中對Go語言做了一些介紹，實際上Go語言還有很多方面在這有限的篇幅中還沒有覆蓋到。這里我們會把沒有講到的內容也做一些簡單的介紹，這樣讀者在之後看到完整的內容之前，也可以有個簡單印象。</p>
|
||||
<p><strong>控製流：</strong> 在本章我們隻介紹了if控製和for，但是沒有提到switch多路選擇。這里是一個簡單的switch的例子：</p>
|
||||
<pre><code class="lang-go"><span class="hljs-keyword">switch</span> coinflip() {
|
||||
<span class="hljs-keyword">case</span> <span class="hljs-string">"heads"</span>:
|
||||
heads++
|
||||
<span class="hljs-keyword">case</span> <span class="hljs-string">"tails"</span>:
|
||||
tails++
|
||||
<span class="hljs-keyword">default</span>:
|
||||
fmt.Println(<span class="hljs-string">"landed on edge!"</span>)
|
||||
<span class="hljs-keyword">case</span> <span class="hljs-string">"heads"</span>:
|
||||
heads++
|
||||
<span class="hljs-keyword">case</span> <span class="hljs-string">"tails"</span>:
|
||||
tails++
|
||||
<span class="hljs-keyword">default</span>:
|
||||
fmt.Println(<span class="hljs-string">"landed on edge!"</span>)
|
||||
}
|
||||
</code></pre>
|
||||
<p>在翻轉硬幣的時候，例子里的coinflip函數返迴幾種不同的結果，每一個case都會對應個返迴結果，這里需要註意，Go語言併不需要顯式地去在每一個case後寫break，語言默認執行完case後的邏輯語句會自動退齣。當然了，如果你想要相鄰的幾個case都執行同一邏輯的話，需要自己顯式地寫上一個fallthrough語句來覆蓋這種默認行爲。不過fallthrough語句在一般的編程中用到得很少。</p>
|
||||
<p>go里的switch還可以不帶操作對象；可以直接羅列多種條件，像其它語言里面的多個if else一樣，下面是一個例子：</p>
|
||||
<p>Go語言里的switch還可以不帶操作對象（譯註：switch不帶操作對象時默認用true值代替，然後將每個case的表達式和true值進行比較）；可以直接羅列多種條件，像其它語言里面的多個if else一樣，下面是一個例子：</p>
|
||||
<pre><code class="lang-go"><span class="hljs-keyword">func</span> Signum(x <span class="hljs-typename">int</span>) <span class="hljs-typename">int</span> {
|
||||
<span class="hljs-keyword">switch</span> {
|
||||
<span class="hljs-keyword">case</span> x > <span class="hljs-number">0</span>:
|
||||
<span class="hljs-keyword">return</span> +<span class="hljs-number">1</span>
|
||||
<span class="hljs-keyword">default</span>:
|
||||
<span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
|
||||
<span class="hljs-keyword">case</span> x < <span class="hljs-number">0</span>:
|
||||
<span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>
|
||||
<span class="hljs-keyword">case</span> x > <span class="hljs-number">0</span>:
|
||||
<span class="hljs-keyword">return</span> +<span class="hljs-number">1</span>
|
||||
<span class="hljs-keyword">default</span>:
|
||||
<span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
|
||||
<span class="hljs-keyword">case</span> x < <span class="hljs-number">0</span>:
|
||||
<span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>這種形式叫做無tag switch(tagless switch)；這和switch true是等價的。</p>
|
||||
<p>像for和if控製語句一樣，switch也可以緊跟一個簡短的變量聲明，一個自增表達式、賦值語句，或者一個函數調用。</p>
|
||||
<p>break和continue語句會改變控製流。和其它語言中的break和continue一樣，break會中斷當前的循環，併開始執行循環之後的內容，而continue會中跳過當前循環，併開始執行下一次循環。這兩個語句除了可以控製for循環，還可以用來控製switch和select語句(之後會講到)，在1.3節中我們看到，continue會跳過是內層的循環，如果我們想跳過的是更外層的循環的話，我們可以在相應的位置加上label，這樣break和continue就可以根據我們的想法來continue和break任意循環。這看起來甚至有點像goto語句的作用了。當然，一般程序員也不會用到這種操作。這兩種行爲更多地被用到機器生成的代碼中。</p>
|
||||
<p>命名類型：類型聲明使得我們可以很方便地給一個特殊類型一個名字。因爲struct類型聲明通常非常地長，所以我們總要給這種struct取一個名字。本章中就有這樣一個例子，2d點類型：</p>
|
||||
<p><strong>命名類型：</strong> 類型聲明使得我們可以很方便地給一個特殊類型一個名字。因爲struct類型聲明通常非常地長，所以我們總要給這種struct取一個名字。本章中就有這樣一個例子，二維點類型：</p>
|
||||
<pre><code class="lang-go"><span class="hljs-keyword">type</span> Point <span class="hljs-keyword">struct</span> {
|
||||
X, Y <span class="hljs-typename">int</span>
|
||||
}
|
||||
<span class="hljs-keyword">var</span> p Point
|
||||
</code></pre>
|
||||
<p>類型聲明和命名類型會在第二章中介紹。</p>
|
||||
<p>指針：Go語言提供了指針。指針是一種直接存儲了變量的內存地址的數據結構。在其它語言中，比如C語言，指針是完全不受約束的。在另外一些語言中，指針一般被稱爲“引用”，除了到處傳遞這些指針之外，併不能對這些指針做太多事情。go在這兩種范圍中取得了一個平衡。指針是可見的內存地址，&操作符可以返迴一個變量的內存地址，併且*操作符可以穫取指針指向的變量內容，但是在go語言里沒有指針運算，也就是不像c語言里可以對指針進行加或減操作。我們會在2.3.2中進行詳細介紹。</p>
|
||||
<p>方法和接口：方法是和命名類型關聯的一類函數。Go語言里比較特殊的是方法可以被關聯到任意一種命名類型。在第六章我們會詳細地講方法。接口是一種抽象類型，這種類型可以讓我們以同樣的方式來處理不同的固有類型，不用關心它們的具體實現，而隻需要關註它們提供的方法。第七章中會詳細説明這些內容。</p>
|
||||
<p>包(packages)：Go語言提供了一些很好用的package，併且這些package是可以擴展的。Go語言社區已經創造併且分享了很多很多。所以Go語言編程大多數情況下就是用已有的package來寫我們自己的代碼。通過這本書，我們會講解一些重要的標準庫內的package，但是還是有很多我們沒有篇幅去説明，因爲我們沒法在這樣的厚度的書里去做一部代碼大全。</p>
|
||||
<p>在你開始寫一個新程序之前，最好先去檢査一下是不是已經有了現成的庫可以幫助你更高效地完成這件事情。你可以在<a href="https://golang.org/pkg" target="_blank">https://golang.org/pkg</a> 和 <a href="https://godoc.org" target="_blank">https://godoc.org</a> 中找到標準庫和社區寫的package。godoc這個工具可以讓你直接在本地命令行閲讀標準庫的文檔。比如下面這個例子。</p>
|
||||
<p><strong>指針：</strong> Go語言提供了指針。指針是一種直接存儲了變量的內存地址的數據類型。在其它語言中，比如C語言，指針操作是完全不受約束的。在另外一些語言中，指針一般被處理爲“引用”，除了到處傳遞這些指針之外，併不能對這些指針做太多事情。Go語言在這兩種范圍中取了一種平衡。指針是可見的內存地址，&操作符可以返迴一個變量的內存地址，併且*操作符可以穫取指針指向的變量內容，但是在Go語言里沒有指針運算，也就是不能像c語言里可以對指針進行加或減操作。我們會在2.3.2中進行詳細介紹。</p>
|
||||
<p><strong>方法和接口：</strong> 方法是和命名類型關聯的一類函數。Go語言里比較特殊的是方法可以被關聯到任意一種命名類型。在第六章我們會詳細地講方法。接口是一種抽象類型，這種類型可以讓我們以同樣的方式來處理不同的固有類型，不用關心它們的具體實現，而隻需要關註它們提供的方法。第七章中會詳細説明這些內容。</p>
|
||||
<p><strong>包（packages）：</strong> Go語言提供了一些很好用的package，併且這些package是可以擴展的。Go語言社區已經創造併且分享了很多很多。所以Go語言編程大多數情況下就是用已有的package來寫我們自己的代碼。通過這本書，我們會講解一些重要的標準庫內的package，但是還是有很多我們沒有篇幅去説明，因爲我們沒法在這樣的厚度的書里去做一部代碼大全。</p>
|
||||
<p>在你開始寫一個新程序之前，最好先去檢査一下是不是已經有了現成的庫可以幫助你更高效地完成這件事情。你可以在 <a href="https://golang.org/pkg" target="_blank">https://golang.org/pkg</a> 和 <a href="https://godoc.org" target="_blank">https://godoc.org</a> 中找到標準庫和社區寫的package。godoc這個工具可以讓你直接在本地命令行閲讀標準庫的文檔。比如下面這個例子。</p>
|
||||
<pre><code>$ go doc http.ListenAndServe
|
||||
package http // import "net/http"
|
||||
func ListenAndServe(addr string, handler Handler) error
|
||||
ListenAndServe listens on the TCP network address addr and then
|
||||
calls Serve with handler to handle requests on incoming connections.
|
||||
...
|
||||
</code></pre><p>註釋：我們之前已經提到過了在源文件的開頭寫的註釋是這個源文件的文檔。在每一個函數之前寫一個説明函數行爲的註釋也是一個好習慣。這些慣例很重要，因爲這些內容會被像godoc這樣的工具檢測到，併且在執行命令時顯示這些註釋。具體可以參考10.7.4。</p>
|
||||
<p>多行註釋可以用/<em> ... </em>/來包裹，和其它大多數語言一樣。在文件一開頭的註釋一般都是這種形式，或者一大段的解釋性的註釋文字也會被這符號包住，來避免每一行都需要加//。在註釋中//和/*是沒什麽意義的，所以不要在註釋中再嵌入註釋。</p>
|
||||
</code></pre><p><strong>註釋：</strong> 我們之前已經提到過了在源文件的開頭寫的註釋是這個源文件的文檔。在每一個函數之前寫一個説明函數行爲的註釋也是一個好習慣。這些慣例很重要，因爲這些內容會被像godoc這樣的工具檢測到，併且在執行命令時顯示這些註釋。具體可以參考10.7.4。</p>
|
||||
<p>多行註釋可以用 <code>/* ... */</code> 來包裹，和其它大多數語言一樣。在文件一開頭的註釋一般都是這種形式，或者一大段的解釋性的註釋文字也會被這符號包住，來避免每一行都需要加//。在註釋中//和/*是沒什麽意義的，所以不要在註釋中再嵌入註釋。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
12
ch1/ch1.html
12
ch1/ch1.html
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="1" data-chapter-title="入門" data-filepath="ch1/ch1.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="1" data-chapter-title="入門" data-filepath="ch1/ch1.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,8 +2024,8 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h1 id="第1章-入門">第1章 入門</h1>
|
||||
<p>本章會介紹Go語言里的一些基本組件。我們希望用信息和例子盡快帶你入門。本章和之後章節的例子都是針對眞實的開發案例給齣。本章我們隻是簡單地爲你介紹一些Go的入門例子，從簡單的文件處理、圖像處理到互聯網併發客戶端和服務端程序。當然，在第一章我們不會詳盡地一一去説明細枝末節，不過用這些程序來學習一門新語言肯定是很有效的。
|
||||
當你學習一門新語言時，你會有去用這門新語言去重寫自己以前熟悉語言例子的傾向。在學習Go的過程中，盡量避免這麽做。我們會向你演示如何纔能寫齣好的Go程序，所以請使用這里的代碼作爲你寫自己的Go程序時的指南。</p>
|
||||
<p>本章會介紹Go語言里的一些基本組件。我們希望用信息和例子盡快帶你入門。本章和之後章節的例子都是針對眞實的開發案例給齣。本章我們隻是簡單地爲你介紹一些Go語言的入門例子，從簡單的文件處理、圖像處理到互聯網併發客戶端和服務端程序。當然，在第一章我們不會詳盡地一一去説明細枝末節，不過用這些程序來學習一門新語言肯定是很有效的。</p>
|
||||
<p>當你學習一門新語言時，你會用這門新語言去重寫自己以前熟悉語言例子的傾向。在學習Go語言的過程中，盡量避免這麽做。我們會向你演示如何纔能寫齣好的Go語言程序，所以請使用這里的代碼作爲你寫自己的Go程序時的指南。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
Reference in New Issue
Block a user