Golang学习笔记20240725，Go语言基础语法

第一个Go程序

package main

import "fmt"

func main() {
	fmt.Println("hello world")
}

1
2
3
4
5
6
7
8

运行方式1：

go run main.go
1

运行方式2：

go build
.\hello_go.exe
1
2

运行方式3：goland右键运行

字符串拼接

使用加号可以对字符串进行拼接。

package main

import "fmt"

func main() {
	fmt.Println("hello world" + "你好世界")
}

1
2
3
4
5
6
7
8

变量的声明和初始化

package main

import "fmt"

func main() {
	var a, b, c int

	a = 11
	b = 22
	c = 333

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

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

简短的声明

上面的变量定义和初始化有更简单的方式，如下：

package main

import "fmt"

func main() {
	a := 11
	b := 22
	c := 333

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

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

格式化输出

使用%d可以在字符串中格式化输入整数类型，如下：

package main

import "fmt"

func main() {
	a := 11
	b := 22
	c := 333

	fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c)
}

1
2
3
4
5
6
7
8
9
10
11
12

if语句

if语句主要有三种格式，如下：

package main

import "fmt"

func main() {
	a := 33

	// 单分支
	if a > 0 {
		fmt.Println(a)
	}

	// 双分支
	if a < 0 {
		fmt.Println(a)
	} else {
		fmt.Println(a + a)
	}

	// 多分支
	if a > 100 {
		fmt.Println(a)
	} else if a > 0 {
		fmt.Println(a + a)
	} else {
		fmt.Println(a + a + a)
	}
}

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

for循环

累加求和：

package main

import "fmt"

func main() {
	sum := 0
	for i := 0; i < 101; i++ {
		sum += i
	}
	fmt.Println(sum)
}

1
2
3
4
5
6
7
8
9
10
11
12

双重for循环打印九九乘法表

package main

import "fmt"

func main() {
	for i := 1; i < 10; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d * %d = %d\t", j, i, i*j)
		}
		fmt.Println()
	}
}

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

for遍历数组

package main

import "fmt"

func main() {
	arr := []int{11, 22, 33}
	for k, v := range arr {
		fmt.Println(k, v)
	}
}

1
2
3
4
5
6
7
8
9
10
11

for 遍历字符串

package main

import "fmt"

func main() {
	arr := "abc"
	for k, v := range arr {
		fmt.Println(k, v)
	}
}

1
2
3
4
5
6
7
8
9
10
11

for遍历字典

package main

import "fmt"

func main() {
	arr := map[string]int{"one": 1, "two": 2, "three": 3}
	for k, v := range arr {
		fmt.Println(k, v)
	}
}

1
2
3
4
5
6
7
8
9
10
11

for 遍历管道

package main

import "fmt"

func main() {
	c := make(chan int)
	go func() {
		c <- 33
		c <- 333
		c <- 333333
		close(c)
	}()

	for v := range c {
		fmt.Println(v)
	}
}

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

匿名变量

如果我们在遍历的时候，不想要key或者value，也可以用下划线替代，下划线叫做匿名变量。

package main

import "fmt"

func main() {
	c := []int{1, 2, 3}

	for _, v := range c {
		fmt.Println(v)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12

switch 语句

go语言里面的switch语句每个case天生就是独立的，不需要加break。

package main

func main() {
	s := "python"

	switch s {
	case "python":
		print("1")
	case "go":
		print("2")
	case "java":
		print("3")
	default:
		print("4")
	}
}

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

switch 可以一个分支捕获多个值

这个是go语言的特点，很少在其他语言看见，我们来看例子：

package main

func main() {
	s := "python"

	switch s {
	case "python", "go", "java":
		print("1")
	default:
		print("4")
	}
}

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

switch的分支可以捕获条件判断

这个也是go语言的特点，我们来看例子：

package main

func main() {
	s := 33

	switch {
	case s > 0 || s < 100:
		print("1")
	default:
		print("4")
	}
}

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

字符串可以通过索引访问字符

package main

func main() {
	s := "abcde"
	print(s[0])
}

1
2
3
4
5
6
7

字符串可以通过切片访问连续字符

package main

func main() {
	s := "abcde"
	print(s[0:3])
}

1
2
3
4
5
6
7

统计字符串的个数要用特殊的方法

package main

import "unicode/utf8"

func main() {
	s := "abcde"
	print(utf8.RuneCountInString(s))
}
1
2
3
4
5
6
7
8

将字符编码转换为字符

package main

func main() {
	s := "abcde"
	print(string(s[1]))
}
1
2
3
4
5
6

遍历字符串的每一个字符

package main

import "fmt"

func main() {
	s := "我 爱 你 中 国"
	cs := []rune(s)
	for _, ch := range cs {
		fmt.Println(string(ch))
	}
}

1
2
3
4
5
6
7
8
9
10
11
12

使用buffer累加字符串

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var bf bytes.Buffer
	for i := 0; i < 10; i++ {
		fmt.Fprintf(&bf, "a%d ", i)
	}
	s := bf.String()
	fmt.Println(s)
}

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

通过指针修改变量的值

指针可以直接对内存地址进行操作。使用*表示指针，使用&取地址。

package main

import "fmt"

func main() {
	a := 33

	pa := &a
	*pa = 333

	fmt.Println(a)
	fmt.Println(*pa)
}

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

使用指针交换两个变量的值

package main

import "fmt"

func swap(a, b *int) {
	*a, *b = *b, *a
}

func main() {
	a, b := 33, 11
	fmt.Println(a, b)

	swap(&a, &b)
	fmt.Println(a, b)
}

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

数组的基本使用

package main

import "fmt"

func main() {
	// 声明
	var arr [8]int

	// 赋值
	for i := 0; i < 8; i++ {
		arr[i] = i * 33
	}

	// 遍历
	for i := 0; i < 8; i++ {
		fmt.Println(arr[i])
	}
}

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

结构体的基本用法

package main

import "fmt"

type User struct {
	Name string
	Age  int
}

func main() {
	zs := User{"zs", 20}
	ls := User{Name: "ls", Age: 20}

	fmt.Println(zs, ls)
}

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

结构体作为函数参数

package main

import "fmt"

type User struct {
	Name string
	Age  int
}

func printUser(u User) {
	fmt.Printf("姓名：%s 年龄：%d \n", u.Name, u.Age)
}

func main() {
	zs := User{"zs", 20}
	ls := User{Name: "ls", Age: 20}

	printUser(zs)
	printUser(ls)
}

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

结构体指针作为函数参数

package main

import "fmt"

type User struct {
	Name string
	Age  int
}

func printUser(u *User) {
	fmt.Printf("姓名：%s 年龄：%d \n", u.Name, u.Age)
}

func main() {
	zs := User{"zs", 20}
	ls := User{Name: "ls", Age: 20}

	printUser(&zs)
	printUser(&ls)
}

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

切片的增删改查

切片在go语言里面非常常用，因为其有动态扩展的特性。

package main

import "fmt"

func main() {
	var arr []int

	// 增加
	arr = append(arr, 11)
	arr = append(arr, 22)
	arr = append(arr, 33)

	// 删除 索引1
	index := 1
	arr = append(arr[:index], arr[index+1:]...)

	// 修改
	arr[0] = 888

	// 遍历
	for _, v := range arr {
		fmt.Println(v)
	}
}

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

map的增删改查

package main

import "fmt"

func main() {
	var m = make(map[string]int)

	// 增加
	m["a"] = 11
	m["b"] = 12
	m["c"] = 13

	// 删除
	delete(m, "a")

	// 修改
	m["c"] = 888

	// 遍历
	for k, v := range m {
		fmt.Println(k, v)
	}
}

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

加法函数

package main

import "fmt"

func add(a, b int) int {
	return a + b
}

func main() {
	fmt.Println(add(1, 2))
}

1
2
3
4
5
6
7
8
9
10
11
12

函数的可变参数

package main

import "fmt"

func add(arr ...int) int {
	sum := 0
	for i := 0; i < len(arr); i++ {
		sum += arr[i]
	}
	return sum
}

func main() {
	fmt.Println(add(1, 2))
	fmt.Println(add(1, 2, 3, 4, 5))
}

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

匿名函数

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("这个是匿名函数")
	}()
	fmt.Println("xxx")
}

1
2
3
4
5
6
7
8
9
10
11