Go入门

基础语法

“Hello World!”

1	fmt.Println("Hello World!")

变量声明

使用var

var a int

声明并赋值

a := 0

同时赋值多个

类似python

1	a, b := 1, 2

if

if a > 0 {
    // do something
} else if a > 5 {
    // do something
} else {
    // do something
}

循环（for）

fori循环

1
2
3

for i := 0; i < 100; i++ {
    // do something
}

仿while循环

1
2
3

for a < b {
    // do something
}

for each循环

使用range内置方法，使用:=

1
2
3

for i, item := range arr {
    // do something
}

类型转换

string转int

1	a := strconv.Atoi(str)

方法func

普通方法

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

// 相同的类型可以简写
func Foo(a, b int) int {
    return a + b
}

不支持重载

递归写法

func Fib(n int) int {
    if m == 1 || m == 2 {
        return 1
    }
    return Fib(m - 2) + Fib(m - 1)
}

提示：go目前没有尾递归优化

方法内的方法

func Foo(a int, b int) int {
    bar := func(m, n int) int {
        return m + n
    }
    return bar(a, b)
}

如果内部函数要递归，则要先定义，比如下面的内部的斐波那契数列

func Fib(n int) int {
    var inner func(m int) int // 先定义
    inner = func(m int) int {
        if m == 1 || m == 2 {
            return 1
        }
        return inner(m - 2) + inner(m - 1)
    }
    return inner(n)
}

switch

a, c, t := 0, 0, 1
switch t {
case a:
    c -= 1
default:
    c += 1
}

fmt.Println(c) // -1

label和goto

label可以定义一个点，可以使用continue和goto进行跳转

使用continue+label来直接继续外层循环

a:
for i := 0; i < 5; i++ {
    for j := 0; j < 5; j++ {
        if i == 3 && i == j {
            continue a
        }
        fmt.Println(i, j)
    }
}

使用goto来跳转到某个代码段执行，如果是for，则重新开始循环

比如把上面的代码的continue换成goto则会无限循环

a:
for i := 0; i < 5; i++ {
    for j := 0; j < 5; j++ {
        if i == 3 && i == j {
            goto a
        }
        fmt.Println(i, j)
    }
}

内置容器

数组

大小

len(arr)

创建

只能是固定大小（代码写死或const变量）

1 2	numbers := [5]int{} // [0 0 0 0 0] numbers := [5]int{1} // [1 0 0 0 0]

slice

创建

1 2	numbers := make([]int, 0) // [] numbers := make([]int, 1) // [0]

增加

使用append

numbers := make([]int, 1)    // [0]
numbers = append(numbers, 1) // [0 1]

// 可以添加多个
numbers = append(numbers, 2, 3) // [0 1 2 3]

append会返回一个新的slice，入参的不会改变
若append时未发生扩容，则共享底层数据

// 发生扩容
arr := make([]int, 1, 1) // 指定cap=1
arr1 := append(arr, 1)
arr1[0] = 100 // 此时arr[0]=0

// 未发生扩容
arr := make([]int, 1, 2) // 初始化cap为2
arr1 := append(arr, 1)
arr1[0] = 100 // 此时arr[0]=100

截取

类似python

前闭后开

1	newSlice := oldSlice[beginInclude: endExclude]

map

创建

使用make

1 2	m := make(map[int]int) m[1] = 2

使用字面量

注意必须有逗号,

1
2
3

m := map[int]int {
    1: 2,
}

取值

如果key不存在，则返回value类型的零值

1 2	m[1] // 2 m[-1] // 0

删除一个key

使用delete关键字

1	delete m[key]

获取key的slice

func KeySlice(m map[int]int) (arr []int) {
    for k, _ := range m {
        arr = append(arr, k)
    }
    return arr
}

range

用于循环

对array、slice

for i, v := range arr {

}

for i, v := range slice {

}

倒序遍历使用fori

对map

1
2
3

for k, v := range m {

}

对string

注意循环体每一项是rune类型

1
2
3

for i, v := range m {

}

排序

引入

1	import "sort"

几个内置类型

都是从小到大

1
2
3

sort.Ints()
sort.Float64()
sort.Strings()

反向

1
2
3

s := []int{5, 2, 6, 3, 1, 4} // unsorted
sort.Sort(sort.Reverse(sort.IntSlice(s)))
fmt.Println(s)

自定义排序

不稳定版本

sort.Slice(arr, func(a, b int) bool {
    v1, v2 := list[a], list[b]
    return v1 < v2 // 从小到大排序
})

稳定版本

sort.SliceStable(arr, func(a, b int) bool {
    v1, v2 := list[a], list[b]
    return v1 < v2 // 从小到大排序
})

Search：二分查找

返回第一个满足的索引

arr := []int{1, 2, 3, 4, 5}

idx := sort.Search(len(arr), func (i int) bool {
    return arr[i] > 2
})

fmt.Println(idx) // 2，3的位置

如果第一个就满足，则返回0
如果都不满足，则返回len(arr)的值

参考

https://golang.google.cn/pkg/sort/

随机数

随机整数`rand.Intn`

import (
    "fmt"
    "math/rand"
)

func main() {
    // 生成一个随机整数
    randomInt := rand.Int()
    fmt.Println("Random Int:", randomInt)

    // 生成一个0到100之间的随机整数
    randomIntBetween0and100 := rand.Intn(100)
    fmt.Println("Random Int between 0 and 100:", randomIntBetween0and100)
}

随机浮点数`rand.Float64()`

import (
    "fmt"
    "math/rand"
)

func main() {
    // 生成一个0~1的随机浮点数
    randomFloat := rand.Float64()
    fmt.Println("Random Float:", randomFloat)
}

技术 / Go

2024-11-12

曹耘豪的博客