基础语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// :=是在函数内部声明变量并赋值,在函数外部不能用
// 变量用var,常量用const,常量不能用:=
k := 3
const K int = 3
var k = 3
// 返回值可以命名,可以多个
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
// 没有初始值的变量会被赋零值
/* 基本数据类型
bool string
int int8 .... int64
uint uint8 ...... uint64
byte // uint8的别名
rune // int32的别名
float32 float64
complex64 complex128
*/

分支循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// if后面可以跟一句初始语句,整个条件语句作用域可用
if a:=b-32; a>0 {
} else {
}
// switch也可以这样,而且不用显示break
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("OS X.")
default:
fmt.Printf("%s.\n", os)
}
// switch也可以没有条件表达式
switch {
case t.Hour() < 12:
fmt.Println("Good morning!")
default:
fmt.Println("Good evening.")
}
// 只有一种循环for,不用小括号,必须用花括号
for i:=0; i<10; i++ {
fmt.Println(i)
}
// defer声明的语句会在外部函数返回才调用,这些语句会被压入到栈中
defer fmt.Println("world")

高级数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// 指针
var p *int = 42
i := 21
pp = &i

// 结构体
type Vertext struct {
X int
Y int
}
v := Vertex{X:1, Y:2}
p := &v

// 数组
// 切片传参是传指针
var a [10]string
primes := [6]int{2, 3, 5, 7, 11, 13}

// 切片以后是在原数组上操作
// 切片的长度和容量:len是切片含有多少个元素,capacity是从切片第一个元素到数组最后一个元素含有的元素个数
s := []int{2,3,4,5}
s = s[:2]
len(s) // 2
cap(s) // 4
s = s[2:]
len(s) // 2
cap(s) // 2

// make创建动态数组
a := make([]int, len, cap)

// append进行切片追加的时候,如果元素个数大于了capacity,那么按什么方式将底层数组扩容?2,4,8?
func append(s []T, vs ...T) []T

// range
// v是浅拷贝还是深拷贝?浅拷贝,依然可以通过v操作原数组
func main() {
var pow = [][]int{[]int{1, 2}, []int{3, 4}}
for i, v := range pow {
v[0] = 5
fmt.Println(v)
// 可以通过pow[i]对原数组进行操作
}
fmt.Printf("%v", pow)
}
/*
[5 2]
[5 4]
[[5 2] [5 4]]
*/

实现built-in的append函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func appendInt(slice []int, data ...int) []int {
m := len(slice)
n := m+len(data)
if n > cap(slice) {
var newSlice []int
if m == 0 {
newSlice = make([]int, 2)
} else {
newSlice = make([]int, 2*m)
}
copy(newSlice, slice)
slice = newSlice
}
slice = slice[0:n]
copy(slice[m:n], data)
return slice
}

slice练习

1
2
3
4
5
6
7
8
9
10
11
12
func Pic(dx, dy int) [][]uint8 {
ret := make([][]uint8, dy)
for y := range ret {
ret[y] = make([]uint8, dx)
for x:=0; x < dx; x++ {
ret[y][x] = uint8(float64(x)*math.Log(float64(y)))
// 两种方法都可以
// ret[y] = append(ret[y], uint8(float64(x)*math.Log(float64(y))))
}
}
return ret
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// map初始化
m := make(map[string]Vertex)
// 操作
a = m[key]
delete(m, key) // 删除key
item, ok := m[key] // 判断key是否在m中

// 参数可以是函数,也可以有匿名函数
// 赋值再调用
fplus := func(x, y int) int { return x + y }
fplus(3,4)
// 直接调用匿名函数
func(x, y int) int { return x + y } (3, 4)

闭包实现斐波那契数列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 跟Python不一样的是,不会发生自由变量降级成为局部变量的现象,也不需要nolocal声明。因为go语言需要变量声明,Python不需要变量声明。

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
pre2 := -1
pre1 := 1
return func() int {
tmp := pre2
pre2 = pre1
pre1 = tmp + pre1
return pre1
}
}

func main() {
f := fibonacci()
for i := 0; i < 10; i++ {
fmt.Println(f())
}
}