从零搭建 Go 开发环境：安装、GOPATH 工作区、Go 命令行工具与 IDE 全指南（build-web-application-with-golang 第一章精读）

本文基于开源 Go 电子书《build-web-application-with-golang》法文版 第一章 及其全部小节，系统讲解如何在你的电脑上完成 Go 开发环境的搭建：从三种安装方式（源码编译、官方安装包、第三方包管理器），到 $GOPATH 工作区的目录规范与自定义包编写，再到 go build、go test、go doc 等官方命令行工具，最后覆盖 LiteIDE、Vim、Emacs、Eclipse 等主流开发环境。读完本章，你将具备独立配置一套可用、可编译、可测试、可持续扩展的 Go 开发工作台的全部实战能力。

为什么先从环境配置开始：Go 的设计初衷

第一章 01.0 开篇先交代了这门语言的定位：Go 是一门系统级编程语言，具备快速编译、并发模型和垃圾回收（ramasse-miettes）三大特征。它带来的工程优势包括：

• 秒级编译：即使是大型项目也能在几秒内完成编译，极大缩短开发反馈循环；
• 简单的静态类型系统：用户不必花费大量时间处理类型之间的关系，可以把它看作一门简化版"面向对象"语言；
• 原生垃圾回收：内置对并发（concurrence）与通信（communication）的基础支持；
• 面向多核设计：专门为现代多核互联计算机而生。

Go 是编译型语言，它试图结合解释型/动态语言的开发效率与静态语言的类型安全。要达到这一目标，语言层面需要解决几个根本问题：一个表现力强且轻量的类型系统、原生并发模型，以及严格管理的垃圾回收。作者指出，长期没有哪个包或工具能务实地把这些问题一并解决——这正是 Go 语言诞生的动机。

第一章的任务就是：教会读者安装并配置属于自己的 Go 开发环境，为后续第 2 章《Go 语言基础》打下地基。全章由五个小节构成，本文按此脉络展开：

• 1.1 安装：三种安装方式
• 1.2 $GOPATH 与工作区：项目目录组织与包管理
• 1.3 Go 命令：官方工具链用法
• 1.4 Go 开发工具：主流 IDE 与编辑器配置
• 1.5 小结：本章回顾与衔接

三种安装方式总览

配置 Go 开发环境有多种途径，可按需选择，最常见的三种是：

1. 官方安装包（Paquets d'installation officiels）：Go 团队为 Windows、Linux、Mac 等系统提供官方安装包，这是初学者最省事的方式；
2. 从源码手动编译（Installation manuelle via les sources）：适合习惯 Unix 环境的开发者；
3. 第三方工具（Utilisation d'outils tiers）：例如 Ubuntu 的 apt-get、Mac 的 homebrew 等包管理器。

如果你需要在同一台机器上安装多个 Go 版本，强烈建议优先考察 GVM（多版本管理工具，类似 Ruby 世界的 rvm），否则就得自己手动处理版本切换。

⚠️ 版本与时效说明：本书撰写于 Go 1.4 时代，下文涉及的下载文件名（如 go1.4.linux-amd64.tar.gz）、源码托管地址（Google Code 的 code.google.com/p/go）以及部分第三方工具属于当时的真实操作步骤。今天的 Go 官方已迁移至新的下载站点与 Git 仓库，安装器行为和目录约定也有演进。阅读时请以"理解环境搭建的原理与流程"为主，实际安装请以 Go 官方当前文档为准。

方式一：从源码编译安装

由于 Go 的部分实现由 C（Plan 9 风格）与 AT&T 汇编编写，从源码安装前必须先准备好 C 编译器：

• Mac：安装 Xcode 即自带编译器；
• 类 Unix 系统：需要 gcc 或等价编译器。以 Ubuntu 的 apt-get 为例：

sudo apt-get install gcc libc6-dev

• Windows：安装 MinGW 以提供 gcc，安装完成后记得配置环境变量。

Go 团队当年使用 Mercurial 管理源码，因此还需要先安装 Mercurial 客户端。之后依次执行：

hg clone -u release https://code.google.com/p/go
cd go/src
./all.bash

安装成功时，终端会输出 "ALL TESTS PASSED."（Windows 上对应运行 all.bat）。

环境变量配置：Windows 的安装包会自动更新环境变量；Unix 系统需要手动配置：

export GOROOT=$HOME/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOROOT/bin

配置完成后，在终端输入 go，如果看到如下输出，说明安装成功：

图 1.1 安装后的 Go 信息输出

如果系统提示"找不到 go 命令"（commande introuvable），请检查 $PATH 中是否包含了 Go 的安装目录。

方式二：官方标准安装包

Go 为每个受支持的操作系统提供了免编译的快速安装包，默认安装到 /usr/local/go（Windows 为 c:\Go）。安装位置可自定义，但若改动位置，仍需按上文方式手动修改环境变量。

先判断系统是 32 位还是 64 位

下载哪个安装包取决于系统架构，务必先确认：

• Windows：按 Win+R 打开运行框，输入 cmd 启动命令行，执行 systeminfo，在输出中找到"系统类型"一行——若显示 "x64-based PC" 则为 64 位，否则为 32 位；
• Mac：强烈建议下载 64 位安装包，因为 Go 在 Mac OSX 上已不再支持 32 位处理器；
• Linux：在终端执行 uname -a 查看系统信息。64 位系统会显示：

<descriptions diverses> x86_64 x86_64 x86_64 GNU/Linux

部分机器（如 Ubuntu 10.04）简化为：

x86_64 GNU/Linux

32 位系统则显示：

<descriptions diverses> i686 i686 i386 GNU/Linux

Mac

前往 Go 官方下载页面，32 位选择 go1.4.darwin-386.pkg，64 位选择 go1.4.darwin-amd64.pkg。一路点击"下一步"直到安装结束，安装器会自动把 ~/go/bin 加入系统 $PATH。打开终端输入 go，即可看到与图 1.1 相同的输出。

Linux

前往下载页面，32 位选择 go1.4.linux-386.tar.gz，64 位选择 go1.4.linux-amd64.tar.gz。假设目标安装目录为 $GO_INSTALL_DIR，解压：

tar zxvf go1.4.linux-amd64.tar.gz -C $GO_INSTALL_DIR

随后配置 $PATH：

export PATH=$PATH:$GO_INSTALL_DIR/go/bin

打开终端输入 go，验证输出是否与图 1.1 一致。

Windows

前往下载页面，32 位选择 go1.4.windows-386.msi，64 位选择 go1.4.windows-amd64.msi。一路"下一步"完成安装，c:/go/bin 会被自动加入 path。打开终端输入 go 验证。

方式三：第三方工具安装

GVM（Go 多版本管理器）

GVM 是第三方开发的多版本管理工具，用法与 Ruby 的 rvm 类似。安装：

bash < <(curl -s -S -L https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)

安装指定版本的 Go：

gvm install go1.4
gvm use go1.4

执行完毕后 Go 即安装完成。GVM 特别适合需要同时维护多个 Go 版本、并在不同项目间切换的场景。

apt-get（Ubuntu）

Ubuntu 是最流行的 Linux 桌面发行版，使用 apt-get 作为包管理器：

sudo add-apt-repository ppa:gophers/go
sudo apt-get update
sudo apt-get install golang-stable

Homebrew（Mac）

Homebrew 是 Mac 上常用的软件包管理工具：

brew install go

$GOPATH 与 workspace：Go 项目的目录组织

Go 命令依赖一个名为 $GOPATH 的环境变量——注意它不是 $GOROOT（后者指向 Go 的安装目录）。$GOPATH 指向你电脑上的 Go 工作区（workspace）。

类 Unix 系统上的配置方式：

export GOPATH=/home/apple/mygo

为了方便，建议把这行追加到 .bashrc 或 .zshrc 等 shell 配置文件中。

Windows 上则需创建名为 GOPATH 的环境变量，值为 c:\mygo：

GOPATH=c:\mygo

$GOPATH 支持多个目录：Unix 下用 : 分隔，Windows 下用 ; 分隔。

在 $GOPATH 下必须存在三个子目录，职责明确：

目录	用途
src	存放源代码（.go、.c、.h、.s 等）
pkg	存放编译后的包文件（.a）
bin	存放编译生成的可执行文件

后续章节中，本书统一使用 Mygo 作为 $GOPATH 目录名。

创建自己的包：mymath 实战

创建包源文件目录：

cd $GOPATH/src
mkdir mymath

每次创建一个新包，都应在 src 下新建对应目录；目录名通常与包名保持一致，且支持多级目录。例如创建 $GOPATH/src/github.com/astaxie/beedb，则包的导入路径就是 github.com/astaxie/beedb，包名取路径最后一段 beedb。

新建 sqrt.go 并写入以下内容（$GOPATH/src/mymath/sqrt.go）：

// Code source de $GOPATH/src/mymath/sqrt.go
package mymath

func Sqrt(x float64) float64 {
	z := 0.0
	for i := 0; i < 1000; i++ {
		z -= (z*z - x) / (2 * x)
	}
	return z
}

推荐做法：包名与目录名一致，目录中包含该包的所有源文件。这里 mymath 包实现了一个基于牛顿迭代法的平方根函数 Sqrt，循环 1000 次逼近结果。

编译包与编写应用程序

编译 mymath 包

包写好后有两种编译方式：

1. 进入包所在目录，执行 go install；
2. 直接指定包名：go install mymath。

编译完成后，可以在如下目录找到产物：

cd $GOPATH/pkg/${GOOS}_${GOARCH}
# 这里能找到编译好的文件
mymath.a

.a 后缀文件就是包的二进制归档文件。要真正"用起来"，还需要编写一个应用程序来引用它。

编写 mathapp 应用程序

新建 mathapp 包：

cd $GOPATH/src
mkdir mathapp
cd mathapp
vim main.go

main.go 内容（$GOPATH/src/mathapp/main.go）：

// Code source de $GOPATH/src/mathapp/main.go.
package main

import (
	"mymath"
	"fmt"
)

func main() {
	fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
}

编译该应用，需进入包目录：

cd $GOPATH/src/mathapp
go install

随后在 $GOPATH/bin/ 下会生成可执行文件 mathapp，运行它：

./mathapp

终端输出：

Hello world. Sqrt(2) = 1.414213562373095

这条输出验证了自定义包 mymath 被成功编译、链接并被 mathapp 正确调用——一个最小的"自研库 + 应用"项目闭环就此打通。

安装远程包：go get

Go 提供 go get 工具安装远程包，支持 GitHub、Google Code、BitBucket、Launchpad 等主流开源社区：

go get github.com/astaxie/beedb

使用 go get -u 可以更新远程包，同时也会更新其依赖。

go get 会根据托管平台自动选择对应的版本控制工具克隆源码：GitHub 用 git、Google Code 用 hg（Mercurial）等。因此使用 go get 前，需先安装好相应 VCS 客户端并配置好 $PATH。

执行上述命令后，目录结构变为：

$GOPATH
	src
	 |-github.com
	 	 |-astaxie
	 	 	 |-beedb
	pkg
	 |--${GOOS}_${GOARCH}
	 	 |-github.com
	 	 	 |-astaxie
	 	 	 	 |-beedb.a

其本质是：go get 先把源码克隆到 $GOPATH/src，随后自动执行 go install。远程包的使用方式与本地包完全一致：

import "github.com/astaxie/beedb"

完整目录树参考

如果按上文全部步骤操作，最终的工作区结构如下：

bin/
	mathapp
pkg/
	${GOOS}_${GOARCH}, such as darwin_amd64, linux_amd64
  mymath.a
  github.com/
    astaxie/
      beedb.a
src/
	mathapp
		main.go
	mymath/
		sqrt.go
	github.com/
		astaxie/
			beedb/
				beedb.go
				util.go

这张目录树清晰地体现了 Go 工作区三大目录的职责：bin 放可执行文件、pkg 放编译产物、src 放包源码。

注：Windows 下环境变量的书写格式为 %GOPATH%，但本书主要遵循 Unix 规范，Windows 用户请自行做相应替换。

Go 命令行工具速查

运行 go 命令会列出 Go 自带的一整套工具链（见下图），它们各自承担编译、格式化、测试、文档等职责。

图 1.3 go 命令显示的工具信息

go build —— 编译测试

go build 用于编译测试，需要时会顺带编译依赖的包。关键行为：

• 若目标不是 main 包（如 1.2 节的 mymath），执行 go build 不会生成任何文件；需要 $GOPATH/pkg 下的 .a 包文件时，应改用 go install；
• 若目标是 main 包，会在当前目录生成可执行文件；想输出到 $GOPATH/bin，则用 go install 或 go build -o ${路径}/a.exe；
• 目录下有多个文件但只想编译其中一个时，在 go build 后追加文件名，例如 go build a.go；不带文件名时编译该目录下所有文件；
• 可用 -o 自定义输出文件名。例如对 mathapp 执行 go build -o astaxie.exe 会生成 astaxie.exe 而非 mathapp.exe。默认命名规则：main 包取目录名，或取第一个源文件名（依据 Go 语言规范，包名以源文件首行的 package 声明为准，不必与目录名一致，但可执行文件默认以目录名命名）；
• go build 会忽略文件名以 _ 或 . 开头的文件；
• 如需按操作系统区分源文件，可在文件名末尾加平台后缀，例如：

array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go

go build 会自动选择与当前系统匹配的文件——Linux 下只编译 array_linux.go，其余忽略。

go clean —— 清理编译产物

go clean 用于删除编译器生成的中间文件，包括：

_obj/            // 旧对象目录，由 Makefiles 创建
_test/           // 旧测试目录，由 Makefiles 创建
_testmain.go     // 旧的 gotest 主文件，由 Makefiles 创建
test.out         // 旧测试输出文件
build.out        // 旧构建输出文件
*.[568ao]        // 对象文件，由 Makefiles 创建

DIR(.exe)        // go build 生成
DIR.test(.exe)   // go test -c 生成
MAINFILE(.exe)   // go build MAINFILE.go 生成

作者的习惯是在提交项目到版本库前先执行 go clean：这些文件对本地测试有用，但不该进入版本控制系统。

go fmt —— 统一代码风格

C/C++ 开发者常年争论 K&R 还是 ANSI 风格，而 Go 只有一种官方代码风格。例如左花括号必须放在行尾、不能独占一行，否则编译报错。好消息是你不必背下全部规则——go fmt <文件名>.go 会自动完成格式化。

不过作者更推荐使用 gofmt -w：go fmt 格式化后不写回源文件，而 gofmt -w src 会直接格式化整个项目。

go get —— 拉取远程包

支持 BitBucket、GitHub、Google Code、Launchpad 等平台。执行时发生两件事：先下载源码，再执行 go install。各平台对应的版本控制工具：

BitBucket   (Mercurial Git)
GitHub      (git)
Google Code (Git, Mercurial, Subversion)
Launchpad   (Bazaar)

使用前须正确安装这些工具并配置好 $PATH。go get 还支持自定义域名，详见 go help remote。

go install —— 编译并安装

编译所有包并生成文件，随后移动到 $GOPATH/pkg 或 $GOPATH/bin。

go test —— 运行测试

go test 会加载所有名为 *_test.go 的文件并生成测试程序，输出类似：

ok   archive/tar   0.011s
FAIL archive/zip   0.022s
ok   compress/gzip 0.033s
...

默认运行全部测试文件，更多选项见 go help testflag。

go doc —— 查阅文档

Go 自带完善的文档工具，无需额外第三方文档（作者还曾开发过 CHM 格式的 godoc）。常用方式：

• go doc builtin：查看 builtin 包文档；
• go doc net/http：查看 http 包文档；
• 想看某个函数的细节：godoc fmt Printf，或 godoc -src fmt Printf 直接查看源码。

运行 godoc -http=:8080 后，浏览器打开 127.0.0.1:8080 即可看到一个"本地版 golang.org"——不仅能查标准包，还能查 $GOPATH/pkg 下的包，对身处特殊网络环境的开发者尤其有用。

其他命令

go fix     // 将 go1 之前的旧代码迁移更新到更新的语法
go version // 查看当前 Go 版本
go env     // 显示 Go 相关环境变量
go list    // 列出已安装的所有包
go run     // 编译临时文件并直接运行程序

所有命令都支持比上文更丰富的选项，统一用 go help <command> 查看。

开发工具与 IDE 配置

本小节介绍多款能显著提升编码效率的工具（代码补全、自动格式化等），它们均为跨平台，操作大同小异。

LiteIDE

LiteIDE 是 visualfc 开发的专为 Go 打造的轻量级跨平台 IDE：

图 1.4 LiteIDE 主面板

主要特性：

• 跨平台：Windows / Linux / Mac OS；
• 交叉编译：多编译环境管理，支持 Go 交叉编译；
• 标准的项目管理：基于 $GOPATH 的文档、编译与 API 索引；
• Go 源码编辑器：代码格式化、完整的 gocode 支持、Go 文档与 API 索引管理；F1 显示表达式说明、F2 跳转函数声明；支持 Gdb；通过 gofmt 自动格式化；
• 其他：多语言、插件系统、编辑器主题、基于 Kate 的语法支持、全文智能补全、快捷键自定义；内置 Markdown 支持（实时预览、自定义 CSS、导出/转换 HTML 与 PDF）。

安装步骤：

1. 先安装 Go，再从下载页获取适配操作系统的版本，解压后直接运行（源码见项目主页）；
2. 安装补全引擎 gocode：

go get -u github.com/nsf/gocode

3. 配置编译环境：根据系统在工具栏切换环境配置。Windows + 64 位 Go 选 win64：进入 Options → 左侧 LiteEnv → 右侧选择 win64.env：

GOROOT=c:\go
GOBIN=
GOARCH=amd64
GOOS=windows
CGO_ENABLED=1

PATH=%GOBIN%;%GOROOT%\bin;%PATH%

将 GOROOT=c:\go 改成你的 Go 安装路径并保存。若装有 MinGW64，把 c:\MinGW64\bin 加入 PATH 以支持 cgo。

Linux + 64 位 Go 选 linux64，编辑 linux64.env：

GOROOT=$HOME/go
GOBIN=
GOARCH=amd64
GOOS=linux
CGO_ENABLED=1

PATH=$GOBIN:$GOROOT/bin:$PATH

同样把 GOROOT=$HOME/go 改成实际路径。

4. **配置 $GOPATH**：`$GOPATH即项目文件夹路径。在 LiteIDE 的View → Setup GOPATH中可直接查看和修改，命令行下可用go help gopath` 查看说明。

Sublime Text 2

组合方案：Sublime Text 2 + GoSublime + gocode + MarGo，提供智能补全、自动格式化、项目管理、语法高亮等功能，且永久免费试用（偶尔提示购买许可，可拒绝）。

安装流程：

1. 按 `Ctrl+`` 打开命令面板，粘贴以下代码安装 Package Control（注意在引号前加反斜杠转义）：

import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Merci de redémarrer Sublime Text pour finaliser l'installation'

重启后，Preferences 菜单中应出现 Package Control 选项。

2. 安装 GoSublime、SidebarEnhancements、Go Build：按 Ctrl+Shift+p 打开 Package Control，输入 pcip（"Package Control: Install Package" 的缩写），输入 "GoSublime" 确认安装，重复操作安装另外两个插件，安装完成后再次重启。

3. 验证安装：打开 main.go 检查语法高亮；输入 import 看是否弹出补全提示；输入 import "fmt" 后再输入 fmt. 看函数智能补全是否生效。若未生效，检查 $PATH：打开终端输入 gocode，若无法运行则说明 $PATH 配置有误。

Vim

Vim 支持智能补全、编译与错误导航：

1. Go 语法高亮：

cp -r $GOROOT/misc/vim/* ~/.vim/

2. 启用高亮，在 vimrc 中加入：

filetype plugin indent on
syntax on

3. 安装 gocode：

go get -u github.com/nsf/gocode

gocode 默认安装到 $GOBIN。

4. 配置 gocode：

cd $GOPATH/src/github.com/nsf/gocode/vim
./update.bash
gocode set propose-builtins true
propose-builtins true
gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
lib-path "/home/border/gocode/pkg/linux_amd64"
gocode set
propose-builtins true
lib-path "/home/border/gocode/pkg/linux_amd64"

配置项含义：

• propose-builtins：是否开启内置函数的自动补全，默认 false；
• lib-path：gocode 默认只搜索 $GOPATH/pkg/$GOOS_$GOARCH 与 $GOROOT/pkg/$GOOS_$GOARCH 下的包，此参数可追加额外搜索路径。

5. 完成！执行 :e main.go 开始你的 Go 之旅。

Emacs

Emacs 不只是编辑器，更是强大的 IDE：

1. 语法高亮：

cp $GOROOT/misc/emacs/* ~/.emacs.d/

2. 安装 gocode：

go get -u github.com/nsf/gocode

3. 配置 gocode（与 Vim 相同）：

cd $GOPATH/src/github.com/nsf/gocode/vim
./update.bash
gocode set propose-builtins true
propose-builtins true
gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
lib-path "/home/border/gocode/pkg/linux_amd64"
gocode set
propose-builtins true
lib-path "/home/border/gocode/pkg/linux_amd64"

4. 安装 Auto Complete：下载解压后：

make install DIR=$HOME/.emacs.d/auto-complete

在 ~/.emacs 中配置：

;;auto-complete
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
(ac-config-default)
(local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
(local-set-key "." 'semantic-complete-self-insert)
(local-set-key ">" 'semantic-complete-self-insert)

5. 配置 .emacs 的 Go 模式：

;; golang mode
(require 'go-mode-load)
(require 'go-autocomplete)
;; speedbar
;; (speedbar 1)
(speedbar-add-supported-extension ".go")
(add-hook
'go-mode-hook
'(lambda ()
    ;; gocode
    (auto-complete-mode 1)
    (setq ac-sources '(ac-source-go))
    ;; Imenu & Speedbar
    (setq imenu-generic-expression
        '(("type" "^type *\\([^ \t\n\r\f]*\\)" 1)
        ("func" "^func *\\(.*\\) {" 1)))
    (imenu-add-to-menubar "Index")
    ;; Outline mode
    (make-local-variable 'outline-regexp)
    (setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....")
    (outline-minor-mode 1)
    (local-set-key "\M-a" 'outline-previous-visible-heading)
    (local-set-key "\M-e" 'outline-next-visible-heading)
    ;; Menu bar
    (require 'easymenu)
    (defconst go-hooked-menu
        '("Go tools"
        ["Go run buffer" go t]
        ["Go reformat buffer" go-fmt-buffer t]
        ["Go check buffer" go-fix-buffer t]))
    (easy-menu-define
        go-added-menu
        (current-local-map)
        "Go tools"
        go-hooked-menu)

    ;; Other
    (setq show-trailing-whitespace t)
    ))
;; helper function
(defun go ()
    "run current buffer"
    (interactive)
    (compile (concat "go run " (buffer-file-name))))

;; helper function
(defun go-fmt-buffer ()
    "run gofmt on current buffer"
    (interactive)
    (if buffer-read-only
    (progn
        (ding)
        (message "Buffer is read only"))
    (let ((p (line-number-at-pos))
    (filename (buffer-file-name))
    (old-max-mini-window-height max-mini-window-height))
        (show-all)
        (if (get-buffer "*Go Reformat Errors*")
    (progn
        (delete-windows-on "*Go Reformat Errors*")
        (kill-buffer "*Go Reformat Errors*")))
        (setq max-mini-window-height 1)
        (if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t))
    (progn
        (erase-buffer)
        (insert-buffer-substring "*Go Reformat Output*")
        (goto-char (point-min))
        (forward-line (1- p)))
    (with-current-buffer "*Go Reformat Errors*"
    (progn
        (goto-char (point-min))
        (while (re-search-forward "<standard input>" nil t)
        (replace-match filename))
        (goto-char (point-min))
        (compilation-mode))))
        (setq max-mini-window-height old-max-mini-window-height)
        (delete-windows-on "*Go Reformat Output*")
        (kill-buffer "*Go Reformat Output*"))))
;; helper function
(defun go-fix-buffer ()
    "run gofix on current buffer"
    (interactive)
    (show-all)
    (shell-command-on-region (point-min) (point-max) "go tool fix -diff"))

6. 完成！Speedbar 默认关闭，取消 ;;(speedbar 1) 的注释即可启用，或通过 M-x speedbar 手动开启。

Eclipse + goclipse

1. 下载安装 Eclipse；
2. 下载 goclipse 插件（安装说明见其项目文档）；
3. 安装 gocode（Windows 下需先通过 msysgit 安装 git）：

go get -u github.com/nsf/gocode

4. 下载安装 MinGW；
5. 配置插件：Windows → Préférences → Go：
   • (1) 配置 Go 编译器（GOROOT 路径）；
   • (2)（可选）配置 gocode，指向 gocode.exe 位置；
   • (3)（可选）配置 gdb，指向 gdb.exe 位置；
6. 验证：新建 Go 项目与 hello.go，在 Eclipse 控制台中执行测试命令确认环境可用。

IntelliJ IDEA

Java 开发者熟悉的 IDEA 通过扩展插件支持 Go 语法高亮与智能补全：

1. 下载 IDEA（Ultimate 与 Community 版均可）；
2. 安装 Go 插件：File → Setting → Plugins，点击 Browser repo；
3. 搜索 golang，双击 download and install，等待下载完成后点击 Apply 并重启；
4. 重启后即可新建 Go 项目，下一步中填写 Go SDK 路径——即你的 $GOROOT。

本章小结

本章围绕"搭建 Go 开发环境"完成了三件大事：

1. 安装：覆盖从源码编译、官方安装包、第三方工具（GVM / apt-get / Homebrew）三种方式；
2. 环境配置：核心是 $GOPATH 工作区的规范——src（源码）、pkg（编译产物）、bin（可执行文件）三分目录，并用 mymath + mathapp 完整演练了"写库 → 编译 → 调用 → 运行"的闭环；
3. 工具链：go build、go install、go fmt、go test、go doc、go get 等官方命令的用途与边界，以及 LiteIDE、Sublime Text、Vim、Emacs、Eclipse、IntelliJ IDEA 等开发环境的选择与配置。

环境就绪后，下一步就进入 第 2 章《Go 语言基础》，开始学习这门语言本身的语法与特性。全书目录见 前言与目录，配套参考资源见 附录 A：参考资料。