一、Go语言的主要特征及Hello World程序

1.Go语言的主要特征

1.1. golang 简介

1.1.1. 来历

​ 很久以前，有一个IT公司，这公司有个传统，允许员工拥有20%自由时间来开发实验性项目。在2007的 某一天，公司的几个大牛，正在用c++开发一些比较繁琐但是核心的工作，主要包括庞大的分布式集 群，大牛觉得很闹心，后来c++委员会来他们公司演讲，说c++将要添加大概35种新特性。这几个大牛 的其中一个人，名为：Rob Pike，听后心中一万个xxx飘过，“c++特性还不够多吗？简化c++应该更 有成就感吧”。于是乎，Rob Pike和其他几个大牛讨论了一下，怎么解决这个问题，过了一会，Rob Pike说要不我们自己搞个语言吧，名字叫“go”，非常简短，容易拼写。其他几位大牛就说好啊，然后 他们找了块白板，在上面写下希望能有哪些功能（详见文尾）。接下来的时间里，大牛们开心的讨论设 计这门语言的特性，经过漫长的岁月，他们决定，以c语言为原型，以及借鉴其他语言的一些特性，来 解放程序员，解放自己，然后在2009年，go语言诞生。

1.1.2. 思想

​ Less can be more 大道至简,小而蕴真 让事情变得复杂很容易，让事情变得简单才难 深刻的工程
文化

1.1.3. 优点

自带gc。
静态编译，编译好后，扔服务器直接运行。
简单的思想，没有继承，多态，类等。
丰富的库和详细的开发文档。
语法层支持并发，和拥有同步并发的channel类型，使并发开发变得非常方便。
简洁的语法，提高开发效率，同时提高代码的阅读性和可维护性。
超级简单的交叉编译，仅需更改环境变量。

Go 语言是谷歌 2009 年首次推出并在 2012 年正式发布的一种全新的编程语言，可以在不损失应用程序性能的情况下降低代码的复杂性。谷歌首席软件工程师罗布派克(Rob Pike)说：我们之所以开发Go，是因为过去10多年间软件开发的难度令人沮丧。Google 对 Go 寄予厚望，其设计是让软件充分发挥多核心处理器同步多工的优点，并可解决面向对象程序设计的麻烦。它具有现代的程序语言特色。
如垃圾回收，帮助开发者处理琐碎但重要的内存管理问题。Go 的速度也非常快，几乎和 C 或 C++程序一样快，且能够快速开发应用程序。

1.1.4. Go语言的主要特征

1.自动立即回收。
2.更丰富的内置类型。
3.函数多返回值。
4.错误处理。
5.匿名函数和闭包。
6.类型和接口。
7.并发编程。
8.反射。
9.语言交互性。

1.1.5. Golang文件名：

 `所有的go源码都是以 ".go" 结尾。

1.1.6. Go语言命名：

1.Go的函数、变量、常量、自定义类型、包 (package) 的命名方式遵循以下规则

1. 首字符可以是任意的Unicode字符或者下划线
2. 剩余字符可以是Unicode字符、下划线、数字
3. 字符长度不限

2.Go只有25个关键字

1. break default func interface select
2. case defer go map struct
3. chan else goto package switch
4. const fallthrough if range type
5. continue for import return var

3.Go还有37个保留字

1. Constants: true false iota nil
2. Types: 	 int int8 int16 int32 int64
3.	 		uint uint8 uint16 uint32 uint64 uintptr
4. 			float32 float64 complex128 complex64
5. 			bool byte rune string error
6. Functions: make len cap new append copy close delete
7. 			complex real imag
8. 			panic recover

4.可见性：

1. 1）声明在函数内部，是函数的本地值，类似private
2. 2）声明在函数外部，是对当前包可见(包内所有.go文件都可见)的全局值，类似protect
3. 3）声明在函数外部且首字母大写是所有包可见的全局值,类似public

1.1.7. Go语言声明：

有四种主要声明方式：

1. var（声明变量）, const（声明常量）, type（声明类型） ,func（声明函数）。

​ Go的程序是保存在多个.go文件中，文件的第一行就是package XXX声明，用来说明该文件属于哪个
包(package)，package声明下来就是import声明，再下来是类型，变量，常量，函数的声明。

1.1.8. Go项目构建及编译

一个Go工程中主要包含以下三个目录：

1. src：源代码文件
2. pkg：包文件
3. bin：相关bin文件

1: 建立工程文件夹 goproject
2: 在工程文件夹中建立src,pkg,bin文件夹
3: 在GOPATH中添加projiect路径 例 e:/goproject
4: 如工程中有自己的包examplepackage，那在src文件夹下建立以包名命名的文件夹 例
examplepackage
5：在src文件夹下编写主程序代码代码 goproject.go
6：在examplepackage文件夹中编写 examplepackage.go 和 包测试文件examplepackage_test.go
7：编译调试包
go build examplepackage
go test examplepackage
go install examplepackage
这时在pkg文件夹中可以发现会有一个相应的操作系统文件夹如windows_386z, 在这个文件夹中会有
examplepackage文件夹，在该文件中有examplepackage.a文件
8：编译主程序
go build goproject.go
成功后会生成goproject.exe文件
至此一个Go工程编辑成功。

1. 1.建立工程文件夹 go
2. $ pwd
3. /Users/***/Desktop/go
4. 2: 在工程文件夹中建立src,pkg,bin文件夹
5. $ ls
6. bin conf pkg src
7. 3: 在GOPATH中添加projiect路径
8. $ go env
9. GOPATH="/Users/liupengjie/Desktop/go"
10. 4: 那在src文件夹下建立以自己的包 example 文件夹
11. $ cd src/
12. $ mkdir example
13. 5：在src文件夹下编写主程序代码代码 goproject.go
14. 6：在example文件夹中编写 example.go 和 包测试文件 example_test.go
15. example.go 写入如下代码：
16.
17. package example
18.
19. func add(a, b int) int {
20. return a + b
21. }
22.
23. func sub(a, b int) int {
24. return a - b
25. }
26.
27. example_test.go 写入如下代码：
28.
29. package example
30.
31. import (
32. "testing"
33. )
34.
35. func TestAdd(t *testing.T) {
36. r := add(2, 4)
37. if r != 6 {
38. t.Fatalf("add(2, 4) error, expect:%d, actual:%d", 6, r)
39. }
40. t.Logf("test add succ")
41. }
42.
43. 7：编译调试包
44. $ go build example
45. $ go test example
46. ok example 0.013s
47. $ go install example
48.
49. $ ls /Users/***/Desktop/go/pkg/
50. darwin_amd64
51. $ ls /Users/***/Desktop/go/pkg/darwin_amd64/
52. example.a
53. 8：编译主程序
54. oproject.go 写入如下代码：
55. package main
56.
57. import (
58. "fmt"
59. )
60.
61. func main(){
62. fmt.Println("go project test")
63. }
64.
65. $ go build goproject.go
66. $ ls
67. example goproject.go goproject
68.
69. 成功后会生成goproject文件
70. 至此一个Go工程编辑成功。
71.
72. 运行该文件：
73. $ ./goproject
74. go project test

1.1.9. go 编译问题

golang的编译使用命令 go build , go install;除非仅写一个main函数，否则还是准备好目录

结构； GOPATH=工程根目录；其下应创建src，pkg，bin目录，bin目录中用于生成可执行文件，
pkg目录中用于生成.a文件； golang中的import name，实际是到GOPATH中去寻找name.a, 使用
时是该name.a的源码中生命的package 名字；这个在前面已经介绍过了。
注意点

1.系统编译时 go install abc_name时，系统会到GOPATH的src目录中寻找abc_name目录，然
后编译其下的go文件；
2.
3.
2.同一个目录中所有的go文件的package声明必须相同，所以main方法要单独放一个文件，否则
在eclipse和liteide中都会报错；
4.
编译报错如下：（假设test目录中有个main.go 和mymath.go,其中main.go声明package
为main，mymath.go声明packag 为test);
5.
6. $ go install test
7.
8.
can't load package: package test: found packages main (main.go) and
test (mymath.go) in /home/wanjm/go/src/test
9.
10.
报错说 不能加载package test（这是命令行的参数），因为发现了两个package，分别时
main.go 和 mymath.go;
11.
12.
3.对于main方法，只能在bin目录下运行 go build path_tomain.go; 可以用-o参数指出输出
文件名；
13.
14.
4.可以添加参数 go build -gcflags "-N -l" ****,可以更好的便于gdb；详细参见
http://golang.org/doc/gdb
15.
16. 5.gdb全局变量主一点。 如有全局变量 a；则应写为 p 'main.a'；注意但引号不可少；

1.2.0 第一个 Go 语言的程序 – Hello World。

Go 语言的基础组成有以下几个部分：

• 包声明
• 引入包
• 函数
• 变量
• 语句 & 表达式
• 注释

“Hello World!”:

package main

import "fmt"

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}

解释

让我们来看下以上程序的各个部分：

1. 第一行代码 *package main* 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

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）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。