1.go的优点
- 简洁、快速、安全
- 并行、有趣、开源
- 内存管理、数组安全、编译迅速
- 对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。
2.语言结构
2.1基础组成部分
包声明、引入包、函数、变量、语句 & 表达式、注释。第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。例子：
package main
import "fmt"
func main() {
/* 这是我的第一个简单的程序 */
fmt.Println("Hello, World!")
}
※ 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
※ { 大括号的左半边，不能单独在一行。
2.2运行程序
两种方式：
1）进入到hello.go所在目录中，运行如下命令
$ go run hello.go
2）先生成二进制文件，再运行二进制文件
$ go build hello.go
$ ls
hello hello.go
$ ./hello
3.基础语法
Go 标记：Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。也即是一行代码中能拆分出来的内容。
标识符：标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。这点同c语言。
数据类型：用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
| 序号 | 类型和描述 |
|---|---|
| 1 | 布尔型 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。 |
| 2 | 数字类型 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。 |
| 3 | 字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 |
| 4 | 派生类型: 包括：
|
语言变量：变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。声明变量的一般形式是使用 var 关键字，这点同scala。
//格式
var identifier type
//例子
var a string = "Runoob"
※：1.指定变量类型，如果没有初始化，则变量默认为零值。数值类型（包括complex64/128）为 0，布尔类型为 false，字符串为 ""（空字符串）。
※：2.根据值自行判定变量类型。eg：var v_name = value
※：3.省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误。也就是说，要用：=，就不要使用var。
值类型和引用类型：
像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值。当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝。
你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040。值类型的变量的值存储在栈中。一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。
使用 := 赋值操作符：如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明。如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误。但是全局变量是允许声明但不使用的。 同一类型的多个变量可以声明在同一行。
语言常量：常量是一个简单值的标识符，在程序运行时，不会被修改的量。常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
//格式
const identifier [type] = value
//例子
显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"
iota：在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
//运行结果
0 1 2 ha ha 100 100 7 8
go语言条件语句：
/* 定义局部变量 */
var a int = 10
/* 使用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" )
}
Go 语言循环语句：for循环
语法：Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。
和 C 语言的 for 一样：
//格式
for init; condition; post { }
//例子
package main
import "fmt"
func main() {
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
fmt.Println(sum)
}
和 C 的 while 一样：
// 这样写也可以，更像 While 语句形式
for sum <= 10{
sum += sum
}
和 C 的 for(;;) 一样：
sum := 0
for {
sum++ // 无限循环下去
}
for-each range 循环：这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。
package main
import "fmt"
func main() {
strings := []string{"google", "runoob"}
for i, s := range strings {
fmt.Println(i, s)
}
//[6]int{1, 2, 3, 5} 表示数组长度是6，类型是int，初始化了前4个元素为{1,2,3,5}
numbers := [6]int{1, 2, 3, 5}
for i,x:= range numbers {
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
}
输出：
0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0
4.Go 语言函数
Go 语言最少有个 main() 函数。
Go 语言函数定义格式如下：
func function_name( [parameter list] ) [return_types] {
函数体
}
例子，两个数比较大小，返回大的数：
/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
/* 声明局部变量 */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
例子，多个返回值的函数，返回值用()括起来：
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Google", "Runoob")
fmt.Println(a, b)
}
Go 语言数组：具有相同唯一类型的一组已编号且长度固定的数据项序列。
声明数组：Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：
//格式
var variable_name [SIZE] variable_type
//例子
var balance [10] float32
//初始化数组
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
//如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。eg: Element[0] = 100
Go 语言指针：
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：
格式
var var_name *var-type
例子
var ip *int /* 指向整型*/
如何使用指针？指针使用流程：定义指针变量，为指针变量赋值，访问指针变量中指向地址的值。在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。当一个指针被定义后没有分配到任何变量时，它的值为 nil。
Go 语言结构体
在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
定义结构体：结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
type struct_variable_type struct {
member definition
member definition
...
member definition
}
eg：
variable_name := structure_variable_type {value1, value2...valuen}
访问结构体成员：如果要访问结构体成员，需要使用点号 . 操作符。
参考：
1.网页资料：https://www.runoob.com/go/go-program-structure.html