Go的关键字
golang的关键字很少，只有25个：
break、default、func、interface、select、case、defer、go、map、struct、chan、else、goto、package、switch、const、fallthrough、if、range、type、continue、for、import、return、var

Go的注释方法
和其他大多语言一样：
// ：单行注释
/* */ ：多行注释

具有最高优先级的运算符放在表的顶部，具有最低优先级的运算符出现在底部。 在表达式中，将首先计算较高优先级运算符。

源文件后缀为.go，比如 hello.go
Go程序是用package来组织的，在源文件第一个非注释行声明包，比如：package main
只有package为main的包才能包含main函数（程序的入口），并且一个可执行程序有且仅有一个main包
通过import关键字导入其它包，两种用法：
1.导入单个包：

import "fmt"

2.导入多个包：

import (
"fmt"
"hehe"
)

3.给包起别名：

import std "fmt"
import (
std "fmt"
)

导入包之后就可以用包名调用包中的函数，比如初学者最常用的输出函

fmt.Println("hello world")

这样做还可以省略包名直接调用（但是不建议这样做）：

//import . "fmt"
import (
. "fmt"
)


func main() {
Println("hello world")
}

Go语言没有像其它语言一样有public、protected、private等访问控制修饰符，它是通过字母大小写来控制可见性的，如果定义的常量、变量、类型、接口、结构、函数等的名称是大写字母开头表示能被其它包访问或调用（相当于public），非大写开头就只能在包内使用（相当于private，变量或常量也可以下划线开头）

例如：
visibility/test.go

package visibility
 
import "fmt"
 
const PI = 3.145
const pi = 3.14
const _PI = 3.14
 
var P int = 1
var p int = 1
 
func private_function() {
fmt.Println("only used in this package!")
}
 
func Public_fuction() {
fmt.Println("used in anywhere!")
}

main.go

package main
 
import (
"visibility"
"fmt"
)
 
func main() {
visibility.Public_fuction() //used in anywhere!
//visibility.private_function() //不能访问私有函数，无法通过编译
fmt.Println(visibility.P) //1
//fmt.Println(visibility.p) //不能访问私有变量，无法通过编译
fmt.Println(visibility.PI) //3.14
//fmt.Println(visibility.pi) //不能访问私有常量，无法通过编译
//fmt.Println(visibility._PI) //不能访问私有常量，无法通过编译
}

整型有：int8/uint8、int16/uint16、int32/uint32、int64/uint64、int/uint、byte、rune

1. 数字表示占多少位，uint的u表示unsigned，有点C语言基础的都知道是什么意思，这里就不赘述了；
2. int/uint会根据运行平台可能为32位或64位；
3. rune相当于int32的别名，通常用于表示一个Unicode码点；
4. byte相当于uint8的别名，一般用于强调数值是一个原始的数据而不是一个小的整数；

浮点型有：float32、float64
float64相当于其它某些语言的double，即双精度浮点型

字符串：string

布尔型：bool
只有true或false，不能用数字代替（比如C语言就允许0代表false，非0代表true）

空值：nil
有些语言是null或NULL

变量声明与赋值示例：

s := ""
var s string
var s = ""
var s string = ""

第一种形式，是一条短变量声明，最简洁，但只能用在函数内部，而不能用于包变量。第二种形式依赖于字符串的默认初始化零值机制，被初始化为""。第三种形式用得很少，除非同时声明多个变量。第四种形式显式地标明变量的类型，当变量类型与初值类型相同时，类型冗余，但如果两者类型不同，变量类型就必须了。一般使用前两种形式中的某个，初始值重要的话就显式地指定变量的类型，否则使用隐式初始化。

var i int = 1 //var关键字声明一个变量，紧跟一个变量名，然后是变量类型，最后是赋值
var hehe = "hehe" //可以省略变量类型，编译器根据赋值的类型自动推算变量的类型
var a,b,c,d = 1,2,3.14,4 //同时申明多个并赋值
j := 10 //省略var关键字
如果是全局的变量，还可以这样：
var (
a = 1
b uint64 = 3
c =3.14
d := 4
)

常量的值必须在编译时期就确定下来，所以要么直接给出确定的值，要么使用Go自带的函数（比如len(),计算长度）；
用const关键字声明
定义与赋值示例：

const _THRESHOLD int = 10 //完整形式
const PI = 3.14 //可省略类型，编译器自动推断
const STR = "hello world"
const (
MAX_VALUE = 1000
MIN_VALUE int = -1000
LEN = len(STR)
)

关键字为iota，没遇到一个const关键字就会置为0，然后递增。还有就是如果定义常量组，没有赋值的编译器会自动将其赋值表达式置为和它前面那个变量的表达式一样

const (
A = 55
B = iota
C
D
)
func main() {
fmt.Println(A)
fmt.Println(B)
fmt.Println(C)
fmt.Println(D)
}

输出：
55
1
2
3

类型零值
变量声明为某种类型后的值就为该类型的零值，它不是空值。通常数值类型默认为0，bool为false，string为空字符串
类型别名
比如：

type text string
func main() {
var t text = "hello world"
fmt.Println(t)
}

类型转换

Go语言不存在隐式转换，必须显式转换，并且只能在两种相互兼容的类型间转换，转换示例：

a := 3.14
b := int(a)
fmt.Println(b)
var c int32 = 256
var d = float64(c)
fmt.Println(d)

运算符
Go的运算符是从左至右结合的（和其它很多语言相反）

指针
Go语言保留了指针，但不支持"->",而是直接用"."来操作指针目标对象的成员
简单使用示例：

var a int = 45
var p *int = &a
fmt.Println(*p)

和其它语言有很大不同，它只能放在变量的后面而不能放在前面，而且只能作为一条语句而不是表达式。
举个栗子：

var i =1
var j = i++

这段代码将不同通过编译

条件表达式没有括号
支持初始化表达式
初始化语句的变量自在本block内有效

if a,b,c := 1,2,3;a+b+c>6 {
fmt.Println("haha")
}else{
fmt.Println("hehe")
}

Go循环只有for关键字，没有while，但可以达到同样的效果

for a,b:=1,2;a+b<100;a++ {
fmt.Println(a+b)
}
i := 1
for i<=100 {
fmt.Println(i)
i++
}
i = 1
for{
if i>100 {
break
}
fmt.Println(i)
i++
}

条件语句可以使用任何类型或表达式，甚至不填
不需要写break，一旦条件符合自动终止，如果希望继续执行下一个case，需使用fallthrough
支持初始化表达式，右侧跟分号

var a int = 1
switch {
case a>=1:
fmt.Println("a>=1")
case a>=0:
fmt.Println("a>=0")
}
var a int = 1
switch a {
case 0:
fmt.Println("a=0")
case 1:
fmt.Println("a=1")
}
switch a:=1; {
case a>=1:
fmt.Println("a>=1")
fallthrough
case a>=0:
fmt.Println("a>=0")
}

和其它许多语言用法大致一样，三种语法支持配合标签使用，标签区分大小写

goto
package main
 
import "fmt"
 
func main() {
var i int = 1
if i <=10 {
goto LABEL
}
fmt.Println("before label")
LABEL:
fmt.Println("after label")
}

输出：
after label

break

package main
 
import "fmt"
 
func main() {
LABEL:
for i:=0;i<100;i++ {
for j:=0;j<100;j++ {
fmt.Println(j)
if j==4 {
break LABEL
}
}
}
}

输出：
0
1
2
3
4

continue

package main
 
import "fmt"
 
func main() {
	LABEL:
	for i:=0;i<4;i++ {
		for j:=0;j<4;j++ {
			fmt.Println(j)
			if j==2 {
				continue LABEL
			}
		}
	}
}

输出：
0
1
2
0
1
2
0
1
2
0
1
2

数组
数组定义格式示例：

var a [2]int
fmt.Println(a)
b := [2]int{2,3}
fmt.Println(b)

输出：
[0 0]
[2 3]

还可以省略数组长度，编译器自动推算：

a := [...]int{5,6,7,8}

还可以使用索引初始化：

a := [...]int{9:1}
fmt.Println(a)

输出：
[0 0 0 0 0 0 0 0 0 1]

需要注意的是，数组长度也是数组类型的一部分，因此长度不同的数组类型也就不同
数组在Go中为值类型，即给传递数组变量的时候是全复制，如果想传递引用，将使用Go特有类型：slice，后面会讲到
数组可以用==或!=来比较
可以使用new创建数组，此时返回的是数组指针：
a := new([10]int)

切片
底层就是数组，多个slice可以在底层可以指向同一个数组
可以指定初始长度和容量，注意长度和容量概念不同，长度是指该slice用于存放数据的数组长度，容量是底层数组分配连续内存的总长度。当给slice append元素，使得长度超出容量的时候，Go会再创建一个容量为当前容量两倍的新数组，并将数据拷贝进去。

切片只能往后拓展长度，不能往前拓展长度，只能截断前面的元素，截掉的前面的元素就不存在数据中了；只能拓展长度，无法拓展容量

var s0 []int //和定义数组类似，只是不需要指定长度
fmt.Println(s0) //[]
a := [10]int{0,1,2,3,4,5,6,7,8,9} //声明一个数组
s1 := a[5:10] //截取数组某一部分
fmt.Println(s1) //[5 6 7 8 9]
s2 := a[5:] //截取从某个索引开始到数组末尾
fmt.Println(s2) //[5 6 7 8 9]
s3 := a[:5] //截取从数组开头开始到某个索引为止
fmt.Println(s3) //[0 1 2 3 4]
s4 := make([]int,3,10) //创建一个类型为整型数组，长度为3，容量为10的slice
fmt.Println(len(s4),cap(s4),s4) //3 10 [0 0 0]
s5 := []int{1,2,3,4} //定义并初始化slice
fmt.Println(s5) //[1,2,3,4]
s6 := a[:] //指向整个a数组
fmt.Println(s6) //[0,1,2,3,4,5,6,7,8,9]

相当于其它语言的哈希表或字典，key-value形式存储数据
key必须是支持==和!=比较运算的类型，不能是函数、map或slice

var m1 map[int]string
m1 = make(map[int]string)
fmt.Println(m1) //map[]
var m2 map[int]string = make(map[int]string)
m2[1] = "OK"
fmt.Println(m2) //map[1:OK]
m3 := make(map[int]string)
fmt.Println(m3) //map[]
m4 := map[int]string{4:"d",1:"a",2:"b",3:"c"}
fmt.Println(m4) //map[4:d 1:a 2:b 3:c]

用关键字func定义
可以有多个返回值

func main(){
f1() //f1
a,b := f2(1,1.2)
fmt.Println(a,b) //4.34 2
c,d,e := f3()
fmt.Println(c,d,e) //1 2 3
f4("OK",1,2,3,4) //OK [1 2 3 4]
f5() //hello world
f := f6(2)
fmt.Println(f(1)) //3
}

func f1(){ //没有返回值就不写
fmt.Println("f1")
}
func f2(a int,b float32)(float32,int){ //可以有多个返回值
return b+3.14,a+1
}
func f3()(a,b,c int){ //参数简写
return 1,2,3
}
func f4(a string,b ...int) int{ //变长参数
fmt.Println(a,b)
return 0
}
func f5(){ //匿名函数
a := func(){
fmt.Println("hello world")
}
a()
}
func f6(x int) func(y int)int{ //闭包
return func(y int)int{
return x+y
}
}

Golang语言的函数可以返回多个返回值，而且可以为每个返回值指定一个名称
声明函数时命名了返回值：
则不用再在函数体中声明，直接用，并且直接将需要返回的值赋予所设置的变量即可，最后使用return可以实现自动的返回对应的变量值。
若某个变量没有出现或被赋值则返回对应变量类型的“零值”。
注意，如果想更改显示的返回值。可以写 return 1, nil
命名变量将会被忽略，返回的真正值为 1, nil

声明函数时未命名返回值：
返回的变量A需要在函数体内声明并写return A

不支持重载，例如下面两个函数相同，参数不同，编译无法通过

func foo(i int) {
fmt.Println(i)
}
func foo(s string) {
fmt.Println(s)
}

Go语言没有提供像其它语言一样的try catch的异常与捕获机制，可以用defer、panic、recover代替。
defer的语句或函数在当前函数执行完之后再执行，先defer的后执行，后defer的先执行。当程序发生严重错误的时候defer也能够执行。有点类似其它语言的析构函数
调用panic来制造一个异常
调用recover来获取异常信息

func main(){
f1()
f2()
f3()
}


 
func f1(){
fmt.Println("f1")
}
func f2(){
defer func() {
if err:=recover();err!=nil {
fmt.Println("catch the exception")
}
 
}()
panic("wa ha ha ha ha ~~~")
}
func f3(){
fmt.Println("f3")
}

输出：
f1
catch the exception
f3

Go没有class，也没有继承机制，只能定义结构体，但是功能还是很强大。本文先演示下它的基本用法。

简单使用示例：

type person struct {
Name string
Age int
}
func main() {
a := person{ //声明的时候可以赋初始值，也可以不要
Name:"cpwl",
Age : 21,
}
a.Name = "roc" //改变值
fmt.Println(a) //{roc 21}
}

注意结构指针：

type person struct {
Name string
Age int
}
func main() {
a := person{
Name:"cpwl",
Age : 21,
}
change1(a)
fmt.Println(a) //{cpwl 21}
change2(&a)
fmt.Println(a) //{roc 21}
b := &person{ //创建的时候就返回指针，我们一般都这样做
Name:"zhansan",
Age:18,
}
change2(b)
fmt.Println(b) //&{roc 18}
}
func change1(p person) { //Go默认是值传递，struct也会拷贝传给调用的函数
p.Name = "roc"
}
func change2(p *person) { //传递指针，能改变原struct的值
p.Name = "roc"
}

匿名struct：

func main() {
a := struct{
Name string
Age int
}{
Name : "roc",
Age : 35,
}
fmt.Println(a) //{roc 35}
 
b := &struct{
Name string
Age int
}{
Name : "roc",
Age : 35,
}
fmt.Println(b) //&{roc 35}
}

嵌套struct：