mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2024-11-12 17:33:40 +00:00
deploy: eb1938e3aa
This commit is contained in:
github-actions[bot]
parent
828440b577
commit
d920c3afd5
@ -161,7 +161,7 @@
|
||||
<hr>
|
||||
|
||||
<h2 id="11-hello-world"><a class="header" href="#11-hello-world">1.1. Hello, World</a></h2>
|
||||
<p>我们以现已成为传统的“hello world”案例来开始吧，这个例子首次出现于1978年出版的C语言圣经<a href="http://s3-us-west-2.amazonaws.com/belllabs-microsite-dritchie/cbook/index.html">《The C Programming Language》</a>（译注：本书作者之一Brian W. Kernighan也是《The C Programming Language》一书的作者）。C语言是直接影响Go语言设计的语言之一。这个例子体现了Go语言一些核心理念。</p>
|
||||
<p>我们以现已成为传统的“hello world”案例来开始吧，这个例子首次出现于 1978 年出版的 C 语言圣经 <a href="http://s3-us-west-2.amazonaws.com/belllabs-microsite-dritchie/cbook/index.html">《The C Programming Language》</a>（译注：本书作者之一 Brian W. Kernighan 也是《The C Programming Language》一书的作者）。C 语言是直接影响 Go 语言设计的语言之一。这个例子体现了 Go 语言一些核心理念。</p>
|
||||
<p><u><i>gopl.io/ch1/helloworld</i></u></p>
|
||||
<pre><code class="language-go">package main
|
||||
|
||||
@ -171,37 +171,37 @@ func main() {
|
||||
fmt.Println("Hello, 世界")
|
||||
}
|
||||
</code></pre>
|
||||
<p>Go是一门编译型语言，Go语言的工具链将源代码及其依赖转换成计算机的机器指令（译注：静态编译）。Go语言提供的工具都通过一个单独的命令<code>go</code>调用，<code>go</code>命令有一系列子命令。最简单的一个子命令就是run。这个命令编译一个或多个以.go结尾的源文件，链接库文件，并运行最终生成的可执行文件。（本书使用$表示命令行提示符。）</p>
|
||||
<pre><code>$ go run helloworld.go
|
||||
<p>Go 是一门编译型语言，Go 语言的工具链将源代码及其依赖转换成计算机的机器指令（译注：静态编译）。Go 语言提供的工具都通过一个单独的命令 <code>go</code> 调用，<code>go</code> 命令有一系列子命令。最简单的一个子命令就是 <code>run</code>。这个命令编译一个或多个以。<code>.go</code> 结尾的源文件，链接库文件，并运行最终生成的可执行文件。（本书使用$表示命令行提示符。）</p>
|
||||
<pre><code class="language-bash">$ go run helloworld.go
|
||||
</code></pre>
|
||||
<p>毫无意外，这个命令会输出：</p>
|
||||
<pre><code>Hello, 世界
|
||||
<pre><code class="language-text">Hello, 世界
|
||||
</code></pre>
|
||||
<p>Go语言原生支持Unicode，它可以处理全世界任何语言的文本。</p>
|
||||
<p>如果不只是一次性实验，你肯定希望能够编译这个程序，保存编译结果以备将来之用。可以用build子命令：</p>
|
||||
<pre><code>$ go build helloworld.go
|
||||
<p>Go 语言原生支持 Unicode，它可以处理全世界任何语言的文本。</p>
|
||||
<p>如果不只是一次性实验，你肯定希望能够编译这个程序，保存编译结果以备将来之用。可以用 <code>build</code> 子命令：</p>
|
||||
<pre><code class="language-shell">$ go build helloworld.go
|
||||
</code></pre>
|
||||
<p>这个命令生成一个名为helloworld的可执行的二进制文件（译注：Windows系统下生成的可执行文件是helloworld.exe，增加了.exe后缀名），之后你可以随时运行它（译注：在Windows系统下在命令行直接输入helloworld.exe命令运行），不需任何处理（译注：因为静态编译，所以不用担心在系统库更新的时候冲突，幸福感满满）。</p>
|
||||
<p>这个命令生成一个名为 <code>helloworld</code> 的可执行的二进制文件（译注：Windows 系统下生成的可执行文件是 <code>helloworld.exe</code>，增加了 <code>.exe</code> 后缀名），之后你可以随时运行它（译注：在 Windows 系统下在命令行直接输入 <code>helloworld.exe</code> 命令运行），不需任何处理（译注：因为静态编译，所以不用担心在系统库更新的时候冲突，幸福感满满）。</p>
|
||||
<pre><code>$ ./helloworld
|
||||
Hello, 世界
|
||||
</code></pre>
|
||||
<p>本书中所有示例代码上都有一行标记，利用这些标记可以从<a href="http://gopl.io">gopl.io</a>网站上本书源码仓库里获取代码：</p>
|
||||
<pre><code>gopl.io/ch1/helloworld
|
||||
<p>本书中所有示例代码上都有一行标记，利用这些标记可以从 <a href="http://gopl.io">gopl.io</a> 网站上本书源码仓库里获取代码：</p>
|
||||
<pre><code class="language-text">gopl.io/ch1/helloworld
|
||||
</code></pre>
|
||||
<p>执行 <code>go get gopl.io/ch1/helloworld</code> 命令，就会从网上获取代码，并放到对应目录中（需要先安装Git或Hg之类的版本管理工具，并将对应的命令添加到PATH环境变量中。序言已经提及，需要先设置好GOPATH环境变量，下载的代码会放在<code>$GOPATH/src/gopl.io/ch1/helloworld</code>目录）。2.6和10.7节有这方面更详细的介绍。</p>
|
||||
<p>来讨论下程序本身。Go语言的代码通过<strong>包</strong>（package）组织，包类似于其它语言里的库（libraries）或者模块（modules）。一个包由位于单个目录下的一个或多个.go源代码文件组成，目录定义包的作用。每个源文件都以一条<code>package</code>声明语句开始，这个例子里就是<code>package main</code>，表示该文件属于哪个包，紧跟着一系列导入（import）的包，之后是存储在这个文件里的程序语句。</p>
|
||||
<p>Go的标准库提供了100多个包，以支持常见功能，如输入、输出、排序以及文本处理。比如<code>fmt</code>包，就含有格式化输出、接收输入的函数。<code>Println</code>是其中一个基础函数，可以打印以空格间隔的一个或多个值，并在最后添加一个换行符，从而输出一整行。</p>
|
||||
<p><code>main</code>包比较特殊。它定义了一个独立可执行的程序，而不是一个库。在<code>main</code>里的<code>main</code> <em>函数</em> 也很特殊，它是整个程序执行时的入口（译注：C系语言差不多都这样）。<code>main</code>函数所做的事情就是程序做的。当然了，<code>main</code>函数一般调用其它包里的函数完成很多工作（如：<code>fmt.Println</code>）。</p>
|
||||
<p>必须告诉编译器源文件需要哪些包，这就是跟随在<code>package</code>声明后面的<code>import</code>声明扮演的角色。hello world例子只用到了一个包，大多数程序需要导入多个包。</p>
|
||||
<p>必须恰当导入需要的包，缺少了必要的包或者导入了不需要的包，程序都无法编译通过。这项严格要求避免了程序开发过程中引入未使用的包（译注：Go语言编译过程没有警告信息，争议特性之一）。</p>
|
||||
<p><code>import</code>声明必须跟在文件的<code>package</code>声明之后。随后，则是组成程序的函数、变量、常量、类型的声明语句（分别由关键字<code>func</code>、<code>var</code>、<code>const</code>、<code>type</code>定义）。这些内容的声明顺序并不重要（译注：最好还是定一下规范）。这个例子的程序已经尽可能短了，只声明了一个函数，其中只调用了一个其他函数。为了节省篇幅，有些时候示例程序会省略<code>package</code>和<code>import</code>声明，但是，这些声明在源代码里有，并且必须得有才能编译。</p>
|
||||
<p>一个函数的声明由<code>func</code>关键字、函数名、参数列表、返回值列表（这个例子里的<code>main</code>函数参数列表和返回值都是空的）以及包含在大括号里的函数体组成。第五章进一步考察函数。</p>
|
||||
<p>Go语言不需要在语句或者声明的末尾添加分号，除非一行上有多条语句。实际上，编译器会主动把特定符号后的换行符转换为分号，因此换行符添加的位置会影响Go代码的正确解析（译注：比如行末是标识符、整数、浮点数、虚数、字符或字符串文字、关键字<code>break</code>、<code>continue</code>、<code>fallthrough</code>或<code>return</code>中的一个、运算符和分隔符<code>++</code>、<code>--</code>、<code>)</code>、<code>]</code>或<code>}</code>中的一个）。举个例子，函数的左括号<code>{</code>必须和<code>func</code>函数声明在同一行上，且位于末尾，不能独占一行，而在表达式<code>x + y</code>中，可在<code>+</code>后换行，不能在<code>+</code>前换行（译注：以+结尾的话不会被插入分号分隔符，但是以x结尾的话则会被分号分隔符，从而导致编译错误）。</p>
|
||||
<p>Go语言在代码格式上采取了很强硬的态度。<code>gofmt</code>工具把代码格式化为标准格式（译注：这个格式化工具没有任何可以调整代码格式的参数，Go语言就是这么任性），并且<code>go</code>工具中的<code>fmt</code>子命令会对指定包，否则默认为当前目录中所有.go源文件应用<code>gofmt</code>命令。本书中的所有代码都被gofmt过。你也应该养成格式化自己的代码的习惯。以法令方式规定标准的代码格式可以避免无尽的无意义的琐碎争执（译注：也导致了Go语言的TIOBE排名较低，因为缺少撕逼的话题）。更重要的是，这样可以做多种自动源码转换，如果放任Go语言代码格式，这些转换就不大可能了。</p>
|
||||
<p>很多文本编辑器都可以配置为保存文件时自动执行<code>gofmt</code>，这样你的源代码总会被恰当地格式化。还有个相关的工具，<code>goimports</code>，可以根据代码需要，自动地添加或删除<code>import</code>声明。这个工具并没有包含在标准的分发包中，可以用下面的命令安装：</p>
|
||||
<pre><code>$ go get golang.org/x/tools/cmd/goimports
|
||||
<p>执行 <code>go get gopl.io/ch1/helloworld</code> 命令，就会从网上获取代码，并放到对应目录中（需要先安装 Git 或 Hg 之类的版本管理工具，并将对应的命令添加到 <code>PATH</code> 环境变量中。序言已经提及，需要先设置好 <code>GOPATH</code> 环境变量，下载的代码会放在 <code>$GOPATH/src/gopl.io/ch1/helloworld</code> 目录）。<a href="../ch2/ch2-06.html">2.6</a> 和 <a href="../ch10/ch10-07.html">10.7 节</a>有这方面更详细的介绍。</p>
|
||||
<p>来讨论下程序本身。Go 语言的代码通过<strong>包</strong>（package）组织，包类似于其它语言里的库（libraries）或者模块（modules）。一个包由位于单个目录下的一个或多个 <code>.go</code> 源代码文件组成，目录定义包的作用。每个源文件都以一条 <code>package</code> 声明语句开始，这个例子里就是 <code>package main</code>，表示该文件属于哪个包，紧跟着一系列导入（import）的包，之后是存储在这个文件里的程序语句。</p>
|
||||
<p>Go 的标准库提供了 100 多个包，以支持常见功能，如输入、输出、排序以及文本处理。比如 <code>fmt</code> 包，就含有格式化输出、接收输入的函数。<code>Println</code> 是其中一个基础函数，可以打印以空格间隔的一个或多个值，并在最后添加一个换行符，从而输出一整行。</p>
|
||||
<p><code>main</code> 包比较特殊。它定义了一个独立可执行的程序，而不是一个库。在 <code>main</code> 里的 <code>main</code> <em>函数</em>也很特殊，它是整个程序执行时的入口（译注：C 系语言差不多都这样）。<code>main</code> 函数所做的事情就是程序做的。当然了，<code>main</code> 函数一般调用其它包里的函数完成很多工作（如：<code>fmt.Println</code>）。</p>
|
||||
<p>必须告诉编译器源文件需要哪些包，这就是跟随在 <code>package</code> 声明后面的 <code>import</code> 声明扮演的角色。<code>hello world</code> 例子只用到了一个包，大多数程序需要导入多个包。</p>
|
||||
<p>必须恰当导入需要的包，缺少了必要的包或者导入了不需要的包，程序都无法编译通过。这项严格要求避免了程序开发过程中引入未使用的包（译注：Go 语言编译过程没有警告信息，争议特性之一）。</p>
|
||||
<p><code>import</code> 声明必须跟在文件的 <code>package</code> 声明之后。随后，则是组成程序的函数、变量、常量、类型的声明语句（分别由关键字 <code>func</code>、<code>var</code>、<code>const</code>、<code>type</code> 定义）。这些内容的声明顺序并不重要（译注：最好还是定一下规范）。这个例子的程序已经尽可能短了，只声明了一个函数，其中只调用了一个其他函数。为了节省篇幅，有些时候示例程序会省略 <code>package</code> 和 <code>import</code> 声明，但是，这些声明在源代码里有，并且必须得有才能编译。</p>
|
||||
<p>一个函数的声明由 <code>func</code> 关键字、函数名、参数列表、返回值列表（这个例子里的 <code>main</code> 函数参数列表和返回值都是空的）以及包含在大括号里的函数体组成。第五章进一步考察函数。</p>
|
||||
<p>Go 语言不需要在语句或者声明的末尾添加分号，除非一行上有多条语句。实际上，编译器会主动把特定符号后的换行符转换为分号，因此换行符添加的位置会影响 Go 代码的正确解析（译注：比如行末是标识符、整数、浮点数、虚数、字符或字符串文字、关键字 <code>break</code>、<code>continue</code>、<code>fallthrough</code>或 <code>return</code> 中的一个、运算符和分隔符 <code>++</code>、<code>--</code>、<code>)</code>、<code>]</code> 或 <code>}</code> 中的一个）。举个例子，函数的左括号 <code>{</code> 必须和 <code>func</code> 函数声明在同一行上，且位于末尾，不能独占一行，而在表达式 <code>x+y</code> 中，可在 <code>+</code> 后换行，不能在 <code>+</code> 前换行（译注：以+结尾的话不会被插入分号分隔符，但是以 x 结尾的话则会被分号分隔符，从而导致编译错误）。</p>
|
||||
<p>Go 语言在代码格式上采取了很强硬的态度。<code>gofmt</code>工具把代码格式化为标准格式（译注：这个格式化工具没有任何可以调整代码格式的参数，Go 语言就是这么任性），并且 <code>go</code> 工具中的 <code>fmt</code> 子命令会对指定包，否则默认为当前目录中所有。go 源文件应用 <code>gofmt</code> 命令。本书中的所有代码都被 gofmt 过。你也应该养成格式化自己的代码的习惯。以法令方式规定标准的代码格式可以避免无尽的无意义的琐碎争执（译注：也导致了 Go 语言的 TIOBE 排名较低，因为缺少撕逼的话题）。更重要的是，这样可以做多种自动源码转换，如果放任 Go 语言代码格式，这些转换就不大可能了。</p>
|
||||
<p>很多文本编辑器都可以配置为保存文件时自动执行 <code>gofmt</code>，这样你的源代码总会被恰当地格式化。还有个相关的工具：<code>goimports</code>，可以根据代码需要，自动地添加或删除 <code>import</code> 声明。这个工具并没有包含在标准的分发包中，可以用下面的命令安装：</p>
|
||||
<pre><code class="language-shell">$ go get golang.org/x/tools/cmd/goimports
|
||||
</code></pre>
|
||||
<p>对于大多数用户来说，下载、编译包、运行测试用例、察看Go语言的文档等等常用功能都可以用go的工具完成。10.7节详细介绍这些知识。</p>
|
||||
<p>对于大多数用户来说，下载、编译包、运行测试用例、察看 Go 语言的文档等等常用功能都可以用 go 的工具完成。<a href="../ch10/ch10-07.html">10.7 节</a>详细介绍这些知识。</p>
|
||||
|
||||
|
||||
<!-- 公众号 -->
|
||||
|
||||
@ -162,10 +162,10 @@
|
||||
|
||||
<h2 id="12-命令行参数"><a class="header" href="#12-命令行参数">1.2. 命令行参数</a></h2>
|
||||
<p>大多数的程序都是处理输入，产生输出；这也正是“计算”的定义。但是，程序如何获取要处理的输入数据呢？一些程序生成自己的数据，但通常情况下，输入来自于程序外部：文件、网络连接、其它程序的输出、敲键盘的用户、命令行参数或其它类似输入源。下面几个例子会讨论其中几个输入源，首先是命令行参数。</p>
|
||||
<p><code>os</code>包以跨平台的方式，提供了一些与操作系统交互的函数和变量。程序的命令行参数可从os包的Args变量获取；os包外部使用os.Args访问该变量。</p>
|
||||
<p>os.Args变量是一个字符串（string）的<em>切片</em>（slice）（译注：slice和Python语言中的切片类似，是一个简版的动态数组），切片是Go语言的基础概念，稍后详细介绍。现在先把切片s当作数组元素序列，序列的长度动态变化，用<code>s[i]</code>访问单个元素，用<code>s[m:n]</code>获取子序列（译注：和python里的语法差不多）。序列的元素数目为len(s)。和大多数编程语言类似，区间索引时，Go语言里也采用左闭右开形式，即，区间包括第一个索引元素，不包括最后一个，因为这样可以简化逻辑。（译注：比如a = [1, 2, 3, 4, 5], a[0:3] = [1, 2, 3]，不包含最后一个元素）。比如s[m:n]这个切片，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)]切片中。如果省略切片表达式的m或n，会默认传入0或len(s)，因此前面的切片可以简写成os.Args[1:]。</p>
|
||||
<p>下面是Unix里echo命令的一份实现，echo把它的命令行参数打印成一行。程序导入了两个包，用括号把它们括起来写成列表形式，而没有分开写成独立的<code>import</code>声明。两种形式都合法，列表形式习惯上用得多。包导入顺序并不重要；gofmt工具格式化时按照字母顺序对包名排序。（示例有多个版本时，我们会对示例编号，这样可以明确当前正在讨论的是哪个。）</p>
|
||||
<p><code>os</code> 包以跨平台的方式，提供了一些与操作系统交互的函数和变量。程序的命令行参数可从 <code>os</code> 包的 <code>Args</code> 变量获取；<code>os</code> 包外部使用 <code>os.Args</code> 访问该变量。</p>
|
||||
<p><code>os.Args</code> 变量是一个字符串（string）的 <em>切片</em>（slice）（译注：slice 和 Python 语言中的切片类似，是一个简版的动态数组），切片是 Go 语言的基础概念，稍后详细介绍。现在先把切片 <code>s</code> 当作数组元素序列，序列的长度动态变化，用 <code>s[i]</code> 访问单个元素，用 <code>s[m:n]</code> 获取子序列（译注：和 Python 里的语法差不多）。序列的元素数目为 <code>len(s)</code>。和大多数编程语言类似，区间索引时，Go 语言里也采用左闭右开形式，即，区间包括第一个索引元素，不包括最后一个，因为这样可以简化逻辑。（译注：比如 <code>a=[1,2,3,4,5]</code>, <code>a[0:3]=[1,2,3]</code>，不包含最后一个元素）。比如 <code>s[m:n]</code> 这个切片，<code>0≤m≤n≤len(s)</code>，包含 <code>n-m</code> 个元素。</p>
|
||||
<p><code>os.Args</code> 的第一个元素：<code>os.Args[0]</code>，是命令本身的名字；其它的元素则是程序启动时传给它的参数。<code>s[m:n]</code> 形式的切片表达式，产生从第 <code>m</code> 个元素到第 <code>n-1</code> 个元素的切片，下个例子用到的元素包含在 <code>os.Args[1:len(os.Args)]</code> 切片中。如果省略切片表达式的 <code>m</code> 或 <code>n</code>，会默认传入 <code>0</code> 或 <code>len(s)</code>，因此前面的切片可以简写成 <code>os.Args[1:]</code>。</p>
|
||||
<p>下面是 Unix 里 <code>echo</code> 命令的一份实现，<code>echo</code> 把它的命令行参数打印成一行。程序导入了两个包，用括号把它们括起来写成列表形式，而没有分开写成独立的 <code>import</code> 声明。两种形式都合法，列表形式习惯上用得多。包导入顺序并不重要；<code>gofmt</code> 工具格式化时按照字母顺序对包名排序。（示例有多个版本时，我们会对示例编号，这样可以明确当前正在讨论的是哪个。）</p>
|
||||
<p><u><i>gopl.io/ch1/echo1</i></u></p>
|
||||
<pre><code class="language-go">// Echo1 prints its command-line arguments.
|
||||
package main
|
||||
@ -184,42 +184,34 @@ func main() {
|
||||
fmt.Println(s)
|
||||
}
|
||||
</code></pre>
|
||||
<p>注释语句以<code>//</code>开头。对于程序员来说，//之后到行末之间所有的内容都是注释，被编译器忽略。按照惯例，我们在每个包的包声明前添加注释；对于<code>main package</code>，注释包含一句或几句话，从整体角度对程序做个描述。</p>
|
||||
<p>var声明定义了两个string类型的变量s和sep。变量会在声明时直接初始化。如果变量没有显式初始化，则被隐式地赋予其类型的<em>零值</em>（zero value），数值类型是0，字符串类型是空字符串""。这个例子里，声明把s和sep隐式地初始化成空字符串。第2章再来详细地讲解变量和声明。</p>
|
||||
<p>对数值类型，Go语言提供了常规的数值和逻辑运算符。而对string类型，<code>+</code>运算符连接字符串（译注：和C++或者js是一样的）。所以表达式：</p>
|
||||
<pre><code class="language-go">sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>表示连接字符串sep和os.Args。程序中使用的语句：</p>
|
||||
<pre><code class="language-go">s += sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>是一条<em>赋值语句</em>，将s的旧值跟sep与os.Args[i]连接后赋值回s，等价于：</p>
|
||||
<pre><code class="language-go">s = s + sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>运算符<code>+=</code>是赋值运算符（assignment operator），每种数值运算符或逻辑运算符，如<code>+</code>或<code>*</code>，都有对应的赋值运算符。</p>
|
||||
<p>echo程序可以每循环一次输出一个参数，这个版本却是不断地把新文本追加到末尾来构造字符串。字符串s开始为空，即值为""，每次循环会添加一些文本；第一次迭代之后，还会再插入一个空格，因此循环结束时每个参数中间都有一个空格。这是一种二次加工（quadratic process），当参数数量庞大时，开销很大，但是对于echo，这种情形不大可能出现。本章会介绍echo的若干改进版，下一章解决低效问题。</p>
|
||||
<p>循环索引变量i在for循环的第一部分中定义。符号<code>:=</code>是<em>短变量声明</em>（short variable declaration）的一部分，这是定义一个或多个变量并根据它们的初始值为这些变量赋予适当类型的语句。下一章有这方面更多说明。</p>
|
||||
<p>自增语句<code>i++</code>给<code>i</code>加1；这和<code>i += 1</code>以及<code>i = i + 1</code>都是等价的。对应的还有<code>i--</code>给<code>i</code>减1。它们是语句，而不像C系的其它语言那样是表达式。所以<code>j = i++</code>非法，而且++和--都只能放在变量名后面，因此<code>--i</code>也非法。</p>
|
||||
<p>Go语言只有for循环这一种循环语句。for循环有多种形式，其中一种如下所示：</p>
|
||||
<p>注释语句以 <code>//</code> 开头。对于程序员来说，<code>//</code> 之后到行末之间所有的内容都是注释，被编译器忽略。按照惯例，我们在每个包的包声明前添加注释；对于 <code>main package</code>，注释包含一句或几句话，从整体角度对程序做个描述。</p>
|
||||
<p><code>var</code> 声明定义了两个 <code>string</code> 类型的变量 <code>s</code> 和 <code>sep</code>。变量会在声明时直接初始化。如果变量没有显式初始化，则被隐式地赋予其类型的 <em>零值</em>（zero value），数值类型是 <code>0</code>，字符串类型是空字符串 <code>""</code>。这个例子里，声明把 <code>s</code> 和 <code>sep</code> 隐式地初始化成空字符串。第 2 章再来详细地讲解变量和声明。</p>
|
||||
<p>对数值类型，Go 语言提供了常规的数值和逻辑运算符。而对 <code>string</code> 类型，<code>+</code> 运算符连接字符串（译注：和 C++ 或者 JavaScript 是一样的）。所以表达式：<code>sep + os.Args[i]</code> 表示连接字符串 <code>sep</code> 和 <code>os.Args</code>。程序中使用的语句：<code>s+=sep+os.Args[i]</code> 是一条 <em>赋值语句</em>，将 <code>s</code> 的旧值跟 <code>sep</code> 与 <code>os.Args[i]</code> 连接后赋值回 <code>s</code>，等价于：<code>s=s+sep+os.Args[i]</code>。</p>
|
||||
<p>运算符 <code>+=</code> 是赋值运算符（assignment operator），每种数值运算符或逻辑运算符，如 <code>+</code> 或 <code>*</code>，都有对应的赋值运算符。</p>
|
||||
<p><code>echo</code> 程序可以每循环一次输出一个参数，这个版本却是不断地把新文本追加到末尾来构造字符串。字符串 <code>s</code> 开始为空，即值为 <code>""</code>，每次循环会添加一些文本；第一次迭代之后，还会再插入一个空格，因此循环结束时每个参数中间都有一个空格。这是一种二次加工（quadratic process），当参数数量庞大时，开销很大，但是对于 <code>echo</code>，这种情形不大可能出现。本章会介绍 <code>echo</code> 的若干改进版，下一章解决低效问题。</p>
|
||||
<p>循环索引变量 <code>i</code> 在 <code>for</code> 循环的第一部分中定义。符号 <code>:=</code> 是 <em>短变量声明</em>（short variable declaration）的一部分，这是定义一个或多个变量并根据它们的初始值为这些变量赋予适当类型的语句。下一章有这方面更多说明。</p>
|
||||
<p>自增语句 <code>i++</code> 给 <code>i</code> 加 <code>1</code>；这和 <code>i+=1</code> 以及 <code>i=i+1</code> 都是等价的。对应的还有 <code>i--</code> 给 <code>i</code> 减 <code>1</code>。它们是语句，而不像 C 系的其它语言那样是表达式。所以 <code>j=i++</code> 非法，而且 <code>++</code> 和 <code>--</code> 都只能放在变量名后面，因此 <code>--i</code> 也非法。</p>
|
||||
<p>Go 语言只有 <code>for</code> 循环这一种循环语句。<code>for</code> 循环有多种形式，其中一种如下所示：</p>
|
||||
<pre><code class="language-go">for initialization; condition; post {
|
||||
// zero or more statements
|
||||
}
|
||||
</code></pre>
|
||||
<p>for循环三个部分不需括号包围。大括号强制要求，左大括号必须和<em>post</em>语句在同一行。</p>
|
||||
<p><em>initialization</em>语句是可选的，在循环开始前执行。<em>initalization</em>如果存在，必须是一条<em>简单语句</em>（simple statement），即，短变量声明、自增语句、赋值语句或函数调用。<code>condition</code>是一个布尔表达式（boolean expression），其值在每次循环迭代开始时计算。如果为<code>true</code>则执行循环体语句。<code>post</code>语句在循环体执行结束后执行，之后再次对<code>condition</code>求值。<code>condition</code>值为<code>false</code>时，循环结束。</p>
|
||||
<p>for循环的这三个部分每个都可以省略，如果省略<code>initialization</code>和<code>post</code>，分号也可以省略：</p>
|
||||
<p><code>for</code> 循环三个部分不需括号包围。大括号强制要求，左大括号必须和 <em><code>post</code></em> 语句在同一行。</p>
|
||||
<p><em><code>initialization</code></em> 语句是可选的，在循环开始前执行。<em><code>initalization</code></em> 如果存在，必须是一条 <em>简单语句</em>（simple statement），即，短变量声明、自增语句、赋值语句或函数调用。<code>condition</code> 是一个布尔表达式（boolean expression），其值在每次循环迭代开始时计算。如果为 <code>true</code> 则执行循环体语句。<code>post</code> 语句在循环体执行结束后执行，之后再次对 <code>condition</code> 求值。<code>condition</code> 值为 <code>false</code> 时，循环结束。</p>
|
||||
<p>for 循环的这三个部分每个都可以省略，如果省略 <code>initialization</code> 和 <code>post</code>，分号也可以省略：</p>
|
||||
<pre><code class="language-go">// a traditional "while" loop
|
||||
for condition {
|
||||
// ...
|
||||
}
|
||||
</code></pre>
|
||||
<p>如果连<code>condition</code>也省略了，像下面这样：</p>
|
||||
<p>如果连 <code>condition</code> 也省略了，像下面这样：</p>
|
||||
<pre><code class="language-go">// a traditional infinite loop
|
||||
for {
|
||||
// ...
|
||||
}
|
||||
</code></pre>
|
||||
<p>这就变成一个无限循环，尽管如此，还可以用其他方式终止循环，如一条<code>break</code>或<code>return</code>语句。</p>
|
||||
<p><code>for</code>循环的另一种形式，在某种数据类型的区间（range）上遍历，如字符串或切片。<code>echo</code>的第二版本展示了这种形式：</p>
|
||||
<p>这就变成一个无限循环，尽管如此，还可以用其他方式终止循环，如一条 <code>break</code> 或 <code>return</code> 语句。</p>
|
||||
<p><code>for</code> 循环的另一种形式，在某种数据类型的区间（range）上遍历，如字符串或切片。<code>echo</code> 的第二版本展示了这种形式：</p>
|
||||
<p><u><i>gopl.io/ch1/echo2</i></u></p>
|
||||
<pre><code class="language-go">// Echo2 prints its command-line arguments.
|
||||
package main
|
||||
@ -238,29 +230,30 @@ func main() {
|
||||
fmt.Println(s)
|
||||
}
|
||||
</code></pre>
|
||||
<p>每次循环迭代，<code>range</code>产生一对值；索引以及在该索引处的元素值。这个例子不需要索引，但<code>range</code>的语法要求，要处理元素，必须处理索引。一种思路是把索引赋值给一个临时变量（如<code>temp</code>）然后忽略它的值，但Go语言不允许使用无用的局部变量（local variables），因为这会导致编译错误。</p>
|
||||
<p>Go语言中这种情况的解决方法是用<code>空标识符</code>（blank identifier），即<code>_</code>（也就是下划线）。空标识符可用于在任何语法需要变量名但程序逻辑不需要的时候（如：在循环里）丢弃不需要的循环索引，并保留元素值。大多数的Go程序员都会像上面这样使用<code>range</code>和<code>_</code>写<code>echo</code>程序，因为隐式地而非显式地索引os.Args，容易写对。</p>
|
||||
<p><code>echo</code>的这个版本使用一条短变量声明来声明并初始化<code>s</code>和<code>seps</code>，也可以将这两个变量分开声明，声明一个变量有好几种方式，下面这些都等价：</p>
|
||||
<p>每次循环迭代，<code>range</code> 产生一对值；索引以及在该索引处的元素值。这个例子不需要索引，但 <code>range</code> 的语法要求，要处理元素，必须处理索引。一种思路是把索引赋值给一个临时变量（如 <code>temp</code>）然后忽略它的值，但 Go 语言不允许使用无用的局部变量（local variables），因为这会导致编译错误。</p>
|
||||
<p>Go 语言中这种情况的解决方法是用 <em>空标识符</em>（blank identifier），即 <code>_</code>（也就是下划线）。空标识符可用于在任何语法需要变量名但程序逻辑不需要的时候（如：在循环里）丢弃不需要的循环索引，并保留元素值。大多数的 Go 程序员都会像上面这样使用 <code>range</code> 和 <code>_</code> 写 <code>echo</code> 程序，因为隐式地而非显式地索引 <code>os.Args</code>，容易写对。</p>
|
||||
<p><code>echo</code> 的这个版本使用一条短变量声明来声明并初始化 <code>s</code> 和 <code>seps</code>，也可以将这两个变量分开声明，声明一个变量有好几种方式，下面这些都等价：</p>
|
||||
<pre><code class="language-go">s := ""
|
||||
var s string
|
||||
var s = ""
|
||||
var s string = ""
|
||||
</code></pre>
|
||||
<p>用哪种不用哪种，为什么呢？第一种形式，是一条短变量声明，最简洁，但只能用在函数内部，而不能用于包变量。第二种形式依赖于字符串的默认初始化零值机制，被初始化为""。第三种形式用得很少，除非同时声明多个变量。第四种形式显式地标明变量的类型，当变量类型与初值类型相同时，类型冗余，但如果两者类型不同，变量类型就必须了。实践中一般使用前两种形式中的某个，初始值重要的话就显式地指定变量的类型，否则使用隐式初始化。</p>
|
||||
<p>如前文所述，每次循环迭代字符串s的内容都会更新。<code>+=</code>连接原字符串、空格和下个参数，产生新字符串，并把它赋值给<code>s</code>。<code>s</code>原来的内容已经不再使用，将在适当时机对它进行垃圾回收。</p>
|
||||
<p>如果连接涉及的数据量很大，这种方式代价高昂。一种简单且高效的解决方案是使用<code>strings</code>包的<code>Join</code>函数：</p>
|
||||
<p>用哪种不用哪种，为什么呢？第一种形式，是一条短变量声明，最简洁，但只能用在函数内部，而不能用于包变量。第二种形式依赖于字符串的默认初始化零值机制，被初始化为 <code>""</code>。第三种形式用得很少，除非同时声明多个变量。第四种形式显式地标明变量的类型，当变量类型与初值类型相同时，类型冗余，但如果两者类型不同，变量类型就必须了。实践中一般使用前两种形式中的某个，初始值重要的话就显式地指定变量的类型，否则使用隐式初始化。</p>
|
||||
<p>如前文所述，每次循环迭代字符串 <code>s</code> 的内容都会更新。<code>+=</code> 连接原字符串、空格和下个参数，产生新字符串，并把它赋值给 <code>s</code>。<code>s</code> 原来的内容已经不再使用，将在适当时机对它进行垃圾回收。</p>
|
||||
<p>如果连接涉及的数据量很大，这种方式代价高昂。一种简单且高效的解决方案是使用 <code>strings</code> 包的 <code>Join</code> 函数：</p>
|
||||
<p><u><i>gopl.io/ch1/echo3</i></u></p>
|
||||
<pre><code class="language-go">func main() {
|
||||
fmt.Println(strings.Join(os.Args[1:], " "))
|
||||
}
|
||||
</code></pre>
|
||||
<p>最后，如果不关心输出格式，只想看看输出值，或许只是为了调试，可以用<code>Println</code>为我们格式化输出。</p>
|
||||
<p>最后，如果不关心输出格式，只想看看输出值，或许只是为了调试，可以用 <code>Println</code> 为我们格式化输出。</p>
|
||||
<pre><code class="language-go">fmt.Println(os.Args[1:])
|
||||
</code></pre>
|
||||
<p>这条语句的输出结果跟<code>strings.Join</code>得到的结果很像，只是被放到了一对方括号里。切片都会被打印成这种格式。</p>
|
||||
<p><strong>练习 1.1：</strong> 修改<code>echo</code>程序，使其能够打印<code>os.Args[0]</code>，即被执行命令本身的名字。</p>
|
||||
<p><strong>练习 1.2：</strong> 修改<code>echo</code>程序，使其打印每个参数的索引和值，每个一行。</p>
|
||||
<p><strong>练习 1.3：</strong> 做实验测量潜在低效的版本和使用了<code>strings.Join</code>的版本的运行时间差异。（1.6节讲解了部分<code>time</code>包，11.4节展示了如何写标准测试程序，以得到系统性的性能评测。）</p>
|
||||
<p>这条语句的输出结果跟 <code>strings.Join</code> 得到的结果很像，只是被放到了一对方括号里。切片都会被打印成这种格式。</p>
|
||||
<hr />
|
||||
<p><strong>练习 1.1：</strong> 修改 <code>echo</code> 程序，使其能够打印 <code>os.Args[0]</code>，即被执行命令本身的名字。</p>
|
||||
<p><strong>练习 1.2：</strong> 修改 <code>echo</code> 程序，使其打印每个参数的索引和值，每个一行。</p>
|
||||
<p><strong>练习 1.3：</strong> 做实验测量潜在低效的版本和使用了 <code>strings.Join</code> 的版本的运行时间差异。（<a href="./ch1-06.html">1.6 节</a>讲解了部分 <code>time</code> 包，<a href="../ch11/ch11-04.html">11.4 节</a>展示了如何写标准测试程序，以得到系统性的性能评测。）</p>
|
||||
|
||||
|
||||
<!-- 公众号 -->
|
||||
|
||||
@ -161,8 +161,8 @@
|
||||
<hr>
|
||||
|
||||
<h2 id="13-查找重复的行"><a class="header" href="#13-查找重复的行">1.3. 查找重复的行</a></h2>
|
||||
<p>对文件做拷贝、打印、搜索、排序、统计或类似事情的程序都有一个差不多的程序结构：一个处理输入的循环，在每个元素上执行计算处理，在处理的同时或最后产生输出。我们会展示一个名为<code>dup</code>的程序的三个版本；灵感来自于Unix的<code>uniq</code>命令，其寻找相邻的重复行。该程序使用的结构和包是个参考范例，可以方便地修改。</p>
|
||||
<p><code>dup</code>的第一个版本打印标准输入中多次出现的行，以重复次数开头。该程序将引入<code>if</code>语句，<code>map</code>数据类型以及<code>bufio</code>包。</p>
|
||||
<p>对文件做拷贝、打印、搜索、排序、统计或类似事情的程序都有一个差不多的程序结构：一个处理输入的循环，在每个元素上执行计算处理，在处理的同时或最后产生输出。我们会展示一个名为 <code>dup</code> 的程序的三个版本；灵感来自于 Unix 的 <code>uniq</code> 命令，其寻找相邻的重复行。该程序使用的结构和包是个参考范例，可以方便地修改。</p>
|
||||
<p><code>dup</code> 的第一个版本打印标准输入中多次出现的行，以重复次数开头。该程序将引入 <code>if</code> 语句，<code>map</code> 数据类型以及 <code>bufio</code> 包。</p>
|
||||
<p><u><i>gopl.io/ch1/dup1</i></u></p>
|
||||
<pre><code class="language-go">// Dup1 prints the text of each line that appears more than
|
||||
// once in the standard input, preceded by its count.
|
||||
@ -188,23 +188,23 @@ func main() {
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>正如<code>for</code>循环一样，<code>if</code>语句条件两边也不加括号，但是主体部分需要加。<code>if</code>语句的<code>else</code>部分是可选的，在<code>if</code>的条件为<code>false</code>时执行。</p>
|
||||
<p><strong>map</strong>存储了键/值（key/value）的集合，对集合元素，提供常数时间的存、取或测试操作。键可以是任意类型，只要其值能用<code>==</code>运算符比较，最常见的例子是字符串；值则可以是任意类型。这个例子中的键是字符串，值是整数。内置函数<code>make</code>创建空<code>map</code>，此外，它还有别的作用。4.3节讨论<code>map</code>。</p>
|
||||
<p>（译注：从功能和实现上说，<code>Go</code>的<code>map</code>类似于<code>Java</code>语言中的<code>HashMap</code>，Python语言中的<code>dict</code>，<code>Lua</code>语言中的<code>table</code>，通常使用<code>hash</code>实现。遗憾的是，对于该词的翻译并不统一，数学界术语为<code>映射</code>，而计算机界众说纷纭莫衷一是。为了防止对读者造成误解，保留不译。）</p>
|
||||
<p>每次<code>dup</code>读取一行输入，该行被当做键存入<code>map</code>，其对应的值递增。<code>counts[input.Text()]++</code>语句等价下面两句：</p>
|
||||
<p>正如 <code>for</code> 循环一样，<code>if</code> 语句条件两边也不加括号，但是主体部分需要加。<code>if</code> 语句的 <code>else</code> 部分是可选的，在 <code>if</code> 的条件为 <code>false</code> 时执行。</p>
|
||||
<p><strong>map</strong> 存储了键/值（key/value）的集合，对集合元素，提供常数时间的存、取或测试操作。键可以是任意类型，只要其值能用 <code>==</code> 运算符比较，最常见的例子是字符串；值则可以是任意类型。这个例子中的键是字符串，值是整数。内置函数 <code>make</code> 创建空 <code>map</code>，此外，它还有别的作用。4.3 节讨论 <code>map</code>。</p>
|
||||
<p>（译注：从功能和实现上说，<code>Go</code> 的 <code>map</code> 类似于 <code>Java</code> 语言中的 <code>HashMap</code>，Python 语言中的 <code>dict</code>，<code>Lua</code> 语言中的 <code>table</code>，通常使用 <code>hash</code> 实现。遗憾的是，对于该词的翻译并不统一，数学界术语为<em>映射</em>，而计算机界众说纷纭莫衷一是。为了防止对读者造成误解，保留不译。）</p>
|
||||
<p>每次 <code>dup</code> 读取一行输入，该行被当做键存入 <code>map</code>，其对应的值递增。<code>counts[input.Text()]++</code> 语句等价下面两句：</p>
|
||||
<pre><code class="language-go">line := input.Text()
|
||||
counts[line] = counts[line] + 1
|
||||
</code></pre>
|
||||
<p><code>map</code>中不含某个键时不用担心，首次读到新行时，等号右边的表达式<code>counts[line]</code>的值将被计算为其类型的零值，对于<code>int</code>即0。</p>
|
||||
<p>为了打印结果，我们使用了基于<code>range</code>的循环，并在<code>counts</code>这个<code>map</code>上迭代。跟之前类似，每次迭代得到两个结果，键和其在<code>map</code>中对应的值。<code>map</code>的迭代顺序并不确定，从实践来看，该顺序随机，每次运行都会变化。这种设计是有意为之的，因为能防止程序依赖特定遍历顺序，而这是无法保证的。（译注：具体可以参见这里http://stackoverflow.com/questions/11853396/google-go-lang-assignment-order）</p>
|
||||
<p>继续来看<code>bufio</code>包，它使处理输入和输出方便又高效。<code>Scanner</code>类型是该包最有用的特性之一，它读取输入并将其拆成行或单词；通常是处理行形式的输入最简单的方法。</p>
|
||||
<p>程序使用短变量声明创建<code>bufio.Scanner</code>类型的变量<code>input</code>。</p>
|
||||
<pre><code>input := bufio.NewScanner(os.Stdin)
|
||||
<p><code>map</code> 中不含某个键时不用担心，首次读到新行时，等号右边的表达式 <code>counts[line]</code> 的值将被计算为其类型的零值，对于 <code>int</code> 即 <code>0</code>。</p>
|
||||
<p>为了打印结果，我们使用了基于 <code>range</code> 的循环，并在 <code>counts</code> 这个 <code>map</code> 上迭代。跟之前类似，每次迭代得到两个结果，键和其在 <code>map</code> 中对应的值。<code>map</code> 的迭代顺序并不确定，从实践来看，该顺序随机，每次运行都会变化。这种设计是有意为之的，因为能防止程序依赖特定遍历顺序，而这是无法保证的。（译注：具体可以参见这里<a href="https://stackoverflow.com/questions/11853396/google-go-lang-assignment-order">https://stackoverflow.com/questions/11853396/google-go-lang-assignment-order</a>）</p>
|
||||
<p>继续来看 <code>bufio</code> 包，它使处理输入和输出方便又高效。<code>Scanner</code> 类型是该包最有用的特性之一，它读取输入并将其拆成行或单词；通常是处理行形式的输入最简单的方法。</p>
|
||||
<p>程序使用短变量声明创建 <code>bufio.Scanner</code> 类型的变量 <code>input</code>。</p>
|
||||
<pre><code class="language-go">input := bufio.NewScanner(os.Stdin)
|
||||
</code></pre>
|
||||
<p>该变量从程序的标准输入中读取内容。每次调用<code>input.Scan()</code>，即读入下一行，并移除行末的换行符；读取的内容可以调用<code>input.Text()</code>得到。<code>Scan</code>函数在读到一行时返回<code>true</code>，不再有输入时返回<code>false</code>。</p>
|
||||
<p>类似于C或其它语言里的<code>printf</code>函数，<code>fmt.Printf</code>函数对一些表达式产生格式化输出。该函数的首个参数是个格式字符串，指定后续参数被如何格式化。各个参数的格式取决于“转换字符”（conversion character），形式为百分号后跟一个字母。举个例子，<code>%d</code>表示以十进制形式打印一个整型操作数，而<code>%s</code>则表示把字符串型操作数的值展开。</p>
|
||||
<p><code>Printf</code>有一大堆这种转换，Go程序员称之为<em>动词（verb）</em>。下面的表格虽然远不是完整的规范，但展示了可用的很多特性：</p>
|
||||
<pre><code>%d 十进制整数
|
||||
<p>该变量从程序的标准输入中读取内容。每次调用 <code>input.Scan()</code>，即读入下一行，并移除行末的换行符；读取的内容可以调用 <code>input.Text()</code> 得到。<code>Scan</code> 函数在读到一行时返回 <code>true</code>，不再有输入时返回 <code>false</code>。</p>
|
||||
<p>类似于 C 或其它语言里的 <code>printf</code> 函数，<code>fmt.Printf</code> 函数对一些表达式产生格式化输出。该函数的首个参数是个格式字符串，指定后续参数被如何格式化。各个参数的格式取决于“转换字符”（conversion character），形式为百分号后跟一个字母。举个例子，<code>%d</code> 表示以十进制形式打印一个整型操作数，而 <code>%s</code> 则表示把字符串型操作数的值展开。</p>
|
||||
<p><code>Printf</code> 有一大堆这种转换，Go程序员称之为<em>动词（verb）</em>。下面的表格虽然远不是完整的规范，但展示了可用的很多特性：</p>
|
||||
<pre><code class="language-text">%d 十进制整数
|
||||
%x, %o, %b 十六进制，八进制，二进制整数。
|
||||
%f, %g, %e 浮点数： 3.141593 3.141592653589793 3.141593e+00
|
||||
%t 布尔：true或false
|
||||
@ -215,8 +215,8 @@ counts[line] = counts[line] + 1
|
||||
%T 变量的类型
|
||||
%% 字面上的百分号标志（无操作数）
|
||||
</code></pre>
|
||||
<p><code>dup1</code>的格式字符串中还含有制表符<code>\t</code>和换行符<code>\n</code>。字符串字面上可能含有这些代表不可见字符的<strong>转义字符（escape sequences）</strong>。默认情况下，<code>Printf</code>不会换行。按照惯例，以字母<code>f</code>结尾的格式化函数，如<code>log.Printf</code>和<code>fmt.Errorf</code>，都采用<code>fmt.Printf</code>的格式化准则。而以<code>ln</code>结尾的格式化函数，则遵循<code>Println</code>的方式，以跟<code>%v</code>差不多的方式格式化参数，并在最后添加一个换行符。（译注：后缀<code>f</code>指<code>format</code>，<code>ln</code>指<code>line</code>。）</p>
|
||||
<p>很多程序要么从标准输入中读取数据，如上面的例子所示，要么从一系列具名文件中读取数据。<code>dup</code>程序的下个版本读取标准输入或是使用<code>os.Open</code>打开各个具名文件，并操作它们。</p>
|
||||
<p><code>dup1</code> 的格式字符串中还含有制表符<code>\t</code>和换行符<code>\n</code>。字符串字面上可能含有这些代表不可见字符的<strong>转义字符（escape sequences）</strong>。默认情况下，<code>Printf</code> 不会换行。按照惯例，以字母 <code>f</code> 结尾的格式化函数，如 <code>log.Printf</code> 和 <code>fmt.Errorf</code>，都采用 <code>fmt.Printf</code> 的格式化准则。而以 <code>ln</code> 结尾的格式化函数，则遵循 <code>Println</code> 的方式，以跟 <code>%v</code> 差不多的方式格式化参数，并在最后添加一个换行符。（译注：后缀 <code>f</code> 指 <code>format</code>，<code>ln</code> 指 <code>line</code>。）</p>
|
||||
<p>很多程序要么从标准输入中读取数据，如上面的例子所示，要么从一系列具名文件中读取数据。<code>dup</code> 程序的下个版本读取标准输入或是使用 <code>os.Open</code> 打开各个具名文件，并操作它们。</p>
|
||||
<p><u><i>gopl.io/ch1/dup2</i></u></p>
|
||||
<pre><code class="language-go">// Dup2 prints the count and text of lines that appear more than once
|
||||
// in the input. It reads from stdin or from a list of named files.
|
||||
@ -259,13 +259,13 @@ func countLines(f *os.File, counts map[string]int) {
|
||||
// NOTE: ignoring potential errors from input.Err()
|
||||
}
|
||||
</code></pre>
|
||||
<p><code>os.Open</code>函数返回两个值。第一个值是被打开的文件(<code>*os.File</code>），其后被<code>Scanner</code>读取。</p>
|
||||
<p><code>os.Open</code>返回的第二个值是内置<code>error</code>类型的值。如果<code>err</code>等于内置值<code>nil</code>（译注：相当于其它语言里的NULL），那么文件被成功打开。读取文件，直到文件结束，然后调用<code>Close</code>关闭该文件，并释放占用的所有资源。相反的话，如果<code>err</code>的值不是<code>nil</code>，说明打开文件时出错了。这种情况下，错误值描述了所遇到的问题。我们的错误处理非常简单，只是使用<code>Fprintf</code>与表示任意类型默认格式值的动词<code>%v</code>，向标准错误流打印一条信息，然后<code>dup</code>继续处理下一个文件；<code>continue</code>语句直接跳到<code>for</code>循环的下个迭代开始执行。</p>
|
||||
<p>为了使示例代码保持合理的大小，本书开始的一些示例有意简化了错误处理，显而易见的是，应该检查<code>os.Open</code>返回的错误值，然而，使用<code>input.Scan</code>读取文件过程中，不大可能出现错误，因此我们忽略了错误处理。我们会在跳过错误检查的地方做说明。5.4节中深入介绍错误处理。</p>
|
||||
<p>注意<code>countLines</code>函数在其声明前被调用。函数和包级别的变量（package-level entities）可以任意顺序声明，并不影响其被调用。（译注：最好还是遵循一定的规范）</p>
|
||||
<p><code>map</code>是一个由<code>make</code>函数创建的数据结构的引用。<code>map</code>作为参数传递给某函数时，该函数接收这个引用的一份拷贝（copy，或译为副本），被调用函数对<code>map</code>底层数据结构的任何修改，调用者函数都可以通过持有的<code>map</code>引用看到。在我们的例子中，<code>countLines</code>函数向<code>counts</code>插入的值，也会被<code>main</code>函数看到。（译注：类似于C++里的引用传递，实际上指针是另一个指针了，但内部存的值指向同一块内存）</p>
|
||||
<p><code>dup</code>的前两个版本以"流”模式读取输入，并根据需要拆分成多个行。理论上，这些程序可以处理任意数量的输入数据。还有另一个方法，就是一口气把全部输入数据读到内存中，一次分割为多行，然后处理它们。下面这个版本，<code>dup3</code>，就是这么操作的。这个例子引入了<code>ReadFile</code>函数（来自于<code>io/ioutil</code>包），其读取指定文件的全部内容，<code>strings.Split</code>函数把字符串分割成子串的切片。（<code>Split</code>的作用与前文提到的<code>strings.Join</code>相反。）</p>
|
||||
<p>我们略微简化了<code>dup3</code>。首先，由于<code>ReadFile</code>函数需要文件名作为参数，因此只读指定文件，不读标准输入。其次，由于行计数代码只在一处用到，故将其移回<code>main</code>函数。</p>
|
||||
<p><code>os.Open</code> 函数返回两个值。第一个值是被打开的文件（<code>*os.File</code>），其后被 <code>Scanner</code> 读取。</p>
|
||||
<p><code>os.Open</code> 返回的第二个值是内置 <code>error</code> 类型的值。如果 <code>err</code> 等于内置值<code>nil</code>（译注：相当于其它语言里的 <code>NULL</code>），那么文件被成功打开。读取文件，直到文件结束，然后调用 <code>Close</code> 关闭该文件，并释放占用的所有资源。相反的话，如果 <code>err</code> 的值不是 <code>nil</code>，说明打开文件时出错了。这种情况下，错误值描述了所遇到的问题。我们的错误处理非常简单，只是使用 <code>Fprintf</code> 与表示任意类型默认格式值的动词 <code>%v</code>，向标准错误流打印一条信息，然后 <code>dup</code> 继续处理下一个文件；<code>continue</code> 语句直接跳到 <code>for</code> 循环的下个迭代开始执行。</p>
|
||||
<p>为了使示例代码保持合理的大小，本书开始的一些示例有意简化了错误处理，显而易见的是，应该检查 <code>os.Open</code> 返回的错误值，然而，使用 <code>input.Scan</code> 读取文件过程中，不大可能出现错误，因此我们忽略了错误处理。我们会在跳过错误检查的地方做说明。5.4 节中深入介绍错误处理。</p>
|
||||
<p>注意 <code>countLines</code> 函数在其声明前被调用。函数和包级别的变量（package-level entities）可以任意顺序声明，并不影响其被调用。（译注：最好还是遵循一定的规范）</p>
|
||||
<p><code>map</code> 是一个由 <code>make</code> 函数创建的数据结构的引用。<code>map</code> 作为参数传递给某函数时，该函数接收这个引用的一份拷贝（copy，或译为副本），被调用函数对 <code>map</code> 底层数据结构的任何修改，调用者函数都可以通过持有的 <code>map</code> 引用看到。在我们的例子中，<code>countLines</code> 函数向 <code>counts</code> 插入的值，也会被 <code>main</code> 函数看到。（译注：类似于 C++ 里的引用传递，实际上指针是另一个指针了，但内部存的值指向同一块内存）</p>
|
||||
<p><code>dup</code> 的前两个版本以"流”模式读取输入，并根据需要拆分成多个行。理论上，这些程序可以处理任意数量的输入数据。还有另一个方法，就是一口气把全部输入数据读到内存中，一次分割为多行，然后处理它们。下面这个版本，<code>dup3</code>，就是这么操作的。这个例子引入了 <code>ReadFile</code> 函数（来自于<code>io/ioutil</code>包），其读取指定文件的全部内容，<code>strings.Split</code> 函数把字符串分割成子串的切片。（<code>Split</code> 的作用与前文提到的 <code>strings.Join</code> 相反。）</p>
|
||||
<p>我们略微简化了 <code>dup3</code>。首先，由于 <code>ReadFile</code> 函数需要文件名作为参数，因此只读指定文件，不读标准输入。其次，由于行计数代码只在一处用到，故将其移回 <code>main</code> 函数。</p>
|
||||
<p><u><i>gopl.io/ch1/dup3</i></u></p>
|
||||
<pre><code class="language-go">package main
|
||||
|
||||
@ -295,9 +295,10 @@ func main() {
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p><code>ReadFile</code>函数返回一个字节切片（byte slice），必须把它转换为<code>string</code>，才能用<code>strings.Split</code>分割。我们会在3.5.4节详细讲解字符串和字节切片。</p>
|
||||
<p>实现上，<code>bufio.Scanner</code>、<code>ioutil.ReadFile</code>和<code>ioutil.WriteFile</code>都使用<code>*os.File</code>的<code>Read</code>和<code>Write</code>方法，但是，大多数程序员很少需要直接调用那些低级（lower-level）函数。高级（higher-level）函数，像<code>bufio</code>和<code>io/ioutil</code>包中所提供的那些，用起来要容易点。</p>
|
||||
<p><strong>练习 1.4：</strong> 修改<code>dup2</code>，出现重复的行时打印文件名称。</p>
|
||||
<p><code>ReadFile</code> 函数返回一个字节切片（byte slice），必须把它转换为 <code>string</code>，才能用 <code>strings.Split</code> 分割。我们会在3.5.4 节详细讲解字符串和字节切片。</p>
|
||||
<p>实现上，<code>bufio.Scanner</code>、<code>ioutil.ReadFile</code> 和 <code>ioutil.WriteFile</code> 都使用 <code>*os.File</code> 的 <code>Read</code> 和 <code>Write</code> 方法，但是，大多数程序员很少需要直接调用那些低级（lower-level）函数。高级（higher-level）函数，像 <code>bufio</code> 和 <code>io/ioutil</code> 包中所提供的那些，用起来要容易点。</p>
|
||||
<hr />
|
||||
<p><strong>练习 1.4：</strong> 修改 <code>dup2</code>，出现重复的行时打印文件名称。</p>
|
||||
|
||||
|
||||
<!-- 公众号 -->
|
||||
|
||||
168
print.html
168
print.html
@ -234,7 +234,7 @@ go version go1.5 linux/amd64
|
||||
<p>本章介绍Go语言的基础组件。本章提供了足够的信息和示例程序，希望可以帮你尽快入门，写出有用的程序。本章和之后章节的示例程序都针对你可能遇到的现实案例。先了解几个Go程序，涉及的主题从简单的文件处理、图像处理到互联网客户端和服务端并发。当然，第一章不会解释细枝末节，但用这些程序来学习一门新语言还是很有效的。</p>
|
||||
<p>学习一门新语言时，会有一种自然的倾向，按照自己熟悉的语言的套路写新语言程序。学习Go语言的过程中，请警惕这种想法，尽量别这么做。我们会演示怎么写好Go语言程序，所以，请使用本书的代码作为你自己写程序时的指南。</p>
|
||||
<div style="break-before: page; page-break-before: always;"></div><h2 id="11-hello-world"><a class="header" href="#11-hello-world">1.1. Hello, World</a></h2>
|
||||
<p>我们以现已成为传统的“hello world”案例来开始吧，这个例子首次出现于1978年出版的C语言圣经<a href="http://s3-us-west-2.amazonaws.com/belllabs-microsite-dritchie/cbook/index.html">《The C Programming Language》</a>（译注：本书作者之一Brian W. Kernighan也是《The C Programming Language》一书的作者）。C语言是直接影响Go语言设计的语言之一。这个例子体现了Go语言一些核心理念。</p>
|
||||
<p>我们以现已成为传统的“hello world”案例来开始吧，这个例子首次出现于 1978 年出版的 C 语言圣经 <a href="http://s3-us-west-2.amazonaws.com/belllabs-microsite-dritchie/cbook/index.html">《The C Programming Language》</a>（译注：本书作者之一 Brian W. Kernighan 也是《The C Programming Language》一书的作者）。C 语言是直接影响 Go 语言设计的语言之一。这个例子体现了 Go 语言一些核心理念。</p>
|
||||
<p><u><i>gopl.io/ch1/helloworld</i></u></p>
|
||||
<pre><code class="language-go">package main
|
||||
|
||||
@ -244,43 +244,43 @@ func main() {
|
||||
fmt.Println("Hello, 世界")
|
||||
}
|
||||
</code></pre>
|
||||
<p>Go是一门编译型语言，Go语言的工具链将源代码及其依赖转换成计算机的机器指令（译注：静态编译）。Go语言提供的工具都通过一个单独的命令<code>go</code>调用，<code>go</code>命令有一系列子命令。最简单的一个子命令就是run。这个命令编译一个或多个以.go结尾的源文件，链接库文件，并运行最终生成的可执行文件。（本书使用$表示命令行提示符。）</p>
|
||||
<pre><code>$ go run helloworld.go
|
||||
<p>Go 是一门编译型语言，Go 语言的工具链将源代码及其依赖转换成计算机的机器指令（译注：静态编译）。Go 语言提供的工具都通过一个单独的命令 <code>go</code> 调用，<code>go</code> 命令有一系列子命令。最简单的一个子命令就是 <code>run</code>。这个命令编译一个或多个以。<code>.go</code> 结尾的源文件，链接库文件，并运行最终生成的可执行文件。（本书使用$表示命令行提示符。）</p>
|
||||
<pre><code class="language-bash">$ go run helloworld.go
|
||||
</code></pre>
|
||||
<p>毫无意外，这个命令会输出：</p>
|
||||
<pre><code>Hello, 世界
|
||||
<pre><code class="language-text">Hello, 世界
|
||||
</code></pre>
|
||||
<p>Go语言原生支持Unicode，它可以处理全世界任何语言的文本。</p>
|
||||
<p>如果不只是一次性实验，你肯定希望能够编译这个程序，保存编译结果以备将来之用。可以用build子命令：</p>
|
||||
<pre><code>$ go build helloworld.go
|
||||
<p>Go 语言原生支持 Unicode，它可以处理全世界任何语言的文本。</p>
|
||||
<p>如果不只是一次性实验，你肯定希望能够编译这个程序，保存编译结果以备将来之用。可以用 <code>build</code> 子命令：</p>
|
||||
<pre><code class="language-shell">$ go build helloworld.go
|
||||
</code></pre>
|
||||
<p>这个命令生成一个名为helloworld的可执行的二进制文件（译注：Windows系统下生成的可执行文件是helloworld.exe，增加了.exe后缀名），之后你可以随时运行它（译注：在Windows系统下在命令行直接输入helloworld.exe命令运行），不需任何处理（译注：因为静态编译，所以不用担心在系统库更新的时候冲突，幸福感满满）。</p>
|
||||
<p>这个命令生成一个名为 <code>helloworld</code> 的可执行的二进制文件（译注：Windows 系统下生成的可执行文件是 <code>helloworld.exe</code>，增加了 <code>.exe</code> 后缀名），之后你可以随时运行它（译注：在 Windows 系统下在命令行直接输入 <code>helloworld.exe</code> 命令运行），不需任何处理（译注：因为静态编译，所以不用担心在系统库更新的时候冲突，幸福感满满）。</p>
|
||||
<pre><code>$ ./helloworld
|
||||
Hello, 世界
|
||||
</code></pre>
|
||||
<p>本书中所有示例代码上都有一行标记，利用这些标记可以从<a href="http://gopl.io">gopl.io</a>网站上本书源码仓库里获取代码：</p>
|
||||
<pre><code>gopl.io/ch1/helloworld
|
||||
<p>本书中所有示例代码上都有一行标记，利用这些标记可以从 <a href="http://gopl.io">gopl.io</a> 网站上本书源码仓库里获取代码：</p>
|
||||
<pre><code class="language-text">gopl.io/ch1/helloworld
|
||||
</code></pre>
|
||||
<p>执行 <code>go get gopl.io/ch1/helloworld</code> 命令，就会从网上获取代码，并放到对应目录中（需要先安装Git或Hg之类的版本管理工具，并将对应的命令添加到PATH环境变量中。序言已经提及，需要先设置好GOPATH环境变量，下载的代码会放在<code>$GOPATH/src/gopl.io/ch1/helloworld</code>目录）。2.6和10.7节有这方面更详细的介绍。</p>
|
||||
<p>来讨论下程序本身。Go语言的代码通过<strong>包</strong>（package）组织，包类似于其它语言里的库（libraries）或者模块（modules）。一个包由位于单个目录下的一个或多个.go源代码文件组成，目录定义包的作用。每个源文件都以一条<code>package</code>声明语句开始，这个例子里就是<code>package main</code>，表示该文件属于哪个包，紧跟着一系列导入（import）的包，之后是存储在这个文件里的程序语句。</p>
|
||||
<p>Go的标准库提供了100多个包，以支持常见功能，如输入、输出、排序以及文本处理。比如<code>fmt</code>包，就含有格式化输出、接收输入的函数。<code>Println</code>是其中一个基础函数，可以打印以空格间隔的一个或多个值，并在最后添加一个换行符，从而输出一整行。</p>
|
||||
<p><code>main</code>包比较特殊。它定义了一个独立可执行的程序，而不是一个库。在<code>main</code>里的<code>main</code> <em>函数</em> 也很特殊，它是整个程序执行时的入口（译注：C系语言差不多都这样）。<code>main</code>函数所做的事情就是程序做的。当然了，<code>main</code>函数一般调用其它包里的函数完成很多工作（如：<code>fmt.Println</code>）。</p>
|
||||
<p>必须告诉编译器源文件需要哪些包，这就是跟随在<code>package</code>声明后面的<code>import</code>声明扮演的角色。hello world例子只用到了一个包，大多数程序需要导入多个包。</p>
|
||||
<p>必须恰当导入需要的包，缺少了必要的包或者导入了不需要的包，程序都无法编译通过。这项严格要求避免了程序开发过程中引入未使用的包（译注：Go语言编译过程没有警告信息，争议特性之一）。</p>
|
||||
<p><code>import</code>声明必须跟在文件的<code>package</code>声明之后。随后，则是组成程序的函数、变量、常量、类型的声明语句（分别由关键字<code>func</code>、<code>var</code>、<code>const</code>、<code>type</code>定义）。这些内容的声明顺序并不重要（译注：最好还是定一下规范）。这个例子的程序已经尽可能短了，只声明了一个函数，其中只调用了一个其他函数。为了节省篇幅，有些时候示例程序会省略<code>package</code>和<code>import</code>声明，但是，这些声明在源代码里有，并且必须得有才能编译。</p>
|
||||
<p>一个函数的声明由<code>func</code>关键字、函数名、参数列表、返回值列表（这个例子里的<code>main</code>函数参数列表和返回值都是空的）以及包含在大括号里的函数体组成。第五章进一步考察函数。</p>
|
||||
<p>Go语言不需要在语句或者声明的末尾添加分号，除非一行上有多条语句。实际上，编译器会主动把特定符号后的换行符转换为分号，因此换行符添加的位置会影响Go代码的正确解析（译注：比如行末是标识符、整数、浮点数、虚数、字符或字符串文字、关键字<code>break</code>、<code>continue</code>、<code>fallthrough</code>或<code>return</code>中的一个、运算符和分隔符<code>++</code>、<code>--</code>、<code>)</code>、<code>]</code>或<code>}</code>中的一个）。举个例子，函数的左括号<code>{</code>必须和<code>func</code>函数声明在同一行上，且位于末尾，不能独占一行，而在表达式<code>x + y</code>中，可在<code>+</code>后换行，不能在<code>+</code>前换行（译注：以+结尾的话不会被插入分号分隔符，但是以x结尾的话则会被分号分隔符，从而导致编译错误）。</p>
|
||||
<p>Go语言在代码格式上采取了很强硬的态度。<code>gofmt</code>工具把代码格式化为标准格式（译注：这个格式化工具没有任何可以调整代码格式的参数，Go语言就是这么任性），并且<code>go</code>工具中的<code>fmt</code>子命令会对指定包，否则默认为当前目录中所有.go源文件应用<code>gofmt</code>命令。本书中的所有代码都被gofmt过。你也应该养成格式化自己的代码的习惯。以法令方式规定标准的代码格式可以避免无尽的无意义的琐碎争执（译注：也导致了Go语言的TIOBE排名较低，因为缺少撕逼的话题）。更重要的是，这样可以做多种自动源码转换，如果放任Go语言代码格式，这些转换就不大可能了。</p>
|
||||
<p>很多文本编辑器都可以配置为保存文件时自动执行<code>gofmt</code>，这样你的源代码总会被恰当地格式化。还有个相关的工具，<code>goimports</code>，可以根据代码需要，自动地添加或删除<code>import</code>声明。这个工具并没有包含在标准的分发包中，可以用下面的命令安装：</p>
|
||||
<pre><code>$ go get golang.org/x/tools/cmd/goimports
|
||||
<p>执行 <code>go get gopl.io/ch1/helloworld</code> 命令，就会从网上获取代码，并放到对应目录中（需要先安装 Git 或 Hg 之类的版本管理工具，并将对应的命令添加到 <code>PATH</code> 环境变量中。序言已经提及，需要先设置好 <code>GOPATH</code> 环境变量，下载的代码会放在 <code>$GOPATH/src/gopl.io/ch1/helloworld</code> 目录）。<a href="ch1/../ch2/ch2-06.html">2.6</a> 和 <a href="ch1/../ch10/ch10-07.html">10.7 节</a>有这方面更详细的介绍。</p>
|
||||
<p>来讨论下程序本身。Go 语言的代码通过<strong>包</strong>（package）组织，包类似于其它语言里的库（libraries）或者模块（modules）。一个包由位于单个目录下的一个或多个 <code>.go</code> 源代码文件组成，目录定义包的作用。每个源文件都以一条 <code>package</code> 声明语句开始，这个例子里就是 <code>package main</code>，表示该文件属于哪个包，紧跟着一系列导入（import）的包，之后是存储在这个文件里的程序语句。</p>
|
||||
<p>Go 的标准库提供了 100 多个包，以支持常见功能，如输入、输出、排序以及文本处理。比如 <code>fmt</code> 包，就含有格式化输出、接收输入的函数。<code>Println</code> 是其中一个基础函数，可以打印以空格间隔的一个或多个值，并在最后添加一个换行符，从而输出一整行。</p>
|
||||
<p><code>main</code> 包比较特殊。它定义了一个独立可执行的程序，而不是一个库。在 <code>main</code> 里的 <code>main</code> <em>函数</em>也很特殊，它是整个程序执行时的入口（译注：C 系语言差不多都这样）。<code>main</code> 函数所做的事情就是程序做的。当然了，<code>main</code> 函数一般调用其它包里的函数完成很多工作（如：<code>fmt.Println</code>）。</p>
|
||||
<p>必须告诉编译器源文件需要哪些包，这就是跟随在 <code>package</code> 声明后面的 <code>import</code> 声明扮演的角色。<code>hello world</code> 例子只用到了一个包，大多数程序需要导入多个包。</p>
|
||||
<p>必须恰当导入需要的包，缺少了必要的包或者导入了不需要的包，程序都无法编译通过。这项严格要求避免了程序开发过程中引入未使用的包（译注：Go 语言编译过程没有警告信息，争议特性之一）。</p>
|
||||
<p><code>import</code> 声明必须跟在文件的 <code>package</code> 声明之后。随后，则是组成程序的函数、变量、常量、类型的声明语句（分别由关键字 <code>func</code>、<code>var</code>、<code>const</code>、<code>type</code> 定义）。这些内容的声明顺序并不重要（译注：最好还是定一下规范）。这个例子的程序已经尽可能短了，只声明了一个函数，其中只调用了一个其他函数。为了节省篇幅，有些时候示例程序会省略 <code>package</code> 和 <code>import</code> 声明，但是，这些声明在源代码里有，并且必须得有才能编译。</p>
|
||||
<p>一个函数的声明由 <code>func</code> 关键字、函数名、参数列表、返回值列表（这个例子里的 <code>main</code> 函数参数列表和返回值都是空的）以及包含在大括号里的函数体组成。第五章进一步考察函数。</p>
|
||||
<p>Go 语言不需要在语句或者声明的末尾添加分号，除非一行上有多条语句。实际上，编译器会主动把特定符号后的换行符转换为分号，因此换行符添加的位置会影响 Go 代码的正确解析（译注：比如行末是标识符、整数、浮点数、虚数、字符或字符串文字、关键字 <code>break</code>、<code>continue</code>、<code>fallthrough</code>或 <code>return</code> 中的一个、运算符和分隔符 <code>++</code>、<code>--</code>、<code>)</code>、<code>]</code> 或 <code>}</code> 中的一个）。举个例子，函数的左括号 <code>{</code> 必须和 <code>func</code> 函数声明在同一行上，且位于末尾，不能独占一行，而在表达式 <code>x+y</code> 中，可在 <code>+</code> 后换行，不能在 <code>+</code> 前换行（译注：以+结尾的话不会被插入分号分隔符，但是以 x 结尾的话则会被分号分隔符，从而导致编译错误）。</p>
|
||||
<p>Go 语言在代码格式上采取了很强硬的态度。<code>gofmt</code>工具把代码格式化为标准格式（译注：这个格式化工具没有任何可以调整代码格式的参数，Go 语言就是这么任性），并且 <code>go</code> 工具中的 <code>fmt</code> 子命令会对指定包，否则默认为当前目录中所有。go 源文件应用 <code>gofmt</code> 命令。本书中的所有代码都被 gofmt 过。你也应该养成格式化自己的代码的习惯。以法令方式规定标准的代码格式可以避免无尽的无意义的琐碎争执（译注：也导致了 Go 语言的 TIOBE 排名较低，因为缺少撕逼的话题）。更重要的是，这样可以做多种自动源码转换，如果放任 Go 语言代码格式，这些转换就不大可能了。</p>
|
||||
<p>很多文本编辑器都可以配置为保存文件时自动执行 <code>gofmt</code>，这样你的源代码总会被恰当地格式化。还有个相关的工具：<code>goimports</code>，可以根据代码需要，自动地添加或删除 <code>import</code> 声明。这个工具并没有包含在标准的分发包中，可以用下面的命令安装：</p>
|
||||
<pre><code class="language-shell">$ go get golang.org/x/tools/cmd/goimports
|
||||
</code></pre>
|
||||
<p>对于大多数用户来说，下载、编译包、运行测试用例、察看Go语言的文档等等常用功能都可以用go的工具完成。10.7节详细介绍这些知识。</p>
|
||||
<p>对于大多数用户来说，下载、编译包、运行测试用例、察看 Go 语言的文档等等常用功能都可以用 go 的工具完成。<a href="ch1/../ch10/ch10-07.html">10.7 节</a>详细介绍这些知识。</p>
|
||||
<div style="break-before: page; page-break-before: always;"></div><h2 id="12-命令行参数"><a class="header" href="#12-命令行参数">1.2. 命令行参数</a></h2>
|
||||
<p>大多数的程序都是处理输入，产生输出；这也正是“计算”的定义。但是，程序如何获取要处理的输入数据呢？一些程序生成自己的数据，但通常情况下，输入来自于程序外部：文件、网络连接、其它程序的输出、敲键盘的用户、命令行参数或其它类似输入源。下面几个例子会讨论其中几个输入源，首先是命令行参数。</p>
|
||||
<p><code>os</code>包以跨平台的方式，提供了一些与操作系统交互的函数和变量。程序的命令行参数可从os包的Args变量获取；os包外部使用os.Args访问该变量。</p>
|
||||
<p>os.Args变量是一个字符串（string）的<em>切片</em>（slice）（译注：slice和Python语言中的切片类似，是一个简版的动态数组），切片是Go语言的基础概念，稍后详细介绍。现在先把切片s当作数组元素序列，序列的长度动态变化，用<code>s[i]</code>访问单个元素，用<code>s[m:n]</code>获取子序列（译注：和python里的语法差不多）。序列的元素数目为len(s)。和大多数编程语言类似，区间索引时，Go语言里也采用左闭右开形式，即，区间包括第一个索引元素，不包括最后一个，因为这样可以简化逻辑。（译注：比如a = [1, 2, 3, 4, 5], a[0:3] = [1, 2, 3]，不包含最后一个元素）。比如s[m:n]这个切片，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)]切片中。如果省略切片表达式的m或n，会默认传入0或len(s)，因此前面的切片可以简写成os.Args[1:]。</p>
|
||||
<p>下面是Unix里echo命令的一份实现，echo把它的命令行参数打印成一行。程序导入了两个包，用括号把它们括起来写成列表形式，而没有分开写成独立的<code>import</code>声明。两种形式都合法，列表形式习惯上用得多。包导入顺序并不重要；gofmt工具格式化时按照字母顺序对包名排序。（示例有多个版本时，我们会对示例编号，这样可以明确当前正在讨论的是哪个。）</p>
|
||||
<p><code>os</code> 包以跨平台的方式，提供了一些与操作系统交互的函数和变量。程序的命令行参数可从 <code>os</code> 包的 <code>Args</code> 变量获取；<code>os</code> 包外部使用 <code>os.Args</code> 访问该变量。</p>
|
||||
<p><code>os.Args</code> 变量是一个字符串（string）的 <em>切片</em>（slice）（译注：slice 和 Python 语言中的切片类似，是一个简版的动态数组），切片是 Go 语言的基础概念，稍后详细介绍。现在先把切片 <code>s</code> 当作数组元素序列，序列的长度动态变化，用 <code>s[i]</code> 访问单个元素，用 <code>s[m:n]</code> 获取子序列（译注：和 Python 里的语法差不多）。序列的元素数目为 <code>len(s)</code>。和大多数编程语言类似，区间索引时，Go 语言里也采用左闭右开形式，即，区间包括第一个索引元素，不包括最后一个，因为这样可以简化逻辑。（译注：比如 <code>a=[1,2,3,4,5]</code>, <code>a[0:3]=[1,2,3]</code>，不包含最后一个元素）。比如 <code>s[m:n]</code> 这个切片，<code>0≤m≤n≤len(s)</code>，包含 <code>n-m</code> 个元素。</p>
|
||||
<p><code>os.Args</code> 的第一个元素：<code>os.Args[0]</code>，是命令本身的名字；其它的元素则是程序启动时传给它的参数。<code>s[m:n]</code> 形式的切片表达式，产生从第 <code>m</code> 个元素到第 <code>n-1</code> 个元素的切片，下个例子用到的元素包含在 <code>os.Args[1:len(os.Args)]</code> 切片中。如果省略切片表达式的 <code>m</code> 或 <code>n</code>，会默认传入 <code>0</code> 或 <code>len(s)</code>，因此前面的切片可以简写成 <code>os.Args[1:]</code>。</p>
|
||||
<p>下面是 Unix 里 <code>echo</code> 命令的一份实现，<code>echo</code> 把它的命令行参数打印成一行。程序导入了两个包，用括号把它们括起来写成列表形式，而没有分开写成独立的 <code>import</code> 声明。两种形式都合法，列表形式习惯上用得多。包导入顺序并不重要；<code>gofmt</code> 工具格式化时按照字母顺序对包名排序。（示例有多个版本时，我们会对示例编号，这样可以明确当前正在讨论的是哪个。）</p>
|
||||
<p><u><i>gopl.io/ch1/echo1</i></u></p>
|
||||
<pre><code class="language-go">// Echo1 prints its command-line arguments.
|
||||
package main
|
||||
@ -299,42 +299,34 @@ func main() {
|
||||
fmt.Println(s)
|
||||
}
|
||||
</code></pre>
|
||||
<p>注释语句以<code>//</code>开头。对于程序员来说，//之后到行末之间所有的内容都是注释，被编译器忽略。按照惯例，我们在每个包的包声明前添加注释；对于<code>main package</code>，注释包含一句或几句话，从整体角度对程序做个描述。</p>
|
||||
<p>var声明定义了两个string类型的变量s和sep。变量会在声明时直接初始化。如果变量没有显式初始化，则被隐式地赋予其类型的<em>零值</em>（zero value），数值类型是0，字符串类型是空字符串""。这个例子里，声明把s和sep隐式地初始化成空字符串。第2章再来详细地讲解变量和声明。</p>
|
||||
<p>对数值类型，Go语言提供了常规的数值和逻辑运算符。而对string类型，<code>+</code>运算符连接字符串（译注：和C++或者js是一样的）。所以表达式：</p>
|
||||
<pre><code class="language-go">sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>表示连接字符串sep和os.Args。程序中使用的语句：</p>
|
||||
<pre><code class="language-go">s += sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>是一条<em>赋值语句</em>，将s的旧值跟sep与os.Args[i]连接后赋值回s，等价于：</p>
|
||||
<pre><code class="language-go">s = s + sep + os.Args[i]
|
||||
</code></pre>
|
||||
<p>运算符<code>+=</code>是赋值运算符（assignment operator），每种数值运算符或逻辑运算符，如<code>+</code>或<code>*</code>，都有对应的赋值运算符。</p>
|
||||
<p>echo程序可以每循环一次输出一个参数，这个版本却是不断地把新文本追加到末尾来构造字符串。字符串s开始为空，即值为""，每次循环会添加一些文本；第一次迭代之后，还会再插入一个空格，因此循环结束时每个参数中间都有一个空格。这是一种二次加工（quadratic process），当参数数量庞大时，开销很大，但是对于echo，这种情形不大可能出现。本章会介绍echo的若干改进版，下一章解决低效问题。</p>
|
||||
<p>循环索引变量i在for循环的第一部分中定义。符号<code>:=</code>是<em>短变量声明</em>（short variable declaration）的一部分，这是定义一个或多个变量并根据它们的初始值为这些变量赋予适当类型的语句。下一章有这方面更多说明。</p>
|
||||
<p>自增语句<code>i++</code>给<code>i</code>加1；这和<code>i += 1</code>以及<code>i = i + 1</code>都是等价的。对应的还有<code>i--</code>给<code>i</code>减1。它们是语句，而不像C系的其它语言那样是表达式。所以<code>j = i++</code>非法，而且++和--都只能放在变量名后面，因此<code>--i</code>也非法。</p>
|
||||
<p>Go语言只有for循环这一种循环语句。for循环有多种形式，其中一种如下所示：</p>
|
||||
<p>注释语句以 <code>//</code> 开头。对于程序员来说，<code>//</code> 之后到行末之间所有的内容都是注释，被编译器忽略。按照惯例，我们在每个包的包声明前添加注释；对于 <code>main package</code>，注释包含一句或几句话，从整体角度对程序做个描述。</p>
|
||||
<p><code>var</code> 声明定义了两个 <code>string</code> 类型的变量 <code>s</code> 和 <code>sep</code>。变量会在声明时直接初始化。如果变量没有显式初始化，则被隐式地赋予其类型的 <em>零值</em>（zero value），数值类型是 <code>0</code>，字符串类型是空字符串 <code>""</code>。这个例子里，声明把 <code>s</code> 和 <code>sep</code> 隐式地初始化成空字符串。第 2 章再来详细地讲解变量和声明。</p>
|
||||
<p>对数值类型，Go 语言提供了常规的数值和逻辑运算符。而对 <code>string</code> 类型，<code>+</code> 运算符连接字符串（译注：和 C++ 或者 JavaScript 是一样的）。所以表达式：<code>sep + os.Args[i]</code> 表示连接字符串 <code>sep</code> 和 <code>os.Args</code>。程序中使用的语句：<code>s+=sep+os.Args[i]</code> 是一条 <em>赋值语句</em>，将 <code>s</code> 的旧值跟 <code>sep</code> 与 <code>os.Args[i]</code> 连接后赋值回 <code>s</code>，等价于：<code>s=s+sep+os.Args[i]</code>。</p>
|
||||
<p>运算符 <code>+=</code> 是赋值运算符（assignment operator），每种数值运算符或逻辑运算符，如 <code>+</code> 或 <code>*</code>，都有对应的赋值运算符。</p>
|
||||
<p><code>echo</code> 程序可以每循环一次输出一个参数，这个版本却是不断地把新文本追加到末尾来构造字符串。字符串 <code>s</code> 开始为空，即值为 <code>""</code>，每次循环会添加一些文本；第一次迭代之后，还会再插入一个空格，因此循环结束时每个参数中间都有一个空格。这是一种二次加工（quadratic process），当参数数量庞大时，开销很大，但是对于 <code>echo</code>，这种情形不大可能出现。本章会介绍 <code>echo</code> 的若干改进版，下一章解决低效问题。</p>
|
||||
<p>循环索引变量 <code>i</code> 在 <code>for</code> 循环的第一部分中定义。符号 <code>:=</code> 是 <em>短变量声明</em>（short variable declaration）的一部分，这是定义一个或多个变量并根据它们的初始值为这些变量赋予适当类型的语句。下一章有这方面更多说明。</p>
|
||||
<p>自增语句 <code>i++</code> 给 <code>i</code> 加 <code>1</code>；这和 <code>i+=1</code> 以及 <code>i=i+1</code> 都是等价的。对应的还有 <code>i--</code> 给 <code>i</code> 减 <code>1</code>。它们是语句，而不像 C 系的其它语言那样是表达式。所以 <code>j=i++</code> 非法，而且 <code>++</code> 和 <code>--</code> 都只能放在变量名后面，因此 <code>--i</code> 也非法。</p>
|
||||
<p>Go 语言只有 <code>for</code> 循环这一种循环语句。<code>for</code> 循环有多种形式，其中一种如下所示：</p>
|
||||
<pre><code class="language-go">for initialization; condition; post {
|
||||
// zero or more statements
|
||||
}
|
||||
</code></pre>
|
||||
<p>for循环三个部分不需括号包围。大括号强制要求，左大括号必须和<em>post</em>语句在同一行。</p>
|
||||
<p><em>initialization</em>语句是可选的，在循环开始前执行。<em>initalization</em>如果存在，必须是一条<em>简单语句</em>（simple statement），即，短变量声明、自增语句、赋值语句或函数调用。<code>condition</code>是一个布尔表达式（boolean expression），其值在每次循环迭代开始时计算。如果为<code>true</code>则执行循环体语句。<code>post</code>语句在循环体执行结束后执行，之后再次对<code>condition</code>求值。<code>condition</code>值为<code>false</code>时，循环结束。</p>
|
||||
<p>for循环的这三个部分每个都可以省略，如果省略<code>initialization</code>和<code>post</code>，分号也可以省略：</p>
|
||||
<p><code>for</code> 循环三个部分不需括号包围。大括号强制要求，左大括号必须和 <em><code>post</code></em> 语句在同一行。</p>
|
||||
<p><em><code>initialization</code></em> 语句是可选的，在循环开始前执行。<em><code>initalization</code></em> 如果存在，必须是一条 <em>简单语句</em>（simple statement），即，短变量声明、自增语句、赋值语句或函数调用。<code>condition</code> 是一个布尔表达式（boolean expression），其值在每次循环迭代开始时计算。如果为 <code>true</code> 则执行循环体语句。<code>post</code> 语句在循环体执行结束后执行，之后再次对 <code>condition</code> 求值。<code>condition</code> 值为 <code>false</code> 时，循环结束。</p>
|
||||
<p>for 循环的这三个部分每个都可以省略，如果省略 <code>initialization</code> 和 <code>post</code>，分号也可以省略：</p>
|
||||
<pre><code class="language-go">// a traditional "while" loop
|
||||
for condition {
|
||||
// ...
|
||||
}
|
||||
</code></pre>
|
||||
<p>如果连<code>condition</code>也省略了，像下面这样：</p>
|
||||
<p>如果连 <code>condition</code> 也省略了，像下面这样：</p>
|
||||
<pre><code class="language-go">// a traditional infinite loop
|
||||
for {
|
||||
// ...
|
||||
}
|
||||
</code></pre>
|
||||
<p>这就变成一个无限循环，尽管如此，还可以用其他方式终止循环，如一条<code>break</code>或<code>return</code>语句。</p>
|
||||
<p><code>for</code>循环的另一种形式，在某种数据类型的区间（range）上遍历，如字符串或切片。<code>echo</code>的第二版本展示了这种形式：</p>
|
||||
<p>这就变成一个无限循环，尽管如此，还可以用其他方式终止循环，如一条 <code>break</code> 或 <code>return</code> 语句。</p>
|
||||
<p><code>for</code> 循环的另一种形式，在某种数据类型的区间（range）上遍历，如字符串或切片。<code>echo</code> 的第二版本展示了这种形式：</p>
|
||||
<p><u><i>gopl.io/ch1/echo2</i></u></p>
|
||||
<pre><code class="language-go">// Echo2 prints its command-line arguments.
|
||||
package main
|
||||
@ -353,32 +345,33 @@ func main() {
|
||||
fmt.Println(s)
|
||||
}
|
||||
</code></pre>
|
||||
<p>每次循环迭代，<code>range</code>产生一对值；索引以及在该索引处的元素值。这个例子不需要索引，但<code>range</code>的语法要求，要处理元素，必须处理索引。一种思路是把索引赋值给一个临时变量（如<code>temp</code>）然后忽略它的值，但Go语言不允许使用无用的局部变量（local variables），因为这会导致编译错误。</p>
|
||||
<p>Go语言中这种情况的解决方法是用<code>空标识符</code>（blank identifier），即<code>_</code>（也就是下划线）。空标识符可用于在任何语法需要变量名但程序逻辑不需要的时候（如：在循环里）丢弃不需要的循环索引，并保留元素值。大多数的Go程序员都会像上面这样使用<code>range</code>和<code>_</code>写<code>echo</code>程序，因为隐式地而非显式地索引os.Args，容易写对。</p>
|
||||
<p><code>echo</code>的这个版本使用一条短变量声明来声明并初始化<code>s</code>和<code>seps</code>，也可以将这两个变量分开声明，声明一个变量有好几种方式，下面这些都等价：</p>
|
||||
<p>每次循环迭代，<code>range</code> 产生一对值；索引以及在该索引处的元素值。这个例子不需要索引，但 <code>range</code> 的语法要求，要处理元素，必须处理索引。一种思路是把索引赋值给一个临时变量（如 <code>temp</code>）然后忽略它的值，但 Go 语言不允许使用无用的局部变量（local variables），因为这会导致编译错误。</p>
|
||||
<p>Go 语言中这种情况的解决方法是用 <em>空标识符</em>（blank identifier），即 <code>_</code>（也就是下划线）。空标识符可用于在任何语法需要变量名但程序逻辑不需要的时候（如：在循环里）丢弃不需要的循环索引，并保留元素值。大多数的 Go 程序员都会像上面这样使用 <code>range</code> 和 <code>_</code> 写 <code>echo</code> 程序，因为隐式地而非显式地索引 <code>os.Args</code>，容易写对。</p>
|
||||
<p><code>echo</code> 的这个版本使用一条短变量声明来声明并初始化 <code>s</code> 和 <code>seps</code>，也可以将这两个变量分开声明，声明一个变量有好几种方式，下面这些都等价：</p>
|
||||
<pre><code class="language-go">s := ""
|
||||
var s string
|
||||
var s = ""
|
||||
var s string = ""
|
||||
</code></pre>
|
||||
<p>用哪种不用哪种，为什么呢？第一种形式，是一条短变量声明，最简洁，但只能用在函数内部，而不能用于包变量。第二种形式依赖于字符串的默认初始化零值机制，被初始化为""。第三种形式用得很少，除非同时声明多个变量。第四种形式显式地标明变量的类型，当变量类型与初值类型相同时，类型冗余，但如果两者类型不同，变量类型就必须了。实践中一般使用前两种形式中的某个，初始值重要的话就显式地指定变量的类型，否则使用隐式初始化。</p>
|
||||
<p>如前文所述，每次循环迭代字符串s的内容都会更新。<code>+=</code>连接原字符串、空格和下个参数，产生新字符串，并把它赋值给<code>s</code>。<code>s</code>原来的内容已经不再使用，将在适当时机对它进行垃圾回收。</p>
|
||||
<p>如果连接涉及的数据量很大，这种方式代价高昂。一种简单且高效的解决方案是使用<code>strings</code>包的<code>Join</code>函数：</p>
|
||||
<p>用哪种不用哪种，为什么呢？第一种形式，是一条短变量声明，最简洁，但只能用在函数内部，而不能用于包变量。第二种形式依赖于字符串的默认初始化零值机制，被初始化为 <code>""</code>。第三种形式用得很少，除非同时声明多个变量。第四种形式显式地标明变量的类型，当变量类型与初值类型相同时，类型冗余，但如果两者类型不同，变量类型就必须了。实践中一般使用前两种形式中的某个，初始值重要的话就显式地指定变量的类型，否则使用隐式初始化。</p>
|
||||
<p>如前文所述，每次循环迭代字符串 <code>s</code> 的内容都会更新。<code>+=</code> 连接原字符串、空格和下个参数，产生新字符串，并把它赋值给 <code>s</code>。<code>s</code> 原来的内容已经不再使用，将在适当时机对它进行垃圾回收。</p>
|
||||
<p>如果连接涉及的数据量很大，这种方式代价高昂。一种简单且高效的解决方案是使用 <code>strings</code> 包的 <code>Join</code> 函数：</p>
|
||||
<p><u><i>gopl.io/ch1/echo3</i></u></p>
|
||||
<pre><code class="language-go">func main() {
|
||||
fmt.Println(strings.Join(os.Args[1:], " "))
|
||||
}
|
||||
</code></pre>
|
||||
<p>最后，如果不关心输出格式，只想看看输出值，或许只是为了调试，可以用<code>Println</code>为我们格式化输出。</p>
|
||||
<p>最后，如果不关心输出格式，只想看看输出值，或许只是为了调试，可以用 <code>Println</code> 为我们格式化输出。</p>
|
||||
<pre><code class="language-go">fmt.Println(os.Args[1:])
|
||||
</code></pre>
|
||||
<p>这条语句的输出结果跟<code>strings.Join</code>得到的结果很像，只是被放到了一对方括号里。切片都会被打印成这种格式。</p>
|
||||
<p><strong>练习 1.1：</strong> 修改<code>echo</code>程序，使其能够打印<code>os.Args[0]</code>，即被执行命令本身的名字。</p>
|
||||
<p><strong>练习 1.2：</strong> 修改<code>echo</code>程序，使其打印每个参数的索引和值，每个一行。</p>
|
||||
<p><strong>练习 1.3：</strong> 做实验测量潜在低效的版本和使用了<code>strings.Join</code>的版本的运行时间差异。（1.6节讲解了部分<code>time</code>包，11.4节展示了如何写标准测试程序，以得到系统性的性能评测。）</p>
|
||||
<p>这条语句的输出结果跟 <code>strings.Join</code> 得到的结果很像，只是被放到了一对方括号里。切片都会被打印成这种格式。</p>
|
||||
<hr />
|
||||
<p><strong>练习 1.1：</strong> 修改 <code>echo</code> 程序，使其能够打印 <code>os.Args[0]</code>，即被执行命令本身的名字。</p>
|
||||
<p><strong>练习 1.2：</strong> 修改 <code>echo</code> 程序，使其打印每个参数的索引和值，每个一行。</p>
|
||||
<p><strong>练习 1.3：</strong> 做实验测量潜在低效的版本和使用了 <code>strings.Join</code> 的版本的运行时间差异。（<a href="ch1/./ch1-06.html">1.6 节</a>讲解了部分 <code>time</code> 包，<a href="ch1/../ch11/ch11-04.html">11.4 节</a>展示了如何写标准测试程序，以得到系统性的性能评测。）</p>
|
||||
<div style="break-before: page; page-break-before: always;"></div><h2 id="13-查找重复的行"><a class="header" href="#13-查找重复的行">1.3. 查找重复的行</a></h2>
|
||||
<p>对文件做拷贝、打印、搜索、排序、统计或类似事情的程序都有一个差不多的程序结构：一个处理输入的循环，在每个元素上执行计算处理，在处理的同时或最后产生输出。我们会展示一个名为<code>dup</code>的程序的三个版本；灵感来自于Unix的<code>uniq</code>命令，其寻找相邻的重复行。该程序使用的结构和包是个参考范例，可以方便地修改。</p>
|
||||
<p><code>dup</code>的第一个版本打印标准输入中多次出现的行，以重复次数开头。该程序将引入<code>if</code>语句，<code>map</code>数据类型以及<code>bufio</code>包。</p>
|
||||
<p>对文件做拷贝、打印、搜索、排序、统计或类似事情的程序都有一个差不多的程序结构：一个处理输入的循环，在每个元素上执行计算处理，在处理的同时或最后产生输出。我们会展示一个名为 <code>dup</code> 的程序的三个版本；灵感来自于 Unix 的 <code>uniq</code> 命令，其寻找相邻的重复行。该程序使用的结构和包是个参考范例，可以方便地修改。</p>
|
||||
<p><code>dup</code> 的第一个版本打印标准输入中多次出现的行，以重复次数开头。该程序将引入 <code>if</code> 语句，<code>map</code> 数据类型以及 <code>bufio</code> 包。</p>
|
||||
<p><u><i>gopl.io/ch1/dup1</i></u></p>
|
||||
<pre><code class="language-go">// Dup1 prints the text of each line that appears more than
|
||||
// once in the standard input, preceded by its count.
|
||||
@ -404,23 +397,23 @@ func main() {
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>正如<code>for</code>循环一样，<code>if</code>语句条件两边也不加括号，但是主体部分需要加。<code>if</code>语句的<code>else</code>部分是可选的，在<code>if</code>的条件为<code>false</code>时执行。</p>
|
||||
<p><strong>map</strong>存储了键/值（key/value）的集合，对集合元素，提供常数时间的存、取或测试操作。键可以是任意类型，只要其值能用<code>==</code>运算符比较，最常见的例子是字符串；值则可以是任意类型。这个例子中的键是字符串，值是整数。内置函数<code>make</code>创建空<code>map</code>，此外，它还有别的作用。4.3节讨论<code>map</code>。</p>
|
||||
<p>（译注：从功能和实现上说，<code>Go</code>的<code>map</code>类似于<code>Java</code>语言中的<code>HashMap</code>，Python语言中的<code>dict</code>，<code>Lua</code>语言中的<code>table</code>，通常使用<code>hash</code>实现。遗憾的是，对于该词的翻译并不统一，数学界术语为<code>映射</code>，而计算机界众说纷纭莫衷一是。为了防止对读者造成误解，保留不译。）</p>
|
||||
<p>每次<code>dup</code>读取一行输入，该行被当做键存入<code>map</code>，其对应的值递增。<code>counts[input.Text()]++</code>语句等价下面两句：</p>
|
||||
<p>正如 <code>for</code> 循环一样，<code>if</code> 语句条件两边也不加括号，但是主体部分需要加。<code>if</code> 语句的 <code>else</code> 部分是可选的，在 <code>if</code> 的条件为 <code>false</code> 时执行。</p>
|
||||
<p><strong>map</strong> 存储了键/值（key/value）的集合，对集合元素，提供常数时间的存、取或测试操作。键可以是任意类型，只要其值能用 <code>==</code> 运算符比较，最常见的例子是字符串；值则可以是任意类型。这个例子中的键是字符串，值是整数。内置函数 <code>make</code> 创建空 <code>map</code>，此外，它还有别的作用。4.3 节讨论 <code>map</code>。</p>
|
||||
<p>（译注：从功能和实现上说，<code>Go</code> 的 <code>map</code> 类似于 <code>Java</code> 语言中的 <code>HashMap</code>，Python 语言中的 <code>dict</code>，<code>Lua</code> 语言中的 <code>table</code>，通常使用 <code>hash</code> 实现。遗憾的是，对于该词的翻译并不统一，数学界术语为<em>映射</em>，而计算机界众说纷纭莫衷一是。为了防止对读者造成误解，保留不译。）</p>
|
||||
<p>每次 <code>dup</code> 读取一行输入，该行被当做键存入 <code>map</code>，其对应的值递增。<code>counts[input.Text()]++</code> 语句等价下面两句：</p>
|
||||
<pre><code class="language-go">line := input.Text()
|
||||
counts[line] = counts[line] + 1
|
||||
</code></pre>
|
||||
<p><code>map</code>中不含某个键时不用担心，首次读到新行时，等号右边的表达式<code>counts[line]</code>的值将被计算为其类型的零值，对于<code>int</code>即0。</p>
|
||||
<p>为了打印结果，我们使用了基于<code>range</code>的循环，并在<code>counts</code>这个<code>map</code>上迭代。跟之前类似，每次迭代得到两个结果，键和其在<code>map</code>中对应的值。<code>map</code>的迭代顺序并不确定，从实践来看，该顺序随机，每次运行都会变化。这种设计是有意为之的，因为能防止程序依赖特定遍历顺序，而这是无法保证的。（译注：具体可以参见这里http://stackoverflow.com/questions/11853396/google-go-lang-assignment-order）</p>
|
||||
<p>继续来看<code>bufio</code>包，它使处理输入和输出方便又高效。<code>Scanner</code>类型是该包最有用的特性之一，它读取输入并将其拆成行或单词；通常是处理行形式的输入最简单的方法。</p>
|
||||
<p>程序使用短变量声明创建<code>bufio.Scanner</code>类型的变量<code>input</code>。</p>
|
||||
<pre><code>input := bufio.NewScanner(os.Stdin)
|
||||
<p><code>map</code> 中不含某个键时不用担心，首次读到新行时，等号右边的表达式 <code>counts[line]</code> 的值将被计算为其类型的零值，对于 <code>int</code> 即 <code>0</code>。</p>
|
||||
<p>为了打印结果，我们使用了基于 <code>range</code> 的循环，并在 <code>counts</code> 这个 <code>map</code> 上迭代。跟之前类似，每次迭代得到两个结果，键和其在 <code>map</code> 中对应的值。<code>map</code> 的迭代顺序并不确定，从实践来看，该顺序随机，每次运行都会变化。这种设计是有意为之的，因为能防止程序依赖特定遍历顺序，而这是无法保证的。（译注：具体可以参见这里<a href="https://stackoverflow.com/questions/11853396/google-go-lang-assignment-order">https://stackoverflow.com/questions/11853396/google-go-lang-assignment-order</a>）</p>
|
||||
<p>继续来看 <code>bufio</code> 包，它使处理输入和输出方便又高效。<code>Scanner</code> 类型是该包最有用的特性之一，它读取输入并将其拆成行或单词；通常是处理行形式的输入最简单的方法。</p>
|
||||
<p>程序使用短变量声明创建 <code>bufio.Scanner</code> 类型的变量 <code>input</code>。</p>
|
||||
<pre><code class="language-go">input := bufio.NewScanner(os.Stdin)
|
||||
</code></pre>
|
||||
<p>该变量从程序的标准输入中读取内容。每次调用<code>input.Scan()</code>，即读入下一行，并移除行末的换行符；读取的内容可以调用<code>input.Text()</code>得到。<code>Scan</code>函数在读到一行时返回<code>true</code>，不再有输入时返回<code>false</code>。</p>
|
||||
<p>类似于C或其它语言里的<code>printf</code>函数，<code>fmt.Printf</code>函数对一些表达式产生格式化输出。该函数的首个参数是个格式字符串，指定后续参数被如何格式化。各个参数的格式取决于“转换字符”（conversion character），形式为百分号后跟一个字母。举个例子，<code>%d</code>表示以十进制形式打印一个整型操作数，而<code>%s</code>则表示把字符串型操作数的值展开。</p>
|
||||
<p><code>Printf</code>有一大堆这种转换，Go程序员称之为<em>动词（verb）</em>。下面的表格虽然远不是完整的规范，但展示了可用的很多特性：</p>
|
||||
<pre><code>%d 十进制整数
|
||||
<p>该变量从程序的标准输入中读取内容。每次调用 <code>input.Scan()</code>，即读入下一行，并移除行末的换行符；读取的内容可以调用 <code>input.Text()</code> 得到。<code>Scan</code> 函数在读到一行时返回 <code>true</code>，不再有输入时返回 <code>false</code>。</p>
|
||||
<p>类似于 C 或其它语言里的 <code>printf</code> 函数，<code>fmt.Printf</code> 函数对一些表达式产生格式化输出。该函数的首个参数是个格式字符串，指定后续参数被如何格式化。各个参数的格式取决于“转换字符”（conversion character），形式为百分号后跟一个字母。举个例子，<code>%d</code> 表示以十进制形式打印一个整型操作数，而 <code>%s</code> 则表示把字符串型操作数的值展开。</p>
|
||||
<p><code>Printf</code> 有一大堆这种转换，Go程序员称之为<em>动词（verb）</em>。下面的表格虽然远不是完整的规范，但展示了可用的很多特性：</p>
|
||||
<pre><code class="language-text">%d 十进制整数
|
||||
%x, %o, %b 十六进制，八进制，二进制整数。
|
||||
%f, %g, %e 浮点数： 3.141593 3.141592653589793 3.141593e+00
|
||||
%t 布尔：true或false
|
||||
@ -431,8 +424,8 @@ counts[line] = counts[line] + 1
|
||||
%T 变量的类型
|
||||
%% 字面上的百分号标志（无操作数）
|
||||
</code></pre>
|
||||
<p><code>dup1</code>的格式字符串中还含有制表符<code>\t</code>和换行符<code>\n</code>。字符串字面上可能含有这些代表不可见字符的<strong>转义字符（escape sequences）</strong>。默认情况下，<code>Printf</code>不会换行。按照惯例，以字母<code>f</code>结尾的格式化函数，如<code>log.Printf</code>和<code>fmt.Errorf</code>，都采用<code>fmt.Printf</code>的格式化准则。而以<code>ln</code>结尾的格式化函数，则遵循<code>Println</code>的方式，以跟<code>%v</code>差不多的方式格式化参数，并在最后添加一个换行符。（译注：后缀<code>f</code>指<code>format</code>，<code>ln</code>指<code>line</code>。）</p>
|
||||
<p>很多程序要么从标准输入中读取数据，如上面的例子所示，要么从一系列具名文件中读取数据。<code>dup</code>程序的下个版本读取标准输入或是使用<code>os.Open</code>打开各个具名文件，并操作它们。</p>
|
||||
<p><code>dup1</code> 的格式字符串中还含有制表符<code>\t</code>和换行符<code>\n</code>。字符串字面上可能含有这些代表不可见字符的<strong>转义字符（escape sequences）</strong>。默认情况下，<code>Printf</code> 不会换行。按照惯例，以字母 <code>f</code> 结尾的格式化函数，如 <code>log.Printf</code> 和 <code>fmt.Errorf</code>，都采用 <code>fmt.Printf</code> 的格式化准则。而以 <code>ln</code> 结尾的格式化函数，则遵循 <code>Println</code> 的方式，以跟 <code>%v</code> 差不多的方式格式化参数，并在最后添加一个换行符。（译注：后缀 <code>f</code> 指 <code>format</code>，<code>ln</code> 指 <code>line</code>。）</p>
|
||||
<p>很多程序要么从标准输入中读取数据，如上面的例子所示，要么从一系列具名文件中读取数据。<code>dup</code> 程序的下个版本读取标准输入或是使用 <code>os.Open</code> 打开各个具名文件，并操作它们。</p>
|
||||
<p><u><i>gopl.io/ch1/dup2</i></u></p>
|
||||
<pre><code class="language-go">// Dup2 prints the count and text of lines that appear more than once
|
||||
// in the input. It reads from stdin or from a list of named files.
|
||||
@ -475,13 +468,13 @@ func countLines(f *os.File, counts map[string]int) {
|
||||
// NOTE: ignoring potential errors from input.Err()
|
||||
}
|
||||
</code></pre>
|
||||
<p><code>os.Open</code>函数返回两个值。第一个值是被打开的文件(<code>*os.File</code>），其后被<code>Scanner</code>读取。</p>
|
||||
<p><code>os.Open</code>返回的第二个值是内置<code>error</code>类型的值。如果<code>err</code>等于内置值<code>nil</code>（译注：相当于其它语言里的NULL），那么文件被成功打开。读取文件，直到文件结束，然后调用<code>Close</code>关闭该文件，并释放占用的所有资源。相反的话，如果<code>err</code>的值不是<code>nil</code>，说明打开文件时出错了。这种情况下，错误值描述了所遇到的问题。我们的错误处理非常简单，只是使用<code>Fprintf</code>与表示任意类型默认格式值的动词<code>%v</code>，向标准错误流打印一条信息，然后<code>dup</code>继续处理下一个文件；<code>continue</code>语句直接跳到<code>for</code>循环的下个迭代开始执行。</p>
|
||||
<p>为了使示例代码保持合理的大小，本书开始的一些示例有意简化了错误处理，显而易见的是，应该检查<code>os.Open</code>返回的错误值，然而，使用<code>input.Scan</code>读取文件过程中，不大可能出现错误，因此我们忽略了错误处理。我们会在跳过错误检查的地方做说明。5.4节中深入介绍错误处理。</p>
|
||||
<p>注意<code>countLines</code>函数在其声明前被调用。函数和包级别的变量（package-level entities）可以任意顺序声明，并不影响其被调用。（译注：最好还是遵循一定的规范）</p>
|
||||
<p><code>map</code>是一个由<code>make</code>函数创建的数据结构的引用。<code>map</code>作为参数传递给某函数时，该函数接收这个引用的一份拷贝（copy，或译为副本），被调用函数对<code>map</code>底层数据结构的任何修改，调用者函数都可以通过持有的<code>map</code>引用看到。在我们的例子中，<code>countLines</code>函数向<code>counts</code>插入的值，也会被<code>main</code>函数看到。（译注：类似于C++里的引用传递，实际上指针是另一个指针了，但内部存的值指向同一块内存）</p>
|
||||
<p><code>dup</code>的前两个版本以"流”模式读取输入，并根据需要拆分成多个行。理论上，这些程序可以处理任意数量的输入数据。还有另一个方法，就是一口气把全部输入数据读到内存中，一次分割为多行，然后处理它们。下面这个版本，<code>dup3</code>，就是这么操作的。这个例子引入了<code>ReadFile</code>函数（来自于<code>io/ioutil</code>包），其读取指定文件的全部内容，<code>strings.Split</code>函数把字符串分割成子串的切片。（<code>Split</code>的作用与前文提到的<code>strings.Join</code>相反。）</p>
|
||||
<p>我们略微简化了<code>dup3</code>。首先，由于<code>ReadFile</code>函数需要文件名作为参数，因此只读指定文件，不读标准输入。其次，由于行计数代码只在一处用到，故将其移回<code>main</code>函数。</p>
|
||||
<p><code>os.Open</code> 函数返回两个值。第一个值是被打开的文件（<code>*os.File</code>），其后被 <code>Scanner</code> 读取。</p>
|
||||
<p><code>os.Open</code> 返回的第二个值是内置 <code>error</code> 类型的值。如果 <code>err</code> 等于内置值<code>nil</code>（译注：相当于其它语言里的 <code>NULL</code>），那么文件被成功打开。读取文件，直到文件结束，然后调用 <code>Close</code> 关闭该文件，并释放占用的所有资源。相反的话，如果 <code>err</code> 的值不是 <code>nil</code>，说明打开文件时出错了。这种情况下，错误值描述了所遇到的问题。我们的错误处理非常简单，只是使用 <code>Fprintf</code> 与表示任意类型默认格式值的动词 <code>%v</code>，向标准错误流打印一条信息，然后 <code>dup</code> 继续处理下一个文件；<code>continue</code> 语句直接跳到 <code>for</code> 循环的下个迭代开始执行。</p>
|
||||
<p>为了使示例代码保持合理的大小，本书开始的一些示例有意简化了错误处理，显而易见的是，应该检查 <code>os.Open</code> 返回的错误值，然而，使用 <code>input.Scan</code> 读取文件过程中，不大可能出现错误，因此我们忽略了错误处理。我们会在跳过错误检查的地方做说明。5.4 节中深入介绍错误处理。</p>
|
||||
<p>注意 <code>countLines</code> 函数在其声明前被调用。函数和包级别的变量（package-level entities）可以任意顺序声明，并不影响其被调用。（译注：最好还是遵循一定的规范）</p>
|
||||
<p><code>map</code> 是一个由 <code>make</code> 函数创建的数据结构的引用。<code>map</code> 作为参数传递给某函数时，该函数接收这个引用的一份拷贝（copy，或译为副本），被调用函数对 <code>map</code> 底层数据结构的任何修改，调用者函数都可以通过持有的 <code>map</code> 引用看到。在我们的例子中，<code>countLines</code> 函数向 <code>counts</code> 插入的值，也会被 <code>main</code> 函数看到。（译注：类似于 C++ 里的引用传递，实际上指针是另一个指针了，但内部存的值指向同一块内存）</p>
|
||||
<p><code>dup</code> 的前两个版本以"流”模式读取输入，并根据需要拆分成多个行。理论上，这些程序可以处理任意数量的输入数据。还有另一个方法，就是一口气把全部输入数据读到内存中，一次分割为多行，然后处理它们。下面这个版本，<code>dup3</code>，就是这么操作的。这个例子引入了 <code>ReadFile</code> 函数（来自于<code>io/ioutil</code>包），其读取指定文件的全部内容，<code>strings.Split</code> 函数把字符串分割成子串的切片。（<code>Split</code> 的作用与前文提到的 <code>strings.Join</code> 相反。）</p>
|
||||
<p>我们略微简化了 <code>dup3</code>。首先，由于 <code>ReadFile</code> 函数需要文件名作为参数，因此只读指定文件，不读标准输入。其次，由于行计数代码只在一处用到，故将其移回 <code>main</code> 函数。</p>
|
||||
<p><u><i>gopl.io/ch1/dup3</i></u></p>
|
||||
<pre><code class="language-go">package main
|
||||
|
||||
@ -511,9 +504,10 @@ func main() {
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p><code>ReadFile</code>函数返回一个字节切片（byte slice），必须把它转换为<code>string</code>，才能用<code>strings.Split</code>分割。我们会在3.5.4节详细讲解字符串和字节切片。</p>
|
||||
<p>实现上，<code>bufio.Scanner</code>、<code>ioutil.ReadFile</code>和<code>ioutil.WriteFile</code>都使用<code>*os.File</code>的<code>Read</code>和<code>Write</code>方法，但是，大多数程序员很少需要直接调用那些低级（lower-level）函数。高级（higher-level）函数，像<code>bufio</code>和<code>io/ioutil</code>包中所提供的那些，用起来要容易点。</p>
|
||||
<p><strong>练习 1.4：</strong> 修改<code>dup2</code>，出现重复的行时打印文件名称。</p>
|
||||
<p><code>ReadFile</code> 函数返回一个字节切片（byte slice），必须把它转换为 <code>string</code>，才能用 <code>strings.Split</code> 分割。我们会在3.5.4 节详细讲解字符串和字节切片。</p>
|
||||
<p>实现上，<code>bufio.Scanner</code>、<code>ioutil.ReadFile</code> 和 <code>ioutil.WriteFile</code> 都使用 <code>*os.File</code> 的 <code>Read</code> 和 <code>Write</code> 方法，但是，大多数程序员很少需要直接调用那些低级（lower-level）函数。高级（higher-level）函数，像 <code>bufio</code> 和 <code>io/ioutil</code> 包中所提供的那些，用起来要容易点。</p>
|
||||
<hr />
|
||||
<p><strong>练习 1.4：</strong> 修改 <code>dup2</code>，出现重复的行时打印文件名称。</p>
|
||||
<div style="break-before: page; page-break-before: always;"></div><h2 id="14-gif动画"><a class="header" href="#14-gif动画">1.4. GIF动画</a></h2>
|
||||
<p>下面的程序会演示Go语言标准库里的image这个package的用法，我们会用这个包来生成一系列的bit-mapped图，然后将这些图片编码为一个GIF动画。我们生成的图形名字叫利萨如图形（Lissajous figures），这种效果是在1960年代的老电影里出现的一种视觉特效。它们是协振子在两个纬度上振动所产生的曲线，比如两个sin正弦波分别在x轴和y轴输入会产生的曲线。图1.1是这样的一个例子：</p>
|
||||
<p><img src="ch1/../images/ch1-01.png" alt="" /></p>
|
||||
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Loading…
Reference in New Issue
Block a user