目录
1、Hello程序解释
Go Hello World 实例
Go 语言的基础组成有以下几个部分：
• 包声明
• 引入包
• 函数
• 变量
• 语句 & 表达式
• 注释
接下来让我们来看下简单的代码 test.go ，该代码输出了"Hello World!":
package main
import "fmt"
func main() {
/* 这是我的第一个简单的程序 */
// 我是单行注释
fmt.Println("Hello, World!")
}
让我们来看下以上程序的各个部分：
1. 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行
指明
这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，
每个 Go 应用程序都包含一个名为 main 的包。
go的路径
2. 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，
或其他元素），
fmt 包实现了格式化 IO（输入/输出）的函数。
3. 下一行 func main() 是程序开始执行的入口函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
4. 下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以 在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，
且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
5. 下一行 fmt.Println(...) 可以将字符串输出到控制台终端，并在最后自动增加换行字符 \n。
使用 fmt.Print("hello, world\n") 可以得到相同的结果。
Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。
6. 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，
如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用 （客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的public）；
标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部 是可见并且可用的（像面向对象语言中的 private ）。
2、语法单词说明
行分隔符
在 Go 程序中，一行代表一个语句结束。
每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将 由编译器自动完成。
如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分
注释
注释不会被编译，每一个包应该有相关注释。
单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。
多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。
标识符
标识符用来命名变量、类型等程序实体。
一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，
但是第一个字符不能是数字，只能是字母或下划线。
“_” 叫作空标识符，一般用在变量声明与包的导入中，例如 Go 语言程序中，
若存在一个没有使用的变量 ，那么编译时会报错，因为 Go 语言要求存在实体
必须使用，
所以可以加_=a这样的代码，这样 Go 语言编译器会认为使用了 就不会报
错了， 实际上并没有对变量 a 做任何操作 。程序初始化后 标识符就会被释放
标识符以字母 （大小写均可）或下画线开头，后面可以是多个字母、下画线和
数字。 Go 语言不许在标识符中使用标点符号，例如＠、$、%等一系列符号
虽然上面说大小写字母均可，但 Go 语言是 种区分大小写的编程语言 ，所以
Test
test Go 言程序中表示的是两个不同的标识符
关键字：
3、基本编程概念
1、Go程序执行命令
go build
Go语言是编译型的静态语言，所以在运行Go语言程序之前，先要将其编译成二进制
的可执行文件。
一般在编辑器中写Go语言代码，然后通过Go语言提供的go build或者go run命令对Go
语言程序进行编译：
go build命令用来启动编译，它可以将Go语言程序与相关依赖编译成一个可执行文件
，其语法格式如下。
go build fileName
其中 fileName 为所需要的参数，可以是一个或者多个 Go 源文件名（当有多个参数
时需要使用空格将两个相邻的参数隔开），也可以省略不写。
使用 go build 命令进行编译时，目标文件只编译不执行，不同参数的执行结果也是不
同的。
1) 当参数不为空时
如果 fileName 为同一 main 包下的所有源文件名（可能有一个或者多个），编译器
将生成一个与第一个
fileName 同名的可执行文件（如执行go build abc.go def.go ...会生成一个 abc.exe
文件）；
如果 fileName 为非 main 包下的源文件名，编译器将只对该包进行语法检查，不生
成可执行文件。
如果需要指定输出可执行文件名，可以使用-o参数，参见下面的例子：
go build -o myexec main.go lib.go
2) 当参数为空时
如果当前目录下存在 main 包，则会生成一个与当前目录名同名的“目录名.exe”可执
行文件（如在 hello目录中执行go build命令时，会生成 hello.exe 文件）；如果不存在 main 包，则只对当前目录下的程序源码进行语法检查，不会生成可执行文件，
比如当前目录下有lib.go 和 main.go 两个文件，如果进行go build 在编译开始时，会搜索当前目录的 go 源码，go build 会找到 lib.go 和main.go 两个文件。
编译这两个文件后，生成当前目录名的可执行文件并放置于当前目录下。
案例： main.go和 lib.go 两个文件在同一个文件夹（gobuild)
main.go代码如下：
package main
import (
"fmt"
)
func main() {
pkgFunc() //外部函数调用
fmt.Println("hello worlds")
}lib.go代码如下：
package main
import "fmt"
func pkgFunc() {
fmt.Println("call pakFunc")
}输入编译命令行如下：
go build
输入执行命令行如下：
./gobuild
运行结果如下：
call pakFunc
hello worlds
其他方法：
$ go build main.go lib.go
$ ls
lib.go main main.go
$ ./main
call pkgFunc
hello world
$ go build -o myexec main.go lib.go
$ ls
lib.go main.go myexec
$ ./myexec
call pkgFunc
hello world
go run 命令
除了使用go build命令外，Go语言还为我们提供了go run命令，go run命令将编译和执
行指令合二为一，
会在编译之后立即执行Go语言程序，但是不会生成可执行文件。
go run命令的语法格式如下：
go run fileName
其中 fileName 为所需要的参数(文件)，参数必须是同一 main 包下的所有源文件名，并且不能为空。
比如：
$go run demo.go
Hello World!
可以看到第 1 行的go run命令执行后，直接在第 2 行输出了程序的运行结果。
案例： hello.go 代码如下
package main
import (
"fmt"
"os"
)
func main() {
fmt.Println("args:", os.Args)
} $go run hello.go --filename xxx.go
修改：
go install 命令
命令格式：go install [可选参数] 。
命令作用：编译并安装源文件、软件包，即把编译后的文件(可执行二进制文件)安装到指定的目录中。
特殊说明：将编译后的文件(可执行二进制文件、归档文件等)安装到指定的目录中。
若设置了环境变量 GOBIN ，则把二进制可执行文件移到该目录。
若禁用 Go modules 则放到 $GOPATH/pkg/$GOOS_$GOARCH下。
实施步骤：
1.whereis demo ....查看当前系统中有没有名称为-demo的程序存在
2.开始编写demo.go源码文件
3.在当前目录下测试功能是否可行
4.查看当前终端的环境是否配置正常
如果没有则手工设置
确保目标程序有写入权限
sudo chmod 0777 /usr /local/bin
5、在当前目录下编译并安装课执行程序
go install -x demo.go
......
6.验证goinstall是否成功
直接demo
7.清理环境，还原目标目录文件
要用install先确定下面的东西为off
export GO111MODULE="off"
sudo chmod 0777 /usr/local/bin
go install -x main.go
输入go install -x main.go后
会输出：
...
mkdir -p /Users/ucwords/go/bin/
...
mv $WORK/b001/exe/a.out /Users/ucwords/go/bin/目标目录(go modules的目录名)
rm -r $WORK/b001/
最后查看：
如果有说GOBIN没设置则，要用如下指令指定:
临时:export GOBIN="/usr/local/go/bin"
永久：
sudo vim ~/.bashrc
export GOBIN=/usr/local/bin
保存退出
source ~/.bashrc
验证：
go env可以验证当前指令是否生效
删除：
sudo rm /usr/local/bin/main
=================================================================
go build+包
一个文件夹（goinstall）里有一个文件（main.go）和一个文件夹（mypkg）。
一个文件夹（mypkg）里有一个文件（mypkg.go）。
main.go代码如下：
package main
import (
"fmt"
"goinstall/mypkg"
)
func main() {
mypkg.CustomPkgFunc()
fmt.Println("hello world")
} mypkg.go代码如下：
package mypkg //建议当前包名和所在目录一致
import "fmt"
func CustomPkgFunc() {
fmt.Println("call CustomPkgFunc")
} 执行以下命令将按包方式编译goinstall代码：
$ go build -o main goinstall
$ ls
main main.go mypkg
$ ./main
call CustomPkgFunc
hello world
如果有如下错误
方法：
go env ⇒ gopath ==>/home/caoqb/go
cp goinstall /home/caoqb/go/src/ -r
cd /home/caoqb/go/src
go build -o main goinstall
./main 验证效果
4、Go编码规范
“代码必须是本着写给人阅读的原则来编写，只不过顺便给机器执行而已。”
=========》这段话来自《计算机程序设计与解释》
代码风格，是一个与人相关、与机器无关的问题。代码风格的好坏，不影响编译器的工
作， 但是影响团队协同，影响代码的复用、演进以及缺陷修复。
Go语言很可能是第一个将代码风格强制统一的语言。一些对于其他语言的编译器完全忽视的问题，在Go编译器前就会被认为是编译错误，比如如果花括号新起了一行摆放，你就会看到一个醒目的编译错误。
这一点会让很多人觉得不可思议。无论喜欢还是讨厌，与其他那些单单编码规范就能写出
一本书的语言相比，
毫无疑问Go语言的这种做法简化了问题。我们接下来介绍Go语言的编码规范，
主要分两类，分别：由Go编译器进行强制的编码规范
由Gotool推行的非强制性编码风格建议。
强制性编码规范：
Go编译器进行强制的编码规范也是Go语言设计者认为最需要统一的代码风格。
1. 命名
命名规则涉及变量、常量、全局函数、结构、接口、方法等的命名。Go语言从语法层
面进行了以下限定：
任何需要对外暴露的名字必须以大写字母开头，不需要对外暴露的则应该以小写字母开
头。
只能由数字英文字母下划线组成，不能以数字开头，不能和关键字冲突。
软件开发行业最流行的两种命名法分别为
骆驼命名法（类似于DoSomething和doSomething）
下划线法（对应为do_something）
而Go语言明确宣告了拥护骆驼命名法而排斥下划线法。骆驼命名法在Java和C#中得到官方的支持和推荐，
而下划线命名法则主要用在C语言的世界里，比如Linux内核和驱动开发上。在开始Go语言编程时，还是忘记下划线法吧，避免写出不伦不类的名字。
2.排列
Go语言甚至对代码的排列方式也进行了语法级别的检查，约定了代码块中花括号的明确摆放位置。下面先列出一个错误的写法：
// 错误写法
func Foo(a, b int)（ret int, err error）
{
if a > b
{
ret = a
}
else
{
ret = b
}
}
这个写法对于众多在微软怀抱里长大的程序员们是最熟悉不过的了，但是在Go语言中会有编译错误
$ go run hello.go
# command-line-arguments
./hello.go:9: syntax error: unexpected semicolon or newline before {
./hello.go:18: non-declaration statement outside function body
./hello.go:19: syntax error: unexpected }
通过上面的错误信息就能猜到，是左花括号{的位置出问题了。下面我们将上面的代码调整 一下：
// 正确写法
func Foo(a, b int)（ret int, err error） {
if a > b {
ret = a
} else {
ret = b
}
}
可以看到，else甚至都必须紧跟在之前的右花括号}后面并且不能换行。Go语言的这条规则基本上就保证了所有Go代码的逻辑结构写法是完全一致的，也不会再出现有洁癖的程序员在维护别人代码之前非要把所有花括号的位置都调整一遍的问题。
非强制性编码风格建议：
package main
import "fmt"
func Foo(a, b int)(ret int, err error){
if a > b {
return a
return 0, nil
}
}
func
main() { i, _ := Foo(1, 2)
fmt.Println("Hello, 世界", i)}
这段代码能够正常编译，也能正常运行，只不过丑陋的让人看不下去。现在我们用Gotool中的格式化功能美化一下（假设上述代码被保存为hello.go）
$ go fmt hello.go
hello.go
执行这个命令后，将会更新hello1.go文件，此时再打开hello1.go，看一下旧貌换新颜的代码可以看到，格式化工具做了很多事情：
1、调整了每条语句的位置
2、重新摆放花括号的位置
3、以制表符缩进代码
4、添加空格
当然，格式化工具不知道怎么帮你改进命名，这就不要苛求了。
这个工具并非只能一次格式化一个文件，比如不带任何参数直接运行go fmt的话，可以直接格式化当前目录下的所有*.go文件，或者也可以指定一个GOPATH中可以找到的包名。
只不过我们并不是非常推荐使用这个工具。毕竟，保持良好的编码风格应该是一开始写代
码时就注意到的。第一次就写成符合规范的样子，以后也就不用再考虑如何美化的问题了。
gofmt 介绍
Go语言的开发团队制定了统一的官方代码风格，并且推出了 gofmt 工具（gofmt 或 go
fmt）
来帮助开发者格式化他们的代码到统一的风格。
gofmt 是一个 cli 程序，会优先读取标准输入，如果传入了文件路径的话，会格式化这个文件，
如果传入一个目录，会格式化目录中所有 .go 文件，如果不传参数，会格式化当前目录下
的所有 .go 文件。
gofmt 默认不对代码进行简化，使用-s参数可以开启简化代码功能，具体来说会进行如下的转换：
go fmt 使用
go fmt -w xx.go
package main
import "fmt"
func main() {
a := 1
b := 2
c := a + b
fmt.Println(c)
}
用以下规则来格式化上面的代码。
gofmt -w -r "a + b -> b + a" main.go
package main
import "fmt"
func main() {
a := 1
b := 2
c := b + a
fmt.Println(c)
}
注意：go fmt 使用 tab 来表示缩进，并且对行宽度无限制，如果手动对代码进行了换行，
gofmt 不会强制把代码格式化回一行。
-l 显示那些需要格式化的文件
-w把改写后的内容直接写入到文件中，而不是作为结果打印到标准输出。
-r添加形如“a[b:len(a)]->a[b:]”的重写规则，方便我们做批量替换.
-r 接受的規則是 pattern -> replacement，其中 pattern 與 replacement 必須是合法的 Go語法，而單一、小寫的字元會被作為萬用字元（Wildcard）.
vim 全局替换命令为: :%s/源字符串/目的字符串/g
-s简化文件中的代码
-d显示格式化前后的diff而不是写入文件，默认是false
-e打印所有的语法错误到标准输出。如果不使用此标记，则只会打印不同行的前10个错
误。
-cpuprofile支持调试模式，写入相应的cpufile到指定的文件
5、课堂练习题
1、编写基本的 “hello world” 练习程序。
2、使用go run go build go install 不同方式安装程序
3、使用 go fmt 来格式化代码练习。