golang笔记--环境配置-golang-ArcherWong博客

golang笔记--环境配置

作者：ArcherWong
分类：golang
时间：2019-01-04 10:34:24
阅读：893

[TOC]

# 1.go的安装

Go有多种安装方式，你可以选择自己喜欢的。这里我们介绍三种最常见的安装方式：

- Go源码安装：这是一种标准的软件安装方式。对于经常使用Unix类系统的用户，尤其对于开发者来说，从源码安装可以自己定制。
- Go标准包安装：Go提供了方便的安装包，支持Windows、Linux、Mac等系统。这种方式适合快速安装，可根据自己的系统位数下载好相应的安装包，一路next就可以轻松安装了。推荐这种方式
- 第三方工具安装：目前有很多方便的第三方软件包工具，例如Ubuntu的apt-get和wget、Mac的homebrew等。这种安装方式适合那些熟悉相应系统的用户。

这里介绍标准包安装

下载地址

```
https://golang.org/dl/
```

下载到相应位置并解压

```
cd /usr/local/src
wget https://dl.google.com/go/go1.11.linux-amd64.tar.gz
tar -xzvf go1.11.linux-amd64.tar.gz
```

添加环境变量
```
vim /etc/profile
```

```
# go的安装位置
export GOROOT=/usr/local/src/go

# go的工作目录地址
export GOPATH=/data/gopath

# 方便运行go的bin和工作目录编译后的bin
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
```

应用环境变量
```
source /etc/profile
```

查看信息，如果显示则安装成功
```
$ go version  
go version go1.11 linux/amd64
```

```
$ go env    
GOARCH="amd64"
GOBIN=""
GOCACHE="/root/.cache/go-build"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/data/gopath"
GOPROXY=""
GORACE=""
GOROOT="/usr/local/src/go"
GOTMPDIR=""
GOTOOLDIR="/usr/local/src/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD=""
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build693193239=/tmp/go-build"

```
创建hello.go文件
```
touch hello.go 
vim hello.go
```

内容
```
package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}
```

运行
```
$ go run hello.go
Hello, World!
```

# 2.gopath和工作空间

## gopath的介绍

go 命令依赖一个重要的环境变量：$GOPATH，上面安装的时候我们有设置过这个路径，并添加到环境变量中。从go 1.8开始，GOPATH环境变量现在有一个默认值，如果它没有被设置。 它在Unix上默认为$HOME/go,在Windows上默认为%USERPROFILE%/go。

这个目录地址不是go的安装目录，而是你自己的工作目录，自己定义一个适合自己的位置。

GOPATH允许多个目录，当有多个目录时，请注意分隔符，多个目录的时候Windows是分号，Linux系统是冒号，当有多个GOPATH时，默认会将go get的内容放在第一个目录下。

以上 $GOPATH 目录约定有三个子目录：

- src 存放源代码（比如：.go .c .h .s等）
- pkg 编译后生成的文件（比如：.a）
- bin 编译后生成的可执行文件（为了方便，可以把此目录加入到 $PATH 变量中，如果有多个gopath，那么使用${GOPATH//://bin:}/bin添加所有的bin目录）

## 合理规划工作目录

GOPATH下的src目录就是接下来开发程序的主要目录，所有的源码都是放在这个目录下面，那么一般我们的做法就是一个目录一个项目，例如: `$GOPATH/src/mymath` 表示mymath这个**应用包或者可执行应用**，这个根据package是main还是其他来决定，**main的话就是可执行应用，其他的话就是应用包**

所以当新建应用或者一个代码包时都是在src目录下新建一个文件夹，文件夹名称一般是代码包名称，当然也允许多级目录，例如在src下面新建了目录`$GOPATH/src/github.com/astaxie/beedb` 那么这个包路径就是`github.com/astaxie/beedb`，包名称是最后一个目录`beedb`

## 编写并编译应用

▶ 编写一个应用包

```
cd $GOPATH/src
mkdir mymath
```
新建文件sqrt.go，内容如下
```
// $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
}
```
这样我的应用包目录和代码已经新建完毕，注意：一般建议package的名称和目录名保持一致

▶ 编译应用

我们上面已经编辑了应用包，如何编译上面的应用包呢？有两种方式

1、进入对应的应用包目录，然后执行 `go install`

2、在任意目录，然后执行 `go install mymath`

执行完毕后，我们进入如下目录

```
cd /data/gopath/pkg/linux_amd64
// cd $GOPATH/pkg/${GOOS}_${GOARCH}
```

可以看到如下文件

```
mymath.a
```

这个.a文件是应用包，那么我们如何进行调用呢？

下面我们在创建一个可执行应用，在里面调用上面常见的mymath.a应用包

新建应用包mathapp

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

内容：
```
//$GOPATH/src/mathapp/main.go源码：

package main

import (
	"mymath"
	"fmt"
)

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

如何编译一个可执行程序呢，方法是：

进入该目录下，然后运行`go build`, 会在该目录下生成一个mathapp的可执行文件

```
# root @ VM_33_19_centos in /data/gopath/src/mathapp 
$ ./mathapp
Hello, world.  Sqrt(2) = 1.414213562373095
```

每次要指定相应目录在运行文件不是很麻烦，如何方便的安装该应用呢？

进入该目录执行`go install`,那么在`$GOPATH/bin/`下增加了一个可执行文件mathapp

我们在安装的时候已经把`$GOPATH/bin`加到我们的环境变量`PATH`里面，这样可以在命令行输入如下命令就可以执行
```
mathapp
```
也是输出如下内容
```
Hello, world.  Sqrt(2) = 1.414213562373095
```

## 获取远程包

go语言有一个获取远程包的工具就是`go get`，目前go get支持多数开源社区(例如：github、googlecode、bitbucket、Launchpad)
```
go get github.com/astaxie/beedb
// go get -u 参数可以自动更新包，而且当go get的时候会自动获取该包依赖的其他第三方包
```
通过这个命令可以获取相应的源码，对应的开源平台采用不同的源码控制工具，例如github采用git、googlecode采用hg，所以要想获取这些源码，必须先安装相应的源码控制工具

在代码中如何使用远程包，很简单的就是和使用本地包一样，只要在开头import相应的路径就可以
```
import "github.com/astaxie/beedb"
```

## 程序的整体结构
通过上面建立的我本地的mygo的目录结构如下所示
```
bin/
	mathapp
pkg/
	平台名/ 如：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
```
从上面的结构我们可以很清晰的看到，bin目录下面存的是编译之后可执行的文件，pkg下面存放的是应用包，src下面保存的是应用源代码

# 3.go 命令

go语言自带一套完整的命令操作工具

```
# root @ VM_33_19_centos in /data/gopath/src [13:36:20] 
$ go      
Go is a tool for managing Go source code.

Usage:

go <command> [arguments]

The commands are:

bug         start a bug report
	build       compile packages and dependencies
	clean       remove object files and cached files
	doc         show documentation for package or symbol
	env         print Go environment information
	fix         update packages to use new APIs
	fmt         gofmt (reformat) package sources
	generate    generate Go files by processing source
	get         download and install packages and dependencies
	install     compile and install packages and dependencies
	list        list packages or modules
	mod         module maintenance
	run         compile and run Go program
	test        test packages
	tool        run specified go tool
	version     print Go version
	vet         report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

buildmode   build modes
	c           calling between Go and C
	cache       build and test caching
	environment environment variables
	filetype    file types
	go.mod      the go.mod file
	gopath      GOPATH environment variable
	gopath-get  legacy GOPATH go get
	goproxy     module proxy protocol
	importpath  import path syntax
	modules     modules, module versions, and more
	module-get  module-aware go get
	packages    package lists and patterns
	testflag    testing flags
	testfunc    testing functions

Use "go help <topic>" for more information about that topic.
```

## go build

这个命令主要用于编译代码。在包的编译过程中，若有必要，会同时编译与之相关联的包。

- 如果是普通包，就像我们在1.2节中编写的mymath包那样，当你执行go build之后，它不会产生任何文件。如果你需要在$GOPATH/pkg下生成相应的文件，那就得执行go install。

- 如果是main包，当你执行go build之后，它就会在当前目录下生成一个可执行文件。如果你需要在$GOPATH/bin下生成相应的文件，需要执行go install，或者使用go build -o 路径/a.exe。

- 如果某个项目文件夹下有多个文件，而你只想编译某个文件，就可在go build之后加上文件名，例如go build a.go；go build命令默认会编译当前目录下的所有go文件。

- 你也可以指定编译输出的文件名。例如1.2节中的mathapp应用，我们可以指定go build -o astaxie.exe，默认情况是你的package名(非main包)，或者是第一个源文件的文件名(main包)。

（注：实际上，package名在Go语言规范中指代码中“package”后使用的名称，此名称可以与文件夹名不同。默认生成的可执行文件名是文件夹名。）

- go build会忽略目录下以“_”或“.”开头的go文件。

- 如果你的源代码针对不同的操作系统需要不同的处理，那么你可以根据不同的操作系统后缀来命名文件。例如有一个读取数组的程序，它对于不同的操作系统可能有如下几个源文件：

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

## go install

这个命令在内部实际上分成了两步操作：第一步是生成结果文件(可执行文件或者.a包)，第二步会把编译好的结果移到$GOPATH/pkg或者$GOPATH/bin。

参数支持go build的编译参数。大家只要记住一个参数-v就好了，这个随时随地的可以查看底层的执行信息。

## go get

这个命令是用来动态获取远程代码包的，目前支持的有BitBucket、GitHub、Google Code和Launchpad。这个命令在内部实际上分成了两步操作：第一步是下载源码包，第二步是执行go install。下载源码包的go工具会自动根据不同的域名调用不同的源码工具，对应关系如下：
```
BitBucket (Mercurial Git)
GitHub (Git)
Google Code Project Hosting (Git, Mercurial, Subversion)
Launchpad (Bazaar)
```
所以为了go get 能正常工作，你必须确保安装了合适的源码管理工具，并同时把这些命令加入你的PATH中。其实go get支持自定义域名的功能，具体参见go help remote。

参数介绍：
```
-d 只下载不安装
-f 只有在你包含了-u参数的时候才有效，不让-u去验证import中的每一个都已经获取了，这对于本地fork的包特别有用
-fix 在获取源码之后先运行fix，然后再去做其他的事情
-t 同时也下载需要为运行测试所需要的包
-u 强制使用网络去更新包和它的依赖包
-v 显示执行的命令
```

## go clean

这个命令是用来移除当前源码包和关联源码包里面编译生成的文件。这些文件包括
```
_obj/            旧的object目录，由Makefiles遗留
_test/           旧的test目录，由Makefiles遗留
_testmain.go     旧的gotest文件，由Makefiles遗留
test.out         旧的test记录，由Makefiles遗留
build.out        旧的test记录，由Makefiles遗留
*.[568ao]        object文件，由Makefiles遗留

DIR(.exe)        由go build产生
DIR.test(.exe)   由go test -c产生
MAINFILE(.exe)   由go build MAINFILE.go产生
*.so             由 SWIG 产生
```

参数介绍
```
-i 清除关联的安装的包和可运行文件，也就是通过go install安装的文件
-n 把需要执行的清除命令打印出来，但是不执行，这样就可以很容易的知道底层是如何运行的
-r 循环的清除在import中引入的包
-x 打印出来执行的详细命令，其实就是-n打印的执行版本
```

## go fmt

go工具集中提供了一个go fmt命令 它可以帮你格式化你写好的代码文件，使你写代码的时候不需要关心格式，你只需要在写完之后执行`go fmt <文件名>.go`，你的代码就被修改成了标准格式，但是我平常很少用到这个命令，因为开发工具里面一般都带了保存时候自动格式化功

使用go fmt命令，其实是调用了gofmt，而且需要参数-w，否则格式化结果不会写入文件。`gofmt -w -l src`，可以格式化整个项目。

所以go fmt是gofmt的上层一个包装的命令，我们想要更多的个性化的格式化可以参考 gofmt

gofmt的参数介绍
```
-l 显示那些需要格式化的文件
-w 把改写后的内容直接写入到文件中，而不是作为结果打印到标准输出。
-r 添加形如“a[b:len(a)] -> a[b:]”的重写规则，方便我们做批量替换
-s 简化文件中的代码
-d 显示格式化前后的diff而不是写入文件，默认是false
-e 打印所有的语法错误到标准输出。如果不使用此标记，则只会打印不同行的前10个错误。
-cpuprofile 支持调试模式，写入相应的cpufile到指定的文件
```

## 更多命令
```
go version 查看go当前的版本
go env 查看当前go的环境变量
go list 列出当前全部安装的package
go run 编译并运行Go程序
```

用户可以使用go help 命令获取更详细的帮助信息

# 4.go get 被墙解决方案

由于墙的存在，我们使用go get的时候经常没反应还没有报错，如果是新手这会浪费我们大量的时间

解决方案 国内主机：cow + 国外可用代理地址：我这里使用了shadowsocks

关于如何搭建代理服务器，请自行谷歌，这里提下国内云服务器（linux）如何配置

关于cow的详细使用，可以参考：https://github.com/cyfdecyf/cow/blob/master/doc/init.d/cow

安装：
```
cd /usr/local/src
curl -L git.io/cow | bash
```

打开配置文件
```
vim ~/.cow/rc
```

增加如下配置
```
listen = http://127.0.0.1:7777

# 代理的地址，配置文件中有详细参数介绍，根据自己的情况配置
proxy = ss://aes-256-cfb:password@67.230.xxx.xxx:13000
```

环境变量中增加如下配置
```
vim /etc/profile
```

```
export http_proxy=http://127.0.0.1:7777
export https_proxy=http://127.0.0.1:7777
```

```
source /etc/profile
```

启动cow，进入`/usr/local/src`
```
./cow &
```

查看是否配置成功
```
$ echo $https_proxy
http://127.0.0.1:7777

# root @ VM_33_19_centos in /usr/local/src 
$ echo $http_proxy 
http://127.0.0.1:7777

# root @ VM_33_19_centos in /usr/local/src 
$ ps -ef | grep cow
root      2644     1  0 14:56 pts/1    00:00:00 sudo -u root -H -- /usr/local/src/cow
root      2646  2644  0 14:56 pts/1    00:00:00 /usr/local/src/cow
root      3462  1469  0 15:04 pts/0    00:00:00 grep --color=auto cow
```

这里提下，cow还提供了一个启动脚本，参考地址：https://github.com/cyfdecyf/cow/blob/master/doc/init.d/cow

简单提下用法：

下载脚本放到 /etc/init.d/下

注意修改下脚本下面的配置，根据自己的情况修改
```
vim /etc/init.d/cow
```
```
BIN=/usr/local/bin/cow
USER=usr
GROUP=grp
```
使用方法：
```
/etc/init.d/cow start
/etc/init.d/cow stop
/etc/init.d/cow restart
/etc/init.d/cow status
```

配置完毕 可以畅快的go get 了

# 5.window下开发工具

可以使用goland，官方网站：https://www.jetbrains.com/go/ ，直接下载

有条件请支持正版，但是还是给个激活学习通道，http://idea.lanyus.com/ ，需要**注意**的是
```
使用前请将“0.0.0.0 account.jetbrains.com”添加到hosts文件中
```

方便之处在于高亮和快速跳转等，可以方便的编译，可以提高我们的工作效率。

# 6.go的包管理工具dep

官方github地址：https://github.com/golang/dep

官方文档：https://golang.github.io/dep/docs/introduction.html

## 安装

### linux下的安装，直接使用脚本
```
$ curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
```
```
# root @ WENGINE in /var/www/gopath/src/webvpn [10:01:17] 
$ curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  5110  100  5110    0     0   2366      0  0:00:02  0:00:02 --:--:-- 12342
ARCH = amd64
OS = linux
Will install into /var/www/gopath/bin
Fetching https://github.com/golang/dep/releases/latest..
Release Tag = v0.5.0
Fetching https://github.com/golang/dep/releases/tag/v0.5.0..
Fetching https://github.com/golang/dep/releases/download/v0.5.0/dep-linux-amd64..
Setting executable permissions.
Moving executable to /var/www/gopath/bin/dep
```

### windows下安装

方式1： 使用go get 获取执行程序，执行程序会被放到$gopath/bin目录下,所以记得把该目录添加到环境变量即可

```
go get -u github.com/golang/dep/cmd/dep
```

方式2： 直接下载程序

- 下载release版本。打开页面 https://github.com/golang/dep/releases ，下载最新的dep-windows-amd64.exe
- 将dep-windows-amd64.exe放入GOPATH/bin下，修改名称为dep

## 使用

1、初始化
- 切换到工程目录下 `cd %GOPATH%/src/github.com/xxx/dep-demo`
- 初始化 `dep init`

2、添加到vendor中

```
dep ensure -add github.com/go-macaron/captcha
```

```
D:\code\gopath\src\webvpn>dep ensure -add github.com/go-macaron/captcha
Fetching sources...

grouped write of manifest, lock and vendor: scratch directory D:\code\gopath\src\webvpn\.vendor-new already exists, please remove it

D:\code\gopath\src\webvpn>dep ensure -add github.com/go-macaron/captcha
Fetching sources...

"github.com/go-macaron/captcha" is not imported by your project, and has been temporarily added to Gopkg.lock and vendor/.
If you run "dep ensure" again before actually importing it, it will disappear from Gopkg.lock and vendor/.
```

参考资料

https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/directory.md

标签：

上一篇：golang笔记---函数

下一篇：golang笔记--基本结构和基本数据类型

golang笔记--环境配置

文章分类

阅读排行

友情链接