Go语言基本语法

Go语言介绍（特点列举）

  1. 高性能、高并发
  2. 语法简单、学习曲线平缓
  3. 丰富的标准库
  4. 完善的工具链
  5. 静态链接
  6. 快速编译
  7. 跨平台
  8. 垃圾回收

开发环境

安装Golang

Golang官网

https://go.dev/

https://studygolang.com/dl

https://goproxy.cn/

配置集成开发环境

你可以使用vscode（下插件）或goland进行配置，其中goland是付费软件，如果想永久使用，那就从网上找个破解版吧

基础语法（速通）

相信你已经有了其他编程语言的基础（没有的话推荐先从C语言开始学习），所以后面将会只用少量代码来快速诠释语法

Hello World

1
2
3
4
5
6
7
8
9
package main   // 属于main包的一部分，main包是程序的一个入口文件

import (     // 导入标准库里的fmt包，fmt包主要是用来对屏幕输入输出字符串，格式化字符串
"fmt"
)

func main() {     // main函数调用了fmt.Println，输出hello world
fmt.Println("hello world")
}

输出

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

import (
	"fmt"
	"math"
)

func main() { //go语言自动推导变量类型
	var a = "initial" // 字符串类型

	var b, c = 1, 2 // 整数类型

	var d = true // 布尔类型

	var e float64  // 占8bytes，内存占用是float32的两倍，声明e为float64类型的变量

	f := float32(e)

	g := a + "foo"
	fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
	fmt.Println(g)                // initialfoo

	const s string = "constant" // const常量没有确定的类型，它会根据上下文自动确定类型
	const h = 500000000
	const i = 3e20 / h
	fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}

输出

1
2
3
initial 1 2 true 0 0
initialfoo
constant 500000000 6e+11 -0.28470407323754404 0.7591864109375384

if else

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

import "fmt"

func main(){
if 7%2 == 0{  // 若if后面跟小括弧，编译器会自动
    fmt.Println("7 is even")
}else {
    fmt.Println("7 is odd")
}

if 8%4 == 0{
fmt.Println("8 is divisible by 4")
}

if num := 9;num < 0 {
    fmt.Println(num,"is negative")
}else if num < 10 {
    fmt.Println(num,"has 1 digit")
}else {
    fmt.Println(num,"has multiple digits")
}
}

输出

1
2
3
7 is odd
8 is divisible by 4
9 has 1 digit

循环

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() {
	i := 1
	for {
		fmt.Println("loop")
		break
	}
	for j := 7; j < 9; j++ {
		fmt.Println(j)
	}

	for n := 0; n < 5; n++ {
		if n%2 == 0 {
			continue
		}
		fmt.Println(n)
	}
	for i <= 3 {
		fmt.Println(i)
		i = i + 1
	}
}

输出

1
2
3
4
5
6
7
8
loop
7
8
1
3
1
2
3

switch

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
import (
	"fmt"
	"time"
)

func main() {
	a := 2
	switch a {  // 可以使用任意变量类型
	case 1:
		fmt.Println("one")  // go的case默认不需要break
	case 2:
		fmt.Println("two")
	case 3, 4:
		fmt.Println("three or four")
	default:
		fmt.Println("other")
	}

	t := time.Now()
	switch {  // 若switch后面不跟变量，则可以在case后面加条件分支来判断
	case t.Hour() < 12:
		fmt.Println("it's before noon")
	default:
		fmt.Println("it's after noon")
	}
}

输出

1
2
two
it's after noon

数组

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

import "fmt"

func main() {
	var a [5]int
	a[4] = 100
	fmt.Println(a[4], len(a))

	b := [5]int{1, 2, 3, 4, 5}
	fmt.Println(b)

	var twoD [2][3]int
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			twoD[i][j] = i + j
		}
	}
	fmt.Println("2d:", twoD)
}

输出

1
2
3
100 5
[1 2 3 4 5]
2d: [[0 1 2] [1 2 3]]

切片（可以更改长度的数组）

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 main() {
	s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
	fmt.Println("get:", s[2])
	fmt.Println("len:", len(s))

	s = append(s, "d")
	s = append(s, "e", "f")
	fmt.Println(s)

	c := make([]string, len(s))
	copy(c, s)
	fmt.Println(c)

	fmt.Println(s[2:5])
	fmt.Println(s[:5])
	fmt.Println(s[2:])

	good := []string{"g", "o", "o", "d"}
	fmt.Println(good)
}

输出

1
2
3
4
5
6
7
8
get: c
len: 3
[a b c d e f]
[a b c d e f]
[c d e]
[a b c d e]
[c d e f]
[g o o d]

map（相当于哈希或字典）

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

import "fmt"

func main() {
	m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	fmt.Println(m)           // map[one:1 two:2]
	fmt.Println(len(m))      // 2
	fmt.Println(m["one"])    // 1
	fmt.Println(m["unknow"]) // 0

	r, ok := m["unknow"]
	fmt.Println(r, ok) // 0 false

	delete(m, "one")

	m2 := map[string]int{"one": 1, "two": 2}
	var m3 = map[string]int{"one": 1, "two": 2}
	fmt.Println(m2, m3)
}

输出

1
2
3
4
5
6
map[one:1 two:2]
2
1
0
0 false
map[one:1 two:2] map[one:1 two:2]

range

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

import "fmt"

func main() {
	nums := []int{2, 3, 4}
	sum := 0
	for i, num := range nums {
		sum += num
		if num == 2 {
			fmt.Println("index:", i, "num", num) // index: 0 num: 2
		}
	}
	fmt.Println(sum) // 9

	m := map[string]string{"a": "A", "b": "B"}
	for k, v := range m {
		fmt.Println(k, v)
	}
	for k := range m {
		fmt.Println("key", k)
	}
}

输出

1
2
3
4
5
6
index: 0 num 2
9
a A
b B
key a
key b

函数

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 int, b int) int {
	return a + b
}

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

func exists(m map[string]string, k string) (v string, ok bool) {
	v, ok = m[k]
	return v, ok
}

func main() {
	res := add(1, 2)
	fmt.Println(res)

	v, ok := exists(map[string]string{"a": "A"}, "a")
	fmt.Println(v, ok)
}

输出

1
2
3
A true

指针

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

import "fmt"

func add2(n int) {  // 这种写法不对，因为这个n只是拷贝，是无效的
	n += 2
}

func add2ptr(n *int) {
	*n += 2
}

func main() {
	n := 5
	add2(n)
	fmt.Println(n)
	add2ptr(&n)
	fmt.Println(n)
}

输出

1
2
5
7