有梦想的鲨鱼 发布于

Golang 函数

1
2
3
4
func 函数名(a，b，类型) 返回的类型(a int,b string){
  ```逻辑代码
  return xxx
}

统计单词出现次数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func countword(word string)map[string]int{
	s2 :=strings.Split(word," ")
	valuemap :=make(map[string]int)
	// ["hello","world","hello","every","one"]
	for _,v := range s2{
		//map[every:1 hello:2 one:1 world:1]
		valuemap[v]++
	}
	return valuemap
}

func main() {
	text := countword("hello world hello every one")
	fmt.Println(text)
}
// map[every:1 hello:2 one:1 world:1]

分金币

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/*
你有50枚金币，需要分配给以下几个人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。
分配规则如下：
a. 名字中每包含1个'e'或'E'分1枚金币
b. 名字中每包含1个'i'或'I'分2枚金币
c. 名字中每包含1个'o'或'O'分3枚金币
d: 名字中每包含1个'u'或'U'分4枚金币
写一个程序，计算每个用户分到多少金币，以及最后剩余多少金币？
程序结构如下，请实现 ‘dispatchCoin’ 函数
*/
func dispatchCoin() int {
	coins := 50
	users := []string{"Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth"}
	distribution := make(map[string]int, len(users))
	/*
		Matthew
		Sarah
		Augustus
		Heidi
		Emilie
		Peter
		Giana
		Adriano
		Aaron
		Elizabeth

	*/
	result := 0
	for _, v := range users {
		//fmt.Println(v)
		distribution[v] = 0
		for _,n := range v{
			if strings.Contains(string(n), "e") || strings.Contains(string(n), "E") {
				distribution[v] += 1

			} else if strings.Contains(string(n), "i") || strings.Contains(string(n), "I") {
				distribution[v] += 2
			} else if strings.Contains(string(n), "o") || strings.Contains(string(n), "O") {
				distribution[v] += 3
			} else if strings.Contains(string(n), "u") || strings.Contains(string(n), "U") {
				distribution[v] += 4
			}
		}
		// map[Aaron:3 Adriano:2 Augustus:4 Elizabeth:1 Emilie:1 Giana:2 Heidi:1 Matthew:1 Peter:1 Sarah:0]

	}
	//fmt.Println(distribution)
	for _, v := range distribution {
		result += v
	}
	last := coins - result
	//fmt.Printf("剩余金币: %d",last)
	return last
}

func main() {
	func1 := dispatchCoin()
	fmt.Println("剩余金币：", func1)
}
///////////////////////////
func dispatchCoin() int {
	coins := 50
	users := []string{"Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth"}
	distribution := make(map[string]int, len(users))
	/*
		Matthew
		Sarah
		Augustus
		Heidi
		Emilie
		Peter
		Giana
		Adriano
		Aaron
		Elizabeth

	*/
	result := 0
	for _, v := range users {
		//fmt.Println(v)
		distribution[v] = 0
		for _, n := range v {
			switch n {
			case 'e', 'E':
				distribution[v] += 1
			case 'i', 'I':
				distribution[v] += 2
			case 'o', 'O':
				distribution[v] += 3
			case 'u', 'U':
				distribution[v] += 4
			}
		}
	}
		for _, v := range distribution {
			result += v
		}
		last := coins - result
		//fmt.Printf("剩余金币: %d",last)
		return last
	}

func main() {
		func1 := dispatchCoin()
		fmt.Println("剩余金币：", func1)
	}

判断回文

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func main() {
	ss := "山西运煤车煤运西山"
	s1 := make([]rune, 0, len(ss))

	for _, h := range ss {
		s1 = append(s1, h)
	}
	// [23665 35199 36816 29028 36710 29028 36816 35199 23665]
	fmt.Println(s1)
	for i := 0; i < len(s1)/2; i++ {
		if s1[i] == s1[len(s1)-1-i]{
			fmt.Println("True")
			return
		}
	}
}

defer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// defer多用于函数结束之前释放资源

func f1()  {
	defer func() {
		err := recover()
		fmt.Println(err)
	}()
	panic("error")
	fmt.Println("1")
}


func f2()  {
	fmt.Println("2")
}

func main() {
	f1()

	f2()
}

匿名函数

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
func extfunc(count int )func() int{
	return func() int {
		count ++
		return count
	}
}

func main() {
	v :=extfunc(1)	// 此时值为1
	fmt.Println(v())	// 2
	fmt.Println(v())	// 3
	fmt.Println(v())	// 4
	fmt.Println(v())	// 5
}

////////////////////////
func makesuffix(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + "." + suffix
		}
		return name
	}
}

func main() {
	jpgfunc := makesuffix("jpg")
	pngfunc := makesuffix("png")
	fmt.Println(jpgfunc("test"))// test.jpg
	fmt.Println(pngfunc("test"))// test.png
}
//////////////////////////////////////////////////
func calc(num int) (func(int) int, func(int) int) {
	add := func(i int) int {
		num += i
		return num
	}

	reduce := func(i int) int {
		num -= i
		return num
	}
	return add, reduce
}

func main() {
	func1, func2 := calc(10)
	fmt.Println(func1(10), func2(5)) // 20 15
	fmt.Println(func1(4), func2(6))	// 19, 13
}


闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 函数和其外部变量的引用
func totalsum(x, y int) {
	total := x + y
	fmt.Println(total)

}

func totalresult(f func(x, y int), x, y int) func() {
	return func() {
		f(x, y)
	}

}

func low(f func()) {
	f()
}

func main() {
	fc := totalresult(totalsum, 1, 2)
	low(fc)
}

函数版的学生管理系统

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*
1.可以查看所有学生信息
2.添加一个学生信息
3.删除一个学生信息
4.退出
*/

var (
	allStudent map[int64]*student
)

func newstudent(name string, id int64) *student {
	return &student{
		name: name,
		id: id,
	}
}

type student struct {
	name string
	id   int64
}

func showallStudent() {
	for k, v := range allStudent {
		fmt.Printf("学生姓名:%s,学生学号:%d\n", v.name,k )
	}
}

func addStudent() {
	var (
		name string
		id   int64
	)

	fmt.Print("请输入姓名:")
	fmt.Scanln(&name)
	fmt.Print("请输入学号:")
	fmt.Scanln(&id)

	addstu := newstudent(name,id)
	allStudent[id]=addstu
}

func delStudent() {
	var id int64

	fmt.Print("请输入学号:")
	fmt.Scanln(&id)
	delete(allStudent, id)
}

func main() {
	allStudent = make(map[int64]*student, 40)
	for {
		var choice int
		fmt.Println("学生系统")
		fmt.Println(`
		1.查看所有学生
		2.添加一个学生
		3.删除一个学生
		4.退出系统
	`)
		fmt.Print("请选择操作:")
		fmt.Scanln(&choice)
		switch choice {
		case 1:
			showallStudent()
		case 2:
			addStudent()
		case 3:
			delStudent()
		case 4:
			os.Exit(1)
		default:
			fmt.Println("爬")
		}
	}

}

递归

1
2
3
4
5
6
7
8
9
10
11
12
13
func f(va int64) int64{
	if va <=1{
		return 1
	}
	return va *f(va-1)
}
func main() {
	//f(10)
	starttime := time.Now()
	fmt.Println(f(10000000))
	resulttime :=time.Now().Sub(starttime)
	fmt.Println(resulttime)
}

给ec2打指定tag

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
63
64
65
66
67
68
69
70
71
72
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/ec2"
	"github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
	"golang.org/x/net/context"
)

func resourcegrouptags(makem1 map[string]string, resourcearn string, target_slice []string) {
	trueflag := 0
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("ap-southeast-1"))
	if err != nil {
		panic(err)
	}
	client := resourcegroupstaggingapi.NewFromConfig(cfg)
	for k, _ := range makem1 {
		for _, targetk := range target_slice {
			if k == targetk {
				trueflag++
			}
		}
	}

	if trueflag == len(makem1) {
		fmt.Println("标签合规")
	} else if trueflag <= len(makem1) {
		fmt.Println("打标签")
		input := &resourcegroupstaggingapi.TagResourcesInput{ResourceARNList: []string{resourcearn}, Tags: makem1}
		_, err = client.TagResources(context.TODO(), input)
		if err != nil {
			return
		}
	}
}

func getec2message(makem1 map[string]string) {
	m1 := make([]string, 0, 50)
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("ap-southeast-1"))
	if err != nil {
		panic(err)
	}

	client := ec2.NewFromConfig(cfg)
	input := &ec2.DescribeInstancesInput{}
	out, err := client.DescribeInstances(context.TODO(), input)

	if err != nil {
		return
	}

	for _, r := range out.Reservations {
		for _, i := range r.Instances {
			ec2_arn := fmt.Sprintf("arn:aws:ec2:ap-southeast-1:811983228092:ec2/%s", *i.InstanceId)
			for _, t := range i.Tags {
				m1 = append(m1, *t.Key)
			}
			resourcegrouptags(makem1, ec2_arn, m1)
		}
	}

}

func main() {
	makem1 := make(map[string]string)
	makem1["aws-migration-project-id"] = "MPE30462"
	makem1["map-migrated"] = "d-server-02qqzw58ztrwxq"

	getec2message(makem1)
}

上台阶

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

func step(x int64) int64 {
	if x == 1 {
		return 1
	} else if x == 2 {
		return 2
	}
	return step(x-1) + step(x-2)
}

func main() {
	starttime := time.Now()
	fmt.Println(step(4))
	resulttime := time.Now().Sub(starttime)
	fmt.Println(resulttime)
}

　

switch-case

1
2
3
4
5
6
7
8
9
a :=1
switch a{
  case 判断逻辑:
  	代码逻辑
  case 判断逻辑:
  	代码逻辑
  default：
  	代码逻辑
}

for循环

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
for i:=0;i<=10;i++{
  代码逻辑
}
//////
tuple :=[...]{1,2,3,4}
sum :=0
for _,v :=range tuple{
  sum += v
}

////找出相加为8的下标

// 外层先进行一次循环，从第一个开始寻找
// 内层在外层后进行循环，也就是从外层后面开始找
// 两个和为8则输出，否则输出其他结果
func main() {
	tuplelist := [...]int{1, 3, 5, 7, 8}
	for x := 0; x < len(tuplelist); x++ {
		for y := x+1; y < len(tuplelist); y++ {
			if tuplelist[x]+tuplelist[y] == 8 {
				fmt.Println(x,y)
			}
		}
	}
}

if语句

1
2
3
4
5
6
7
if xxxx{
  代码逻辑
}else if{
  代码逻辑
}else{
  代码逻辑
}

切片

1
2
3
4
5
// 切片的本质：切片就是一个方框，框住了一块连续的内存
// 切片属于引用类型，真正的数据都存储在底层数组里
// 容量：底层数组从切片的第一个元素到最后元素的数量
// 一个nil值的切片长度和容量都为0，但是不能说一个长度和容量为0的切片是nil
// 判断切片是否为空，应该是 len(s1) == 0 而不要使用 s1 == nil来判断

make生成切片

1
2
3
4
5
6
7
8
// make(切片类型,长度,容量)
// make([]int,5,10)
func main() {
	s1 :=make([]int,5,10)
	fmt.Printf("s1=%v,len(s1)=%d,cap(s1)=%d",s1,len(s1),cap(s1))
}
// output:  s1=[0 0 0 0 0],len(s1)=5,cap(s1)=10

切片复制

1
2
3
4
5
6
7
	s2 := []int{1,3,5}
	s3 :=s2
	fmt.Println(s2,s3)
	s2[0]=6
	fmt.Println(s2,s3)
// [6 3 5] [6 3 5]

切片append

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
// 调用append函数必须用原来的切片变量接收返回值
// 如果底层数组容量不够了，go底层是会将底层数组换一个
// 必须用变量来接收append返回值

func main() {
	s1 :=[]string{"北京","深圳","上海"}
	s1 = append(s1,"广州")
	fmt.Println(s1)
}
// 扩容
func main() {
	s1 :=[]string{"北京","深圳","上海"}
	s1 = append(s1,"广州")
	fmt.Printf("s1=%v,len(s1)=%d,cap(s1)=%d\n",s1,len(s1),cap(s1))
	s2 :=[]string{"杭州","成都","重庆","江苏","西安"}
	s1 = append(s1,s2...)
	fmt.Printf("s1=%v,len(s1)=%d,cap(s1)=%d",s1,len(s1),cap(s1))
}
// s1=[北京 深圳 上海 广州],len(s1)=4,cap(s1)=6
// s1=[北京 深圳 上海 广州 杭州 成都 重庆 江苏 西安],len(s1)=9,cap(s1)=12

// 切片
func main() {
	s1 := []string{"北京", "深圳", "上海","南京"}
	// 切片
	x1 := s1[:]
	x1 = append(x1[0:1], x1[2:]...)
	//x1[1] = "hhh"
	fmt.Println(x1)
	fmt.Println(s1)
}
// [北京 上海 南京]
// [北京 上海 南京 南京]

![image-20220110110749355](/Users/agilewing/Library/Application Support/typora-user-images/image-20220110110749355.png)

切片copy

1
2
3
4
5
6
7
8
9
10
11
func main() {
	s1 :=[]string{"北京","深圳","上海"}
	fmt.Printf("s1=%v,len(s1)=%d,cap(s1)=%d\n",s1,len(s1),cap(s1))

	s3 :=make([]string,3)
	copy(s3,s1)
	fmt.Printf("s3=%v,len(s3)=%d,cap(s3)=%d\n",s3,len(s3),cap(s3))
}
// s1=[北京 深圳 上海],len(s1)=3,cap(s1)=3
// s3=[北京 深圳 上海],len(s3)=3,cap(s3)=3

指针

1
2
3
4
5
6
7
8
// &：取地址
// *：根据地址取值
func main() {
	p := 18
	b := &p
	fmt.Println(*b)
}
// 18

new

1
2
3
4
5
6
7
// new申请一块地址
func main() {
	a :=new(int)
	fmt.Println(a)
	*a=100
	fmt.Println(*a)
}

make

1
// make也是用于内存分配，区别于new，make只用于slice，map，chan的内存创建。而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回指针了

new和make的区别

1
2
3
// new很少用，一般用来给基本的数据类型申请内存，它返回的是对应类型的指针
// make是用来给slice，map，chan申请内存的，返回的是这三个类型的本身

Map

1
2
3
4
5
6
7
8
9
func main() {
	m1 := make(map[string]int)
	m1["分数"] = 90
	m1["理想"] = 100
	fmt.Println(m1)
}
// map[分数:90 理想:100]


确认key是否存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 确认key是否存在
func main() {
	m1 := make(map[string]int)
	m1["分数"] = 90
	m1["理想"] = 100
	fmt.Println(m1)
// 行业约定写法
	value, ok := m1["hahh"]
	if !ok {
		fmt.Println("无")
	} else {
		fmt.Println(value)
	}
}

map遍历

1
2
3
4
5
6
7
8
9
10
11
func main() {
	m1 := make(map[string]int)
	m1["分数"] = 90
	m1["理想"] = 100
	for k, v := range m1 {
		fmt.Println(k, v)
	}
}
// 分数 90
// 理想 100

delete删除元素

1
2
3
4
5
6
7
8
9
func main() {
	m1 := make(map[string]int)
	m1["分数"] = 90
	m1["理想"] = 100
	delete(m1,"理想")
	fmt.Println(m1)
}
// map[分数:90]

map和slice结合

1
2
3
4
5
6
func main() {
	s1 :=make([]map[int]string,5,5)
	s1[0] = make(map[int]string,1)
	s1[0][1]="aaa"
	fmt.Println(s1)
}

值为切片类型的map

1
2
3
4
5
6
func main() {
	m1 := make(map[string][]int,10)
	m1["深圳"] = []int{1,2,3,4}
	fmt.Println(m1)
}
// map[深圳:[1 2 3 4]]

数组

多维数组

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
```

# 输出类型

## ![image-20220118182758344](/Users/agilewing/Library/Application Support/typora-user-images/image-20220118182758344.png)

# 结构体

```go
type message struct {
	name string
	age int
	country string
}


func main() {
	//声明一个message的变量a
	var a message
	a.name = "张三"
	a.age = 10
	a.country ="中国"
	fmt.Println(a.country)
}
/// 中国

结构体嵌套

1
//

匿名结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 没有名字的结构体
	s := struct {
		name string
		age int
	}{}
// 又或者 var s struct{
//					name string
//	}
	s.name = "李四"
	s.age = 18
	fmt.Printf("Type: %T\nValue: %v",s,s)

//	Type: struct { name string; age int }
//	Value: {李四 18}

指针类型的结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// go语言的函数永远都是值拷贝，所以会需要有指针这个概念出现
type message struct {
	name string
	age int
	country string
}

func f2(p *message) {
	p.name="李四"	// 根据内存地址找到原来的变量，并且修改变量的值，此处是一个语法糖，会自动根据指针找到原始变量
}

func main() {
	//声明一个message的变量a
	var a message
	a.name = "张三"

	fmt.Println(a.name)
	f2(&a)
	fmt.Println(a.name)
}
// 李四

创建指针类型结构体

![image-20220123111337473](/Users/agilewing/Library/Application Support/typora-user-images/image-20220123111337473.png)

取结构体的地址实例化

![image-20220123111409580](/Users/agilewing/Library/Application Support/typora-user-images/image-20220123111409580.png)

方法和接收者

1
2
3
func (接收者变量 接收者类型) 方法名(参数列表)(返回参数){
  函数体
}

值接收者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 传拷贝值
type dog struct {
	name string
}

func newdog(name string)dog{
	return dog{name: name}
}

// 方法是作用于特定类型的函数
// 接收者表示的是调用该方法的具体类型变量 ，多用类型名首字母表示
func (d dog)wang(){
	fmt.Printf("%s:汪汪汪~",d.name)
}

func main() {
	d1 :=newdog("李富贵")
	d1.wang()
}

指针接收者

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
// 传内存地址
type dog struct {
	name string
}

func newdog(name string) dog {
	return dog{name: name}
}

// 方法是作用于特定类型的函数
// 接收者表示的是调用该方法的具体类型变量 ，多用类型名首字母表示
func (d dog) wang() {
	fmt.Printf("%s:汪汪汪~\n", d.name)
}

func (d *dog) wang2() {
	fmt.Printf("%s:汪汪汪~", d.name)
}

func main() {
	d1 := newdog("李富贵")
	d1.wang() //李富贵:汪汪汪~
	d1 = newdog("七仔")
	d1.wang2() //七仔:汪汪汪~
}

什么时候应该使用指针接收者

1
2
3
// 1.需要修改接收者中的值
// 2.接收者是拷贝代价较大的大对象(当结构体的字段多，成员占的内存大)
// 3.保证一致性，如果有个某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者

任意类型

![image-20220123140233004](/Users/agilewing/Library/Application Support/typora-user-images/image-20220123140233004.png)

Small Shark

Small Shark

鲨鱼也会有划水的一天

13
0
6
NOTICE

flex-block主题部分重构，详情查看https://github.com/miiiku/flex-block

CATEGORYS
TAGS
CDN Route53 SSM Tag VPN s3