go语言快速掌握语法特色--基本语法

0x00 背景

  • 主要是针对:想快速低成本掌握golang开发人群,主要是讲区别其他语言的特色语法、用法和思想。

  • 最好是已经熟悉了一门后段语言,可以快速的掌握和上手go语言

  • 因为编程思想是想通的,对于已经熟练一门语言的开发者,只要掌握开发这个语言的特性,很快就能上手了。

  • 下面的每个知识点,没有单独去拿出来讲,知识点都是在代码旁边的注释里面,我感觉还是蛮不错的,有代码例子应该很快就能理解

0x01 GO基本语法

注意go里面有个很特殊的:
每个变量声明之后必须要在后面使用,不允许存在变量声明没有使用的情况,所以下面的代码没有调试通,可以先看看,是不是有变量没有使用。

0x011 基本的函数编写格式:(括号、;)

1
2
3
4
5
6
7
8
9
10
11
12
package main //程序的包名

import (
"fmt"
"time"
)

//main函数
func main() { //函数的{ 一定是 和函数名在同一行的,否则编译错误
//golang中的表达式,加";", 和不加 都可以,建议是不加
fmt.Println(" hello Go!")
}

0x012 四种变量的声明方式

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
package main

import (
"fmt"
)

//声明全局变量 方法一、方法二、方法三是可以的
var gA int = 100
var gB = 200

//用方法四 只能局部变量,在函数体内
// := 只能够用在 函数体内来声明
//gC := 200

func main() {
//方法一:声明一个变量 默认的值是0
var a int

//方法二:声明一个变量,初始化一个值
var b int = 100

//方法三:在初始化的时候,可以省去数据类型,通过值自动匹配当前的变量的数据类型
var c = 100
var cc = "abcd"

//方法四:(常用的方法) 省去var关键字,直接自动匹配
e := 100
f := "abcd"
g := 3.14

// 声明多个变量
var xx, yy int = 100, 200
var kk, ll = 100, "Aceld"

//多行的多变量声明
var (
vv int = 100
jj bool = true
)
fmt.Println("自行输出吧")
}

0x013 函数多返回值

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
51
52
53
54
55
56
57
58
59
60
61
62
package main

import "fmt"

//一般返回
func foo1(a string, b int) int {
fmt.Println("a = ", a)
fmt.Println("b = ", b)

c := 100
return c
}

//返回多个返回值,匿名的
func foo2(a string, b int) (int, int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
return 666, 777
}

//返回多个返回值, 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
fmt.Println("---- foo3 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)

//r1 r2 属于foo3的形参, 初始化默认的值是0
//r1 r2 作用域空间 是foo3 整个函数体的{}空间
fmt.Println("r1 = ", r1)
fmt.Println("r2 = ", r2)

//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}

//有相同的返回类型
func foo4(a string, b int) (r1, r2 int) {
fmt.Println("---- foo4 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000

return
}

func main() {
c := foo1("abc", 555)
fmt.Println("c = ", c)

ret1, ret2 := foo2("haha", 999)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)

ret1, ret2 = foo3("foo3", 333)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)

ret1, ret2 = foo4("foo4", 444)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
}

0x014 iota 只能够配合const

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
package main

import "fmt"

//const 来定义枚举类型
const (
//可以在const() 添加一个关键字 iota, 每行的iota都会累加1, 第一行的iota的默认值是0
BEIJING = 10*iota //iota = 0
SHANGHAI //iota = 1
SHENZHEN //iota = 2
)

const (
a, b = iota+1, iota+2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
c, d // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
e, f // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4

g, h = iota * 2, iota *3 // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9
i, k // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)

func main() {
//常量(只读属性),常量是不允许修改的
const length int = 10
fmt.Println("length = ", length)

fmt.Println("BEIJIGN = ", BEIJING)
fmt.Println("SHANGHAI = ", SHANGHAI)
fmt.Println("SHENZHEN = ", SHENZHEN)

fmt.Println("a = ", a, "b = ", b)
fmt.Println("c = ", c, "d = ", d)
fmt.Println("e = ", e, "f = ", f)

fmt.Println("g = ", g, "h = ", h)
fmt.Println("i = ", i, "k = ", k)

// iota 只能够配合const() 一起使用, iota只有在const进行累加效果。
//var a int = iota

}

0x015 defer

这个东西类似于python装饰器+finally ,在函数执行完执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
//写入defer关键字
defer fmt.Println("main end1")
defer fmt.Println("main end2")
fmt.Println("main::hello go 1")
fmt.Println("main::hello go 2")
}
//main::hello go 1
//main::hello go 2
//main end2
//main end1

0x016 数组和循环遍历

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
package main

import "fmt"

func printArray(myArray [4]int) {
//值拷贝

for index, value := range myArray {
fmt.Println("index = ", index, ", value = ", value)
}

myArray[0] = 111
}


func main() {
//固定长度的数组
var myArray1 [10]int

myArray2 := [10]int{1,2,3,4}
myArray3 := [4]int{11,22,33,44}

//for i := 0; i < 10; i++ 类似于C语言的常规遍历
for i := 0; i < len(myArray1); i++ {
fmt.Println(myArray1[i])
}

//使用range 遍历数组切片,返回值为 数组下标和值
for index, value := range myArray2 {
fmt.Println("index = ", index, ", value = ", value)
}

//查看数组的数据类型
fmt.Printf("myArray1 types = %T\n", myArray1)
fmt.Printf("myArray2 types = %T\n", myArray2)
fmt.Printf("myArray3 types = %T\n", myArray3)

printArray(myArray3)
for index, value := range myArray3 {
fmt.Println("index = ", index, ", value = ", value)
}
}

0x2 silce切片

silce赋值

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
package main

import "fmt"

func printArray(myArray [4]int) {
//值拷贝

for index, value := range myArray {
fmt.Println("index = ", index, ", value = ", value)
}

myArray[0] = 111
}


func main() {
//固定长度的数组
var myArray1 [10]int

myArray2 := [10]int{1,2,3,4}
myArray3 := [4]int{11,22,33,44}

//for i := 0; i < 10; i++ {
for i := 0; i < len(myArray1); i++ {
fmt.Println(myArray1[i])
}

for index, value := range myArray2 {
fmt.Println("index = ", index, ", value = ", value)
}

//查看数组的数据类型
fmt.Printf("myArray1 types = %T\n", myArray1)
fmt.Printf("myArray2 types = %T\n", myArray2)
fmt.Printf("myArray3 types = %T\n", myArray3)

printArray(myArray3)
fmt.Println(" ------ ")
for index, value := range myArray3 {
fmt.Println("index = ", index, ", value = ", value)
}
}

动态数组slice

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
package main

import "fmt"

func printArray2(myArray []int) {
//引用传递
// _ 表示匿名的变量
for _, value := range myArray {
fmt.Println("value = ", value)
}

myArray[0] = 100
}

func main() {
myArray := []int{1,2,3,4} // 动态数组,切片 slice

fmt.Printf("myArray type is %T\n", myArray)

printArray2(myArray)

fmt.Println(" ==== ")

for _, value := range myArray {
fmt.Println("value = ", value)
}
}

silce几种声明方式

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
package main

import "fmt"

func main() {
//声明slice1是一个切片,并且初始化,默认值是1,2,3。 长度len是3
slice1 := []int{1, 2, 3}

//声明slice2是一个切片,但是并没有给slice分配空间
var slice2 []int
fmt.Printf("slice2: %v\n",slice2)
//slice1 = make([]int, 3) //开辟3个空间 ,默认值是0

//声明slice1是一个切片,同时给slice分配空间,3个空间,初始化值是0
//var slice1 []int = make([]int, 3)

//声明slice1是一个切片,同时给slice分配空间,3个空间,初始化值是0, 通过:=推导出slice是一个切片
// 常见
slice3 := make([]int, 3)
fmt.Printf("slice3: %v\n",slice3)

fmt.Printf("len = %d, slice = %v\n", len(slice1), slice1)

//判断一个silce是否为0
if slice2 == nil {
fmt.Println("slice2 是一个空切片")
} else {
fmt.Println("slice2 是有空间的")
}
}

这里面长度和空间的概念是不一个:

  • 空间是这个slice的具体占用空间个数
  • 长度len 是已经存放占有的空间个数

slice的追加

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
package main

import "fmt"

func main() {

var numbers = make([]int, 3, 5)
// 长度为3 容量为5 [0,0,0,空,空]

fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)

//向numbers切片追加一个元素1, numbers len = 4, [0,0,0,1], cap = 5
numbers = append(numbers, 1)

fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)

//向numbers切片追加一个元素2, numbers len = 5, [0,0,0,1,2], cap = 5
numbers = append(numbers, 2)

fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)

//向一个容量cap已经满的slice 追加元素,追加的数量为之前申请的5个,[0,0,0,1,2,2,0,0,0,0]
numbers = append(numbers, 3)

fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
// len = 6, cap = 10, slice = [0 0 0 1 2 3]

// 不指定长度的slice
var numbers2 = make([]int, 3)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)
// len = 3, cap = 3, slice = [0 0 0]

numbers2 = append(numbers2, 1)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)
// len = 4, cap = 6, slice = [0 0 0 1]
}

slice的截取

和python的截取一样

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
package main

import "fmt"

func main() {
s := []int{1, 2, 3} //len = 3, cap = 3, [1,2,3]

//[0, 2)
s1 := s[0:2] // [1, 2]

fmt.Println(s1)

s1[0] = 100

fmt.Println(s)
fmt.Println(s1)

//copy 可以将底层数组的slice一起进行拷贝
s2 := make([]int, 3) //s2 = [0,0,0]

//将s中的值 依次拷贝到s2中
copy(s2, s)
fmt.Println(s2)

}

切片语法:

操作 含义
s[n] 切片s中索引位置为n的项
s[:] 从切片s的索引位置0到len(s)-1处所获得的切片
s[low:] 从切片s的索引位置low到len(s)-1处所获得的切片
s[:high] 从切片s的索引位置0到high处所获得的切片,len=high
s[low:high] 从切片s的索引位置low到high处所获得的切片,len=high-low
s[low:high:max] 从切片s的索引位置low到high处所获得的切片,len=high-low,cap=max-low
len(s) 切片s的长度,总是<=cap(s)
cap(s) 切片s的容量,总是>=len(s)

0x03 map

map定义

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
package main

import "fmt"

func main() {
//===> 第一种声明方式

//声明myMap1是一种map类型 key是string, value是string
var myMap1 map[string]string
if myMap1 == nil {
fmt.Println("myMap1 是一个空map")
}

//在使用map前, 需要先用make给map分配数据空间
myMap1 = make(map[string]string, 10)

myMap1["one"] = "java"
myMap1["two"] = "c++"
myMap1["three"] = "python"

fmt.Println(myMap1)

//===> 第二种声明方式,自动分配空间
myMap2 := make(map[int]string)
myMap2[1] = "java"
myMap2[2] = "c++"
myMap2[3] = "python"

fmt.Println(myMap2)

//===> 第三种声明方式
myMap3 := map[string]string{
"one": "php",
"two": "c++",
"three": "python",
}
fmt.Println(myMap3)
}

map的使用

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
package main

import "fmt"

func printMap(tmpMap map[string]string) {
//cityMap 是一个引用传递
for key, value := range tmpMap {
fmt.Println("key = ", key)
fmt.Println("value = ", value)
}
}

func ChangeValue(cityMap map[string]string) {
cityMap["England"] = "London"
}

func main() {
cityMap := make(map[string]string)

//添加
cityMap["China"] = "Beijing"
cityMap["Japan"] = "Tokyo"
cityMap["USA"] = "NewYork"

//遍历
printMap(cityMap)

//删除
delete(cityMap, "China")

//修改
cityMap["USA"] = "DC"
ChangeValue(cityMap)

fmt.Println("-------")

//遍历
printMap(cityMap)
}