golang入门
特点：
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的数组，每个元素为一个字节
[2N] 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
}
数组复制：
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）等。
