Go语言基础

Go语言介绍（特点列举）

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

开发环境

安装Golang

Golang官网: https://go.dev/

Golang中文站下载: https://studygolang.com/dl

Golang模块代理站: https://goproxy.cn/

配置集成开发环境

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

基础语法（速通）

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

Hello World

package main   // 属于main包的一部分，main包是程序的一个入口文件

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

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

输出

hello world

变量

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))
}

输出

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

if else

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")
}
}

输出

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

循环

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

输出

loop
7
8
1
3
1
2
3

switch

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")
	}
}

输出

two
it's after noon

数组

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)
}

输出

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

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

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)
}

输出

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（相当于哈希或字典）

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)
}

输出

map[one:1 two:2]
2
1
0
0 false
map[one:1 two:2] map[one:1 two:2]

range

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)
	}
}

输出

index: 0 num 2
9
a A
b B
key a
key b

函数

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 sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

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

	v, ok := exists(map[string]string{"a": "A"}, "a")
	fmt.Println(v, ok)
    
    sum(1, 2)
    
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

输出

3
A true
[1 2] 3
[1 2 3 4] 10

指针

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)
}

输出

5
7

进阶

闭包

Go是支持匿名函数的，而匿名函数可以构成闭包。你可以在不想命名函数的情况下内联定义函数。

package main

import "fmt"

func intSeq() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

func main() {

    nextInt := intSeq()

    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())

    newInts := intSeq()
    fmt.Println(newInts())
}

输出

1
2
3
1

递归

package main

import "fmt"

func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}

func main() {
    fmt.Println(fact(7))

    var fib func(n int) int

    fib = func(n int) int {
        if n < 2 {
            return n
        }

        return fib(n-1) + fib(n-2)
    }

    fmt.Println(fib(7))
}

输出

5040
13