曹耘豪的博客

Go入门

  1. 基础语法
    1. “Hello World!”
    2. 变量声明
      1. 使用var
      2. 声明并赋值
      3. 同时赋值多个
    3. if
    4. 循环（for）
      1. fori循环
      2. 仿while循环
      3. for each循环
    5. 类型转换
      1. string转int
    6. 方法func
      1. 普通方法
      2. 递归写法
      3. 方法内的方法
    7. switch
    8. label和goto
  2. 内置容器
    1. 数组
      1. 大小
      2. 创建
    2. slice
      1. 创建
      2. 增加
      3. 截取
    3. map
      1. 创建
      2. 取值
      3. 删除一个key
      4. 获取key的slice
    4. range
      1. 对array、slice
      2. 对map
      3. 对string
  3. 排序
    1. 引入
    2. 几个内置类型
    3. 自定义排序
    4. Search：二分查找
    5. 参考
  4. 随机数
    1. 随机整数rand.Intn
    2. 随机浮点数rand.Float64()

基础语法

“Hello World!”

1
fmt.Println("Hello World!")

变量声明

使用var

1
var a int

声明并赋值

1
a := 0

同时赋值多个

类似python

1
a, b := 1, 2

if

1
2
3
4
5
6
7
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

普通方法

1
2
3
4
5
6
7
8
func Foo(a int, b int) int {
    return a + b
}

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

递归写法

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

方法内的方法

1
2
3
4
5
6
func Foo(a int, b int) int {
    bar := func(m, n int) int {
        return m + n
    }
    return bar(a, b)
}

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

1
2
3
4
5
6
7
8
9
10
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

1
2
3
4
5
6
7
8
9
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来直接继续外层循环

1
2
3
4
5
6
7
8
9
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则会无限循环

1
2
3
4
5
6
7
8
9
a:
for i := 0; i < 5; i++ {
    for j := 0; j < 5; j++ {
        if i == 3 && i == j {
            goto a
        }
        fmt.Println(i, j)
    }
}

内置容器

数组

大小

1
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

1
2
3
4
5
numbers := make([]int, 1)    // [0]
numbers = append(numbers, 1) // [0 1]

// 可以添加多个
numbers = append(numbers, 2, 3) // [0 1 2 3]
1
2
3
4
5
6
7
8
9
// 发生扩容
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,
}

取值

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

删除一个key

使用delete关键字

1
delete m[key]

获取key的slice

1
2
3
4
5
6
func KeySlice(m map[int]int) (arr []int) {
    for k, _ := range m {
        arr = append(arr, k)
    }
    return arr
}

range

用于循环

对array、slice

1
2
3
4
5
6
7
for i, v := range arr {

}

for i, v := range slice {

}

对map

1
2
3
for k, v := range m {

}

对string

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)

自定义排序

不稳定版本

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

稳定版本

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

Search：二分查找

返回第一个满足的索引

1
2
3
4
5
6
7
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的位置

参考

随机数

随机整数rand.Intn

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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()

1
2
3
4
5
6
7
8
9
10
import (
    "fmt"
    "math/rand"
)

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