初学Golang的N个小技巧

1. 如何初始化array

var a [2]int	# 仅定义
var b = [2]int{1, 2} # 定义并初始化
c := [3]int{1, 2, 3} 
d := [...]int{1, 2, 3, 4} # 可以省略长度而采用 `...` 的方式， Go 会自动根据元素个数来计算长度
e := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}} # 定义并初始化二位数组
f := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}} # 上面的声明可以简化，直接忽略内部的类型

2. 如何初始化slice

var a []int # 仅定义
var b = []int{1, 2} # 定义并初始化
c := []int{1, 2, 3}
d := c[:1] # 从已有Slice声明一个Slice，等价 d := c[0:1]，包含元素1， 2
e := c[1:] # 等价 e := [1:2], 包含元素2，3
f := [:] # 等价 f := [0:2], 包含元素1，2，3

3. 如何初始化map

var a map[string]int # 声明key是字符串，值为int的map, 需要在使用之前使用make 初始化
b := make(map[string]int) # 声明并初始化
c := map[string]int{"a": 1, "b": 2} # 声明并初始化

4. 如何实现Set集合效果

# 定义一个类型为string的Set集合：
var set = map[string]struct{}{}

# 判断Set集合是否存在a:
if _, ok := set["a"]; ok {
    fmt.Println("set contains a")
}
# 结果：ok=false

# 先传入b，再判断Set集合是否存在b:
set["b"] = struct{}{}
if _, ok := set["b"]; ok {
    fmt.Println("set contains b")
}
# 结果：ok=true

# 遍历Set集合：
for s := range set {
	fmt.Println(s)
}

5. 如何对字符串Split

str := "abc|def|ghi"

不带参数N的写法：
s1 := strings.Split(str, "|") 结果：[abc def ghi]

带参数N的写法，其中：
n>0：最多n个子串；最后一个子串将是未拆分的余数。
n==0：结果为零（零个子字符串）
n<0：所有子字符串
s2 := strings.SplitN(str, "|", 2) 结果：[abc def|ghi]
s3 := strings.SplitN(str, "|", 1) 结果：[abc|def|ghi]
s4 := strings.SplitN(str, "|", 0) 结果：[]
s5 := strings.SplitN(str, "|", -1) 结果：[abc def ghi] （该效果等同于不带参数N的写法）

6. 如何获取两个数中最大值或最小值

func max(x, y int) int {
    if x > y {
        return x
    }
    return y
}

func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

7. 如何交换两个数组元素

arr[i], arr[j] = arr[j], arr[i]

8. 如何翻转字符串

func reverse(s string) string {
    str := []rune(s)
    l := len(str)
    for i := 0; i < l/2; i++ {
        str[i], str[l-1-i] = str[l-1-i], str[i]
    }
    return string(str)
}

9. 如何对Slice排序

# TimePoint为自定义类型
type TimePoint []string
func (t TimePoint) Len() int           { return len(t) }
func (t TimePoint) Swap(i, j int)      { t[i], t[j] = t[j], t[i] }
func (t TimePoint) Less(i, j int) bool { return t[i] < t[j] }

func main() {
	timePoints := []string{"05:31", "22:08", "00:35"}
	sort.Sort(TimePoint(timePoints))
	fmt.Println(timePoints) // [00:35 05:31 22:08]
}

# 上方的[]string还是基础类型，那么如何对自定义类型排序，请往下看
## BikeStore为自定义类型，有一个字段amount表示自行车店拥有的自行车数量
type BikeStore struct {
    amount int
}

## 下方就是自行车店排序规则
type BikeSort []BikeStore

func (b BikeSort) Len() int {
    return len(b)
}

func (b BikeSort) Swap(i, j int) {
    b[i], b[j] = b[j], b[i]
}

func (b BikeSort) Less(i, j int) bool {
    return b[i].amount < b[j].amount
}

func main() {
    s1 := BikeSort{BikeStore{5}, BikeStore{1}, BikeStore{3}}
    sort.Sort(s1) 
    # 结果： [{1} {3} {5}]
}