## 目录
1. Golang开发环境准备
2. Golang项目结构
3. Golang常用命令
4. Golang语言基础
## 1. Golang开发环境准备
1. 安装Golang
- Windows 安装Golang
下载并安装Windows版本Golang
国内下载链接：[https://studygolang.com/dl](https://studygolang.com/dl)
- Linux 安装Golang
```
# 下载链接见 https://studygolang.com/dl
# 切换到home路径，创建GOPATH文件夹”go“
cd ~
mkdir go
# 下载Golang安装文件，解压到/usr/local路径下
wget https://studygolang.com/dl/golang/go1.14.3.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.14.3.linux-amd64.tar.gz
# 编辑.profile文件，把Golang环境变量追加到文件尾部
vim ~/.profile
export GOPATH=$HOME/go
export GOROOT=/usr/local/go
export PATH=$PATH:/usr/local/go/bin
# 使用source命令使环境变量生效
source ~/.profile
```
1. 配置Golang（如无需要，可不配置）
```
# 开启GOMODULE
go env -w GO111MODULE="on"
# 配置代理
go env -w GOPROXY="https://goproxy.cn,direct"
go env -w GOSUMDB="off"
```
1. 安装Golang开发工具
- 安装VSCode
VSCode下载路径：[https://code.visualstudio.com/](https://code.visualstudio.com/)
- 配置VSCode Golang开发环境
安装插件：
- [Go](ms-vscode.go)
- [Go Coverage Viewer](defaltd.go-coverage-viewer)
- [Go Profiling](maxmedia.go-prof)
- [Chinese (Simplified) Language Pack for Visual Studio Code](ms-ceintl.vscode-language-pack-zh-hans)
安装go tools：
VSCode F1打开命令窗口，输入”GO: Install/Update Tools“，选择全部tool 点击确定完成安装。
- gocode
- gopkgs
- go-outline
- go-symbols
- guru
- gorename
- gotests
- gomodifytags
- impl
- fillstruct
- goplay
- godoctor
- dlv
- gocode-gomod
- godef
- goreturns
- golint
- gopls
## 2. Golang项目结构
1. 创建项目
1. 创建并打开项目文件夹"goproject"
2. 目录下执行 go mod 命令初始化项目 go.mod 文件
```
go mod init goproject
```
3. 创建main.go文件
```
package main // 包名
import (
f "fmt" // 内部包 可以使用包别名，也可以不使用
_ "goproj/models" // 使用_别名，表示只调用init 函数
. "goproj/utils" // 本地包 可以使用.别名，调用时省略包名 不推荐使用
)
var (
a = 10 // 全局变量
b = 20
)
const (
c = 30 // 全局常量
)
// 项目执行入口
func main() {
// 调用内部包函数
f.Println(c)
// 调用本地包函数
floatN := Sum(a, b)
f.Println(floatN)
}
```
4. 创建 ./utils/util.go 文件
```
package utils
// Sum : 两个整数相加后返回一个浮点数
// 首字母大写的 方法、函数、字段可被外部包引用，
func Sum(a, b int) float32 {
n := a + b
f := intToFloat(n)
return f
}
// intToFloat : 整数转换为浮点数返回
// Golang 变量不支持隐式转换，需要显式转换
// 首字母大写的 方法、函数、字段可被外部包引用，
func intToFloat(num int) float32 {
return float32(num)
}
```
5. 创建 ./models/model.go 文件
```
package models
// Num 首字母大写的成员可被外部包使用
var Num = 10
// init init 函数在包被引用时执行
// 一个包可以有多个init 函数，按包内go 文件名排序执行
func init() {
Num = 20
}
```
2. 项目结构
```
.
├── README.md
├── go.mod
├── main.go
├── models
│ └── model.go
└── utils
└── util.go
```
3. go文件结构
```
package main // 包名
import (
f "fmt" // 内部包 可以使用包别名，也可以不使用
_ "goproj/models" // 使用_别名，表示只调用init 函数
. "goproj/utils" // 本地包 可以使用.别名，调用时省略包名 不推荐使用
)
var (
a = 10 // 全局变量
b = 20
)
const (
c = 30 // 全局常量
)
// 项目执行入口
func main() {
// 调用内部包函数
f.Println(c)
// 调用本地包函数
floatN := Sum(a, b)
f.Println(floatN)
}
```
## 3. Golang常用命令
```
go help # 查看go所有命令
go help build # 查看go buil命令
go version # 查看Golang 版本
go env # 查看Golang环境变量
go run [main.go] # 执行go文件
go build [main.go] # 编译项目
go get k8s.io/client-go[@master] # 拉取远程包，可指定版本
...
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 add dependencies to current module and install them
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
```
## 4. Golang语言基础
1. Golang 关键字
|关键字|说明|
|-|-|
|break|结束循环|
|default|switch和select语句中的默认分支|
|func|定义函数或方法|
|interface|接口类型或接口类型变量|
|select|管道分支语句|
|case|switch或select语句中的分支|
|defer|先进后出的延迟执行语句|
|go|开启协程语句|
|map|无序的kv引用类型|
|struct|结构体类型|
|chan|管道标记|
|else|if else 分支语句|
|goto|跳转到标签语句|
|package|包声明语句|
|switch|多条件分支语句|
|const|常量定义|
|fallthrough|满足当前分支条件下，完成当前分支语句，直接执行下一个分支，不考虑是否满足条件|
|if|if else 分支语句|
|range|遍历数组、切片、map、管道|
|type|定义类型语句|
|continue|进入下一轮循环|
|for|for 循环语句|
|import|导入包语句|
|return|返回结果，结束当前函数或方法|
|var|定义变量|
2. Golang 预定义名字
```
true false iota nil
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
make len cap new append copy close delete
complexrealimag
panic recover
```
3. Golang 语言基础实践
>能够看到关键字和预定义名字就能想到使用场景，就基本掌握了语言基础。
- package 和import 的使用
go 文件中的package 名一般和文件所在文件夹的名称一致，main 包除外。
可执行项目一定要有main包和main函数。
./main.go 文件
```
package main // 包名
import (
f "fmt" // 内部包 可以使用包别名，也可以不使用
_ "goproj/models" // 使用_别名，表示只调用init 函数
. "goproj/utils" // 本地包 可以使用.别名，调用时省略包名 不推荐使用
)
var (
a = 10 // 全局变量
b = 20
)
const (
c = 30 // 全局常量
)
// 项目执行入口
func main() {
// 调用内部包函数
f.Println(c)
// 调用本地包函数
floatN := Sum(a, b)
f.Println(floatN)
}
```
./models/model.go 文件
```
package models
// Num 首字母大写的成员可被外部包使用
var Num = 10
// init init 函数在包被引用时执行
// 一个包可以有多个init 函数，按包内go 文件名排序执行
func init() {
Num = 20
}
```
- type 的使用
type 语句可以定义类型，声明类型别名
```
package main
import "fmt"
// IAccount 定义 IAccount 接口类型
// IAccount 接口类型有一个 GetName 方法
// 只要实现了GetName 方法的类型都实现了 IAccount 接口
type IAccount interface {
GetName() string
}
// AAccount 定义AAccount 结构体类型
type AAccount struct {
Name, Password string
}
// RichInt 定义 RichInt 类型
// RichInt 拥有 int 类型的字段和方法
// RichInt 可以创建其他方法，而不影响 int 类型
// 此种写法通常用于扩展现有类型
type RichInt int
// Echo 实现 RichInt 类型的打印方法，int 类型不会拥有此方法
func (r RichInt) Echo() {
fmt.Println(r)
}
// IntAlias 给 int 类型起了个别名
// 可以同时使用 IntAlias 和 int 类型
type IntAlias = int
// GetName 给 AAccount 类型定义了一个方法
// AAccount 实现了 "GetName() string" 方法，所以 AAccount 实现了 IAccount 接口
func (a AAccount) GetName() string {
return a.Name
}
// GetName 写了一个包函数
// 方法属于类型，有类型或者类型的指针接收者 "func (a AAccount) GetName() string {}"
// 函数属于包， "func GetName() string {}"
func GetName() string {
return "Jim"
}
func main() {
// 声明接口类型变量，接口类型不能实例化
// 但可以通过实现类型实例化
var iAccount IAccount
iAccount = AAccount{Name: "张三", Password: "******"}
name := iAccount.GetName()
fmt.Println(name) // 输出 张三
// RichInt 类型 拥有 int 类型的字段和方法
// 但 int 类型不会拥有 RichInt 类型实现的方法
// RichInt 类型和int类型是两种类型
var i int = 20
var ri RichInt = 18
fmt.Println(i) // 输出 20
ri.Echo() // 输出 18
// IntAlias 类型只是int 类型的别名
// IntAlias 类型和int 类型是相同类型可以相互赋值
var ii int = 30
var ia IntAlias = 40
ii = ia
fmt.Println(ii) // 输出 40
fmt.Println(ia) // 输出 40
}
```
- func 的使用
func 可以用来定义函数和方法和函数变量
```
package main
import "fmt"
// AAccount 定义AAccount 结构体类型
type AAccount struct {
Name, Password string
}
// GetName 给 AAccount 类型定义了一个方法
// AAccount 实现了 "GetName() string" 方法，所以 AAccount 实现了 IAccount 接口
func (a AAccount) GetName() string {
return a.Name
}
// GetName 写了一个包函数
// 方法属于类型，有类型或者类型的指针接收者 "func (a AAccount) GetName() string {}"
// 函数属于包， "func GetName() string {}"
func GetName() string {
return "Jim"
}
func main() {
// 函数和方法的区别在于是否有接收者
// 调用函数，如果是外部包，需要使用 packname.FuncName 方式调用
name := GetName()
fmt.Println(name) // 输出 Jim
// 调用方法
aAccount := AAccount{Name: "张三", Password: "****"}
aName := aAccount.GetName()
fmt.Println(aName) // 输出 张三
// 定义函数变量和使用匿名函数
f := GetName
fName := f()
fmt.Println(fName) // 输出 Jim
func(a, b int) {
fmt.Println(a + b) // 输出7
}(3, 4)
}
```
有疑问加站长微信联系（非本文作者）
