特点： a.自动垃圾回收 b.丰富的内置类型 c.函数多返回值 d.错误处理 e.匿名函数和闭包 f.类型和接口 g.goroutine并发编程 h.反射 i.CGO调用c函数

go语言从main包中的main函数开始执行，Go语言的main()函数不能带参数，也不能定义返回值。命令行传入的参数在os.Args变量中保存。如果需要支持命令行开关，可使用flag包。在包声明之后，是一系列的import语句，用于导入该程序所依赖的包。 package main import "fmt"// 我们需要使用fmt包中的Println()函数 func main() { fmt.Println("Hello, world. 你好，世界！ ") } 》go run hello.go 》go build hello.go 1.变量 =赋值运算符 := 类型推断并附初值 a.各种变量的声明 var v1 int var v2 string var v3 [10]int // 数组 var v4 []int // 数组切片 var v5 struct { f int } var v6 *int // 指针 var v7 map[string]int // map，key为string类型，value为int类型 var v8 func(a int) int const zero = 0.0

b.变量声明时初始化 var v1 int = 10 // 正确的使用方式1 var v2 = 10 // 正确的使用方式2，编译器可以自动推导出v2的类型 v3 := 10 // 正确的使用方式3，编译器可以自动推导出v3的类型 go语言是一种强类型语言，在变量定义时可以指明数据类型，也可以选择自动推导

c.变量赋值 i, j = j, i //支持多重赋值

d.匿名变量"_"表示 假 设GetName()函数的定义如下，它返回3个值，分别为firstName、lastName和 nickName： func GetName() (firstName, lastName, nickName string) { return "May", "Chan", "Chibi Maruko" } 若只想获得nickName，则函数调用语句可以用如下方式编写： _, _, nickName := GetName() 假 设GetName()函数的定义如下，它返回3个值，分别为firstName、lastName和 nickName： func GetName() (firstName, lastName, nickName string) { return "May", "Chan", "Chibi Maruko" } 若只想获得nickName，则函数调用语句可以用如下方式编写： _, _, nickName := GetName()

e.常量，定义时添加const const Pi float64 = 3.14159265358979323846 const zero = 0.0 // 无类型浮点常量 const ( size int64 = 1024 eof = -1 // 无类型整型常量 ) const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值 const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo", 无类型整型和字符串常量

f.枚举 下面是一个常规的枚举表示法，其中定义了一系列整型常量： const ( Sunday = iota Monday Tuesday Wednesday Thursday Friday Saturday numberOfDays // 这个常量没有导出 ) 同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。 以上例子中numberOfDays为包内私有，其他符号则可被其他包访问。

g.go语言的数据类型  布尔类型：bool。  整型：int8、uint8、byte、int16、int、uint、int32、int64、uintptr等。  浮点类型：float32、float64。  复数类型：complex64(由2个float32构成的复数类型)、complex128。 2+3i  字符串：string。  字符类型：rune。 代表单个Unicode字符。  错误类型：error。 此外，Go语言也支持以下这些复合类型：  指针（pointer）  数组（array）  切片（slice）  字典（map）  通道（chan）  结构体（struct）  接口（interface）

字符串取值及其遍历 str := "Hello,世界" n := len(str) for i := 0; i < n; i++ { ch := str[i] // str[i]="x";错误，字符串是不能重新被改变了，数组才行 fmt.Println(i, ch) }

数组的使用 [32]byte // 长度为32的数组，每个元素为一个字节 [2*N] struct { x, y int32 } // 复杂类型数组 [1000]*float64 // 指针数组 [3][5]int // 二维数组 [2][2][2]float64 // 等同于2

var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

mySlice := myArray[:] //基于myArray的所有元素创建数组切片 mySlice := myArray[:5] //基于myArray的前5个元素创建数组切片 mySlice := myArray[5:] //基于从第5个元素开始的所有元素创建数组切片 mySlice := make([]int, 5) //创建一个初始元素个数为5的数组切片，元素初始值为0： mySlice := make([]int, 5, 10) //创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：len(mySlice)=5 cap(mySlice)=10 ,mySlice = append(mySlice, 1, 2, 3) ,任何数组都可以动态增长 mySlice := []int{1, 2, 3, 4, 5} //直接创建并初始化包含5个元素的数组切片：

for _, v := range myArray { //数组遍历 fmt.Print(v, " ") } for i := 0; i <len(mySlice); i++ { fmt.Println("mySlice[", i, "] =", mySlice[i]) }

数组复制： slice1 := []int{1, 2, 3, 4, 5} slice2 := []int{5, 4, 3} copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中 copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

map的使用 map是一堆键值对的未排序集合。

var personDB map[string] PersonInfo personDB = make(map[string] PersonInfo) personDB["12345"] = PersonInfo{"12345", "Tom", "Room 203,..."} person, ok := personDB["1234"] // ok是一个返回的bool型，返回true表示找到了对应的数据 delete(myMap, "1234") //删除一个key

2.流程控制 a.if语句 if a < 5 { return 0 } else { return 1 } b.switch..case.. switch i { case 0: fmt.Printf("0") case 1: fmt.Printf("1") case 2: fallthrough default: fmt.Printf("Default") }

c.for for i := 0; i < 10; i++ { sum += i }

d.goto i := 0 HERE: fmt.Println(i) i++ if i < 10 { goto HERE } }

e.函数定义 实名函数 package mymath import "errors" func Add(a int, b int) (ret int, err error) { if a < 0 || b < 0 { // 假设这个函数只支持两个非负数字的加法 err= errors.New("Should be non-negative numbers!") return } return a + b, nil // 支持多重返回值 }

import "mymath"// 假设Add被放在一个叫mymath的包中 // ... c := mymath.Add(1, 2)

匿名函数 f := func(x, y int) int { return x + y }

闭包函数 var j int = 5 //全局变量 a := func()(func()) { var i int = 10 return func() { fmt.Printf("i, j: %d, %d\n", i++, j) //闭包的记忆性 } }()

3.面向对象编程 Go语言中的大多数类型都基于值语义而不是引用赋值语义，包括：  基本类型，如byte、 int、 bool、 float32、 float64和string等；  复合类型，如数组（array）、结构体（struct）和指针（pointer）等。